Major moq-transport API simplification (#68)

Exponentially easier to use moq-transport as there's no message handling required. This is a BREAKING CHANGE.
2023-09-15 12:06:28 -07:00 · 2023-09-15 12:06:28 -07:00 · 88542e266c
parent 35c2127683
commit 88542e266c
84 changed files with 3172 additions and 2603 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -1,3 +1,2 @@
-media/*.mp4
+target
-target/*
+dev
 cert/*
--- a/.github/logo.svg
+++ b/.github/logo.svg
@ -0,0 +1,348 @@
 <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
 	 width="100%" viewBox="0 0 1600 350" enable-background="new 0 0 1600 350" xml:space="preserve">
 <path fill="#00BF2D" opacity="1.000000" stroke="none"
 	d="
 M629.000000,251.175552
 	C696.998962,251.217285 764.499023,251.043793 831.996460,251.381424
 	C872.647339,251.584763 913.298706,252.386017 953.941528,253.292007
 	C982.745422,253.934082 1011.545044,254.980118 1040.328979,256.247833
 	C1072.095703,257.646881 1103.870239,259.095795 1135.590210,261.269958
 	C1172.600830,263.806732 1209.631958,266.431824 1246.516602,270.323273
 	C1295.623901,275.504242 1344.692993,281.265167 1393.597412,288.076874
 	C1427.318604,292.773712 1460.732422,299.676239 1494.286621,305.576050
 	C1495.344238,305.762024 1496.434937,305.760956 1497.510132,305.847107
 	C1497.821045,305.462891 1498.131958,305.078674 1498.442871,304.694458
 	C1488.217285,293.633759 1477.855469,282.693481 1467.882812,271.409302
 	C1465.925903,269.195099 1464.219971,265.425110 1464.695190,262.786316
 	C1465.133423,260.352997 1468.427979,257.132629 1470.885132,256.711182
 	C1473.629028,256.240570 1477.574585,257.756165 1479.722534,259.768066
 	C1486.266846,265.897827 1492.221802,272.660034 1498.360718,279.218506
 	C1505.749878,287.112610 1513.088989,295.053375 1520.459839,302.964661
 	C1521.367432,303.938873 1522.438965,304.774780 1523.260864,305.812347
 	C1527.773071,311.508759 1525.604370,317.245026 1518.569824,318.799347
 	C1514.398804,319.720978 1510.317749,321.054749 1506.204834,322.233215
 	C1492.317871,326.212219 1478.444458,330.239075 1464.535034,334.137756
 	C1463.163330,334.522247 1461.333008,334.640198 1460.143799,334.037231
 	C1457.149780,332.519318 1454.400635,330.518280 1451.553345,328.710907
 	C1453.454956,326.675415 1454.985962,323.813782 1457.329102,322.762604
 	C1463.820068,319.850586 1470.642944,317.674500 1477.350464,315.251526
 	C1478.867554,314.703461 1480.448853,314.333069 1481.939453,313.325989
 	C1472.812378,312.558197 1463.662720,311.992706 1454.562866,310.980316
 	C1435.890259,308.902893 1417.238159,306.635834 1398.588989,304.354828
 	C1376.142456,301.609375 1353.720581,298.658081 1331.263916,295.999207
 	C1308.310791,293.281616 1285.343750,290.661316 1262.354004,288.277039
 	C1243.162964,286.286713 1223.942993,284.541443 1204.712646,282.972260
 	C1179.338867,280.901733 1153.949097,279.014832 1128.553101,277.235474
 	C1115.102783,276.293091 1101.631714,275.571259 1088.158325,275.050995
 	C1040.065796,273.194092 991.970093,271.413574 943.871704,269.715393
 	C924.729553,269.039551 905.579163,268.302917 886.429138,268.194153
 	C777.940491,267.577850 669.451111,267.074097 560.961487,266.667938
 	C464.478882,266.306732 367.991150,266.582184 271.514618,265.650635
 	C228.399628,265.234344 185.303329,262.628845 142.205185,260.855164
 	C126.569107,260.211700 110.952034,259.103943 95.327812,258.182037
 	C94.409203,258.127808 93.504318,257.841095 92.610275,256.814972
 	C93.799576,256.692017 94.988075,256.470398 96.178314,256.460632
 	C124.171005,256.231537 152.166306,256.187103 180.156113,255.771332
 	C210.804214,255.316101 241.445053,254.377655 272.093018,253.907425
 	C324.735779,253.099701 377.379822,252.239914 430.026611,251.863953
 	C496.182678,251.391495 562.342041,251.383850 629.000000,251.175552
 z"/>
 <path fill="#FBFBFC" opacity="1.000000" stroke="none"
 	d="
 M1136.531250,75.468430
 	C1149.502686,89.464615 1158.312866,105.204132 1161.071167,123.944977
 	C1164.256714,145.588089 1155.058838,161.365723 1137.358032,172.860504
 	C1132.915649,175.745377 1128.063721,177.999420 1123.526367,180.474442
 	C1126.513184,187.666153 1129.579590,195.049347 1132.855957,202.938431
 	C1123.931519,204.148102 1115.508179,202.346771 1110.577148,195.110870
 	C1105.483032,187.635696 1100.227417,187.258179 1092.027954,188.385681
 	C1070.494629,191.346680 1049.619141,188.256668 1031.786011,174.742630
 	C999.943604,150.612198 998.185486,104.367447 1027.705688,76.309776
 	C1039.444458,65.152596 1052.978394,57.629692 1069.411377,55.724426
 	C1075.942505,54.967213 1082.346558,52.011589 1088.812012,51.999477
 	C1108.218750,51.963127 1123.192627,61.870239 1136.531250,75.468430
 M1081.841064,145.525299
 	C1080.419556,139.547165 1081.585205,135.960693 1085.617065,133.906250
 	C1089.598022,131.877777 1093.365967,133.214371 1097.057617,138.187378
 	C1098.537598,140.181168 1099.774536,142.367310 1101.005127,144.532379
 	C1104.915039,151.411697 1108.770020,158.322296 1113.107422,166.041336
 	C1120.483521,162.215363 1127.704468,159.163391 1134.170044,154.951767
 	C1143.576294,148.824509 1148.202881,139.659027 1146.197388,128.397034
 	C1141.447144,101.723297 1125.503296,83.583786 1101.300049,72.604919
 	C1092.501587,68.613853 1082.749512,66.282639 1073.111206,68.667519
 	C1058.141846,72.371498 1045.922119,80.847488 1036.339478,92.972885
 	C1019.910889,113.760803 1022.760925,144.436249 1042.867920,159.496338
 	C1057.771973,170.659393 1075.039429,171.245407 1092.828979,169.646286
 	C1089.109741,161.592758 1085.579102,153.947586 1081.841064,145.525299
 z"/>
 <path fill="#FAFAFB" opacity="1.000000" stroke="none"
 	d="
 M163.409271,97.601189
 	C159.556641,82.961777 155.850479,68.708122 152.144302,54.454468
 	C151.539719,54.494175 150.935135,54.533886 150.330551,54.573593
 	C150.238388,56.162678 150.003922,57.758244 150.075943,59.339851
 	C150.856064,76.471855 152.018768,93.594795 152.371094,110.734718
 	C152.574844,120.646263 152.286118,130.707367 150.768463,140.475784
 	C149.239716,150.315628 139.963211,153.317551 133.007675,146.116348
 	C126.618286,139.501297 120.986832,131.806183 116.531418,123.751656
 	C109.635605,111.285385 104.017014,98.112022 97.877350,85.228714
 	C97.052658,83.498199 96.347321,81.710808 95.109352,78.844490
 	C93.638824,92.596100 92.969818,105.222824 90.824066,117.593391
 	C86.344818,143.416916 81.103470,169.108627 76.107986,194.841431
 	C75.765762,196.604324 75.335861,198.819595 74.120293,199.838791
 	C72.050568,201.574173 68.985298,203.912735 66.967407,203.420258
 	C64.912872,202.918823 62.141987,199.226456 62.258987,197.071014
 	C62.652668,189.818619 63.983761,182.589264 65.329239,175.421097
 	C72.090233,139.401337 76.428711,103.108971 78.109642,66.492729
 	C78.467834,58.690132 79.265854,50.906723 79.913078,43.118782
 	C80.302116,38.437618 82.696655,35.136398 87.391167,34.368179
 	C92.028061,33.609390 95.074997,36.559422 96.790001,40.362938
 	C101.086494,49.891605 105.364403,59.453991 109.039825,69.232117
 	C116.894081,90.127693 125.350204,110.678284 138.704605,128.815002
 	C139.493042,129.885788 140.304932,130.941299 141.151642,131.966141
 	C141.447189,132.323883 141.880798,132.567551 143.146240,133.577560
 	C143.830902,128.312241 145.004654,123.667191 144.932312,119.041618
 	C144.690186,103.559769 143.727631,88.087433 143.584473,72.606430
 	C143.492386,62.647972 144.171692,52.666691 144.934692,42.728611
 	C145.096863,40.616306 147.122131,38.647049 148.289017,36.611893
 	C150.504868,38.044456 153.744263,38.964149 154.762741,40.996700
 	C159.663269,50.776634 164.578201,60.630810 168.352448,70.876930
 	C176.551086,93.134140 184.218704,115.592049 191.787308,138.074326
 	C196.154129,151.045807 197.230148,164.420029 194.373154,178.764542
 	C193.094727,177.356552 191.899033,176.219727 190.911789,174.924072
 	C182.707550,164.156830 177.968872,151.777100 174.438080,138.884979
 	C170.711868,125.279350 167.175201,111.621811 163.409271,97.601189
 z"/>
 <path fill="#FBFBFB" opacity="1.000000" stroke="none"
 	d="
 M1318.623291,213.559036
 	C1326.593018,211.154846 1334.216919,208.927917 1340.603882,207.062286
 	C1344.129639,171.296021 1347.595703,136.135696 1351.028809,101.308739
 	C1342.915527,102.577072 1334.153809,104.093391 1325.344238,105.241043
 	C1322.425903,105.621231 1319.333374,105.347610 1316.410278,104.847801
 	C1312.129639,104.115845 1309.018921,100.919800 1309.508179,96.984612
 	C1309.856445,94.183403 1312.863647,90.051605 1315.391113,89.441330
 	C1338.757202,83.799500 1362.226318,78.544655 1385.787476,73.779846
 	C1391.750977,72.573822 1398.291504,72.711571 1404.852295,76.730232
 	C1392.971924,90.214096 1376.451050,92.201271 1360.660645,98.128868
 	C1369.758423,132.311966 1362.319824,166.812546 1360.679443,201.668655
 	C1369.330933,200.256683 1377.375122,198.362335 1385.510742,197.808289
 	C1391.530029,197.398361 1397.741577,198.331177 1403.728638,199.425430
 	C1408.042236,200.213837 1408.640625,202.562515 1405.111938,204.918213
 	C1399.963013,208.355545 1394.470825,212.122604 1388.599731,213.484131
 	C1366.290161,218.657791 1343.783691,222.992584 1321.318115,227.476761
 	C1315.322754,228.673447 1310.937744,226.695831 1309.865845,223.001495
 	C1308.736206,219.107834 1311.269165,216.317764 1318.623291,213.559036
 z"/>
 <path fill="#FBFBFB" opacity="1.000000" stroke="none"
 	d="
 M1287.844727,130.118118
 	C1294.262207,144.747940 1300.462524,159.051559 1306.968994,173.214539
 	C1310.164185,180.170013 1310.593384,186.843002 1306.737915,194.156265
 	C1300.050781,192.227844 1294.365967,189.112549 1290.990601,182.952011
 	C1286.840210,175.377365 1283.038086,167.611832 1279.091431,159.925705
 	C1278.517090,158.807190 1277.975586,157.671844 1277.343994,156.393036
 	C1274.793579,161.344620 1272.824829,166.260513 1269.945923,170.568115
 	C1256.856689,190.153320 1232.661377,197.443680 1213.129883,187.786453
 	C1199.905762,181.247833 1192.978516,169.579681 1189.343994,156.023926
 	C1183.894531,135.699097 1183.905884,114.917877 1185.908691,94.103676
 	C1186.309937,89.935753 1188.117554,86.130157 1192.624146,86.199341
 	C1197.307983,86.271255 1199.271851,90.129578 1199.567261,94.530823
 	C1200.413452,107.143066 1200.622437,119.827904 1202.148315,132.354294
 	C1203.181030,140.831161 1205.151001,149.424347 1208.237061,157.369156
 	C1213.500000,170.918060 1223.648682,176.521271 1238.000244,173.992706
 	C1253.198120,171.315033 1265.452393,163.931900 1270.945557,148.483078
 	C1271.809204,146.054733 1271.923828,142.860641 1271.133911,140.426361
 	C1266.598022,126.445602 1263.218018,112.255936 1262.750122,97.529289
 	C1262.626465,93.635056 1262.824219,89.307877 1264.435791,85.922951
 	C1265.601440,83.474945 1269.326782,80.929306 1271.949707,80.887558
 	C1274.252197,80.850899 1277.810791,83.795891 1278.690063,86.200768
 	C1280.482788,91.103928 1281.747070,96.555244 1281.603394,101.735649
 	C1281.326904,111.707245 1284.505249,120.671661 1287.844727,130.118118
 z"/>
 <path fill="#FBFBFB" opacity="1.000000" stroke="none"
 	d="
 M342.167328,116.560349
 	C342.607605,128.632126 346.551636,139.397873 349.744049,150.408463
 	C353.743408,164.202164 356.755859,178.281998 360.194305,192.238327
 	C359.493927,192.600998 358.793518,192.963654 358.093140,193.326324
 	C353.282837,188.887039 348.472504,184.447754 343.396149,179.762924
 	C342.712463,181.693939 342.026672,183.621872 341.347015,185.551987
 	C336.777466,198.529419 325.178802,206.497086 313.291534,204.823074
 	C301.280579,203.131653 292.968079,193.438995 292.280273,179.400070
 	C291.788818,169.369019 294.304321,159.899078 300.247253,151.620850
 	C307.615692,141.356949 316.363403,140.147446 328.292542,147.976822
 	C327.980743,145.991440 327.800507,144.420532 327.481873,142.878204
 	C322.446899,118.508255 316.997528,94.213493 312.583099,69.732010
 	C311.228119,62.217468 312.484894,54.181606 312.943695,46.407955
 	C313.253174,41.164368 317.112122,38.454212 321.743195,37.473629
 	C326.174896,36.535255 329.411072,39.629780 330.726501,43.192245
 	C333.578522,50.916084 336.623993,58.818966 337.689606,66.899292
 	C339.840698,83.211403 340.724609,99.690636 342.167328,116.560349
 M309.993713,172.914719
 	C309.980682,175.578445 309.777679,178.257812 309.995667,180.902496
 	C310.400360,185.813385 313.078979,188.762299 318.044159,189.620300
 	C326.737244,191.122452 338.776581,180.273026 338.102356,171.451462
 	C338.053619,170.813690 337.791229,170.173080 337.535583,169.573257
 	C335.144562,163.962906 332.733246,158.361206 330.440308,153.019058
 	C328.357971,153.635178 326.326569,154.664383 324.247040,154.773209
 	C317.316254,155.135880 313.925201,159.362122 311.976410,165.337982
 	C311.257599,167.542145 310.705719,169.800751 309.993713,172.914719
 z"/>
 <path fill="#FBFBFB" opacity="1.000000" stroke="none"
 	d="
 M1513.002930,170.004578
 	C1494.165283,176.457748 1475.004761,181.331024 1454.884521,179.858139
 	C1440.411255,178.798630 1427.254639,173.872086 1416.528076,163.787704
 	C1401.059082,149.244965 1397.860962,127.149376 1408.758911,108.019783
 	C1421.130615,86.303116 1439.984131,73.373810 1464.666260,69.665749
 	C1469.809692,68.893051 1475.527588,70.309135 1480.654785,71.821388
 	C1482.884399,72.479012 1484.290283,75.929276 1486.070312,78.111168
 	C1483.802979,79.326584 1481.623413,81.378937 1479.254517,81.627686
 	C1456.195435,84.049095 1439.207275,96.295998 1426.711914,114.875160
 	C1416.032837,130.753922 1421.064209,147.970795 1438.437866,155.968704
 	C1453.955200,163.112061 1470.665405,166.288895 1487.626831,167.681854
 	C1495.733643,168.347626 1503.915161,168.104095 1512.499268,168.560028
 	C1512.958008,169.233292 1512.980469,169.618927 1513.002930,170.004578
 z"/>
 <path fill="#FBFBFB" opacity="1.000000" stroke="none"
 	d="
 M239.201996,130.145264
 	C248.979431,126.278221 258.399506,125.809898 267.565765,130.571045
 	C279.664764,136.855499 281.621063,148.989212 271.858185,158.454910
 	C261.869293,168.139725 249.079178,173.241089 236.618393,178.784348
 	C235.295547,179.372803 233.914032,179.829407 231.761765,180.652298
 	C242.173447,194.611206 255.143845,202.371750 273.385498,202.476227
 	C265.802246,207.568604 258.215027,210.398682 249.902466,210.877014
 	C231.864685,211.914963 216.718536,199.375671 212.102386,179.896667
 	C207.268417,159.498505 217.625748,140.263992 239.201996,130.145264
 M242.810928,159.339478
 	C250.042633,155.146423 257.274323,150.953354 265.286041,146.308029
 	C252.233353,139.755737 233.610580,150.564499 231.300339,164.740128
 	C235.050735,163.017868 238.613678,161.381699 242.810928,159.339478
 z"/>
 <path fill="#FBFBFB" opacity="1.000000" stroke="none"
 	d="
 M624.167725,142.316818
 	C627.976257,136.513885 630.969482,130.369003 635.563232,125.851997
 	C641.728455,119.789795 648.274597,120.355034 655.143066,125.560020
 	C655.977478,126.192337 657.476501,126.451340 658.519653,126.219101
 	C663.589783,125.090317 668.150696,126.073051 672.096252,129.341476
 	C682.107605,137.634766 686.472229,148.416443 684.693054,161.209671
 	C683.076294,172.835236 674.802002,179.983856 661.441101,182.456970
 	C644.284973,185.632584 627.357971,176.376709 623.780945,160.850235
 	C622.462158,155.125778 623.890076,148.768494 624.167725,142.316818
 M649.053528,141.777878
 	C647.990417,141.277863 646.927307,140.777863 645.846741,140.269623
 	C635.844177,152.499466 640.121277,164.773209 655.520142,167.670135
 	C657.451111,168.033401 659.509094,168.111038 661.461914,167.897369
 	C668.356323,167.143036 671.814758,162.153915 670.620911,155.275330
 	C669.067078,146.321915 662.716980,141.557297 655.674438,137.376404
 	C653.544861,138.765686 651.604553,140.031464 649.053528,141.777878
 z"/>
 <path fill="#FAFAFB" opacity="1.000000" stroke="none"
 	d="
 M772.803223,161.083405
 	C770.535583,148.230927 774.162292,137.747620 784.392395,130.386093
 	C794.918396,122.811592 806.447388,122.673988 817.790405,128.736755
 	C825.595703,132.908661 827.257202,141.721008 821.407837,148.616196
 	C813.783691,157.603333 803.725098,160.429779 792.228149,158.507355
 	C791.281921,158.349136 790.339722,158.167206 788.353943,157.807709
 	C797.509705,171.729874 810.399170,176.276154 824.957275,177.567291
 	C820.938843,183.615295 807.955444,188.047073 798.095459,186.049118
 	C784.516785,183.297653 776.255554,174.859680 772.803223,161.083405
 M809.558899,135.862030
 	C798.588806,134.269241 792.872375,137.437286 789.616760,147.077301
 	C798.363342,144.511520 808.040649,144.867493 815.703674,137.563873
 	C813.464600,136.878754 811.919861,136.406067 809.558899,135.862030
 z"/>
 <path fill="#FAFAFA" opacity="1.000000" stroke="none"
 	d="
 M738.921509,145.878479
 	C743.540833,140.195419 747.723938,134.589798 752.464417,129.503799
 	C755.873108,125.846649 758.645569,126.472183 759.393555,131.253906
 	C760.107605,135.818985 760.240601,141.074524 758.657593,145.285431
 	C754.134583,157.316803 746.475342,167.422684 736.250244,175.312180
 	C726.499817,182.835358 719.246155,181.199112 712.776489,170.630692
 	C705.711975,159.090546 703.272278,146.248688 702.279846,133.068970
 	C702.142761,131.247955 704.191101,129.262344 705.227661,127.352921
 	C706.951050,128.577072 709.394531,129.419556 710.279236,131.088379
 	C715.386841,140.722626 720.126099,150.552109 725.727478,161.795441
 	C730.797424,155.703156 734.760620,150.940750 738.921509,145.878479
 z"/>
 <path fill="#F9F9FA" opacity="1.000000" stroke="none"
 	d="
 M467.165802,147.065536
 	C472.151550,142.035843 476.259644,141.605576 479.298157,147.278534
 	C485.218536,158.331879 490.264221,169.873840 495.226379,181.405243
 	C496.375275,184.075195 495.731476,187.516586 495.914032,190.627243
 	C485.614532,190.666885 480.080963,186.271896 472.886597,173.218597
 	C468.179077,176.379196 463.730988,180.169205 458.632111,182.586426
 	C452.203400,185.634048 445.446136,185.023941 440.131805,179.805389
 	C434.910126,174.677826 434.783051,168.194519 437.191345,161.708786
 	C441.004791,151.438919 449.126953,146.544067 459.485138,145.024109
 	C461.408630,144.741852 463.548248,145.932449 465.833313,147.078125
 	C465.015228,148.906235 464.032562,150.185135 462.873444,151.276627
 	C459.494141,154.458847 455.682281,157.263580 452.731049,160.793991
 	C450.146057,163.886307 447.220856,167.825180 450.510193,171.991028
 	C453.720581,176.056946 458.457642,175.628967 462.928589,174.324921
 	C464.630066,173.828644 466.167450,172.678284 467.693420,171.692612
 	C470.238068,170.048920 470.982910,168.047455 469.733948,164.947800
 	C467.439240,159.252930 465.345367,153.405151 467.165802,147.065536
 z"/>
 <path fill="#FAFAFA" opacity="1.000000" stroke="none"
 	d="
 M857.086792,179.194427
 	C850.600952,181.854446 846.328918,179.966370 844.737183,173.525055
 	C843.466309,168.382309 842.729065,163.088470 842.050903,157.823563
 	C841.268188,151.747162 840.628784,145.639175 840.283630,139.524780
 	C840.096436,136.210342 838.479553,131.607040 844.893616,131.885284
 	C845.673340,131.919128 846.687500,130.233536 847.330750,129.184052
 	C859.965393,108.569351 884.028992,113.000961 896.941345,124.514656
 	C891.695740,125.275612 886.481995,125.892799 881.320496,126.805115
 	C860.490051,130.486984 855.529175,139.071472 858.402710,160.841064
 	C858.792725,163.796036 859.318726,166.771271 860.180298,169.616455
 	C861.346863,173.468765 860.345154,176.458069 857.086792,179.194427
 z"/>
 <path fill="#FAFBFB" opacity="1.000000" stroke="none"
 	d="
 M380.792236,102.062325
 	C380.235046,99.406120 379.549133,97.142342 379.399231,94.843613
 	C378.919006,87.477249 380.686188,84.940620 388.542725,81.606430
 	C387.097687,80.077728 385.776917,78.680450 384.315948,77.134903
 	C388.208435,72.881897 393.210083,73.350266 398.035309,74.871124
 	C409.622528,78.523277 416.637024,95.479935 411.179871,106.306816
 	C408.505524,111.612694 404.068512,114.634636 398.109192,114.996391
 	C391.277008,115.411140 386.330261,112.096550 382.769348,106.511284
 	C381.974762,105.264984 381.520081,103.801987 380.792236,102.062325
 z"/>
 <path fill="#F9F9FA" opacity="1.000000" stroke="none"
 	d="
 M391.399902,139.195312
 	C393.872406,142.425400 396.737183,145.267319 397.940125,148.692810
 	C402.384827,161.349411 406.280365,174.198837 410.381775,186.975983
 	C410.483490,187.292831 410.608765,187.605957 410.672058,187.930756
 	C411.964386,194.566360 409.668182,199.769592 404.835266,201.174149
 	C400.390320,202.465942 395.465637,199.427383 393.409119,193.040955
 	C391.333191,186.594208 389.840393,179.908524 388.701935,173.223679
 	C387.197479,164.389755 386.045258,155.477432 385.207855,146.555038
 	C384.677216,140.901108 386.365387,139.208511 391.399902,139.195312
 z"/>
 <path fill="#058B2C" opacity="1.000000" stroke="none"
 	d="
 M80.124115,257.917877
 	C73.365936,257.403900 67.078743,256.905029 60.791542,256.406158
 	C60.831306,256.228943 60.871075,256.051727 60.910839,255.874512
 	C70.181015,255.874512 79.451187,255.874512 88.721367,255.874512
 	C88.736588,256.560669 88.751801,257.246826 88.767021,257.932983
 	C86.043045,257.932983 83.319061,257.932983 80.124115,257.917877
 z"/>
 <path fill="#A4A7AE" opacity="1.000000" stroke="none"
 	d="
 M1513.363892,170.057541
 	C1512.980469,169.618927 1512.958008,169.233292 1512.905029,168.553741
 	C1514.441284,168.074600 1516.007935,167.889343 1517.574707,167.704102
 	C1517.666748,168.004990 1517.758911,168.305893 1517.851074,168.606781
 	C1516.475708,169.108032 1515.100220,169.609268 1513.363892,170.057541
 z"/>
 </svg>
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,7 +1,3 @@
 [workspace]
-members = [
+members = ["moq-transport", "moq-relay", "moq-pub"]
-    "moq-transport",
+resolver = "2"
 	"moq-quinn",
    "moq-pub",
    "moq-warp",
 ]
--- a/47
+++ b/47
@ -1,44 +1,19 @@
 FROM rust:latest as builder
-# Make a fake Rust app to keep a cached layer of compiled crates
+# Create a build directory and copy over all of the files
-RUN USER=root cargo new app
+WORKDIR /build
 WORKDIR /usr/src/app
 COPY Cargo.toml Cargo.lock ./
 RUN mkdir -p moq-transport/src moq-quinn/src moq-warp/src moq-pub/src
 COPY moq-transport/Cargo.toml moq-transport/Cargo.toml
 COPY moq-quinn/Cargo.toml moq-quinn/Cargo.toml
 COPY moq-pub/Cargo.toml moq-pub/Cargo.toml
 COPY moq-warp/Cargo.toml moq-warp/Cargo.toml
 RUN touch moq-transport/src/lib.rs
 RUN touch moq-warp/src/lib.rs
 RUN touch moq-pub/src/lib.rs
 RUN touch moq-quinn/src/lib.rs
 RUN sed -i '/default-run.*/d' moq-quinn/Cargo.toml
 # Will build all dependent crates in release mode
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
    --mount=type=cache,target=/usr/src/app/target \
    cargo build --release
 # Copy the rest
 COPY . .
-# Build (install) the actual binaries
+# Reuse a cache between builds.
-RUN cargo install --path moq-quinn
+# I tried to `cargo install`, but it doesn't seem to work with workspaces.
 # There's also issues with the cache mount since it builds into /usr/local/cargo/bin, and we can't mount that without clobbering cargo itself.
 # We instead we build the binaries and copy them to the cargo bin directory.
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
    --mount=type=cache,target=/build/target \
    cargo build --release && cp /build/target/release/moq-* /usr/local/cargo/bin
 # Runtime image
 FROM rust:latest
-# Run as "app" user
+# Copy the compiled binaries
-RUN useradd -ms /bin/bash app
+COPY --from=builder /usr/local/cargo/bin /usr/local/cargo/bin
 USER app
 WORKDIR /app
 # Get compiled binaries from builder's cargo install directory
 COPY --from=builder /usr/local/cargo/bin/moq-quinn /app/moq-quinn
 ADD entrypoint.sh .
 # No CMD or ENTRYPOINT, see fly.toml with `cmd` override.
--- a/README.md
+++ b/README.md
@ -1,5 +1,9 @@
 # Media over QUIC
 <p align="center">
 	<img height="256" src="https://github.com/kixelated/moq-rs/blob/main/.github/logo.svg">
 </p>
 Media over QUIC (MoQ) is a live media delivery protocol utilizing QUIC streams.
 See the [MoQ working group](https://datatracker.ietf.org/wg/moq/about/) for more information.
@ -8,7 +12,6 @@ It requires a client to actually publish/view content, such as [moq-js](https://
 Join the [Discord](https://discord.gg/FCYF3p99mr) for updates and discussion.
 ## Setup
 ### Certificates
@ -19,8 +22,8 @@ If you have a valid certificate you can use it instead of self-signing.
 Use [mkcert](https://github.com/FiloSottile/mkcert) to generate a self-signed certificate.
 Unfortunately, this currently requires Go in order to [fork](https://github.com/FiloSottile/mkcert/pull/513) the tool.
-```
+```bash
-./cert/generate
+./dev/cert
 ```
 Unfortunately, WebTransport in Chrome currently (May 2023) doesn't verify certificates using the root CA.
@ -28,16 +31,68 @@ The workaround is to use the `serverFingerprints` options, which requires the ce
 This is also why we're using a fork of mkcert, because it generates certificates valid for years by default.
 This limitation will be removed once Chrome uses the system CA for WebTransport.
 ### Media
 If you're using `moq-pub` then you'll want some test footage to broadcast.
 ```bash
 mkdir media
 wget http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4 -O dev/source.mp4
 ```
 ## Usage
-Run the server:
+### moq-relay
-```
+**moq-relay** is a server that forwards subscriptions from publishers to subscribers, caching and deduplicating along the way.
-cargo run
+It's designed to be run in a datacenter, relaying media across multiple hops to deduplicate and improve QoS.
 You can run the development server with the following command, automatically using the self-signed certificate generated earlier:
 ```bash
 ./dev/relay
 ```
-This listens for WebTransport connections on `https://localhost:4443` by default.
+Notable arguments:
-Use a [MoQ client](https://github.com/kixelated/moq-js) to connect to the server.
+
 -   `--bind <ADDR>` Listen on this address [default: [::]:4443]
 -   `--cert <CERT>` Use the certificate file at this path
 -   `--key <KEY>` Use the private key at this path
 This listens for WebTransport connections on `UDP https://localhost:4443` by default.
 You need a client to connect to that address, to both publish and consume media.
 The server also listens on `TCP localhost:4443` when in development mode.
 This is exclusively to serve a `/fingerprint` endpoint via HTTPS for self-signed certificates, which are not needed in production.
 ### moq-pub
 This is a client that publishes a fMP4 stream from stdin over MoQ.
 This can be combined with ffmpeg (and other tools) to produce a live stream.
 The following command runs a development instance, broadcasing `dev/source.mp4` to `localhost:4443`:
 ```bash
 ./dev/pub
 ```
 Notable arguments:
 -   `<URI>` connect to the given address, which must start with moq://.
 ### moq-js
 There's currently no way to consume broadcasts with `moq-rs`, at least until somebody writes `moq-sub`.
 Until then, you can use [moq.js](https://github.com/kixelated/moq-js) both watch broadcasts and publish broadcasts.
 There's a hosted version available at [quic.video](https://quic.video/).
 There's a secret `?server` parameter that can be used to connect to a different address.
 -   Publish to localhost: `https://quic.video/publish/?server=localhost:4443`
 -   Watch from localhost: `https://quic.video/watch/<name>/?server=localhost:4443`
 Note that self-signed certificates are ONLY supported if the server name starts with `localhost`.
 You'll need to add an entry to `/etc/hosts` if you want to use a self-signed certs and an IP address.
 ## License
--- a/cert/.gitignore
+++ b/cert/.gitignore
@ -1,3 +1,4 @@
 *.crt
 *.key
 *.hex
 *.mp4
--- a/cert/generate
+++ b/cert/generate
--- a/cert/go.mod
+++ b/cert/go.mod
--- a/cert/go.sum
+++ b/cert/go.sum
--- a/dev/pub
+++ b/dev/pub
@ -0,0 +1,25 @@
 #!/bin/bash
 set -euo pipefail
 # Change directory to the root of the project
 cd "$(dirname "$0")/.."
 # Connect to localhost by default.
 HOST="${HOST:-localhost:4443}"
 # Generate a random 16 character name by default.
 NAME="${NAME:-$(head /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | head -c 16)}"
 # Combine the host and name into a URI.
 URI="${URI:-"moq://$HOST/$NAME"}"
 # Default to a source video
 MEDIA="${MEDIA:-dev/source.mp4}"
 # Run ffmpeg and pipe the output to moq-pub
 ffmpeg -hide_banner -v quiet \
 	-stream_loop -1 -re \
 	-i "$MEDIA" \
 	-an \
 	-f mp4 -movflags empty_moov+frag_every_frame+separate_moof+omit_tfhd_offset - \
 	| RUST_LOG=info cargo run --bin moq-pub -- "$URI" "$@"
--- a/dev/relay
+++ b/dev/relay
@ -0,0 +1,13 @@
 #!/bin/bash
 set -euo pipefail
 # Change directory to the root of the project
 cd "$(dirname "$0")/.."
 # Default to a self-signed certificate
 # TODO automatically generate if it doesn't exist.
 CERT="${CERT:-dev/localhost.crt}"
 KEY="${KEY:-dev/localhost.key}"
 # Run the relay and forward any arguments
 RUST_LOG=info cargo run --bin moq-relay -- --cert "$CERT" --key "$KEY" --fingerprint "$@"
--- a/entrypoint.sh
+++ b/entrypoint.sh
@ -1,8 +0,0 @@
 #!/usr/bin/env sh
 mkdir cert
 # Nothing to see here...
 echo "$MOQ_CRT" | base64 -d > cert/moq-demo.crt
 echo "$MOQ_KEY" | base64 -d > cert/moq-demo.key
 RUST_LOG=info ./moq-quinn --cert cert/moq-demo.crt --key cert/moq-demo.key
--- a/moq-pub/Cargo.toml
+++ b/moq-pub/Cargo.toml
@ -15,8 +15,6 @@ categories = ["multimedia", "network-programming", "web-programming"]
 [dependencies]
 moq-transport = { path = "../moq-transport" }
 #moq-transport-quinn = { path = "../moq-transport-quinn" }
 moq-warp = { path = "../moq-warp" }
 # QUIC
 quinn = "0.10"
@ -36,9 +34,9 @@ tokio = { version = "1.27", features = ["full"] }
 clap = { version = "4.0", features = ["derive"] }
 log = { version = "0.4", features = ["std"] }
 env_logger = "0.9.3"
 anyhow = { version = "1.0.70", features = ["backtrace"]}
 mp4 = "0.13.0"
 rustls-native-certs = "0.6.3"
 anyhow = { version = "1.0.70", features = ["backtrace"] }
 serde_json = "1.0.105"
 rfc6381-codec = "0.1.0"
@ -46,11 +44,3 @@ rfc6381-codec = "0.1.0"
 http = "0.2.9"
 clap = { version = "4.0", features = ["derive"] }
 clap_mangen = "0.2.12"
 [dependencies.uuid]
 version = "1.4.1"
 features = [
    "v4",                # Lets you generate random UUIDs
    "fast-rng",          # Use a faster (but still sufficiently random) RNG
    "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs
 ]
--- a/moq-pub/README.md
+++ b/moq-pub/README.md
@ -5,22 +5,9 @@ A command line tool for publishing media via Media over QUIC (MoQ).
 Expects to receive fragmented MP4 via standard input and connect to a MOQT relay.
 ```
-ffmpeg ... - | moq-pub -i - -u https://localhost:4443
+ffmpeg ... - | moq-pub -i - --host localhost:4443
 ```
 ### A note on the `moq-pub` code organization
 - `Media` is responsible for reading from stdin and parsing MP4 boxes. It populates a `MapSource` of `Track`s for which it holds the producer side, pushing segments of video/audio into them and notifying consumers via tokio watch async primitives.
 - `SessionRunner` is where we create and hold the MOQT Session from the `moq_transport` library. We currently hard-code our implementation to use `quinn` as the underlying WebTranport implementation. We use a series of `mpsc` and `broadcast` channels to make it possible for other parts of our code to send/recieve control messages via that Session. Sending Objects is handled a little differently because we are able to clone the MOQT Session's sender wherever we need to do that.
 - `MediaRunner` is responsible for consuming the `Track`s that `Media` produces and populates. `MediaRunner` spawns tasks for each `Track` to `.await` new segments and then put the media data into Objects and onto the wire (via channels into `SessionRunner`). Note that these tasks are created, but block waiting un the reception of a MOQT SUBSCRIBE message before they actually send any segments on the wire. `MediaRunner` is also responsible for sending the initial MOQT ANNOUNCE message announcing the namespace for the tracks we will send.
 - `LogViewer` as the name implies is responsible for logging. It snoops on some channels going in/out of `SessionRunner` and logs MOQT control messages.
 Longer term, I think it'd be interesting to refactor everything such that the `Media` + `MediaRunner` bits consume an interface that's _closer_ to what we'd like to eventually expose as a C FFI for consumption by external tools. That probably means greatly reducing the use of async Rust in the parts of this code that make up both sides of that interface boundary.
 ### Invoking `moq-pub`:
 Here's how I'm currently testing things, with a local copy of Big Buck Bunny named `bbb_source.mp4`:
@ -29,13 +16,13 @@ Here's how I'm currently testing things, with a local copy of Big Buck Bunny nam
 $ ffmpeg -hide_banner -v quiet -stream_loop -1 -re -i bbb_source.mp4 -an -f mp4 -movflags empty_moov+frag_every_frame+separate_moof+omit_tfhd_offset - | RUST_LOG=moq_pub=info moq-pub -i -
 ```
-This relies on having `moq-quinn` (the relay server) already running locally in another shell.
+This relies on having `moq-relay` (the relay server) already running locally in another shell.
 Note also that we're dropping the audio track (`-an`) above until audio playback is stabilized on the `moq-js` side.
 ### Known issues
- Expects only one H.264/AVC1-encoded video track (catalog generation doesn't support audio tracks yet)
+-   Expects only one H.264/AVC1-encoded video track (catalog generation doesn't support audio tracks yet)
- Doesn't yet gracefully handle EOF - workaround: never stop sending it media (`-stream_loop -1`)
+-   Doesn't yet gracefully handle EOF - workaround: never stop sending it media (`-stream_loop -1`)
- Probably still full of lots of bugs
+-   Probably still full of lots of bugs
- Various other TODOs you can find in the code
+-   Various other TODOs you can find in the code
--- a/moq-pub/src/cli.rs
+++ b/moq-pub/src/cli.rs
@ -1,36 +1,34 @@
-use clap::{Parser, ValueEnum};
+use clap::Parser;
 use std::net;
-#[derive(Parser, Clone)]
+#[derive(Parser, Clone, Debug)]
 #[command(arg_required_else_help(true))]
 pub struct Config {
-	#[arg(long, hide_short_help = true, default_value = "[::]:0")]
+	/// Listen for UDP packets on the given address.
-	pub bind_address: net::SocketAddr,
+	#[arg(long, default_value = "[::]:0")]
 	pub bind: net::SocketAddr,
-	#[arg(short, long, default_value = "https://localhost:4443")]
+	/// Advertise this frame rate in the catalog (informational)
-	pub uri: http::uri::Uri,
+	// TODO auto-detect this from the input when not provided
 	#[arg(long, default_value = "24")]
 	pub fps: u8,
-	#[arg(short, long, required = true, value_parser=input_parser)]
+	/// Advertise this bit rate in the catalog (informational)
-	input: InputValues,
+	// TODO auto-detect this from the input when not provided
 	#[arg(long, default_value = "1500000")]
 	pub bitrate: u32,
-	#[arg(long, hide_short_help = true, default_value = "24")]
+	/// Connect to the given URI starting with moq://
-	pub catalog_fps: u8,
+	#[arg(value_parser = moq_uri)]
-
+	pub uri: http::Uri,
 	#[arg(long, hide_short_help = true, default_value = "1500000")]
 	pub catalog_bit_rate: u32,
 	#[arg(short, long, required = false, default_value = "")]
 	pub namespace: String,
 }
-fn input_parser(s: &str) -> Result<InputValues, String> {
+fn moq_uri(s: &str) -> Result<http::Uri, String> {
-	if s == "-" {
+	let uri = http::Uri::try_from(s).map_err(|e| e.to_string())?;
-		return Ok(InputValues::Stdin);
+
 	// Make sure the scheme is moq
 	if uri.scheme_str() != Some("moq") {
 		return Err("uri scheme must be moq".to_string());
 	}
 	Err("The only currently supported input value is: '-' (stdin)".to_string())
 }
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+	Ok(uri)
 pub enum InputValues {
 	Stdin,
 }
--- a/moq-pub/src/log_viewer.rs
+++ b/moq-pub/src/log_viewer.rs
@ -1,39 +0,0 @@
 use log::{debug, info};
 use tokio::{select, sync::broadcast};
 pub struct LogViewer {
 	incoming_ctl_receiver: broadcast::Receiver<moq_transport::Message>,
 	incoming_obj_receiver: broadcast::Receiver<moq_transport::Object>,
 }
 impl LogViewer {
 	pub async fn new(
 		incoming: (
 			broadcast::Receiver<moq_transport::Message>,
 			broadcast::Receiver<moq_transport::Object>,
 		),
 	) -> anyhow::Result<Self> {
 		Ok(Self {
 			incoming_ctl_receiver: incoming.0,
 			incoming_obj_receiver: incoming.1,
 		})
 	}
 	pub async fn run(&mut self) -> anyhow::Result<()> {
 		debug!("log_viewer.run()");
 		loop {
 			select! {
 			msg = self.incoming_ctl_receiver.recv() => {
 				info!(
 				"Received incoming MOQT Control message: {:?}",
 				&msg?
 			);}
 			obj = self.incoming_obj_receiver.recv() => {
 				info!(
 				"Received incoming MOQT Object with header: {:?}",
 				&obj?
 			);}
 			}
 		}
 	}
 }
--- a/moq-pub/src/main.rs
+++ b/moq-pub/src/main.rs
@ -1,23 +1,13 @@
 use anyhow::Context;
 use clap::Parser;
 use tokio::task::JoinSet;
 mod session_runner;
 use session_runner::*;
 mod media_runner;
 use media_runner::*;
 mod log_viewer;
 use log_viewer::*;
 mod media;
 use media::*;
 mod cli;
 use cli::*;
-use uuid::Uuid;
+mod media;
 use media::*;
 use moq_transport::model::broadcast;
 // TODO: clap complete
@ -25,35 +15,49 @@ use uuid::Uuid;
 async fn main() -> anyhow::Result<()> {
 	env_logger::init();
-	let mut config = Config::parse();
+	let config = Config::parse();
-	if config.namespace.is_empty() {
+	let (publisher, subscriber) = broadcast::new();
-		config.namespace = format!("quic.video/{}", Uuid::new_v4());
+	let mut media = Media::new(&config, publisher).await?;
 	// Ugh, just let me use my native root certs already
 	let mut roots = rustls::RootCertStore::empty();
 	for cert in rustls_native_certs::load_native_certs().expect("could not load platform certs") {
 		roots.add(&rustls::Certificate(cert.0)).unwrap();
 	}
-	let mut media = Media::new(&config).await?;
+	let mut tls_config = rustls::ClientConfig::builder()
-	let session_runner = SessionRunner::new(&config).await?;
+		.with_safe_defaults()
-	let mut log_viewer = LogViewer::new(session_runner.get_incoming_receivers().await).await?;
+		.with_root_certificates(roots)
-	let mut media_runner = MediaRunner::new(
+		.with_no_client_auth();
 		session_runner.get_send_objects().await,
 		session_runner.get_outgoing_senders().await,
 		session_runner.get_incoming_receivers().await,
 	)
 	.await?;
-	let mut join_set: JoinSet<anyhow::Result<()>> = tokio::task::JoinSet::new();
+	tls_config.alpn_protocols = vec![webtransport_quinn::ALPN.to_vec()]; // this one is important
-	join_set.spawn(async { session_runner.run().await.context("failed to run session runner") });
+	let arc_tls_config = std::sync::Arc::new(tls_config);
-	join_set.spawn(async move { log_viewer.run().await.context("failed to run media source") });
+	let quinn_client_config = quinn::ClientConfig::new(arc_tls_config);
-	media_runner.announce(&config.namespace, media.source()).await?;
+	let mut endpoint = quinn::Endpoint::client(config.bind)?;
 	endpoint.set_default_client_config(quinn_client_config);
-	join_set.spawn(async move { media.run().await.context("failed to run media source") });
+	log::info!("connecting to {}", config.uri);
 	join_set.spawn(async move { media_runner.run().await.context("failed to run client") });
-	while let Some(res) = join_set.join_next().await {
+	// Change the uri scheme to "https" for WebTransport
-		dbg!(&res);
+	let mut parts = config.uri.into_parts();
-		res??;
+	parts.scheme = Some(http::uri::Scheme::HTTPS);
 	let uri = http::Uri::from_parts(parts)?;
 	let session = webtransport_quinn::connect(&endpoint, &uri)
 		.await
 		.context("failed to create WebTransport session")?;
 	let session = moq_transport::session::Client::publisher(session, subscriber)
 		.await
 		.context("failed to create MoQ Transport session")?;
 	// TODO run a task that returns a 404 for all unknown subscriptions.
 	tokio::select! {
 		res = session.run() => res.context("session error")?,
 		res = media.run() => res.context("media error")?,
 	}
 	Ok(())
--- a/moq-pub/src/media.rs
+++ b/moq-pub/src/media.rs
@ -1,25 +1,25 @@
 use crate::cli::Config;
 use anyhow::{self, Context};
-use log::{debug, info};
+use moq_transport::model::{broadcast, segment, track};
 use moq_transport::VarInt;
 use moq_warp::model::{segment, track};
 use mp4::{self, ReadBox};
 use serde_json::json;
 use std::collections::HashMap;
 use std::io::Cursor;
 use std::sync::Arc;
 use std::time;
 use tokio::io::AsyncReadExt;
 pub struct Media {
-	// The tracks we're producing.
+	// We hold on to publisher so we don't close then while media is still being published.
-	tracks: HashMap<String, Track>,
+	_broadcast: broadcast::Publisher,
 	_catalog: track::Publisher,
 	_init: track::Publisher,
-	source: Arc<MapSource>,
+	tracks: HashMap<String, Track>,
 }
 impl Media {
-	pub async fn new(config: &Config) -> anyhow::Result<Self> {
+	pub async fn new(config: &Config, mut broadcast: broadcast::Publisher) -> anyhow::Result<Self> {
 		let mut stdin = tokio::io::stdin();
 		let ftyp = read_atom(&mut stdin).await?;
 		anyhow::ensure!(&ftyp[4..8] == b"ftyp", "expected ftyp atom");
@ -38,45 +38,43 @@ impl Media {
 		// Parse the moov box so we can detect the timescales for each track.
 		let moov = mp4::MoovBox::read_box(&mut moov_reader, moov_header.size)?;
-		// Create a source that can be subscribed to.
+		// Create the catalog track with a single segment.
-		let mut source = HashMap::default();
+		let mut init_track = broadcast.create_track("1.mp4")?;
 		let mut init_segment = init_track.create_segment(segment::Info {
 			sequence: VarInt::ZERO,
 			priority: i32::MAX,
 			expires: None,
 		})?;
 		init_segment.write_chunk(init.into())?;
 		let mut tracks = HashMap::new();
 		// Create the init track
 		let init_track_name = "1.mp4";
 		let (_init, subscriber) = Self::create_init(init);
 		source.insert(init_track_name.to_string(), subscriber);
 		for trak in &moov.traks {
 			let id = trak.tkhd.track_id;
 			let name = id.to_string();
 			//let name = "2".to_string();
 			//dbg!("trak name: {}", &name);
 			let timescale = track_timescale(&moov, id);
 			// Store the track publisher in a map so we can update it later.
-			let track = Track::new(&name, timescale);
+			let track = broadcast.create_track(&name)?;
-			source.insert(name.to_string(), track.subscribe());
+			let track = Track::new(track, timescale);
 			tracks.insert(name, track);
 		}
 		let mut catalog = broadcast.create_track(".catalog")?;
 		// Create the catalog track
-		let (_catalog, subscriber) = Self::create_catalog(
+		Self::serve_catalog(&mut catalog, config, init_track.name.to_string(), &moov, &tracks)?;
 			config,
 			config.namespace.to_string(),
 			init_track_name.to_string(),
 			&moov,
 			&tracks,
 		)?;
 		source.insert(".catalog".to_string(), subscriber);
-		let source = Arc::new(MapSource(source));
+		Ok(Media {
-
+			_broadcast: broadcast,
-		Ok(Media { tracks, source })
+			_catalog: catalog,
 			_init: init_track,
 			tracks,
 		})
 	}
 	pub async fn run(&mut self) -> anyhow::Result<()> {
 		let mut stdin = tokio::io::stdin();
 		// The current track name
@ -122,45 +120,18 @@ impl Media {
 		}
 	}
-	fn create_init(raw: Vec<u8>) -> (track::Publisher, track::Subscriber) {
+	fn serve_catalog(
-		// Create a track with a single segment containing the init data.
+		track: &mut track::Publisher,
 		let mut init_track = track::Publisher::new("1.mp4");
 		// Subscribe to the init track before we push the segment.
 		let subscriber = init_track.subscribe();
 		let mut segment = segment::Publisher::new(segment::Info {
 			sequence: VarInt::from_u32(0), // first and only segment
 			send_order: i32::MIN,          // highest priority
 			expires: None,                 // never delete from the cache
 		});
 		// Add the segment and add the fragment.
 		init_track.push_segment(segment.subscribe());
 		segment.fragments.push(raw.into());
 		// Return the catalog
 		(init_track, subscriber)
 	}
 	fn create_catalog(
 		config: &Config,
 		namespace: String,
 		init_track_name: String,
 		moov: &mp4::MoovBox,
 		_tracks: &HashMap<String, Track>,
-	) -> Result<(track::Publisher, track::Subscriber), anyhow::Error> {
+	) -> Result<(), anyhow::Error> {
-		// Create a track with a single segment containing the init data.
+		let mut segment = track.create_segment(segment::Info {
-		let mut catalog_track = track::Publisher::new(".catalog");
+			sequence: VarInt::ZERO,
-
+			priority: i32::MAX,
-		// Subscribe to the catalog before we push the segment.
+			expires: None,
-		let catalog_subscriber = catalog_track.subscribe();
+		})?;
 		let mut segment = segment::Publisher::new(segment::Info {
 			sequence: VarInt::from_u32(0), // first and only segment
 			send_order: i32::MIN,          // highest priority
 			expires: None,                 // never delete from the cache
 		});
 		// avc1[.PPCCLL]
 		//
@ -192,30 +163,24 @@ impl Media {
 			"tracks": [
 				{
 				"container": "mp4",
 				"namespace": namespace,
 				"kind": "video",
 				"init_track": init_track_name,
 				"data_track": "1", // assume just one track for now
 				"codec": codec_str,
 				"width": width,
 				"height": height,
-				"frame_rate": config.catalog_fps,
+				"frame_rate": config.fps,
-				"bit_rate": config.catalog_bit_rate,
+				"bit_rate": config.bitrate,
 				}
 			]
 		});
 		let catalog_str = serde_json::to_string_pretty(&catalog)?;
-		info!("catalog: {}", catalog_str);
+		log::info!("catalog: {}", catalog_str);
 		// Add the segment and add the fragment.
-		catalog_track.push_segment(segment.subscribe());
+		segment.write_chunk(catalog_str.into())?;
 		segment.fragments.push(catalog_str.into());
-		// Return the catalog
+		Ok(())
 		Ok((catalog_track, catalog_subscriber))
 	}
 	pub fn source(&self) -> Arc<MapSource> {
 		self.source.clone()
 	}
 }
@ -230,8 +195,6 @@ async fn read_atom<R: AsyncReadExt + Unpin>(reader: &mut R) -> anyhow::Result<Ve
 	let mut raw = buf.to_vec();
 	debug!("size: {}", &size);
 	let mut limit = match size {
 		// Runs until the end of the file.
 		0 => reader.take(u64::MAX),
@ -249,13 +212,11 @@ async fn read_atom<R: AsyncReadExt + Unpin>(reader: &mut R) -> anyhow::Result<Ve
 			anyhow::bail!("impossible box size: {}", size)
 		}
 		// Otherwise read based on the size.
 		size => reader.take(size - 8),
 	};
 	// Append to the vector and return it.
-	let read_bytes = limit.read_to_end(&mut raw).await?;
+	let _read_bytes = limit.read_to_end(&mut raw).await?;
 	debug!("read_bytes: {}", read_bytes);
 	Ok(raw)
 }
@ -275,9 +236,7 @@ struct Track {
 }
 impl Track {
-	fn new(name: &str, timescale: u64) -> Self {
+	fn new(track: track::Publisher, timescale: u64) -> Self {
 		let track = track::Publisher::new(name);
 		Self {
 			track,
 			sequence: 0,
@ -290,13 +249,12 @@ impl Track {
 		if let Some(segment) = self.segment.as_mut() {
 			if !fragment.keyframe {
 				// Use the existing segment
-				segment.fragments.push(raw.into());
+				segment.write_chunk(raw.into())?;
 				return Ok(());
 			}
 		}
 		// Otherwise make a new segment
 		let now = time::Instant::now();
 		// Compute the timestamp in milliseconds.
 		// Overflows after 583 million years, so we're fine.
@ -306,50 +264,32 @@ impl Track {
 			.try_into()
 			.context("timestamp too large")?;
-		// The send order is simple; newer timestamps should be higher priority.
+		// Create a new segment.
-		// TODO give audio a boost?
+		let mut segment = self.track.create_segment(segment::Info {
-		// TODO Use timestamps for prioritization again after quinn priority bug fixed
+			sequence: VarInt::try_from(self.sequence).context("sequence too large")?,
-		let send_order = i32::MIN;
+			priority: i32::MAX, // TODO
-		// Delete segments after 10s.
+			// Delete segments after 10s.
-		let expires = Some(now + time::Duration::from_secs(10)); // TODO increase this once send order is implemented
+			expires: Some(time::Duration::from_secs(10)),
-		let sequence = self.sequence.try_into().context("sequence too large")?;
+		})?;
 		self.sequence += 1;
 		// Create a new segment.
 		let segment = segment::Info {
 			sequence,
 			expires,
 			send_order,
 		};
 		let mut segment = segment::Publisher::new(segment);
 		self.track.push_segment(segment.subscribe());
 		// Insert the raw atom into the segment.
-		segment.fragments.push(raw.into());
+		segment.write_chunk(raw.into())?;
 		// Save for the next iteration
 		self.segment = Some(segment);
 		// Remove any segments older than 10s.
 		// TODO This can only drain from the FRONT of the queue, so don't get clever with expirations.
 		self.track.drain_segments(now);
 		Ok(())
 	}
 	pub fn data(&mut self, raw: Vec<u8>) -> anyhow::Result<()> {
 		let segment = self.segment.as_mut().context("missing segment")?;
-		segment.fragments.push(raw.into());
+		segment.write_chunk(raw.into())?;
 		Ok(())
 	}
 	pub fn subscribe(&self) -> track::Subscriber {
 		self.track.subscribe()
 	}
 }
 struct Fragment {
@ -434,16 +374,3 @@ fn track_timescale(moov: &mp4::MoovBox, track_id: u32) -> u64 {
 	trak.mdia.mdhd.timescale as u64
 }
 pub trait Source {
 	fn subscribe(&self, name: &str) -> Option<track::Subscriber>;
 }
 #[derive(Clone, Default, Debug)]
 pub struct MapSource(pub HashMap<String, track::Subscriber>);
 impl Source for MapSource {
 	fn subscribe(&self, name: &str) -> Option<track::Subscriber> {
 		self.0.get(name).cloned()
 	}
 }
--- a/moq-pub/src/media_runner.rs
+++ b/moq-pub/src/media_runner.rs
@ -1,159 +0,0 @@
 use crate::media::{self, MapSource};
 use anyhow::bail;
 use log::{debug, error};
 use moq_transport::message::Message;
 use moq_transport::message::{Announce, SubscribeError, SubscribeOk};
 use moq_transport::{object, Object, VarInt};
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::io::AsyncWriteExt;
 use tokio::sync::broadcast;
 use tokio::sync::mpsc;
 use tokio::task::JoinSet;
 use webtransport_generic::Session as WTSession;
 pub struct MediaRunner<S: WTSession> {
 	send_objects: object::Sender<S>,
 	outgoing_ctl_sender: mpsc::Sender<Message>,
 	incoming_ctl_receiver: broadcast::Receiver<Message>,
 	source: Arc<MapSource>,
 }
 impl<S: WTSession> MediaRunner<S> {
 	pub async fn new(
 		send_objects: object::Sender<S>,
 		outgoing: mpsc::Sender<Message>,
 		incoming: (broadcast::Receiver<Message>, broadcast::Receiver<Object>),
 	) -> anyhow::Result<Self> {
 		let outgoing_ctl_sender = outgoing;
 		let (incoming_ctl_receiver, _incoming_obj_receiver) = incoming;
 		Ok(Self {
 			send_objects,
 			outgoing_ctl_sender,
 			incoming_ctl_receiver,
 			source: Arc::new(MapSource::default()),
 		})
 	}
 	pub async fn announce(&mut self, namespace: &str, source: Arc<media::MapSource>) -> anyhow::Result<()> {
 		debug!("media_runner.announce()");
 		// Only allow one souce at a time for now?
 		self.source = source;
 		// ANNOUNCE the namespace
 		self.outgoing_ctl_sender
 			.send(Message::Announce(Announce {
 				track_namespace: namespace.to_string(),
 			}))
 			.await?;
 		// wait for the go ahead
 		loop {
 			match self.incoming_ctl_receiver.recv().await? {
 				Message::AnnounceOk(_) => {
 					break;
 				}
 				Message::AnnounceError(announce_error) => {
 					error!(
 						"Failed to announce namespace '{}' with error code '{}' and reason '{}'",
 						&namespace, &announce_error.code, &announce_error.reason
 					);
 					// TODO: Think about how to recover here? Retry?
 					bail!("Failed to announce namespace");
 				}
 				_ => {
 					// TODO: work out how to ignore unknown/unrelated messages here without consuming them prematurely
 				}
 			}
 		}
 		Ok(())
 	}
 	pub async fn run(&mut self) -> anyhow::Result<()> {
 		debug!("media_runner.run()");
 		let source = self.source.clone();
 		let mut join_set: JoinSet<anyhow::Result<()>> = tokio::task::JoinSet::new();
 		let mut track_dispatcher: HashMap<String, tokio::sync::mpsc::Sender<VarInt>> = HashMap::new();
 		let mut incoming_ctl_receiver = self.incoming_ctl_receiver.resubscribe();
 		let outgoing_ctl_sender = self.outgoing_ctl_sender.clone();
 		// Pre-spawn tasks for each track we have
 		// and let them .await on receiving the go ahead via a channel
 		for (track_name, track) in source.0.iter() {
 			let (sender, mut receiver) = tokio::sync::mpsc::channel(1);
 			track_dispatcher.insert(track_name.to_string(), sender);
 			let mut objects = self.send_objects.clone();
 			let mut track = track.clone();
 			join_set.spawn(async move {
 				let track_id = receiver.recv().await.ok_or(anyhow::anyhow!("channel closed"))?;
 				// TODO: validate track_id is valid (not already in use), for now just trust subscribers are correct
 				loop {
 					let mut segment = track.next_segment().await?;
 					debug!("segment: {:?}", &segment);
 					let object = Object {
 						track: track_id,
 						group: segment.sequence,
 						sequence: VarInt::from_u32(0), // Always zero since we send an entire group as an object
 						send_order: segment.send_order,
 					};
 					debug!("object: {:?}", &object);
 					let mut stream = objects.open(object).await?;
 					// Write each fragment as they are available.
 					while let Some(fragment) = segment.fragments.next().await {
 						stream.write_all(&fragment).await?;
 					}
 				}
 			});
 		}
 		join_set.spawn(async move {
 			loop {
 				if let Message::Subscribe(subscribe) = incoming_ctl_receiver.recv().await? {
 					debug!("Received a subscription request");
 					let track_id = subscribe.track_id;
 					let track_name = subscribe.track_name;
 					debug!("Looking up track_name: {} (track_id: {})", &track_name, &track_id);
 					// Look up track in source
 					match source.0.get(&track_name.to_string()) {
 						None => {
 							// if track !exist, send subscribe error
 							outgoing_ctl_sender
 								.send(Message::SubscribeError(SubscribeError {
 									track_id: subscribe.track_id,
 									code: moq_transport::VarInt::from_u32(1),
 									reason: "Only bad reasons (don't know what that track is)".to_string(),
 								}))
 								.await?;
 						}
 						// if track exists, send go-ahead signal to unblock task to send data to subscriber
 						Some(track) => {
 							debug!("We have the track! (Good news everyone)");
 							track_dispatcher
 								.get(&track.name)
 								.ok_or(anyhow::anyhow!("missing task for track"))?
 								.send(track_id)
 								.await?;
 							outgoing_ctl_sender
 								.send(Message::SubscribeOk(SubscribeOk {
 									track_id: subscribe.track_id,
 									expires: Some(VarInt::from_u32(0)), // valid until unsubscribed
 								}))
 								.await?;
 						}
 					};
 				}
 			}
 		});
 		while let Some(res) = join_set.join_next().await {
 			debug!("MediaRunner task finished with result: {:?}", &res);
 		}
 		Ok(())
 	}
 }
--- a/moq-pub/src/session_runner.rs
+++ b/moq-pub/src/session_runner.rs
@ -1,122 +0,0 @@
 use crate::cli::Config;
 use anyhow::Context;
 use log::debug;
 use moq_transport::{object, Object};
 use tokio::sync::broadcast;
 use tokio::sync::mpsc;
 use tokio::task::JoinSet;
 pub struct SessionRunner {
 	moq_transport_session: moq_transport::Session<webtransport_quinn::Session>,
 	outgoing_ctl_sender: mpsc::Sender<moq_transport::Message>,
 	outgoing_ctl_receiver: mpsc::Receiver<moq_transport::Message>,
 	incoming_ctl_sender: broadcast::Sender<moq_transport::Message>,
 	incoming_obj_sender: broadcast::Sender<Object>,
 }
 impl SessionRunner {
 	pub async fn new(config: &Config) -> anyhow::Result<Self> {
 		let mut roots = rustls::RootCertStore::empty();
 		for cert in rustls_native_certs::load_native_certs().expect("could not load platform certs") {
 			roots.add(&rustls::Certificate(cert.0)).unwrap();
 		}
 		let mut tls_config = rustls::ClientConfig::builder()
 			.with_safe_defaults()
 			.with_root_certificates(roots)
 			.with_no_client_auth();
 		tls_config.alpn_protocols = vec![webtransport_quinn::ALPN.to_vec()]; // this one is important
 		let arc_tls_config = std::sync::Arc::new(tls_config);
 		let quinn_client_config = quinn::ClientConfig::new(arc_tls_config);
 		let mut endpoint = quinn::Endpoint::client(config.bind_address)?;
 		endpoint.set_default_client_config(quinn_client_config);
 		let webtransport_session = webtransport_quinn::connect(&endpoint, &config.uri)
 			.await
 			.context("failed to create WebTransport session")?;
 		let moq_transport_session =
 			moq_transport::Session::connect(webtransport_session, moq_transport::setup::Role::Both)
 				.await
 				.context("failed to create MoQ Transport session")?;
 		// outgoing ctl msgs
 		let (outgoing_ctl_sender, outgoing_ctl_receiver) = mpsc::channel(5);
 		// incoming ctl msg
 		let (incoming_ctl_sender, _incoming_ctl_receiver) = broadcast::channel(5);
 		// incoming objs
 		let (incoming_obj_sender, _incoming_obj_receiver) = broadcast::channel(5);
 		Ok(SessionRunner {
 			moq_transport_session,
 			outgoing_ctl_sender,
 			outgoing_ctl_receiver,
 			incoming_ctl_sender,
 			incoming_obj_sender,
 		})
 	}
 	pub async fn get_outgoing_senders(&self) -> mpsc::Sender<moq_transport::Message> {
 		self.outgoing_ctl_sender.clone()
 	}
 	pub async fn get_incoming_receivers(
 		&self,
 	) -> (
 		broadcast::Receiver<moq_transport::Message>,
 		broadcast::Receiver<moq_transport::Object>,
 	) {
 		(
 			self.incoming_ctl_sender.subscribe(),
 			self.incoming_obj_sender.subscribe(),
 		)
 	}
 	pub async fn run(mut self) -> anyhow::Result<()> {
 		debug!("session_runner.run()");
 		let mut join_set: JoinSet<anyhow::Result<()>> = tokio::task::JoinSet::new();
 		// Send outgoing control messages
 		join_set.spawn(async move {
 			loop {
 				let msg = self
 					.outgoing_ctl_receiver
 					.recv()
 					.await
 					.ok_or(anyhow::anyhow!("error receiving outbound control message"))?;
 				debug!("Sending outgoing MOQT Control Message: {:?}", &msg);
 				self.moq_transport_session.send_control.send(msg).await?;
 			}
 		});
 		// Route incoming Control messages
 		join_set.spawn(async move {
 			loop {
 				let msg = self.moq_transport_session.recv_control.recv().await?;
 				self.incoming_ctl_sender.send(msg)?;
 			}
 		});
 		// Route incoming Objects headers
 		// NOTE: Only sends the headers for incoming objects, not the associated streams
 		// We don't currently expose any way to read incoming bytestreams because we don't expect any
 		join_set.spawn(async move {
 			loop {
 				let receive_stream = self.moq_transport_session.recv_objects.recv().await?;
 				self.incoming_obj_sender.send(receive_stream.0)?;
 			}
 		});
 		while let Some(res) = join_set.join_next().await {
 			debug!("SessionRunner task finished with result: {:?}", &res);
 			let _ = res?; // if we finish, it'll be with an error, which we can return
 		}
 		Ok(())
 	}
 	pub async fn get_send_objects(&self) -> object::Sender<webtransport_quinn::Session> {
 		self.moq_transport_session.send_objects.clone()
 	}
 }
--- a/moq-relay/Cargo.toml
+++ b/moq-relay/Cargo.toml
@ -1,5 +1,5 @@
 [package]
-name = "moq-quinn"
+name = "moq-relay"
 description = "Media over QUIC"
 authors = ["Luke Curley"]
 repository = "https://github.com/kixelated/moq-rs"
@ -11,14 +11,8 @@ edition = "2021"
 keywords = ["quic", "http3", "webtransport", "media", "live"]
 categories = ["multimedia", "network-programming", "web-programming"]
 default-run = "moq-quinn"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 moq-transport = { path = "../moq-transport" }
 moq-warp = { path = "../moq-warp" }
 # QUIC
 quinn = "0.10"
@ -42,3 +36,5 @@ clap = { version = "4.0", features = ["derive"] }
 log = { version = "0.4", features = ["std"] }
 env_logger = "0.9.3"
 anyhow = "1.0.70"
 tracing = "0.1"
 tracing-subscriber = "0.3.0"
--- a/moq-relay/README.md
+++ b/moq-relay/README.md
@ -0,0 +1,17 @@
 # moq-relay
 A server that connects publishing clients to subscribing clients.
 All subscriptions are deduplicated and cached, so that a single publisher can serve many subscribers.
 ## Usage
 The publisher must choose a unique name for their broadcast, sent as the WebTransport path when connecting to the server.
 We currently do a dumb string comparison, so capatilization matters as do slashes.
 For example: `CONNECT https://relay.quic.video/BigBuckBunny`
 The MoqTransport handshake includes a `role` parameter, which must be `publisher` or `subscriber`.
 The specification allows a `both` role but you'll get an error.
 You can have one publisher and any number of subscribers connected to the same path.
 If the publisher disconnects, then all subscribers receive an error and will not get updates, even if a new publisher reuses the path.
--- a/moq-relay/src/config.rs
+++ b/moq-relay/src/config.rs
@ -0,0 +1,23 @@
 use std::{net, path};
 use clap::Parser;
 /// Search for a pattern in a file and display the lines that contain it.
 #[derive(Parser, Clone)]
 pub struct Config {
 	/// Listen on this address
 	#[arg(long, default_value = "[::]:4443")]
 	pub bind: net::SocketAddr,
 	/// Use the certificate file at this path
 	#[arg(long)]
 	pub cert: path::PathBuf,
 	/// Use the private key at this path
 	#[arg(long)]
 	pub key: path::PathBuf,
 	/// Listen on HTTPS and serve /fingerprint, for self-signed certificates
 	#[arg(long, action)]
 	pub fingerprint: bool,
 }
--- a/moq-relay/src/main.rs
+++ b/moq-relay/src/main.rs
@ -1,59 +1,45 @@
-use std::{fs, io, net, path, sync};
+use std::{fs, io, sync};
 use anyhow::Context;
 use clap::Parser;
 use ring::digest::{digest, SHA256};
 use warp::Filter;
 mod config;
 mod server;
-use server::*;
+mod session;
-/// Search for a pattern in a file and display the lines that contain it.
+pub use config::*;
-#[derive(Parser, Clone)]
+pub use server::*;
-struct Cli {
+pub use session::*;
 	/// Listen on this address
 	#[arg(short, long, default_value = "[::]:4443")]
 	addr: net::SocketAddr,
 	/// Use the certificate file at this path
 	#[arg(short, long, default_value = "cert/localhost.crt")]
 	cert: path::PathBuf,
 	/// Use the private key at this path
 	#[arg(short, long, default_value = "cert/localhost.key")]
 	key: path::PathBuf,
 }
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
 	env_logger::init();
-	let args = Cli::parse();
+	// Disable tracing so we don't get a bunch of Quinn spam.
 	let tracer = tracing_subscriber::FmtSubscriber::builder()
 		.with_max_level(tracing::Level::WARN)
 		.finish();
 	tracing::subscriber::set_global_default(tracer).unwrap();
-	// Create a web server to serve the fingerprint
+	let config = Config::parse();
 	let serve = serve_http(args.clone());
 	// Create a server to actually serve the media
-	let config = ServerConfig {
+	let server = Server::new(config.clone()).context("failed to create server")?;
 		addr: args.addr,
 		cert: args.cert,
 		key: args.key,
 	};
 	let server = Server::new(config).context("failed to create server")?;
 	// Run all of the above
 	tokio::select! {
 		res = server.run() => res.context("failed to run server"),
-		res = serve => res.context("failed to run HTTP server"),
+		res = serve_http(config), if config.fingerprint => res.context("failed to run HTTP server"),
 	}
 }
 // Run a HTTP server using Warp
 // TODO remove this when Chrome adds support for self-signed certificates using WebTransport
-async fn serve_http(args: Cli) -> anyhow::Result<()> {
+async fn serve_http(config: Config) -> anyhow::Result<()> {
 	// Read the PEM certificate file
-	let crt = fs::File::open(&args.cert)?;
+	let crt = fs::File::open(&config.cert)?;
 	let mut crt = io::BufReader::new(crt);
 	// Parse the DER certificate
@ -75,9 +61,9 @@ async fn serve_http(args: Cli) -> anyhow::Result<()> {
 	warp::serve(routes)
 		.tls()
-		.cert_path(args.cert)
+		.cert_path(config.cert)
-		.key_path(args.key)
+		.key_path(config.key)
-		.run(args.addr)
+		.run(config.bind)
 		.await;
 	Ok(())
--- a/moq-relay/src/server.rs
+++ b/moq-relay/src/server.rs
@ -1,29 +1,30 @@
-use std::{fs, io, net, path, sync, time};
+use std::{
 	collections::HashMap,
 	fs, io,
 	sync::{Arc, Mutex},
 	time,
 };
 use anyhow::Context;
-use moq_warp::relay;
+use moq_transport::model::broadcast;
 use tokio::task::JoinSet;
 use crate::{Config, Session};
 pub struct Server {
 	server: quinn::Endpoint,
 	// The media sources.
 	broker: relay::Broker,
 	// The active connections.
 	conns: JoinSet<anyhow::Result<()>>,
 }
-pub struct ServerConfig {
+	// The map of active broadcasts by path.
-	pub addr: net::SocketAddr,
+	broadcasts: Arc<Mutex<HashMap<String, broadcast::Subscriber>>>,
 	pub cert: path::PathBuf,
 	pub key: path::PathBuf,
 }
 impl Server {
 	// Create a new server
-	pub fn new(config: ServerConfig) -> anyhow::Result<Self> {
+	pub fn new(config: Config) -> anyhow::Result<Self> {
 		// Read the PEM certificate chain
 		let certs = fs::File::open(config.cert).context("failed to open cert file")?;
 		let mut certs = io::BufReader::new(certs);
@ -51,21 +52,25 @@ impl Server {
 		tls_config.max_early_data_size = u32::MAX;
 		tls_config.alpn_protocols = vec![webtransport_quinn::ALPN.to_vec()];
-		let mut server_config = quinn::ServerConfig::with_crypto(sync::Arc::new(tls_config));
+		let mut server_config = quinn::ServerConfig::with_crypto(Arc::new(tls_config));
 		// Enable BBR congestion control
 		// TODO validate the implementation
 		let mut transport_config = quinn::TransportConfig::default();
 		transport_config.keep_alive_interval(Some(time::Duration::from_secs(2)));
-		transport_config.congestion_controller_factory(sync::Arc::new(quinn::congestion::BbrConfig::default()));
+		transport_config.congestion_controller_factory(Arc::new(quinn::congestion::BbrConfig::default()));
-		server_config.transport = sync::Arc::new(transport_config);
+		server_config.transport = Arc::new(transport_config);
-		let server = quinn::Endpoint::server(server_config, config.addr)?;
+		let server = quinn::Endpoint::server(server_config, config.bind)?;
 		let broker = relay::Broker::new();
 		let broadcasts = Default::default();
 		let conns = JoinSet::new();
-		Ok(Self { server, broker, conns })
+		Ok(Self {
 			server,
 			broadcasts,
 			conns,
 		})
 	}
 	pub async fn run(mut self) -> anyhow::Result<()> {
@ -73,44 +78,16 @@ impl Server {
 			tokio::select! {
 				res = self.server.accept() => {
 					let conn = res.context("failed to accept QUIC connection")?;
-					let broker = self.broker.clone();
+					let mut session = Session::new(self.broadcasts.clone());
-
+					self.conns.spawn(async move { session.run(conn).await });
 					self.conns.spawn(async move { Self::handle(conn, broker).await });
 				},
 				res = self.conns.join_next(), if !self.conns.is_empty() => {
 					let res = res.expect("no tasks").expect("task aborted");
 					if let Err(err) = res {
-						log::error!("connection terminated: {:?}", err);
+						log::warn!("connection terminated: {:?}", err);
 					}
 				},
 			}
 		}
 	}
 	async fn handle(conn: quinn::Connecting, broker: relay::Broker) -> anyhow::Result<()> {
 		// Wait for the QUIC connection to be established.
 		let conn = conn.await.context("failed to establish QUIC connection")?;
 		// Wait for the CONNECT request.
 		let request = webtransport_quinn::accept(conn)
 			.await
 			.context("failed to receive WebTransport request")?;
 		// TODO parse the request URI
 		// Accept the CONNECT request.
 		let session = request
 			.ok()
 			.await
 			.context("failed to respond to WebTransport request")?;
 		// Perform the MoQ handshake.
 		let session = moq_transport::Session::accept(session, moq_transport::setup::Role::Both)
 			.await
 			.context("failed to perform MoQ handshake")?;
 		// Run the relay code.
 		let session = relay::Session::new(session, broker);
 		session.run().await
 	}
 }
--- a/moq-relay/src/session.rs
+++ b/moq-relay/src/session.rs
@ -0,0 +1,96 @@
 use std::{
 	collections::{hash_map, HashMap},
 	sync::{Arc, Mutex},
 };
 use anyhow::Context;
 use moq_transport::{model::broadcast, session::Request, setup::Role};
 #[derive(Clone)]
 pub struct Session {
 	broadcasts: Arc<Mutex<HashMap<String, broadcast::Subscriber>>>,
 }
 impl Session {
 	pub fn new(broadcasts: Arc<Mutex<HashMap<String, broadcast::Subscriber>>>) -> Self {
 		Self { broadcasts }
 	}
 	pub async fn run(&mut self, conn: quinn::Connecting) -> anyhow::Result<()> {
 		// Wait for the QUIC connection to be established.
 		let conn = conn.await.context("failed to establish QUIC connection")?;
 		// Wait for the CONNECT request.
 		let request = webtransport_quinn::accept(conn)
 			.await
 			.context("failed to receive WebTransport request")?;
 		let path = request.uri().path().to_string();
 		// Accept the CONNECT request.
 		let session = request
 			.ok()
 			.await
 			.context("failed to respond to WebTransport request")?;
 		// Perform the MoQ handshake.
 		let request = moq_transport::session::Server::accept(session)
 			.await
 			.context("failed to accept handshake")?;
 		let role = request.role();
 		match role {
 			Role::Publisher => self.serve_publisher(request, &path).await,
 			Role::Subscriber => self.serve_subscriber(request, &path).await,
 			Role::Both => request.reject(300),
 		};
 		Ok(())
 	}
 	async fn serve_publisher(&mut self, request: Request, path: &str) {
 		log::info!("publisher: path={}", path);
 		let (publisher, subscriber) = broadcast::new();
 		match self.broadcasts.lock().unwrap().entry(path.to_string()) {
 			hash_map::Entry::Occupied(_) => return request.reject(409),
 			hash_map::Entry::Vacant(entry) => entry.insert(subscriber),
 		};
 		if let Err(err) = self.run_publisher(request, publisher).await {
 			log::warn!("pubisher error: path={} err={:?}", path, err);
 		}
 		self.broadcasts.lock().unwrap().remove(path);
 	}
 	async fn run_publisher(&mut self, request: Request, publisher: broadcast::Publisher) -> anyhow::Result<()> {
 		let session = request.subscriber(publisher).await?;
 		session.run().await?;
 		Ok(())
 	}
 	async fn serve_subscriber(&mut self, request: Request, path: &str) {
 		log::info!("subscriber: path={}", path);
 		let broadcast = match self.broadcasts.lock().unwrap().get(path) {
 			Some(broadcast) => broadcast.clone(),
 			None => {
 				return request.reject(404);
 			}
 		};
 		if let Err(err) = self.run_subscriber(request, broadcast).await {
 			log::warn!("subscriber error: path={} err={:?}", path, err);
 		}
 	}
 	async fn run_subscriber(&mut self, request: Request, broadcast: broadcast::Subscriber) -> anyhow::Result<()> {
 		let session = request.publisher(broadcast).await?;
 		session.run().await?;
 		Ok(())
 	}
 }
--- a/moq-transport/Cargo.toml
+++ b/moq-transport/Cargo.toml
@ -5,7 +5,7 @@ authors = ["Luke Curley"]
 repository = "https://github.com/kixelated/moq-rs"
 license = "MIT OR Apache-2.0"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 keywords = ["quic", "http3", "webtransport", "media", "live"]
@ -18,5 +18,9 @@ categories = ["multimedia", "network-programming", "web-programming"]
 bytes = "1.4"
 thiserror = "1"
 anyhow = "1"
-webtransport-generic = "0.5"
+tokio = { version = "1.27", features = ["macros", "io-util", "sync"] }
-tokio = { version = "1.27", features = ["macros", "io-util", "rt", "sync"] }
+log = "0.4"
 indexmap = "2"
 quinn = "0.10"
 webtransport-quinn = "0.5.2"
--- a/moq-transport/README.md
+++ b/moq-transport/README.md
@ -0,0 +1,10 @@
 [![Documentation](https://docs.rs/moq-transport/badge.svg)](https://docs.rs/moq-transport/)
 [![Crates.io](https://img.shields.io/crates/v/moq-transport.svg)](https://crates.io/crates/moq-transport)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE-MIT)
 # moq-transport
 A Rust implementation of the proposed IETF standard.
 [Specification](https://datatracker.ietf.org/doc/draft-ietf-moq-transport/)
 [Github](https://github.com/moq-wg/moq-transport)
--- a/moq-transport/src/coding/decode.rs
+++ b/moq-transport/src/coding/decode.rs
@ -1,8 +1,14 @@
-use super::VarInt;
+use super::{BoundsExceeded, VarInt};
 use std::str;
 use thiserror::Error;
 // I'm too lazy to add these trait bounds to every message type.
 // TODO Use trait aliases when they're stable, or add these bounds to every method.
 pub trait AsyncRead: tokio::io::AsyncRead + Unpin + Send {}
 impl AsyncRead for webtransport_quinn::RecvStream {}
 /// A decode error.
 #[derive(Error, Debug)]
 pub enum DecodeError {
 	#[error("unexpected end of buffer")]
@ -14,6 +20,9 @@ pub enum DecodeError {
 	#[error("invalid type: {0:?}")]
 	InvalidType(VarInt),
 	#[error("varint bounds exceeded")]
 	BoundsExceeded(#[from] BoundsExceeded),
 	#[error("io error: {0}")]
 	IoError(#[from] std::io::Error),
 }
--- a/moq-transport/src/coding/encode.rs
+++ b/moq-transport/src/coding/encode.rs
@ -2,11 +2,20 @@ use super::BoundsExceeded;
 use thiserror::Error;
 // I'm too lazy to add these trait bounds to every message type.
 // TODO Use trait aliases when they're stable, or add these bounds to every method.
 pub trait AsyncWrite: tokio::io::AsyncWrite + Unpin + Send {}
 impl AsyncWrite for webtransport_quinn::SendStream {}
 /// An encode error.
 #[derive(Error, Debug)]
 pub enum EncodeError {
 	#[error("varint too large")]
 	BoundsExceeded(#[from] BoundsExceeded),
 	#[error("invalid value")]
 	InvalidValue,
 	#[error("i/o error: {0}")]
 	IoError(#[from] std::io::Error),
 }
--- a/moq-transport/src/coding/string.rs
+++ b/moq-transport/src/coding/string.rs
@ -1,20 +1,22 @@
 use std::cmp::min;
 use crate::coding::{AsyncRead, AsyncWrite};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use webtransport_generic::{RecvStream, SendStream};
 use crate::VarInt;
 use super::{DecodeError, EncodeError};
-pub async fn encode_string<W: SendStream>(s: &str, w: &mut W) -> Result<(), EncodeError> {
+/// Encode a string with a varint length prefix.
 pub async fn encode_string<W: AsyncWrite>(s: &str, w: &mut W) -> Result<(), EncodeError> {
 	let size = VarInt::try_from(s.len())?;
 	size.encode(w).await?;
 	w.write_all(s.as_ref()).await?;
 	Ok(())
 }
-pub async fn decode_string<R: RecvStream>(r: &mut R) -> Result<String, DecodeError> {
+/// Decode a string with a varint length prefix.
 pub async fn decode_string<R: AsyncRead>(r: &mut R) -> Result<String, DecodeError> {
 	let size = VarInt::decode(r).await?.into_inner();
 	let mut str = String::with_capacity(min(1024, size) as usize);
 	r.take(size).read_to_string(&mut str).await?;
--- a/moq-transport/src/coding/varint.rs
+++ b/moq-transport/src/coding/varint.rs
@ -5,14 +5,14 @@
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
 use crate::coding::{AsyncRead, AsyncWrite};
 use thiserror::Error;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use webtransport_generic::{RecvStream, SendStream};
 use super::{DecodeError, EncodeError};
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Error)]
-#[error("value too large for varint encoding")]
+#[error("value out of range")]
 pub struct BoundsExceeded;
 /// An integer less than 2^62
@ -24,8 +24,12 @@ pub struct BoundsExceeded;
 pub struct VarInt(u64);
 impl VarInt {
 	/// The largest possible value.
 	pub const MAX: Self = Self((1 << 62) - 1);
 	/// The smallest possible value.
 	pub const ZERO: Self = Self(0);
 	/// Construct a `VarInt` infallibly using the largest available type.
 	/// Larger values need to use `try_from` instead.
 	pub const fn from_u32(x: u32) -> Self {
@ -109,6 +113,45 @@ impl TryFrom<usize> for VarInt {
 	}
 }
 impl TryFrom<VarInt> for u32 {
 	type Error = BoundsExceeded;
 	/// Succeeds iff `x` < 2^32
 	fn try_from(x: VarInt) -> Result<Self, BoundsExceeded> {
 		if x.0 <= u32::MAX.into() {
 			Ok(x.0 as u32)
 		} else {
 			Err(BoundsExceeded)
 		}
 	}
 }
 impl TryFrom<VarInt> for u16 {
 	type Error = BoundsExceeded;
 	/// Succeeds iff `x` < 2^16
 	fn try_from(x: VarInt) -> Result<Self, BoundsExceeded> {
 		if x.0 <= u16::MAX.into() {
 			Ok(x.0 as u16)
 		} else {
 			Err(BoundsExceeded)
 		}
 	}
 }
 impl TryFrom<VarInt> for u8 {
 	type Error = BoundsExceeded;
 	/// Succeeds iff `x` < 2^8
 	fn try_from(x: VarInt) -> Result<Self, BoundsExceeded> {
 		if x.0 <= u8::MAX.into() {
 			Ok(x.0 as u8)
 		} else {
 			Err(BoundsExceeded)
 		}
 	}
 }
 impl fmt::Debug for VarInt {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		self.0.fmt(f)
@ -122,7 +165,8 @@ impl fmt::Display for VarInt {
 }
 impl VarInt {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	/// Decode a varint from the given reader.
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let mut buf = [0u8; 8];
 		r.read_exact(buf[0..1].as_mut()).await?;
@ -149,7 +193,8 @@ impl VarInt {
 		Ok(Self(x))
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	/// Encode a varint to the given writer.
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		let x = self.0;
 		if x < 2u64.pow(6) {
 			w.write_u8(x as u8).await?;
@ -166,3 +211,10 @@ impl VarInt {
 		Ok(())
 	}
 }
 // This is a fork of quinn::VarInt.
 impl From<quinn::VarInt> for VarInt {
 	fn from(v: quinn::VarInt) -> Self {
 		Self(v.into_inner())
 	}
 }
--- a/moq-transport/src/error.rs
+++ b/moq-transport/src/error.rs
@ -0,0 +1,76 @@
 use thiserror::Error;
 use crate::VarInt;
 /// A MoQTransport error with an associated error code.
 #[derive(Copy, Clone, Debug, Error)]
 pub enum Error {
 	/// A clean termination, represented as error code 0.
 	/// This error is automatically used when publishers or subscribers are dropped without calling close.
 	#[error("closed")]
 	Closed,
 	/// An ANNOUNCE_RESET or SUBSCRIBE_RESET was sent by the publisher.
 	#[error("reset code={0:?}")]
 	Reset(u32),
 	/// An ANNOUNCE_STOP or SUBSCRIBE_STOP was sent by the subscriber.
 	#[error("stop")]
 	Stop,
 	/// The requested resource was not found.
 	#[error("not found")]
 	NotFound,
 	/// A resource already exists with that ID.
 	#[error("duplicate")]
 	Duplicate,
 	/// The role negiotiated in the handshake was violated. For example, a publisher sent a SUBSCRIBE, or a subscriber sent an OBJECT.
 	#[error("role violation: msg={0}")]
 	Role(VarInt),
 	/// An error occured while reading from the QUIC stream.
 	#[error("failed to read from stream")]
 	Read,
 	/// An error occured while writing to the QUIC stream.
 	#[error("failed to write to stream")]
 	Write,
 	/// An unclassified error because I'm lazy. TODO classify these errors
 	#[error("unknown error")]
 	Unknown,
 }
 impl Error {
 	/// An integer code that is sent over the wire.
 	pub fn code(&self) -> u32 {
 		match self {
 			Self::Closed => 0,
 			Self::Reset(code) => *code,
 			Self::Stop => 206,
 			Self::NotFound => 404,
 			Self::Role(_) => 405,
 			Self::Duplicate => 409,
 			Self::Unknown => 500,
 			Self::Write => 501,
 			Self::Read => 502,
 		}
 	}
 	/// A reason that is sent over the wire.
 	pub fn reason(&self) -> &str {
 		match self {
 			Self::Closed => "closed",
 			Self::Reset(_) => "reset",
 			Self::Stop => "stop",
 			Self::NotFound => "not found",
 			Self::Duplicate => "duplicate",
 			Self::Role(_msg) => "role violation",
 			Self::Unknown => "unknown",
 			Self::Read => "read error",
 			Self::Write => "write error",
 		}
 	}
 }
--- a/moq-transport/src/lib.rs
+++ b/moq-transport/src/lib.rs
@ -1,10 +1,20 @@
 //! An implementation of the MoQ Transport protocol.
 //!
 //! MoQ Transport is a pub/sub protocol over QUIC.
 //! While originally designed for live media, MoQ Transport is generic and can be used for other live applications.
 //! The specification is a work in progress and will change.
 //! See the [specification](https://datatracker.ietf.org/doc/draft-ietf-moq-transport/) and [github](https://github.com/moq-wg/moq-transport) for any updates.
 //!
 //! **FORKED**: This is implementation makes extensive changes to the protocol.
 //! See [KIXEL_00](crate::setup::Version::KIXEL_00) for a list of differences.
 //! Many of these will get merged into the specification, so don't panic.
 mod coding;
 mod error;
 pub mod message;
-pub mod object;
+pub mod model;
 pub mod session;
 pub mod setup;
 pub use coding::VarInt;
-pub use message::Message;
+pub use error::*;
 pub use object::Object;
 pub use session::Session;
--- a/moq-transport/src/message/announce.rs
+++ b/moq-transport/src/message/announce.rs
@ -1,21 +1,22 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError};
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the publisher to announce the availability of a group of tracks.
 #[derive(Clone, Debug)]
 pub struct Announce {
 	// The track namespace
-	pub track_namespace: String,
+	pub namespace: String,
 }
 impl Announce {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
-		let track_namespace = decode_string(r).await?;
+		let namespace = decode_string(r).await?;
-		Ok(Self { track_namespace })
+		Ok(Self { namespace })
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
-		encode_string(&self.track_namespace, w).await?;
+		encode_string(&self.namespace, w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/announce_error.rs
+++ b/moq-transport/src/message/announce_error.rs
@ -1,38 +0,0 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError, VarInt};
 use webtransport_generic::{RecvStream, SendStream};
 #[derive(Clone, Debug)]
 pub struct AnnounceError {
 	// Echo back the namespace that was announced.
 	// TODO Propose using an ID to save bytes.
 	pub track_namespace: String,
 	// An error code.
 	pub code: VarInt,
 	// An optional, human-readable reason.
 	pub reason: String,
 }
 impl AnnounceError {
 	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
 		let track_namespace = decode_string(r).await?;
 		let code = VarInt::decode(r).await?;
 		let reason = decode_string(r).await?;
 		Ok(Self {
 			track_namespace,
 			code,
 			reason,
 		})
 	}
 	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
 		encode_string(&self.track_namespace, w).await?;
 		self.code.encode(w).await?;
 		encode_string(&self.reason, w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/announce_ok.rs
+++ b/moq-transport/src/message/announce_ok.rs
@ -1,21 +1,20 @@
-use crate::coding::{decode_string, encode_string, DecodeError, EncodeError};
+use crate::coding::{decode_string, encode_string, AsyncRead, AsyncWrite, DecodeError, EncodeError};
 use webtransport_generic::{RecvStream, SendStream};
 /// Sent by the subscriber to accept an Announce.
 #[derive(Clone, Debug)]
 pub struct AnnounceOk {
 	// Echo back the namespace that was announced.
 	// TODO Propose using an ID to save bytes.
-	pub track_namespace: String,
+	pub namespace: String,
 }
 impl AnnounceOk {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
-		let track_namespace = decode_string(r).await?;
+		let namespace = decode_string(r).await?;
-		Ok(Self { track_namespace })
+		Ok(Self { namespace })
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
-		encode_string(&self.track_namespace, w).await
+		encode_string(&self.namespace, w).await
 	}
 }
--- a/moq-transport/src/message/announce_reset.rs
+++ b/moq-transport/src/message/announce_reset.rs
@ -0,0 +1,38 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError, VarInt};
 use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the subscriber to reject an Announce.
 #[derive(Clone, Debug)]
 pub struct AnnounceReset {
 	// Echo back the namespace that was reset
 	pub namespace: String,
 	// An error code.
 	pub code: u32,
 	// An optional, human-readable reason.
 	pub reason: String,
 }
 impl AnnounceReset {
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let namespace = decode_string(r).await?;
 		let code = VarInt::decode(r).await?.try_into()?;
 		let reason = decode_string(r).await?;
 		Ok(Self {
 			namespace,
 			code,
 			reason,
 		})
 	}
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		encode_string(&self.namespace, w).await?;
 		VarInt::from_u32(self.code).encode(w).await?;
 		encode_string(&self.reason, w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/announce_stop.rs
+++ b/moq-transport/src/message/announce_stop.rs
@ -0,0 +1,24 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError};
 use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the publisher to terminate an Announce.
 #[derive(Clone, Debug)]
 pub struct AnnounceStop {
 	// Echo back the namespace that was reset
 	pub namespace: String,
 }
 impl AnnounceStop {
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let namespace = decode_string(r).await?;
 		Ok(Self { namespace })
 	}
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		encode_string(&self.namespace, w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/go_away.rs
+++ b/moq-transport/src/message/go_away.rs
@ -1,19 +1,20 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError};
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the server to indicate that the client should connect to a different server.
 #[derive(Clone, Debug)]
 pub struct GoAway {
 	pub url: String,
 }
 impl GoAway {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let url = decode_string(r).await?;
 		Ok(Self { url })
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		encode_string(&self.url, w).await
 	}
 }
--- a/moq-transport/src/message/mod.rs
+++ b/moq-transport/src/message/mod.rs
@ -1,48 +1,74 @@
 //! Low-level message sent over the wire, as defined in the specification.
 //!
 //! All of these messages are sent over a bidirectional QUIC stream.
 //! This introduces some head-of-line blocking but preserves ordering.
 //! The only exception are OBJECT "messages", which are sent over dedicated QUIC streams.
 //!
 //! Messages sent by the publisher:
 //! - [Announce]
 //! - [AnnounceReset]
 //! - [SubscribeOk]
 //! - [SubscribeReset]
 //! - [Object]
 //!
 //! Messages sent by the subscriber:
 //! - [Subscribe]
 //! - [SubscribeStop]
 //! - [AnnounceOk]
 //! - [AnnounceStop]
 //!
 //! Example flow:
 //! ```test
 //!  -> ANNOUNCE        namespace="foo"
 //!  <- ANNOUNCE_OK     namespace="foo"
 //!  <- SUBSCRIBE       id=0 namespace="foo" name="bar"
 //!  -> SUBSCRIBE_OK    id=0
 //!  -> OBJECT          id=0 sequence=69 priority=4 expires=30
 //!  -> OBJECT          id=0 sequence=70 priority=4 expires=30
 //!  -> OBJECT          id=0 sequence=70 priority=4 expires=30
 //!  <- SUBSCRIBE_STOP  id=0
 //!  -> SUBSCRIBE_RESET id=0 code=206 reason="closed by peer"
 //! ```
 mod announce;
 mod announce_error;
 mod announce_ok;
 mod announce_reset;
 mod announce_stop;
 mod go_away;
-mod receiver;
+mod object;
 mod sender;
 mod subscribe;
 mod subscribe_error;
 mod subscribe_ok;
 mod subscribe_reset;
 mod subscribe_stop;
 pub use announce::*;
 pub use announce_error::*;
 pub use announce_ok::*;
 pub use announce_reset::*;
 pub use announce_stop::*;
 pub use go_away::*;
-pub use receiver::*;
+pub use object::*;
 pub use sender::*;
 pub use subscribe::*;
 pub use subscribe_error::*;
 pub use subscribe_ok::*;
 pub use subscribe_reset::*;
 pub use subscribe_stop::*;
 use crate::coding::{DecodeError, EncodeError, VarInt};
 use std::fmt;
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 // NOTE: This is forked from moq-transport-00.
 //   1. SETUP role indicates local support ("I can subscribe"), not remote support ("server must publish")
 //   2. SETUP_SERVER is id=2 to disambiguate
 //   3. messages do not have a specified length.
 //   4. messages are sent over a single bidrectional stream (after SETUP), not unidirectional streams.
 //   5. SUBSCRIBE specifies the track_id, not SUBSCRIBE_OK
 //   6. optional parameters are written in order, and zero when unset (setup, announce, subscribe)
 // Use a macro to generate the message types rather than copy-paste.
 // This implements a decode/encode method that uses the specified type.
 macro_rules! message_types {
    {$($name:ident = $val:expr,)*} => {
 		/// All supported message types.
 		#[derive(Clone)]
 		pub enum Message {
 			$($name($name)),*
 		}
 		impl Message {
-			pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+			pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 				let t = VarInt::decode(r).await?;
 				match t.into_inner() {
@ -54,7 +80,7 @@ macro_rules! message_types {
 				}
 			}
-			pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+			pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 				match self {
 					$(Self::$name(ref m) => {
 						VarInt::from_u32($val).encode(w).await?;
@ -62,6 +88,22 @@ macro_rules! message_types {
 					},)*
 				}
 			}
 			pub fn id(&self) -> VarInt {
 				match self {
 					$(Self::$name(_) => {
 						VarInt::from_u32($val)
 					},)*
 				}
 			}
 			pub fn name(&self) -> &'static str {
 				match self {
 					$(Self::$name(_) => {
 						stringify!($name)
 					},)*
 				}
 			}
 		}
 		$(impl From<$name> for Message {
@ -89,9 +131,11 @@ message_types! {
 	// SetupServer = 0x2
 	Subscribe = 0x3,
 	SubscribeOk = 0x4,
-	SubscribeError = 0x5,
+	SubscribeReset = 0x5,
 	SubscribeStop = 0x15,
 	Announce = 0x6,
 	AnnounceOk = 0x7,
-	AnnounceError = 0x8,
+	AnnounceReset = 0x8,
 	AnnounceStop = 0x18,
 	GoAway = 0x10,
 }
--- a/moq-transport/src/message/object.rs
+++ b/moq-transport/src/message/object.rs
@ -0,0 +1,70 @@
 use std::time;
 use crate::coding::{DecodeError, EncodeError, VarInt};
 use crate::coding::{AsyncRead, AsyncWrite};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 /// Sent by the publisher as the header of each data stream.
 #[derive(Clone, Debug)]
 pub struct Object {
 	// An ID for this track.
 	// Proposal: https://github.com/moq-wg/moq-transport/issues/209
 	pub track: VarInt,
 	// The sequence number within the track.
 	pub sequence: VarInt,
 	// The priority, where **larger** values are sent first.
 	// Proposal: int32 instead of a varint.
 	pub priority: i32,
 	// Cache the object for at most this many seconds.
 	// Zero means never expire.
 	pub expires: Option<time::Duration>,
 }
 impl Object {
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let typ = VarInt::decode(r).await?;
 		if typ.into_inner() != 0 {
 			return Err(DecodeError::InvalidType(typ));
 		}
 		// NOTE: size has been omitted
 		let track = VarInt::decode(r).await?;
 		let sequence = VarInt::decode(r).await?;
 		let priority = r.read_i32().await?; // big-endian
 		let expires = match VarInt::decode(r).await?.into_inner() {
 			0 => None,
 			secs => Some(time::Duration::from_secs(secs)),
 		};
 		Ok(Self {
 			track,
 			sequence,
 			priority,
 			expires,
 		})
 	}
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		VarInt::ZERO.encode(w).await?;
 		self.track.encode(w).await?;
 		self.sequence.encode(w).await?;
 		w.write_i32(self.priority).await?;
 		// Round up if there's any decimal points.
 		let expires = match self.expires {
 			None => 0,
 			Some(time::Duration::ZERO) => return Err(EncodeError::InvalidValue), // there's no way of expressing zero currently.
 			Some(expires) if expires.subsec_nanos() > 0 => expires.as_secs() + 1,
 			Some(expires) => expires.as_secs(),
 		};
 		VarInt::try_from(expires)?.encode(w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/receiver.rs
+++ b/moq-transport/src/message/receiver.rs
@ -1,19 +0,0 @@
 use crate::{coding::DecodeError, message::Message};
 use webtransport_generic::RecvStream;
 pub struct Receiver<R: RecvStream> {
 	stream: R,
 }
 impl<R: RecvStream> Receiver<R> {
 	pub fn new(stream: R) -> Self {
 		Self { stream }
 	}
 	// Read the next full message from the stream.
 	// NOTE: This is not cancellable; you must poll the future to completion.
 	pub async fn recv(&mut self) -> Result<Message, DecodeError> {
 		Message::decode(&mut self.stream).await
 	}
 }
--- a/moq-transport/src/message/sender.rs
+++ b/moq-transport/src/message/sender.rs
@ -1,21 +0,0 @@
 use crate::message::Message;
 use webtransport_generic::SendStream;
 pub struct Sender<S: SendStream> {
 	stream: S,
 }
 impl<S: SendStream> Sender<S> {
 	pub fn new(stream: S) -> Self {
 		Self { stream }
 	}
 	// Read the next full message from the stream.
 	// NOTE: This is not cancellable; you must poll the future to completion.
 	pub async fn send<T: Into<Message>>(&mut self, msg: T) -> anyhow::Result<()> {
 		let msg = msg.into();
 		msg.encode(&mut self.stream).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/subscribe.rs
+++ b/moq-transport/src/message/subscribe.rs
@ -1,39 +1,38 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError, VarInt};
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the subscriber to request all future objects for the given track.
 ///
 /// Objects will use the provided ID instead of the full track name, to save bytes.
 #[derive(Clone, Debug)]
 pub struct Subscribe {
 	// An ID we choose so we can map to the track_name.
 	// Proposal: https://github.com/moq-wg/moq-transport/issues/209
-	pub track_id: VarInt,
+	pub id: VarInt,
 	// The track namespace.
-	pub track_namespace: String,
+	pub namespace: String,
 	// The track name.
-	pub track_name: String,
+	pub name: String,
 }
 impl Subscribe {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
-		let track_id = VarInt::decode(r).await?;
+		let id = VarInt::decode(r).await?;
-		let track_namespace = decode_string(r).await?;
+		let namespace = decode_string(r).await?;
-		let track_name = decode_string(r).await?;
+		let name = decode_string(r).await?;
-		Ok(Self {
+		Ok(Self { id, namespace, name })
 			track_id,
 			track_namespace,
 			track_name,
 		})
 	}
 }
 impl Subscribe {
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
-		self.track_id.encode(w).await?;
+		self.id.encode(w).await?;
-		encode_string(&self.track_namespace, w).await?;
+		encode_string(&self.namespace, w).await?;
-		encode_string(&self.track_name, w).await?;
+		encode_string(&self.name, w).await?;
 		Ok(())
 	}
--- a/moq-transport/src/message/subscribe_error.rs
+++ b/moq-transport/src/message/subscribe_error.rs
@ -1,37 +0,0 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError, VarInt};
 use webtransport_generic::{RecvStream, SendStream};
 #[derive(Clone, Debug)]
 pub struct SubscribeError {
 	// NOTE: No full track name because of this proposal: https://github.com/moq-wg/moq-transport/issues/209
 	// The ID for this track.
 	pub track_id: VarInt,
 	// An error code.
 	pub code: VarInt,
 	// An optional, human-readable reason.
 	pub reason: String,
 }
 impl SubscribeError {
 	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
 		let track_id = VarInt::decode(r).await?;
 		let code = VarInt::decode(r).await?;
 		let reason = decode_string(r).await?;
 		Ok(Self { track_id, code, reason })
 	}
 }
 impl SubscribeError {
 	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
 		self.track_id.encode(w).await?;
 		self.code.encode(w).await?;
 		encode_string(&self.reason, w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/subscribe_ok.rs
+++ b/moq-transport/src/message/subscribe_ok.rs
@ -1,34 +1,26 @@
 use crate::coding::{DecodeError, EncodeError, VarInt};
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the publisher to accept a Subscribe.
 #[derive(Clone, Debug)]
 pub struct SubscribeOk {
 	// NOTE: No full track name because of this proposal: https://github.com/moq-wg/moq-transport/issues/209
 	// The ID for this track.
-	pub track_id: VarInt,
+	pub id: VarInt,
 	// The subscription will end after this duration has elapsed.
 	// A value of zero is invalid.
 	pub expires: Option<VarInt>,
 }
 impl SubscribeOk {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
-		let track_id = VarInt::decode(r).await?;
+		let id = VarInt::decode(r).await?;
-		let expires = VarInt::decode(r).await?;
+		Ok(Self { id })
 		let expires = if expires.into_inner() == 0 { None } else { Some(expires) };
 		Ok(Self { track_id, expires })
 	}
 }
 impl SubscribeOk {
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
-		self.track_id.encode(w).await?;
+		self.id.encode(w).await?;
 		self.expires.unwrap_or_default().encode(w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/subscribe_reset.rs
+++ b/moq-transport/src/message/subscribe_reset.rs
@ -0,0 +1,36 @@
 use crate::coding::{decode_string, encode_string, DecodeError, EncodeError, VarInt};
 use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the publisher to reject a Subscribe.
 #[derive(Clone, Debug)]
 pub struct SubscribeReset {
 	// NOTE: No full track name because of this proposal: https://github.com/moq-wg/moq-transport/issues/209
 	// The ID for this subscription.
 	pub id: VarInt,
 	// An error code.
 	pub code: u32,
 	// An optional, human-readable reason.
 	pub reason: String,
 }
 impl SubscribeReset {
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let id = VarInt::decode(r).await?;
 		let code = VarInt::decode(r).await?.try_into()?;
 		let reason = decode_string(r).await?;
 		Ok(Self { id, code, reason })
 	}
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		self.id.encode(w).await?;
 		VarInt::from_u32(self.code).encode(w).await?;
 		encode_string(&self.reason, w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/message/subscribe_stop.rs
+++ b/moq-transport/src/message/subscribe_stop.rs
@ -0,0 +1,26 @@
 use crate::coding::{DecodeError, EncodeError, VarInt};
 use crate::coding::{AsyncRead, AsyncWrite};
 /// Sent by the subscriber to terminate a Subscribe.
 #[derive(Clone, Debug)]
 pub struct SubscribeStop {
 	// NOTE: No full track name because of this proposal: https://github.com/moq-wg/moq-transport/issues/209
 	// The ID for this subscription.
 	pub id: VarInt,
 }
 impl SubscribeStop {
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let id = VarInt::decode(r).await?;
 		Ok(Self { id })
 	}
 }
 impl SubscribeStop {
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		self.id.encode(w).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/model/broadcast.rs
+++ b/moq-transport/src/model/broadcast.rs
@ -0,0 +1,211 @@
 //! A broadcast is a collection of tracks, split into two handles: [Publisher] and [Subscriber].
 //!
 //! The [Publisher] can create tracks, either manually or on request.
 //! It receives all requests by a [Subscriber] for a tracks that don't exist.
 //! The simplest implementation is to close every unknown track with [Error::NotFound].
 //!
 //! A [Subscriber] can request tracks by name.
 //! If the track already exists, it will be returned.
 //! If the track doesn't exist, it will be sent to [Unknown] to be handled.
 //! A [Subscriber] can be cloned to create multiple subscriptions.
 //!
 //! The broadcast is automatically closed with [Error::Closed] when [Publisher] is dropped, or all [Subscriber]s are dropped.
 use std::{
 	collections::{hash_map, HashMap, VecDeque},
 	fmt,
 	sync::Arc,
 };
 use crate::Error;
 use super::{track, Watch};
 /// Create a new broadcast.
 pub fn new() -> (Publisher, Subscriber) {
 	let state = Watch::new(State::default());
 	let publisher = Publisher::new(state.clone());
 	let subscriber = Subscriber::new(state);
 	(publisher, subscriber)
 }
 /// Dynamic information about the broadcast.
 #[derive(Debug)]
 struct State {
 	tracks: HashMap<String, track::Subscriber>,
 	requested: VecDeque<track::Publisher>,
 	closed: Result<(), Error>,
 }
 impl State {
 	pub fn get(&self, name: &str) -> Result<Option<track::Subscriber>, Error> {
 		// Don't check closed, so we can return from cache.
 		Ok(self.tracks.get(name).cloned())
 	}
 	pub fn insert(&mut self, track: track::Subscriber) -> Result<(), Error> {
 		self.closed?;
 		match self.tracks.entry(track.name.clone()) {
 			hash_map::Entry::Occupied(_) => return Err(Error::Duplicate),
 			hash_map::Entry::Vacant(v) => v.insert(track),
 		};
 		Ok(())
 	}
 	pub fn request(&mut self, name: &str) -> Result<track::Subscriber, Error> {
 		self.closed?;
 		// Create a new track.
 		let (publisher, subscriber) = track::new(name);
 		// Insert the track into our Map so we deduplicate future requests.
 		self.tracks.insert(name.to_string(), subscriber.clone());
 		// Send the track to the Publisher to handle.
 		self.requested.push_back(publisher);
 		Ok(subscriber)
 	}
 	pub fn has_next(&self) -> Result<bool, Error> {
 		// Check if there's any elements in the queue before checking closed.
 		if !self.requested.is_empty() {
 			return Ok(true);
 		}
 		self.closed?;
 		Ok(false)
 	}
 	pub fn next(&mut self) -> track::Publisher {
 		// We panic instead of erroring to avoid a nasty wakeup loop if you don't call has_next first.
 		self.requested.pop_front().expect("no entry in queue")
 	}
 	pub fn close(&mut self, err: Error) -> Result<(), Error> {
 		self.closed?;
 		self.closed = Err(err);
 		Ok(())
 	}
 }
 impl Default for State {
 	fn default() -> Self {
 		Self {
 			tracks: HashMap::new(),
 			closed: Ok(()),
 			requested: VecDeque::new(),
 		}
 	}
 }
 /// Publish new tracks for a broadcast by name.
 // TODO remove Clone
 #[derive(Clone)]
 pub struct Publisher {
 	state: Watch<State>,
 	_dropped: Arc<Dropped>,
 }
 impl Publisher {
 	fn new(state: Watch<State>) -> Self {
 		let _dropped = Arc::new(Dropped::new(state.clone()));
 		Self { state, _dropped }
 	}
 	/// Create a new track with the given name, inserting it into the broadcast.
 	pub fn create_track(&mut self, name: &str) -> Result<track::Publisher, Error> {
 		let (publisher, subscriber) = track::new(name);
 		self.state.lock_mut().insert(subscriber)?;
 		Ok(publisher)
 	}
 	/// Insert a track into the broadcast.
 	pub fn insert_track(&mut self, track: track::Subscriber) -> Result<(), Error> {
 		self.state.lock_mut().insert(track)
 	}
 	/// Block until the next track requested by a subscriber.
 	pub async fn next_track(&mut self) -> Result<Option<track::Publisher>, Error> {
 		loop {
 			let notify = {
 				let state = self.state.lock();
 				if state.has_next()? {
 					return Ok(Some(state.into_mut().next()));
 				}
 				state.changed()
 			};
 			notify.await;
 		}
 	}
 	/// Close the broadcast with an error.
 	pub fn close(self, err: Error) -> Result<(), Error> {
 		self.state.lock_mut().close(err)
 	}
 }
 impl fmt::Debug for Publisher {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("Publisher").field("state", &self.state).finish()
 	}
 }
 /// Subscribe to a broadcast by requesting tracks.
 ///
 /// This can be cloned to create handles.
 #[derive(Clone)]
 pub struct Subscriber {
 	state: Watch<State>,
 	_dropped: Arc<Dropped>,
 }
 impl Subscriber {
 	fn new(state: Watch<State>) -> Self {
 		let _dropped = Arc::new(Dropped::new(state.clone()));
 		Self { state, _dropped }
 	}
 	/// Get a track from the broadcast by name.
 	/// If the track does not exist, it will be created and potentially fufilled by the publisher (via Unknown).
 	/// Otherwise, it will return [Error::NotFound].
 	pub fn get_track(&self, name: &str) -> Result<track::Subscriber, Error> {
 		let state = self.state.lock();
 		if let Some(track) = state.get(name)? {
 			return Ok(track);
 		}
 		// Request a new track if it does not exist.
 		state.into_mut().request(name)
 	}
 }
 impl fmt::Debug for Subscriber {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("Subscriber").field("state", &self.state).finish()
 	}
 }
 // A handle that closes the broadcast when dropped:
 // - when all Subscribers are dropped or
 // - when Publisher and Unknown are dropped.
 struct Dropped {
 	state: Watch<State>,
 }
 impl Dropped {
 	fn new(state: Watch<State>) -> Self {
 		Self { state }
 	}
 }
 impl Drop for Dropped {
 	fn drop(&mut self) {
 		self.state.lock_mut().close(Error::Closed).ok();
 	}
 }
--- a/moq-transport/src/model/mod.rs
+++ b/moq-transport/src/model/mod.rs
@ -0,0 +1,11 @@
 //! Allows a publisher to push updates, automatically caching and fanning it out to any subscribers.
 //!
 //! The naming scheme doesn't match the spec because it's vague and confusing.
 //! The hierarchy is: [broadcast] -> [track] -> [segment] -> [Bytes](bytes::Bytes)
 pub mod broadcast;
 pub mod segment;
 pub mod track;
 pub(crate) mod watch;
 pub(crate) use watch::*;
--- a/moq-transport/src/model/segment.rs
+++ b/moq-transport/src/model/segment.rs
@ -0,0 +1,215 @@
 //! A segment is a stream of bytes with a header, split into a [Publisher] and [Subscriber] handle.
 //!
 //! A [Publisher] writes an ordered stream of bytes in chunks.
 //! There's no framing, so these chunks can be of any size or position, and won't be maintained over the network.
 //!
 //! A [Subscriber] reads an ordered stream of bytes in chunks.
 //! These chunks are returned directly from the QUIC connection, so they may be of any size or position.
 //! A closed [Subscriber] will receive a copy of all future chunks. (fanout)
 //!
 //! The segment is closed with [Error::Closed] when all publishers or subscribers are dropped.
 use core::fmt;
 use std::{ops::Deref, sync::Arc, time};
 use crate::{Error, VarInt};
 use bytes::Bytes;
 use super::Watch;
 /// Create a new segment with the given info.
 pub fn new(info: Info) -> (Publisher, Subscriber) {
 	let state = Watch::new(State::default());
 	let info = Arc::new(info);
 	let publisher = Publisher::new(state.clone(), info.clone());
 	let subscriber = Subscriber::new(state, info);
 	(publisher, subscriber)
 }
 /// Static information about the segment.
 #[derive(Debug)]
 pub struct Info {
 	// The sequence number of the segment within the track.
 	pub sequence: VarInt,
 	// The priority of the segment within the BROADCAST.
 	pub priority: i32,
 	// Cache the segment for at most this long.
 	pub expires: Option<time::Duration>,
 }
 struct State {
 	// The data that has been received thus far.
 	data: Vec<Bytes>,
 	// Set when the publisher is dropped.
 	closed: Result<(), Error>,
 }
 impl State {
 	pub fn close(&mut self, err: Error) -> Result<(), Error> {
 		self.closed?;
 		self.closed = Err(err);
 		Ok(())
 	}
 }
 impl Default for State {
 	fn default() -> Self {
 		Self {
 			data: Vec::new(),
 			closed: Ok(()),
 		}
 	}
 }
 impl fmt::Debug for State {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		// We don't want to print out the contents, so summarize.
 		let size = self.data.iter().map(|chunk| chunk.len()).sum::<usize>();
 		let data = format!("size={} chunks={}", size, self.data.len());
 		f.debug_struct("State")
 			.field("data", &data)
 			.field("closed", &self.closed)
 			.finish()
 	}
 }
 /// Used to write data to a segment and notify subscribers.
 pub struct Publisher {
 	// Mutable segment state.
 	state: Watch<State>,
 	// Immutable segment state.
 	info: Arc<Info>,
 	// Closes the segment when all Publishers are dropped.
 	_dropped: Arc<Dropped>,
 }
 impl Publisher {
 	fn new(state: Watch<State>, info: Arc<Info>) -> Self {
 		let _dropped = Arc::new(Dropped::new(state.clone()));
 		Self { state, info, _dropped }
 	}
 	/// Write a new chunk of bytes.
 	pub fn write_chunk(&mut self, data: Bytes) -> Result<(), Error> {
 		let mut state = self.state.lock_mut();
 		state.closed?;
 		state.data.push(data);
 		Ok(())
 	}
 	/// Close the segment with an error.
 	pub fn close(self, err: Error) -> Result<(), Error> {
 		self.state.lock_mut().close(err)
 	}
 }
 impl Deref for Publisher {
 	type Target = Info;
 	fn deref(&self) -> &Self::Target {
 		&self.info
 	}
 }
 impl fmt::Debug for Publisher {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("Publisher")
 			.field("state", &self.state)
 			.field("info", &self.info)
 			.finish()
 	}
 }
 /// Notified when a segment has new data available.
 #[derive(Clone)]
 pub struct Subscriber {
 	// Modify the segment state.
 	state: Watch<State>,
 	// Immutable segment state.
 	info: Arc<Info>,
 	// The number of chunks that we've read.
 	// NOTE: Cloned subscribers inherit this index, but then run in parallel.
 	index: usize,
 	// Dropped when all Subscribers are dropped.
 	_dropped: Arc<Dropped>,
 }
 impl Subscriber {
 	fn new(state: Watch<State>, info: Arc<Info>) -> Self {
 		let _dropped = Arc::new(Dropped::new(state.clone()));
 		Self {
 			state,
 			info,
 			index: 0,
 			_dropped,
 		}
 	}
 	/// Block until the next chunk of bytes is available.
 	pub async fn read_chunk(&mut self) -> Result<Option<Bytes>, Error> {
 		loop {
 			let notify = {
 				let state = self.state.lock();
 				if self.index < state.data.len() {
 					let chunk = state.data[self.index].clone();
 					self.index += 1;
 					return Ok(Some(chunk));
 				}
 				match state.closed {
 					Err(Error::Closed) => return Ok(None),
 					Err(err) => return Err(err),
 					Ok(()) => state.changed(),
 				}
 			};
 			notify.await; // Try again when the state changes
 		}
 	}
 }
 impl Deref for Subscriber {
 	type Target = Info;
 	fn deref(&self) -> &Self::Target {
 		&self.info
 	}
 }
 impl fmt::Debug for Subscriber {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("Subscriber")
 			.field("state", &self.state)
 			.field("info", &self.info)
 			.field("index", &self.index)
 			.finish()
 	}
 }
 struct Dropped {
 	// Modify the segment state.
 	state: Watch<State>,
 }
 impl Dropped {
 	fn new(state: Watch<State>) -> Self {
 		Self { state }
 	}
 }
 impl Drop for Dropped {
 	fn drop(&mut self) {
 		self.state.lock_mut().close(Error::Closed).ok();
 	}
 }
--- a/moq-transport/src/model/track.rs
+++ b/moq-transport/src/model/track.rs
@ -0,0 +1,337 @@
 //! A track is a collection of semi-reliable and semi-ordered segments, split into a [Publisher] and [Subscriber] handle.
 //!
 //! A [Publisher] creates segments with a sequence number and priority.
 //! The sequest number is used to determine the order of segments, while the priority is used to determine which segment to transmit first.
 //! This may seem counter-intuitive, but is designed for live streaming where the newest segments may be higher priority.
 //! A cloned [Publisher] can be used to create segments in parallel, but will error if a duplicate sequence number is used.
 //!
 //! A [Subscriber] may not receive all segments in order or at all.
 //! These segments are meant to be transmitted over congested networks and the key to MoQ Tranport is to not block on them.
 //! Segments will be cached for a potentially limited duration added to the unreliable nature.
 //! A cloned [Subscriber] will receive a copy of all new segment going forward (fanout).
 //!
 //! The track is closed with [Error::Closed] when all publishers or subscribers are dropped.
 use std::{collections::BinaryHeap, fmt, ops::Deref, sync::Arc, time};
 use indexmap::IndexMap;
 use super::{segment, Watch};
 use crate::{Error, VarInt};
 /// Create a track with the given name.
 pub fn new(name: &str) -> (Publisher, Subscriber) {
 	let state = Watch::new(State::default());
 	let info = Arc::new(Info { name: name.to_string() });
 	let publisher = Publisher::new(state.clone(), info.clone());
 	let subscriber = Subscriber::new(state, info);
 	(publisher, subscriber)
 }
 /// Static information about a track.
 #[derive(Debug)]
 pub struct Info {
 	pub name: String,
 }
 struct State {
 	// Store segments in received order so subscribers can detect changes.
 	// The key is the segment sequence, which could have gaps.
 	// A None value means the segment has expired.
 	lookup: IndexMap<VarInt, Option<segment::Subscriber>>,
 	// Store when segments will expire in a priority queue.
 	expires: BinaryHeap<SegmentExpiration>,
 	// The number of None entries removed from the start of the lookup.
 	pruned: usize,
 	// Set when the publisher is closed/dropped, or all subscribers are dropped.
 	closed: Result<(), Error>,
 }
 impl State {
 	pub fn close(&mut self, err: Error) -> Result<(), Error> {
 		self.closed?;
 		self.closed = Err(err);
 		Ok(())
 	}
 	pub fn insert(&mut self, segment: segment::Subscriber) -> Result<(), Error> {
 		self.closed?;
 		let entry = match self.lookup.entry(segment.sequence) {
 			indexmap::map::Entry::Occupied(_entry) => return Err(Error::Duplicate),
 			indexmap::map::Entry::Vacant(entry) => entry,
 		};
 		if let Some(expires) = segment.expires {
 			self.expires.push(SegmentExpiration {
 				sequence: segment.sequence,
 				expires: time::Instant::now() + expires,
 			});
 		}
 		entry.insert(Some(segment));
 		// Expire any existing segments on insert.
 		// This means if you don't insert then you won't expire... but it's probably fine since the cache won't grow.
 		// TODO Use a timer to expire segments at the correct time instead
 		self.expire();
 		Ok(())
 	}
 	// Try expiring any segments
 	pub fn expire(&mut self) {
 		let now = time::Instant::now();
 		while let Some(segment) = self.expires.peek() {
 			if segment.expires > now {
 				break;
 			}
 			// Update the entry to None while preserving the index.
 			match self.lookup.entry(segment.sequence) {
 				indexmap::map::Entry::Occupied(mut entry) => entry.insert(None),
 				indexmap::map::Entry::Vacant(_) => panic!("expired segment not found"),
 			};
 			self.expires.pop();
 		}
 		// Remove None entries from the start of the lookup.
 		while let Some((_, None)) = self.lookup.get_index(0) {
 			self.lookup.shift_remove_index(0);
 			self.pruned += 1;
 		}
 	}
 }
 impl Default for State {
 	fn default() -> Self {
 		Self {
 			lookup: Default::default(),
 			expires: Default::default(),
 			pruned: 0,
 			closed: Ok(()),
 		}
 	}
 }
 impl fmt::Debug for State {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("State")
 			.field("lookup", &self.lookup)
 			.field("pruned", &self.pruned)
 			.field("closed", &self.closed)
 			.finish()
 	}
 }
 /// Creates new segments for a track.
 pub struct Publisher {
 	state: Watch<State>,
 	info: Arc<Info>,
 	_dropped: Arc<Dropped>,
 }
 impl Publisher {
 	fn new(state: Watch<State>, info: Arc<Info>) -> Self {
 		let _dropped = Arc::new(Dropped::new(state.clone()));
 		Self { state, info, _dropped }
 	}
 	/// Insert a new segment.
 	pub fn insert_segment(&mut self, segment: segment::Subscriber) -> Result<(), Error> {
 		self.state.lock_mut().insert(segment)
 	}
 	/// Create an insert a segment with the given info.
 	pub fn create_segment(&mut self, info: segment::Info) -> Result<segment::Publisher, Error> {
 		let (publisher, subscriber) = segment::new(info);
 		self.insert_segment(subscriber)?;
 		Ok(publisher)
 	}
 	/// Close the segment with an error.
 	pub fn close(self, err: Error) -> Result<(), Error> {
 		self.state.lock_mut().close(err)
 	}
 }
 impl Deref for Publisher {
 	type Target = Info;
 	fn deref(&self) -> &Self::Target {
 		&self.info
 	}
 }
 impl fmt::Debug for Publisher {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("Publisher")
 			.field("state", &self.state)
 			.field("info", &self.info)
 			.finish()
 	}
 }
 /// Receives new segments for a track.
 #[derive(Clone)]
 pub struct Subscriber {
 	state: Watch<State>,
 	info: Arc<Info>,
 	// The index of the next segment to return.
 	index: usize,
 	// If there are multiple segments to return, we put them in here to return them in priority order.
 	pending: BinaryHeap<SegmentPriority>,
 	// Dropped when all subscribers are dropped.
 	_dropped: Arc<Dropped>,
 }
 impl Subscriber {
 	fn new(state: Watch<State>, info: Arc<Info>) -> Self {
 		let _dropped = Arc::new(Dropped::new(state.clone()));
 		Self {
 			state,
 			info,
 			index: 0,
 			pending: Default::default(),
 			_dropped,
 		}
 	}
 	/// Block until the next segment arrives, or return None if the track is [Error::Closed].
 	pub async fn next_segment(&mut self) -> Result<Option<segment::Subscriber>, Error> {
 		loop {
 			let notify = {
 				let state = self.state.lock();
 				// Get our adjusted index, which could be negative if we've removed more broadcasts than read.
 				let mut index = self.index.saturating_sub(state.pruned);
 				// Push all new segments into a priority queue.
 				while index < state.lookup.len() {
 					let (_, segment) = state.lookup.get_index(index).unwrap();
 					// Skip None values (expired segments).
 					// TODO These might actually be expired, so we should check the expiration time.
 					if let Some(segment) = segment {
 						self.pending.push(SegmentPriority(segment.clone()));
 					}
 					index += 1;
 				}
 				self.index = state.pruned + index;
 				// Return the higher priority segment.
 				if let Some(segment) = self.pending.pop() {
 					return Ok(Some(segment.0));
 				}
 				// Otherwise check if we need to return an error.
 				match state.closed {
 					Err(Error::Closed) => return Ok(None),
 					Err(err) => return Err(err),
 					Ok(()) => state.changed(),
 				}
 			};
 			notify.await
 		}
 	}
 }
 impl Deref for Subscriber {
 	type Target = Info;
 	fn deref(&self) -> &Self::Target {
 		&self.info
 	}
 }
 impl fmt::Debug for Subscriber {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("Subscriber")
 			.field("state", &self.state)
 			.field("info", &self.info)
 			.field("index", &self.index)
 			.finish()
 	}
 }
 // Closes the track on Drop.
 struct Dropped {
 	state: Watch<State>,
 }
 impl Dropped {
 	fn new(state: Watch<State>) -> Self {
 		Self { state }
 	}
 }
 impl Drop for Dropped {
 	fn drop(&mut self) {
 		self.state.lock_mut().close(Error::Closed).ok();
 	}
 }
 // Used to order segments by expiration time.
 struct SegmentExpiration {
 	sequence: VarInt,
 	expires: time::Instant,
 }
 impl Ord for SegmentExpiration {
 	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
 		// Reverse order so the earliest expiration is at the top of the heap.
 		other.expires.cmp(&self.expires)
 	}
 }
 impl PartialOrd for SegmentExpiration {
 	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
 		Some(self.cmp(other))
 	}
 }
 impl PartialEq for SegmentExpiration {
 	fn eq(&self, other: &Self) -> bool {
 		self.expires == other.expires
 	}
 }
 impl Eq for SegmentExpiration {}
 // Used to order segments by priority
 #[derive(Clone)]
 struct SegmentPriority(pub segment::Subscriber);
 impl Ord for SegmentPriority {
 	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
 		// Reverse order so the highest priority is at the top of the heap.
 		// TODO I let CodePilot generate this code so yolo
 		other.0.priority.cmp(&self.0.priority)
 	}
 }
 impl PartialOrd for SegmentPriority {
 	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
 		Some(self.cmp(other))
 	}
 }
 impl PartialEq for SegmentPriority {
 	fn eq(&self, other: &Self) -> bool {
 		self.0.priority == other.0.priority
 	}
 }
 impl Eq for SegmentPriority {}
--- a/moq-transport/src/model/watch.rs
+++ b/moq-transport/src/model/watch.rs
@ -0,0 +1,180 @@
 use std::{
 	fmt,
 	future::Future,
 	ops::{Deref, DerefMut},
 	pin::Pin,
 	sync::{Arc, Mutex, MutexGuard},
 	task,
 };
 struct State<T> {
 	value: T,
 	wakers: Vec<task::Waker>,
 	epoch: usize,
 }
 impl<T> State<T> {
 	pub fn new(value: T) -> Self {
 		Self {
 			value,
 			wakers: Vec::new(),
 			epoch: 0,
 		}
 	}
 	pub fn register(&mut self, waker: &task::Waker) {
 		self.wakers.retain(|existing| !existing.will_wake(waker));
 		self.wakers.push(waker.clone());
 	}
 	pub fn notify(&mut self) {
 		self.epoch += 1;
 		for waker in self.wakers.drain(..) {
 			waker.wake();
 		}
 	}
 }
 impl<T: Default> Default for State<T> {
 	fn default() -> Self {
 		Self::new(T::default())
 	}
 }
 impl<T: fmt::Debug> fmt::Debug for State<T> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		self.value.fmt(f)
 	}
 }
 pub struct Watch<T> {
 	state: Arc<Mutex<State<T>>>,
 }
 impl<T> Watch<T> {
 	pub fn new(initial: T) -> Self {
 		let state = Arc::new(Mutex::new(State::new(initial)));
 		Self { state }
 	}
 	pub fn lock(&self) -> WatchRef<T> {
 		WatchRef {
 			state: self.state.clone(),
 			lock: self.state.lock().unwrap(),
 		}
 	}
 	pub fn lock_mut(&self) -> WatchMut<T> {
 		WatchMut {
 			lock: self.state.lock().unwrap(),
 		}
 	}
 }
 impl<T> Clone for Watch<T> {
 	fn clone(&self) -> Self {
 		Self {
 			state: self.state.clone(),
 		}
 	}
 }
 impl<T: Default> Default for Watch<T> {
 	fn default() -> Self {
 		Self::new(T::default())
 	}
 }
 impl<T: fmt::Debug> fmt::Debug for Watch<T> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match self.state.try_lock() {
 			Ok(lock) => lock.value.fmt(f),
 			Err(_) => write!(f, "<locked>"),
 		}
 	}
 }
 pub struct WatchRef<'a, T> {
 	state: Arc<Mutex<State<T>>>,
 	lock: MutexGuard<'a, State<T>>,
 }
 impl<'a, T> WatchRef<'a, T> {
 	// Release the lock and wait for a notification when next updated.
 	pub fn changed(self) -> WatchChanged<T> {
 		WatchChanged {
 			state: self.state,
 			epoch: self.lock.epoch,
 		}
 	}
 	// Upgrade to a mutable references that automatically calls notify on drop.
 	pub fn into_mut(self) -> WatchMut<'a, T> {
 		WatchMut { lock: self.lock }
 	}
 }
 impl<'a, T> Deref for WatchRef<'a, T> {
 	type Target = T;
 	fn deref(&self) -> &Self::Target {
 		&self.lock.value
 	}
 }
 impl<'a, T: fmt::Debug> fmt::Debug for WatchRef<'a, T> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		self.lock.fmt(f)
 	}
 }
 pub struct WatchMut<'a, T> {
 	lock: MutexGuard<'a, State<T>>,
 }
 impl<'a, T> Deref for WatchMut<'a, T> {
 	type Target = T;
 	fn deref(&self) -> &Self::Target {
 		&self.lock.value
 	}
 }
 impl<'a, T> DerefMut for WatchMut<'a, T> {
 	fn deref_mut(&mut self) -> &mut Self::Target {
 		&mut self.lock.value
 	}
 }
 impl<'a, T> Drop for WatchMut<'a, T> {
 	fn drop(&mut self) {
 		self.lock.notify();
 	}
 }
 impl<'a, T: fmt::Debug> fmt::Debug for WatchMut<'a, T> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		self.lock.fmt(f)
 	}
 }
 pub struct WatchChanged<T> {
 	state: Arc<Mutex<State<T>>>,
 	epoch: usize,
 }
 impl<T> Future for WatchChanged<T> {
 	type Output = ();
 	fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
 		// TODO is there an API we can make that doesn't drop this lock?
 		let mut state = self.state.lock().unwrap();
 		if state.epoch > self.epoch {
 			task::Poll::Ready(())
 		} else {
 			state.register(cx.waker());
 			task::Poll::Pending
 		}
 	}
 }
--- a/moq-transport/src/object/mod.rs
+++ b/moq-transport/src/object/mod.rs
@ -1,60 +0,0 @@
 mod receiver;
 mod sender;
 pub use receiver::*;
 pub use sender::*;
 use crate::coding::{DecodeError, EncodeError, VarInt};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use webtransport_generic::{RecvStream, SendStream};
 #[derive(Clone, Debug)]
 pub struct Object {
 	// An ID for this track.
 	// Proposal: https://github.com/moq-wg/moq-transport/issues/209
 	pub track: VarInt,
 	// The group sequence number.
 	pub group: VarInt,
 	// The object sequence number.
 	pub sequence: VarInt,
 	// The priority/send order.
 	// Proposal: int32 instead of a varint.
 	pub send_order: i32,
 }
 impl Object {
 	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
 		let typ = VarInt::decode(r).await?;
 		if typ.into_inner() != 0 {
 			return Err(DecodeError::InvalidType(typ));
 		}
 		// NOTE: size has been omitted
 		let track = VarInt::decode(r).await?;
 		let group = VarInt::decode(r).await?;
 		let sequence = VarInt::decode(r).await?;
 		let send_order = r.read_i32().await?; // big-endian
 		Ok(Self {
 			track,
 			group,
 			sequence,
 			send_order,
 		})
 	}
 	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
 		VarInt::from_u32(0).encode(w).await?;
 		self.track.encode(w).await?;
 		self.group.encode(w).await?;
 		self.sequence.encode(w).await?;
 		w.write_i32(self.send_order).await?;
 		Ok(())
 	}
 }
--- a/moq-transport/src/object/receiver.rs
+++ b/moq-transport/src/object/receiver.rs
@ -1,42 +0,0 @@
 use crate::Object;
 use anyhow::Context;
 use tokio::task::JoinSet;
 use webtransport_generic::Session;
 pub struct Receiver<S: Session> {
 	session: S,
 	// Streams that we've accepted but haven't read the header from yet.
 	streams: JoinSet<anyhow::Result<(Object, S::RecvStream)>>,
 }
 impl<S: Session> Receiver<S> {
 	pub fn new(session: S) -> Self {
 		Self {
 			session,
 			streams: JoinSet::new(),
 		}
 	}
 	pub async fn recv(&mut self) -> anyhow::Result<(Object, S::RecvStream)> {
 		loop {
 			tokio::select! {
 				res = self.session.accept_uni() => {
 					let stream = res.context("failed to accept stream")?;
 					self.streams.spawn(async move { Self::read(stream).await });
 				},
 				res = self.streams.join_next(), if !self.streams.is_empty() => {
 					return res.unwrap().context("failed to run join set")?;
 				}
 			}
 		}
 	}
 	async fn read(mut stream: S::RecvStream) -> anyhow::Result<(Object, S::RecvStream)> {
 		let header = Object::decode(&mut stream).await?;
 		Ok((header, stream))
 	}
 }
--- a/moq-transport/src/object/sender.rs
+++ b/moq-transport/src/object/sender.rs
@ -1,29 +0,0 @@
 use anyhow::Context;
 use crate::Object;
 use webtransport_generic::{SendStream, Session};
 // Allow this to be cloned so we can have multiple senders.
 #[derive(Clone)]
 pub struct Sender<S: Session> {
 	// The session.
 	session: S,
 }
 impl<S: Session> Sender<S> {
 	pub fn new(session: S) -> Self {
 		Self { session }
 	}
 	pub async fn open(&mut self, object: Object) -> anyhow::Result<S::SendStream> {
 		let mut stream = self.session.open_uni().await.context("failed to open uni stream")?;
 		stream.set_priority(object.send_order);
 		object.encode(&mut stream).await.context("failed to write header")?;
 		// log::info!("created stream: {:?}", header);
 		Ok(stream)
 	}
 }
--- a/moq-transport/src/session.rs
+++ b/moq-transport/src/session.rs
@ -1,87 +0,0 @@
 use anyhow::Context;
 use crate::{message, object, setup};
 use webtransport_generic::Session as WTSession;
 pub struct Session<S: WTSession> {
 	pub send_control: message::Sender<S::SendStream>,
 	pub recv_control: message::Receiver<S::RecvStream>,
 	pub send_objects: object::Sender<S>,
 	pub recv_objects: object::Receiver<S>,
 }
 impl<S: WTSession> Session<S> {
 	/// Called by a server with an established WebTransport session.
 	// TODO close the session with an error code
 	pub async fn accept(session: S, role: setup::Role) -> anyhow::Result<Self> {
 		let (mut send, mut recv) = session.accept_bi().await.context("failed to accept bidi stream")?;
 		let setup_client = setup::Client::decode(&mut recv)
 			.await
 			.context("failed to read CLIENT SETUP")?;
 		setup_client
 			.versions
 			.iter()
 			.find(|version| **version == setup::Version::DRAFT_00)
 			.context("no supported versions")?;
 		let setup_server = setup::Server {
 			role,
 			version: setup::Version::DRAFT_00,
 		};
 		setup_server
 			.encode(&mut send)
 			.await
 			.context("failed to send setup server")?;
 		let send_control = message::Sender::new(send);
 		let recv_control = message::Receiver::new(recv);
 		let send_objects = object::Sender::new(session.clone());
 		let recv_objects = object::Receiver::new(session.clone());
 		Ok(Session {
 			send_control,
 			recv_control,
 			send_objects,
 			recv_objects,
 		})
 	}
 	/// Called by a client with an established WebTransport session.
 	pub async fn connect(session: S, role: setup::Role) -> anyhow::Result<Self> {
 		let (mut send, mut recv) = session.open_bi().await.context("failed to oen bidi stream")?;
 		let setup_client = setup::Client {
 			role,
 			versions: vec![setup::Version::DRAFT_00].into(),
 			path: "".to_string(),
 		};
 		setup_client
 			.encode(&mut send)
 			.await
 			.context("failed to send SETUP CLIENT")?;
 		let setup_server = setup::Server::decode(&mut recv).await.context("failed to read SETUP")?;
 		if setup_server.version != setup::Version::DRAFT_00 {
 			anyhow::bail!("unsupported version: {:?}", setup_server.version);
 		}
 		let send_control = message::Sender::new(send);
 		let recv_control = message::Receiver::new(recv);
 		let send_objects = object::Sender::new(session.clone());
 		let recv_objects = object::Receiver::new(session.clone());
 		Ok(Session {
 			send_control,
 			recv_control,
 			send_objects,
 			recv_objects,
 		})
 	}
 }
--- a/moq-transport/src/session/client.rs
+++ b/moq-transport/src/session/client.rs
@ -0,0 +1,62 @@
 use super::{Publisher, Subscriber};
 use crate::{model::broadcast, setup};
 use webtransport_quinn::{RecvStream, SendStream, Session};
 use anyhow::Context;
 /// An endpoint that connects to a URL to publish and/or consume live streams.
 pub struct Client {}
 impl Client {
 	/// Connect using an established WebTransport session, performing the MoQ handshake as a publisher.
 	pub async fn publisher(session: Session, source: broadcast::Subscriber) -> anyhow::Result<Publisher> {
 		let control = Self::send_setup(&session, setup::Role::Publisher).await?;
 		let publisher = Publisher::new(session, control, source);
 		Ok(publisher)
 	}
 	/// Connect using an established WebTransport session, performing the MoQ handshake as a subscriber.
 	pub async fn subscriber(session: Session, source: broadcast::Publisher) -> anyhow::Result<Subscriber> {
 		let control = Self::send_setup(&session, setup::Role::Subscriber).await?;
 		let subscriber = Subscriber::new(session, control, source);
 		Ok(subscriber)
 	}
 	// TODO support performing both roles
 	/*
 		pub async fn connect(self) -> anyhow::Result<(Publisher, Subscriber)> {
 			self.connect_role(setup::Role::Both).await
 		}
 	*/
 	async fn send_setup(session: &Session, role: setup::Role) -> anyhow::Result<(SendStream, RecvStream)> {
 		let mut control = session.open_bi().await.context("failed to oen bidi stream")?;
 		let client = setup::Client {
 			role,
 			versions: vec![setup::Version::KIXEL_00].into(),
 		};
 		client
 			.encode(&mut control.0)
 			.await
 			.context("failed to send SETUP CLIENT")?;
 		let server = setup::Server::decode(&mut control.1)
 			.await
 			.context("failed to read SETUP")?;
 		if server.version != setup::Version::KIXEL_00 {
 			anyhow::bail!("unsupported version: {:?}", server.version);
 		}
 		// Make sure the server replied with the
 		if !client.role.is_compatible(server.role) {
 			anyhow::bail!("incompatible roles: client={:?} server={:?}", client.role, server.role);
 		}
 		Ok(control)
 	}
 }
--- a/moq-transport/src/session/control.rs
+++ b/moq-transport/src/session/control.rs
@ -0,0 +1,35 @@
 // A helper class to guard sending control messages behind a Mutex.
 use std::{fmt, sync::Arc};
 use tokio::sync::Mutex;
 use webtransport_quinn::{RecvStream, SendStream};
 use crate::{message::Message, Error};
 #[derive(Debug, Clone)]
 pub(crate) struct Control {
 	send: Arc<Mutex<SendStream>>,
 	recv: Arc<Mutex<RecvStream>>,
 }
 impl Control {
 	pub fn new(send: SendStream, recv: RecvStream) -> Self {
 		Self {
 			send: Arc::new(Mutex::new(send)),
 			recv: Arc::new(Mutex::new(recv)),
 		}
 	}
 	pub async fn send<T: Into<Message> + fmt::Debug>(&self, msg: T) -> Result<(), Error> {
 		let mut stream = self.send.lock().await;
 		log::info!("sending message: {:?}", msg);
 		msg.into().encode(&mut *stream).await.map_err(|_e| Error::Write)
 	}
 	// It's likely a mistake to call this from two different tasks, but it's easier to just support it.
 	pub async fn recv(&self) -> Result<Message, Error> {
 		let mut stream = self.recv.lock().await;
 		Message::decode(&mut *stream).await.map_err(|_e| Error::Read)
 	}
 }
--- a/moq-transport/src/session/mod.rs
+++ b/moq-transport/src/session/mod.rs
@ -0,0 +1,25 @@
 //! A MoQ Transport session, on top of a WebTransport session, on top of a QUIC connection.
 //!
 //! The handshake is relatively simple but split into different steps.
 //! All of these handshakes slightly differ depending on if the endpoint is a client or server.
 //! 1. Complete the QUIC handhake.
 //! 2. Complete the WebTransport handshake.
 //! 3. Complete the MoQ handshake.
 //!
 //! Use [Client] or [Server] for the MoQ handshake depending on the endpoint.
 //! Then, decide if you want to create a [Publisher] or [Subscriber], or both (TODO).
 //!
 //! A [Publisher] can announce broadcasts, which will automatically be served over the network.
 //! A [Subscriber] can subscribe to broadcasts, which will automatically be served over the network.
 mod client;
 mod control;
 mod publisher;
 mod server;
 mod subscriber;
 pub use client::*;
 pub(crate) use control::*;
 pub use publisher::*;
 pub use server::*;
 pub use subscriber::*;
--- a/moq-transport/src/session/publisher.rs
+++ b/moq-transport/src/session/publisher.rs
@ -0,0 +1,189 @@
 use std::{
 	collections::{hash_map, HashMap},
 	sync::{Arc, Mutex},
 };
 use tokio::task::AbortHandle;
 use webtransport_quinn::{RecvStream, SendStream, Session};
 use crate::{
 	message,
 	message::Message,
 	model::{broadcast, segment, track},
 	Error, VarInt,
 };
 use super::Control;
 /// Serves broadcasts over the network, automatically handling subscriptions and caching.
 // TODO Clone specific fields when a task actually needs it.
 #[derive(Clone, Debug)]
 pub struct Publisher {
 	// A map of active subscriptions, containing an abort handle to cancel them.
 	subscribes: Arc<Mutex<HashMap<VarInt, AbortHandle>>>,
 	webtransport: Session,
 	control: Control,
 	source: broadcast::Subscriber,
 }
 impl Publisher {
 	pub(crate) fn new(webtransport: Session, control: (SendStream, RecvStream), source: broadcast::Subscriber) -> Self {
 		let control = Control::new(control.0, control.1);
 		Self {
 			webtransport,
 			subscribes: Default::default(),
 			control,
 			source,
 		}
 	}
 	// TODO Serve a broadcast without sending an ANNOUNCE.
 	// fn serve(&mut self, broadcast: broadcast::Subscriber) -> Result<(), Error> {
 	// TODO Wait until the next subscribe that doesn't route to an ANNOUNCE.
 	// pub async fn subscribed(&mut self) -> Result<track::Producer, Error> {
 	pub async fn run(mut self) -> Result<(), Error> {
 		loop {
 			tokio::select! {
 				_stream = self.webtransport.accept_uni() => {
 					return Err(Error::Role(VarInt::ZERO));
 				}
 				// NOTE: this is not cancel safe, but it's fine since the other branch is a fatal error.
 				msg = self.control.recv() => {
 					let msg = msg.map_err(|_x| Error::Read)?;
 					log::info!("message received: {:?}", msg);
 					if let Err(err) = self.recv_message(&msg).await {
 						log::warn!("message error: {:?} {:?}", err, msg);
 					}
 				}
 			}
 		}
 	}
 	async fn recv_message(&mut self, msg: &Message) -> Result<(), Error> {
 		match msg {
 			Message::AnnounceOk(msg) => self.recv_announce_ok(msg).await,
 			Message::AnnounceStop(msg) => self.recv_announce_stop(msg).await,
 			Message::Subscribe(msg) => self.recv_subscribe(msg).await,
 			Message::SubscribeStop(msg) => self.recv_subscribe_stop(msg).await,
 			_ => Err(Error::Role(msg.id())),
 		}
 	}
 	async fn recv_announce_ok(&mut self, _msg: &message::AnnounceOk) -> Result<(), Error> {
 		// We didn't send an announce.
 		Err(Error::NotFound)
 	}
 	async fn recv_announce_stop(&mut self, _msg: &message::AnnounceStop) -> Result<(), Error> {
 		// We didn't send an announce.
 		Err(Error::NotFound)
 	}
 	async fn recv_subscribe(&mut self, msg: &message::Subscribe) -> Result<(), Error> {
 		// Assume that the subscribe ID is unique for now.
 		let abort = match self.start_subscribe(msg.clone()) {
 			Ok(abort) => abort,
 			Err(err) => return self.reset_subscribe(msg.id, err).await,
 		};
 		// Insert the abort handle into the lookup table.
 		match self.subscribes.lock().unwrap().entry(msg.id) {
 			hash_map::Entry::Occupied(_) => return Err(Error::Duplicate), // TODO fatal, because we already started the task
 			hash_map::Entry::Vacant(entry) => entry.insert(abort),
 		};
 		self.control.send(message::SubscribeOk { id: msg.id }).await
 	}
 	async fn reset_subscribe(&mut self, id: VarInt, err: Error) -> Result<(), Error> {
 		let msg = message::SubscribeReset {
 			id,
 			code: err.code(),
 			reason: err.reason().to_string(),
 		};
 		self.control.send(msg).await
 	}
 	fn start_subscribe(&mut self, msg: message::Subscribe) -> Result<AbortHandle, Error> {
 		// We currently don't use the namespace field in SUBSCRIBE
 		if !msg.namespace.is_empty() {
 			return Err(Error::NotFound);
 		}
 		let mut track = self.source.get_track(&msg.name)?;
 		// TODO only clone the fields we need
 		let mut this = self.clone();
 		let handle = tokio::spawn(async move {
 			log::info!("serving track: name={}", track.name);
 			let res = this.run_subscribe(msg.id, &mut track).await;
 			if let Err(err) = &res {
 				log::warn!("failed to serve track: name={} err={:?}", track.name, err);
 			}
 			// Make sure we send a reset at the end.
 			let err = res.err().unwrap_or(Error::Closed);
 			this.reset_subscribe(msg.id, err).await.ok();
 			// We're all done, so clean up the abort handle.
 			this.subscribes.lock().unwrap().remove(&msg.id);
 		});
 		Ok(handle.abort_handle())
 	}
 	async fn run_subscribe(&self, id: VarInt, track: &mut track::Subscriber) -> Result<(), Error> {
 		// TODO add an Ok method to track::Publisher so we can send SUBSCRIBE_OK
 		while let Some(mut segment) = track.next_segment().await? {
 			// TODO only clone the fields we need
 			let this = self.clone();
 			tokio::spawn(async move {
 				if let Err(err) = this.run_segment(id, &mut segment).await {
 					log::warn!("failed to serve segment: {:?}", err)
 				}
 			});
 		}
 		Ok(())
 	}
 	async fn run_segment(&self, id: VarInt, segment: &mut segment::Subscriber) -> Result<(), Error> {
 		let object = message::Object {
 			track: id,
 			sequence: segment.sequence,
 			priority: segment.priority,
 			expires: segment.expires,
 		};
 		log::debug!("serving object: {:?}", object);
 		let mut stream = self.webtransport.open_uni().await.map_err(|_e| Error::Write)?;
 		stream.set_priority(object.priority).ok();
 		// TODO better handle the error.
 		object.encode(&mut stream).await.map_err(|_e| Error::Write)?;
 		while let Some(data) = segment.read_chunk().await? {
 			stream.write_chunk(data).await.map_err(|_e| Error::Write)?;
 		}
 		Ok(())
 	}
 	async fn recv_subscribe_stop(&mut self, msg: &message::SubscribeStop) -> Result<(), Error> {
 		let abort = self.subscribes.lock().unwrap().remove(&msg.id).ok_or(Error::NotFound)?;
 		abort.abort();
 		self.reset_subscribe(msg.id, Error::Stop).await
 	}
 }
--- a/moq-transport/src/session/server.rs
+++ b/moq-transport/src/session/server.rs
@ -0,0 +1,100 @@
 use super::{Publisher, Subscriber};
 use crate::{model::broadcast, setup};
 use webtransport_quinn::{RecvStream, SendStream, Session};
 use anyhow::Context;
 /// An endpoint that accepts connections, publishing and/or consuming live streams.
 pub struct Server {}
 impl Server {
 	/// Accept an established Webtransport session, performing the MoQ handshake.
 	///
 	/// This returns a [Request] half-way through the handshake that allows the application to accept or deny the session.
 	pub async fn accept(session: Session) -> anyhow::Result<Request> {
 		let mut control = session.accept_bi().await.context("failed to accept bidi stream")?;
 		let client = setup::Client::decode(&mut control.1)
 			.await
 			.context("failed to read CLIENT SETUP")?;
 		client
 			.versions
 			.iter()
 			.find(|version| **version == setup::Version::KIXEL_00)
 			.context("no supported versions")?;
 		Ok(Request {
 			session,
 			client,
 			control,
 		})
 	}
 }
 /// A partially complete MoQ Transport handshake.
 pub struct Request {
 	session: Session,
 	client: setup::Client,
 	control: (SendStream, RecvStream),
 }
 impl Request {
 	/// Accept the session as a publisher, using the provided broadcast to serve subscriptions.
 	pub async fn publisher(mut self, source: broadcast::Subscriber) -> anyhow::Result<Publisher> {
 		self.send_setup(setup::Role::Publisher).await?;
 		let publisher = Publisher::new(self.session, self.control, source);
 		Ok(publisher)
 	}
 	/// Accept the session as a subscriber only.
 	pub async fn subscriber(mut self, source: broadcast::Publisher) -> anyhow::Result<Subscriber> {
 		self.send_setup(setup::Role::Subscriber).await?;
 		let subscriber = Subscriber::new(self.session, self.control, source);
 		Ok(subscriber)
 	}
 	// TODO Accept the session and perform both roles.
 	/*
 	pub async fn accept(self) -> anyhow::Result<(Publisher, Subscriber)> {
 		self.ok(setup::Role::Both).await
 	}
 	*/
 	async fn send_setup(&mut self, role: setup::Role) -> anyhow::Result<()> {
 		let server = setup::Server {
 			role,
 			version: setup::Version::KIXEL_00,
 		};
 		// We need to sure we support the opposite of the client's role.
 		// ex. if the client is a publisher, we must be a subscriber ONLY.
 		if !self.client.role.is_compatible(server.role) {
 			anyhow::bail!(
 				"incompatible roles: client={:?} server={:?}",
 				self.client.role,
 				server.role
 			);
 		}
 		server
 			.encode(&mut self.control.0)
 			.await
 			.context("failed to send setup server")?;
 		Ok(())
 	}
 	/// Reject the request, closing the Webtransport session.
 	pub fn reject(self, code: u32) {
 		self.session.close(code, b"")
 	}
 	/// The role advertised by the client.
 	pub fn role(&self) -> setup::Role {
 		self.client.role
 	}
 }
--- a/moq-transport/src/session/subscriber.rs
+++ b/moq-transport/src/session/subscriber.rs
@ -0,0 +1,152 @@
 use webtransport_quinn::{RecvStream, SendStream, Session};
 use std::{
 	collections::HashMap,
 	sync::{atomic, Arc, Mutex},
 };
 use crate::{
 	message,
 	message::Message,
 	model::{broadcast, segment, track},
 	Error, VarInt,
 };
 use super::Control;
 /// Receives broadcasts over the network, automatically handling subscriptions and caching.
 // TODO Clone specific fields when a task actually needs it.
 #[derive(Clone, Debug)]
 pub struct Subscriber {
 	// The webtransport session.
 	webtransport: Session,
 	// The list of active subscriptions, each guarded by an mutex.
 	subscribes: Arc<Mutex<HashMap<VarInt, track::Publisher>>>,
 	// The sequence number for the next subscription.
 	next: Arc<atomic::AtomicU32>,
 	// A channel for sending messages.
 	control: Control,
 	// All unknown subscribes comes here.
 	source: broadcast::Publisher,
 }
 impl Subscriber {
 	pub(crate) fn new(webtransport: Session, control: (SendStream, RecvStream), source: broadcast::Publisher) -> Self {
 		let control = Control::new(control.0, control.1);
 		Self {
 			webtransport,
 			subscribes: Default::default(),
 			next: Default::default(),
 			control,
 			source,
 		}
 	}
 	pub async fn run(self) -> Result<(), Error> {
 		let inbound = self.clone().run_inbound();
 		let streams = self.clone().run_streams();
 		let source = self.clone().run_source();
 		// Return the first error.
 		tokio::select! {
 			res = inbound => res,
 			res = streams => res,
 			res = source => res,
 		}
 	}
 	async fn run_inbound(mut self) -> Result<(), Error> {
 		loop {
 			let msg = self.control.recv().await.map_err(|_e| Error::Read)?;
 			log::info!("message received: {:?}", msg);
 			if let Err(err) = self.recv_message(&msg).await {
 				log::warn!("message error: {:?} {:?}", err, msg);
 			}
 		}
 	}
 	async fn recv_message(&mut self, msg: &Message) -> Result<(), Error> {
 		match msg {
 			Message::Announce(_) => Ok(()),      // don't care
 			Message::AnnounceReset(_) => Ok(()), // also don't care
 			Message::SubscribeOk(_) => Ok(()),   // guess what, don't care
 			Message::SubscribeReset(msg) => self.recv_subscribe_reset(msg).await,
 			Message::GoAway(_msg) => unimplemented!("GOAWAY"),
 			_ => Err(Error::Role(msg.id())),
 		}
 	}
 	async fn recv_subscribe_reset(&mut self, msg: &message::SubscribeReset) -> Result<(), Error> {
 		let err = Error::Reset(msg.code);
 		let mut subscribes = self.subscribes.lock().unwrap();
 		let subscribe = subscribes.remove(&msg.id).ok_or(Error::NotFound)?;
 		subscribe.close(err)?;
 		Ok(())
 	}
 	async fn run_streams(self) -> Result<(), Error> {
 		loop {
 			// Accept all incoming unidirectional streams.
 			let stream = self.webtransport.accept_uni().await.map_err(|_| Error::Read)?;
 			let this = self.clone();
 			tokio::spawn(async move {
 				if let Err(err) = this.run_stream(stream).await {
 					log::warn!("failed to receive stream: err={:?}", err);
 				}
 			});
 		}
 	}
 	async fn run_stream(self, mut stream: RecvStream) -> Result<(), Error> {
 		// Decode the object on the data stream.
 		let object = message::Object::decode(&mut stream).await.map_err(|_| Error::Read)?;
 		log::debug!("received object: {:?}", object);
 		// A new scope is needed because the async compiler is dumb
 		let mut publisher = {
 			let mut subscribes = self.subscribes.lock().unwrap();
 			let track = subscribes.get_mut(&object.track).ok_or(Error::NotFound)?;
 			track.create_segment(segment::Info {
 				sequence: object.sequence,
 				priority: object.priority,
 				expires: object.expires,
 			})?
 		};
 		while let Some(data) = stream.read_chunk(usize::MAX, true).await.map_err(|_| Error::Read)? {
 			publisher.write_chunk(data.bytes)?;
 		}
 		Ok(())
 	}
 	async fn run_source(mut self) -> Result<(), Error> {
 		while let Some(track) = self.source.next_track().await? {
 			let name = track.name.clone();
 			let id = VarInt::from_u32(self.next.fetch_add(1, atomic::Ordering::SeqCst));
 			self.subscribes.lock().unwrap().insert(id, track);
 			let msg = message::Subscribe {
 				id,
 				namespace: "".to_string(),
 				name,
 			};
 			self.control.send(msg).await?;
 		}
 		Ok(())
 	}
 }
--- a/moq-transport/src/setup/client.rs
+++ b/moq-transport/src/setup/client.rs
@ -1,30 +1,27 @@
 use super::{Role, Versions};
 use crate::{
-	coding::{decode_string, encode_string, DecodeError, EncodeError},
+	coding::{DecodeError, EncodeError},
 	VarInt,
 };
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
-// Sent by the client to setup up the session.
+/// Sent by the client to setup the session.
 // NOTE: This is not a message type, but rather the control stream header.
 // Proposal: https://github.com/moq-wg/moq-transport/issues/138
 #[derive(Debug)]
 pub struct Client {
-	// NOTE: This is not a message type, but rather the control stream header.
+	/// The list of supported versions in preferred order.
 	// Proposal: https://github.com/moq-wg/moq-transport/issues/138
 	// The list of supported versions in preferred order.
 	pub versions: Versions,
-	// Indicate if the client is a publisher, a subscriber, or both.
+	/// Indicate if the client is a publisher, a subscriber, or both.
 	// Proposal: moq-wg/moq-transport#151
 	pub role: Role,
 	// The path, non-empty ONLY when not using WebTransport.
 	pub path: String,
 }
 impl Client {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	/// Decode a client setup message.
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let typ = VarInt::decode(r).await?;
 		if typ.into_inner() != 1 {
 			return Err(DecodeError::InvalidType(typ));
@ -32,16 +29,15 @@ impl Client {
 		let versions = Versions::decode(r).await?;
 		let role = Role::decode(r).await?;
 		let path = decode_string(r).await?;
-		Ok(Self { versions, role, path })
+		Ok(Self { versions, role })
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	/// Encode a server setup message.
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		VarInt::from_u32(1).encode(w).await?;
 		self.versions.encode(w).await?;
 		self.role.encode(w).await?;
 		encode_string(&self.path, w).await?;
 		Ok(())
 	}
--- a/moq-transport/src/setup/mod.rs
+++ b/moq-transport/src/setup/mod.rs
@ -1,3 +1,9 @@
 //! Messages used for the MoQ Transport handshake.
 //!
 //! After establishing the WebTransport session, the client creates a bidirectional QUIC stream.
 //! The client sends the [Client] message and the server responds with the [Server] message.
 //! Both sides negotate the [Version] and [Role].
 mod client;
 mod role;
 mod server;
--- a/moq-transport/src/setup/role.rs
+++ b/moq-transport/src/setup/role.rs
@ -1,7 +1,8 @@
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 use crate::coding::{DecodeError, EncodeError, VarInt};
 /// Indicates the endpoint is a publisher, subscriber, or both.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Role {
 	Publisher,
@ -10,6 +11,7 @@ pub enum Role {
 }
 impl Role {
 	/// Returns true if the role is publisher.
 	pub fn is_publisher(&self) -> bool {
 		match self {
 			Self::Publisher | Self::Both => true,
@ -17,12 +19,18 @@ impl Role {
 		}
 	}
 	/// Returns true if the role is a subscriber.
 	pub fn is_subscriber(&self) -> bool {
 		match self {
 			Self::Subscriber | Self::Both => true,
 			Self::Publisher => false,
 		}
 	}
 	/// Returns true if two endpoints are compatible.
 	pub fn is_compatible(&self, other: Role) -> bool {
 		self.is_publisher() == other.is_subscriber() && self.is_subscriber() == other.is_publisher()
 	}
 }
 impl From<Role> for VarInt {
@ -49,12 +57,14 @@ impl TryFrom<VarInt> for Role {
 }
 impl Role {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	/// Decode the role.
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let v = VarInt::decode(r).await?;
 		v.try_into()
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	/// Encode the role.
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		VarInt::from(*self).encode(w).await
 	}
 }
--- a/moq-transport/src/setup/server.rs
+++ b/moq-transport/src/setup/server.rs
@ -4,23 +4,24 @@ use crate::{
 	VarInt,
 };
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
-// Sent by the server in response to a client.
+/// Sent by the server in response to a client setup.
 // NOTE: This is not a message type, but rather the control stream header.
 // Proposal: https://github.com/moq-wg/moq-transport/issues/138
 #[derive(Debug)]
 pub struct Server {
-	// The list of supported versions in preferred order.
+	/// The list of supported versions in preferred order.
 	pub version: Version,
-	// param: 0x0: Indicate if the server is a publisher, a subscriber, or both.
+	/// Indicate if the server is a publisher, a subscriber, or both.
 	// Proposal: moq-wg/moq-transport#151
 	pub role: Role,
 }
 impl Server {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	/// Decode the server setup.
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let typ = VarInt::decode(r).await?;
 		if typ.into_inner() != 2 {
 			return Err(DecodeError::InvalidType(typ));
@ -32,7 +33,8 @@ impl Server {
 		Ok(Self { version, role })
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	/// Encode the server setup.
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		VarInt::from_u32(2).encode(w).await?;
 		self.version.encode(w).await?;
 		self.role.encode(w).await?;
--- a/moq-transport/src/setup/version.rs
+++ b/moq-transport/src/setup/version.rs
@ -1,14 +1,61 @@
 use crate::coding::{DecodeError, EncodeError, VarInt};
-use webtransport_generic::{RecvStream, SendStream};
+use crate::coding::{AsyncRead, AsyncWrite};
 use std::ops::Deref;
 /// A version number negotiated during the setup.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Version(pub VarInt);
+pub struct Version(VarInt);
 impl Version {
 	/// <https://www.ietf.org/archive/id/draft-ietf-moq-transport-00.html>
 	pub const DRAFT_00: Version = Version(VarInt::from_u32(0xff00));
 	/// Fork of draft-ietf-moq-transport-00.
 	///
 	/// Rough list of differences:
 	///
 	/// # Messages
 	/// - Messages are sent over a control stream or a data stream.
 	///   - Data streams: each unidirectional stream contains a single OBJECT message.
 	///   - Control stream: a (client-initiated) bidirectional stream containing SETUP and then all other messages.
 	/// - Messages do not contain a length; unknown messages are fatal.
 	///
 	/// # SETUP
 	/// - SETUP is split into SETUP_CLIENT and SETUP_SERVER with separate IDs.
 	/// - SETUP uses version `0xff00` for draft-00.
 	/// - SETUP no longer contains optional parameters; all are encoded in order and possibly zero.
 	/// - SETUP `role` indicates the role of the sender, not the role of the server.
 	/// - SETUP `path` field removed; use WebTransport for path.
 	///
 	/// # SUBSCRIBE
 	/// - SUBSCRIBE `full_name` is split into separate `namespace` and `name` fields.
 	/// - SUBSCRIBE no longer contains optional parameters; all are encoded in order and possibly zero.
 	/// - SUBSCRIBE no longer contains the `auth` parameter; use WebTransport for auth.
 	/// - SUBSCRIBE no longer contains the `group` parameter; concept no longer exists.
 	/// - SUBSCRIBE contains the `id` instead of SUBSCRIBE_OK.
 	/// - SUBSCRIBE_OK and SUBSCRIBE_ERROR reference the subscription `id` the instead of the track `full_name`.
 	/// - SUBSCRIBE_ERROR was renamed to SUBSCRIBE_RESET, sent by publisher to terminate a SUBSCRIBE.
 	/// - SUBSCRIBE_STOP was added, sent by the subscriber to terminate a SUBSCRIBE.
 	/// - SUBSCRIBE_OK no longer has `expires`.
 	///
 	/// # ANNOUNCE
 	/// - ANNOUNCE no longer contains optional parameters; all are encoded in order and possibly zero.
 	/// - ANNOUNCE no longer contains the `auth` field; use WebTransport for auth.
 	/// - ANNOUNCE_ERROR was renamed to ANNOUNCE_RESET, sent by publisher to terminate an ANNOUNCE.
 	/// - ANNOUNCE_STOP was added, sent by the subscriber to terminate an ANNOUNCE.
 	///
 	/// # OBJECT
 	/// - OBJECT uses a dedicated QUIC stream.
 	/// - OBJECT has no size and continues until stream FIN.
 	/// - OBJECT `priority` is a i32 instead of a varint. (for practical reasons)
 	/// - OBJECT `expires` was added, a varint in seconds.
 	/// - OBJECT `group` was removed.
 	///
 	/// # GROUP
 	/// - GROUP concept was removed, replaced with OBJECT as a QUIC stream.
 	pub const KIXEL_00: Version = Version(VarInt::from_u32(0xbad00));
 }
 impl From<VarInt> for Version {
@ -24,22 +71,26 @@ impl From<Version> for VarInt {
 }
 impl Version {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	/// Decode the version number.
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let v = VarInt::decode(r).await?;
 		Ok(Self(v))
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	/// Encode the version number.
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		self.0.encode(w).await?;
 		Ok(())
 	}
 }
 /// A list of versions in arbitrary order.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Versions(pub Vec<Version>);
+pub struct Versions(Vec<Version>);
 impl Versions {
-	pub async fn decode<R: RecvStream>(r: &mut R) -> Result<Self, DecodeError> {
+	/// Decode the version list.
 	pub async fn decode<R: AsyncRead>(r: &mut R) -> Result<Self, DecodeError> {
 		let count = VarInt::decode(r).await?.into_inner();
 		let mut vs = Vec::new();
@ -51,7 +102,8 @@ impl Versions {
 		Ok(Self(vs))
 	}
-	pub async fn encode<W: SendStream>(&self, w: &mut W) -> Result<(), EncodeError> {
+	/// Encode the version list.
 	pub async fn encode<W: AsyncWrite>(&self, w: &mut W) -> Result<(), EncodeError> {
 		let size: VarInt = self.0.len().try_into()?;
 		size.encode(w).await?;
--- a/moq-warp/Cargo.toml
+++ b/moq-warp/Cargo.toml
@ -1,24 +0,0 @@
 [package]
 name = "moq-warp"
 description = "Media over QUIC"
 authors = ["Luke Curley"]
 repository = "https://github.com/kixelated/moq-rs"
 license = "MIT OR Apache-2.0"
 version = "0.1.0"
 edition = "2021"
 keywords = ["quic", "http3", "webtransport", "media", "live"]
 categories = ["multimedia", "network-programming", "web-programming"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 moq-transport = { path = "../moq-transport" }
 webtransport-generic = "0.5"
 tokio = "1.27"
 anyhow = "1.0.70"
 log = "0.4"       # TODO remove
 bytes = "1.4"
--- a/moq-warp/src/lib.rs
+++ b/moq-warp/src/lib.rs
@ -1,2 +0,0 @@
 pub mod model;
 pub mod relay;
--- a/moq-warp/src/model/broadcast.rs
+++ b/moq-warp/src/model/broadcast.rs
@ -1,64 +0,0 @@
 use std::{error, fmt};
 use moq_transport::VarInt;
 // TODO generialize broker::Broadcasts and source::Source into this module.
 /*
 pub struct Publisher {
 	pub namespace: String,
 	pub tracks: watch::Publisher<track::Subscriber>,
 }
 impl Publisher {
 	pub fn new(namespace: &str) -> Self {
 		Self {
 			namespace: namespace.to_string(),
 			tracks: watch::Publisher::new(),
 		}
 	}
 	pub fn subscribe(&self) -> Subscriber {
 		Subscriber {
 			namespace: self.namespace.clone(),
 			tracks: self.tracks.subscribe(),
 		}
 	}
 }
 #[derive(Clone)]
 pub struct Subscriber {
 	pub namespace: String,
 	pub tracks: watch::Subscriber<track::Subscriber>,
 }
 */
 #[derive(Clone)]
 pub struct Error {
 	pub code: VarInt,
 	pub reason: String,
 }
 impl error::Error for Error {}
 impl fmt::Debug for Error {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		if !self.reason.is_empty() {
 			write!(f, "broadcast error ({}): {}", self.code, self.reason)
 		} else {
 			write!(f, "broadcast error ({})", self.code)
 		}
 	}
 }
 impl fmt::Display for Error {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		if !self.reason.is_empty() {
 			write!(f, "broadcast error ({}): {}", self.code, self.reason)
 		} else {
 			write!(f, "broadcast error ({})", self.code)
 		}
 	}
 }
--- a/moq-warp/src/model/fragment.rs
+++ b/moq-warp/src/model/fragment.rs
@ -1,5 +0,0 @@
 use super::watch;
 use bytes::Bytes;
 pub type Publisher = watch::Publisher<Bytes>;
 pub type Subscriber = watch::Subscriber<Bytes>;
--- a/moq-warp/src/model/mod.rs
+++ b/moq-warp/src/model/mod.rs
@ -1,5 +0,0 @@
 pub mod broadcast;
 pub mod fragment;
 pub mod segment;
 pub mod track;
 pub mod watch;
--- a/moq-warp/src/model/segment.rs
+++ b/moq-warp/src/model/segment.rs
@ -1,66 +0,0 @@
 use super::watch;
 use bytes::Bytes;
 use moq_transport::VarInt;
 use std::ops::Deref;
 use std::sync::Arc;
 use std::time;
 #[derive(Clone, Debug)]
 pub struct Info {
 	// The sequence number of the segment within the track.
 	pub sequence: VarInt,
 	// The priority of the segment within the BROADCAST.
 	pub send_order: i32,
 	// The time at which the segment expires for cache purposes.
 	pub expires: Option<time::Instant>,
 }
 pub struct Publisher {
 	pub info: Arc<Info>,
 	// A list of fragments that make up the segment.
 	pub fragments: watch::Publisher<Bytes>,
 }
 impl Publisher {
 	pub fn new(info: Info) -> Self {
 		Self {
 			info: Arc::new(info),
 			fragments: watch::Publisher::new(),
 		}
 	}
 	pub fn subscribe(&self) -> Subscriber {
 		Subscriber {
 			info: self.info.clone(),
 			fragments: self.fragments.subscribe(),
 		}
 	}
 }
 impl Deref for Publisher {
 	type Target = Info;
 	fn deref(&self) -> &Self::Target {
 		&self.info
 	}
 }
 #[derive(Clone, Debug)]
 pub struct Subscriber {
 	pub info: Arc<Info>,
 	// A list of fragments that make up the segment.
 	pub fragments: watch::Subscriber<Bytes>,
 }
 impl Deref for Subscriber {
 	type Target = Info;
 	fn deref(&self) -> &Self::Target {
 		&self.info
 	}
 }
--- a/moq-warp/src/model/track.rs
+++ b/moq-warp/src/model/track.rs
@ -1,101 +0,0 @@
 use super::{segment, watch};
 use std::{error, fmt, time};
 use moq_transport::VarInt;
 pub struct Publisher {
 	pub name: String,
 	segments: watch::Publisher<Result<segment::Subscriber, Error>>,
 }
 impl Publisher {
 	pub fn new(name: &str) -> Publisher {
 		Self {
 			name: name.to_string(),
 			segments: watch::Publisher::new(),
 		}
 	}
 	pub fn push_segment(&mut self, segment: segment::Subscriber) {
 		self.segments.push(Ok(segment))
 	}
 	pub fn drain_segments(&mut self, before: time::Instant) {
 		self.segments.drain(|segment| {
 			if let Ok(segment) = segment {
 				if let Some(expires) = segment.expires {
 					return expires < before;
 				}
 			}
 			false
 		})
 	}
 	pub fn close(mut self, err: Error) {
 		self.segments.push(Err(err))
 	}
 	pub fn subscribe(&self) -> Subscriber {
 		Subscriber {
 			name: self.name.clone(),
 			segments: self.segments.subscribe(),
 		}
 	}
 }
 impl fmt::Debug for Publisher {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		write!(f, "track publisher: {:?}", self.name)
 	}
 }
 #[derive(Clone, Debug)]
 pub struct Subscriber {
 	pub name: String,
 	// A list of segments, which are independently decodable.
 	segments: watch::Subscriber<Result<segment::Subscriber, Error>>,
 }
 impl Subscriber {
 	pub async fn next_segment(&mut self) -> Result<segment::Subscriber, Error> {
 		let res = self.segments.next().await;
 		match res {
 			None => Err(Error {
 				code: VarInt::from_u32(0),
 				reason: String::from("closed"),
 			}),
 			Some(res) => res,
 		}
 	}
 }
 #[derive(Clone)]
 pub struct Error {
 	pub code: VarInt,
 	pub reason: String,
 }
 impl error::Error for Error {}
 impl fmt::Debug for Error {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		if !self.reason.is_empty() {
 			write!(f, "track error ({}): {}", self.code, self.reason)
 		} else {
 			write!(f, "track error ({})", self.code)
 		}
 	}
 }
 impl fmt::Display for Error {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		if !self.reason.is_empty() {
 			write!(f, "track error ({}): {}", self.code, self.reason)
 		} else {
 			write!(f, "track error ({})", self.code)
 		}
 	}
 }
--- a/moq-warp/src/model/watch.rs
+++ b/moq-warp/src/model/watch.rs
@ -1,135 +0,0 @@
 use core::fmt;
 use std::collections::VecDeque;
 use tokio::sync::watch;
 #[derive(Default)]
 struct State<T> {
 	queue: VecDeque<T>,
 	drained: usize,
 }
 impl<T> fmt::Debug for State<T> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		write!(
 			f,
 			"State<{}> ( queue.len(): {}, drained: {} )",
 			std::any::type_name::<T>(),
 			&self.queue.len(),
 			&self.drained
 		)
 	}
 }
 impl<T> State<T> {
 	fn new() -> Self {
 		Self {
 			queue: VecDeque::new(),
 			drained: 0,
 		}
 	}
 	// Add a new element to the end of the queue.
 	fn push(&mut self, t: T) {
 		self.queue.push_back(t)
 	}
 	// Remove elements from the head of the queue if they match the conditional.
 	fn drain<F>(&mut self, f: F) -> usize
 	where
 		F: Fn(&T) -> bool,
 	{
 		let prior = self.drained;
 		while let Some(first) = self.queue.front() {
 			if !f(first) {
 				break;
 			}
 			self.queue.pop_front();
 			self.drained += 1;
 		}
 		self.drained - prior
 	}
 }
 pub struct Publisher<T: Clone> {
 	sender: watch::Sender<State<T>>,
 }
 impl<T: Clone> Publisher<T> {
 	pub fn new() -> Self {
 		let state = State::new();
 		let (sender, _) = watch::channel(state);
 		Self { sender }
 	}
 	// Push a new element to the end of the queue.
 	pub fn push(&mut self, value: T) {
 		self.sender.send_modify(|state| state.push(value));
 	}
 	// Remove any elements from the front of the queue that match the condition.
 	pub fn drain<F>(&mut self, f: F)
 	where
 		F: Fn(&T) -> bool,
 	{
 		// Use send_if_modified to never notify with the updated state.
 		self.sender.send_if_modified(|state| {
 			state.drain(f);
 			false
 		});
 	}
 	// Subscribe for all NEW updates.
 	pub fn subscribe(&self) -> Subscriber<T> {
 		let index = self.sender.borrow().queue.len();
 		Subscriber {
 			state: self.sender.subscribe(),
 			index,
 		}
 	}
 }
 impl<T: Clone> Default for Publisher<T> {
 	fn default() -> Self {
 		Self::new()
 	}
 }
 #[derive(Clone, Debug)]
 pub struct Subscriber<T: Clone> {
 	state: watch::Receiver<State<T>>,
 	index: usize,
 }
 impl<T: Clone> Subscriber<T> {
 	pub async fn next(&mut self) -> Option<T> {
 		// Wait until the queue has a new element or if it's closed.
 		let state = self
 			.state
 			.wait_for(|state| self.index < state.drained + state.queue.len())
 			.await;
 		let state = match state {
 			Ok(state) => state,
 			Err(_) => return None, // publisher was dropped
 		};
 		// If our index is smaller than drained, skip past those elements we missed.
 		let index = self.index.saturating_sub(state.drained);
 		if index < state.queue.len() {
 			// Clone the next element in the queue.
 			let element = state.queue[index].clone();
 			// Increment our index, relative to drained so we can skip ahead if needed.
 			self.index = index + state.drained + 1;
 			Some(element)
 		} else {
 			unreachable!("impossible subscriber state")
 		}
 	}
 }
--- a/moq-warp/src/relay/broker.rs
+++ b/moq-warp/src/relay/broker.rs
@ -1,76 +0,0 @@
 use crate::model::{broadcast, track, watch};
 use crate::relay::contribute;
 use std::collections::hash_map::HashMap;
 use std::sync::{Arc, Mutex};
 use anyhow::Context;
 #[derive(Clone, Default)]
 pub struct Broker {
 	// Operate on the inner struct so we can share/clone the outer struct.
 	inner: Arc<Mutex<BrokerInner>>,
 }
 #[derive(Default)]
 struct BrokerInner {
 	// TODO Automatically reclaim dropped sources.
 	lookup: HashMap<String, Arc<contribute::Broadcast>>,
 	updates: watch::Publisher<BrokerUpdate>,
 }
 #[derive(Clone)]
 pub enum BrokerUpdate {
 	// Broadcast was announced
 	Insert(String), // TODO include source?
 	// Broadcast was unannounced
 	Remove(String, broadcast::Error),
 }
 impl Broker {
 	pub fn new() -> Self {
 		Default::default()
 	}
 	// Return the list of available broadcasts, and a subscriber that will return updates (add/remove).
 	pub fn available(&self) -> (Vec<String>, watch::Subscriber<BrokerUpdate>) {
 		// Grab the lock.
 		let this = self.inner.lock().unwrap();
 		// Get the list of all available tracks.
 		let keys = this.lookup.keys().cloned().collect();
 		// Get a subscriber that will return future updates.
 		let updates = this.updates.subscribe();
 		(keys, updates)
 	}
 	pub fn announce(&self, namespace: &str, source: Arc<contribute::Broadcast>) -> anyhow::Result<()> {
 		let mut this = self.inner.lock().unwrap();
 		if let Some(_existing) = this.lookup.get(namespace) {
 			anyhow::bail!("namespace already registered");
 		}
 		this.lookup.insert(namespace.to_string(), source);
 		this.updates.push(BrokerUpdate::Insert(namespace.to_string()));
 		Ok(())
 	}
 	pub fn unannounce(&self, namespace: &str, error: broadcast::Error) -> anyhow::Result<()> {
 		let mut this = self.inner.lock().unwrap();
 		this.lookup.remove(namespace).context("namespace was not published")?;
 		this.updates.push(BrokerUpdate::Remove(namespace.to_string(), error));
 		Ok(())
 	}
 	pub fn subscribe(&self, namespace: &str, name: &str) -> Option<track::Subscriber> {
 		let this = self.inner.lock().unwrap();
 		this.lookup.get(namespace).and_then(|v| v.subscribe(name))
 	}
 }
--- a/moq-warp/src/relay/contribute.rs
+++ b/moq-warp/src/relay/contribute.rs
@ -1,308 +0,0 @@
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::time;
 use tokio::io::AsyncReadExt;
 use tokio::sync::mpsc;
 use tokio::task::JoinSet; // lock across await boundaries
 use moq_transport::message::{Announce, AnnounceError, AnnounceOk, Subscribe, SubscribeError, SubscribeOk};
 use moq_transport::{object, Object, VarInt};
 use webtransport_generic::Session as WTSession;
 use bytes::BytesMut;
 use anyhow::Context;
 use crate::model::{broadcast, segment, track};
 use crate::relay::{
 	message::{Component, Contribute},
 	Broker,
 };
 // TODO experiment with making this Clone, so every task can have its own copy.
 pub struct Session<S: WTSession> {
 	// Used to receive objects.
 	objects: object::Receiver<S>,
 	// Used to send and receive control messages.
 	control: Component<Contribute>,
 	// Globally announced namespaces, which we can add ourselves to.
 	broker: Broker,
 	// The names of active broadcasts being produced.
 	broadcasts: HashMap<String, Arc<Broadcast>>,
 	//  Active tracks being produced by this session.
 	publishers: Publishers,
 	// Tasks we are currently serving.
 	run_segments: JoinSet<anyhow::Result<()>>, // receiving objects
 }
 impl<S: WTSession> Session<S> {
 	pub fn new(objects: object::Receiver<S>, control: Component<Contribute>, broker: Broker) -> Self {
 		Self {
 			objects,
 			control,
 			broker,
 			broadcasts: HashMap::new(),
 			publishers: Publishers::new(),
 			run_segments: JoinSet::new(),
 		}
 	}
 	pub async fn run(mut self) -> anyhow::Result<()> {
 		loop {
 			tokio::select! {
 				res = self.run_segments.join_next(), if !self.run_segments.is_empty() => {
 					let res = res.expect("no tasks").expect("task aborted");
 					if let Err(err) = res {
 						log::warn!("failed to produce segment: {:?}", err);
 					}
 				},
 				object = self.objects.recv() => {
 					let (object, stream) = object.context("failed to receive object")?;
 					let res = self.receive_object(object, stream).await;
 					if let Err(err) = res {
 						log::warn!("failed to receive object: {:?}", err);
 					}
 				},
 				subscribe = self.publishers.incoming() => {
 					let msg = subscribe.context("failed to receive subscription")?;
 					self.control.send(msg).await?;
 				},
 				msg = self.control.recv() => {
 					let msg = msg.context("failed to receive control message")?;
 					self.receive_message(msg).await?;
 				},
 			}
 		}
 	}
 	async fn receive_message(&mut self, msg: Contribute) -> anyhow::Result<()> {
 		match msg {
 			Contribute::Announce(msg) => self.receive_announce(msg).await,
 			Contribute::SubscribeOk(msg) => self.receive_subscribe_ok(msg),
 			Contribute::SubscribeError(msg) => self.receive_subscribe_error(msg),
 		}
 	}
 	async fn receive_object(&mut self, obj: Object, stream: S::RecvStream) -> anyhow::Result<()> {
 		let track = obj.track;
 		// Keep objects in memory for 10s
 		let expires = time::Instant::now() + time::Duration::from_secs(10);
 		let segment = segment::Info {
 			sequence: obj.sequence,
 			send_order: obj.send_order,
 			expires: Some(expires),
 		};
 		let segment = segment::Publisher::new(segment);
 		self.publishers
 			.push_segment(track, segment.subscribe())
 			.context("failed to publish segment")?;
 		// TODO implement a timeout
 		self.run_segments
 			.spawn(async move { Self::run_segment(segment, stream).await });
 		Ok(())
 	}
 	async fn run_segment(mut segment: segment::Publisher, mut stream: S::RecvStream) -> anyhow::Result<()> {
 		let mut buf = BytesMut::new();
 		while stream.read_buf(&mut buf).await? > 0 {
 			// Split off the data we read into the buffer, freezing it so multiple threads can read simitaniously.
 			let data = buf.split().freeze();
 			segment.fragments.push(data);
 		}
 		Ok(())
 	}
 	async fn receive_announce(&mut self, msg: Announce) -> anyhow::Result<()> {
 		match self.receive_announce_inner(&msg).await {
 			Ok(()) => {
 				let msg = AnnounceOk {
 					track_namespace: msg.track_namespace,
 				};
 				self.control.send(msg).await
 			}
 			Err(e) => {
 				let msg = AnnounceError {
 					track_namespace: msg.track_namespace,
 					code: VarInt::from_u32(1),
 					reason: e.to_string(),
 				};
 				self.control.send(msg).await
 			}
 		}
 	}
 	async fn receive_announce_inner(&mut self, msg: &Announce) -> anyhow::Result<()> {
 		// Create a broadcast and announce it.
 		// We don't actually start producing the broadcast until we receive a subscription.
 		let broadcast = Arc::new(Broadcast::new(&msg.track_namespace, &self.publishers));
 		self.broker.announce(&msg.track_namespace, broadcast.clone())?;
 		self.broadcasts.insert(msg.track_namespace.clone(), broadcast);
 		Ok(())
 	}
 	fn receive_subscribe_ok(&mut self, _msg: SubscribeOk) -> anyhow::Result<()> {
 		// TODO make sure this is for a track we are subscribed to
 		Ok(())
 	}
 	fn receive_subscribe_error(&mut self, msg: SubscribeError) -> anyhow::Result<()> {
 		let error = track::Error {
 			code: msg.code,
 			reason: msg.reason,
 		};
 		// Stop producing the track.
 		self.publishers
 			.close(msg.track_id, error)
 			.context("failed to close track")?;
 		Ok(())
 	}
 }
 impl<S: WTSession> Drop for Session<S> {
 	fn drop(&mut self) {
 		// Unannounce all broadcasts we have announced.
 		// TODO make this automatic so we can't screw up?
 		// TOOD Implement UNANNOUNCE so we can return good errors.
 		for broadcast in self.broadcasts.keys() {
 			let error = broadcast::Error {
 				code: VarInt::from_u32(1),
 				reason: "connection closed".to_string(),
 			};
 			self.broker.unannounce(broadcast, error).unwrap();
 		}
 	}
 }
 // A list of subscriptions for a broadcast.
 #[derive(Clone)]
 pub struct Broadcast {
 	// Our namespace
 	namespace: String,
 	// A lookup from name to a subscription (duplicate subscribers)
 	subscriptions: Arc<Mutex<HashMap<String, track::Subscriber>>>,
 	// Issue a SUBSCRIBE message for a new subscription (new subscriber)
 	queue: mpsc::UnboundedSender<(String, track::Publisher)>,
 }
 impl Broadcast {
 	pub fn new(namespace: &str, publishers: &Publishers) -> Self {
 		Self {
 			namespace: namespace.to_string(),
 			subscriptions: Default::default(),
 			queue: publishers.sender.clone(),
 		}
 	}
 	pub fn subscribe(&self, name: &str) -> Option<track::Subscriber> {
 		let mut subscriptions = self.subscriptions.lock().unwrap();
 		// Check if there's an existing subscription.
 		if let Some(subscriber) = subscriptions.get(name).cloned() {
 			return Some(subscriber);
 		}
 		// Otherwise, make a new track and tell the publisher to fufill it.
 		let track = track::Publisher::new(name);
 		let subscriber = track.subscribe();
 		// Save the subscriber for duplication.
 		subscriptions.insert(name.to_string(), subscriber.clone());
 		// Send the publisher to another thread to actually subscribe.
 		self.queue.send((self.namespace.clone(), track)).unwrap();
 		// Return the subscriber we created.
 		Some(subscriber)
 	}
 }
 pub struct Publishers {
 	// A lookup from subscription ID to a track being produced, or none if it's been closed.
 	tracks: HashMap<VarInt, Option<track::Publisher>>,
 	// The next subscription ID
 	next: u64,
 	// A queue of subscriptions that we need to fulfill
 	receiver: mpsc::UnboundedReceiver<(String, track::Publisher)>,
 	// A clonable queue, so other threads can issue subscriptions.
 	sender: mpsc::UnboundedSender<(String, track::Publisher)>,
 }
 impl Default for Publishers {
 	fn default() -> Self {
 		let (sender, receiver) = mpsc::unbounded_channel();
 		Self {
 			tracks: Default::default(),
 			next: 0,
 			sender,
 			receiver,
 		}
 	}
 }
 impl Publishers {
 	pub fn new() -> Self {
 		Self::default()
 	}
 	pub fn push_segment(&mut self, id: VarInt, segment: segment::Subscriber) -> anyhow::Result<()> {
 		let track = self.tracks.get_mut(&id).context("no track with that ID")?;
 		let track = track.as_mut().context("track closed")?; // TODO don't make fatal
 		track.push_segment(segment);
 		track.drain_segments(time::Instant::now());
 		Ok(())
 	}
 	pub fn close(&mut self, id: VarInt, err: track::Error) -> anyhow::Result<()> {
 		let track = self.tracks.get_mut(&id).context("no track with that ID")?;
 		let track = track.take().context("track closed")?;
 		track.close(err);
 		Ok(())
 	}
 	// Returns the next subscribe message we need to issue.
 	pub async fn incoming(&mut self) -> anyhow::Result<Subscribe> {
 		let (namespace, track) = self.receiver.recv().await.context("no more subscriptions")?;
 		let id = VarInt::try_from(self.next)?;
 		self.next += 1;
 		let msg = Subscribe {
 			track_id: id,
 			track_namespace: namespace,
 			track_name: track.name.clone(),
 		};
 		self.tracks.insert(id, Some(track));
 		Ok(msg)
 	}
 }
--- a/moq-warp/src/relay/distribute.rs
+++ b/moq-warp/src/relay/distribute.rs
@ -1,205 +0,0 @@
 use anyhow::Context;
 use tokio::io::AsyncWriteExt;
 use tokio::task::JoinSet; // allows locking across await
 use moq_transport::message::{Announce, AnnounceError, AnnounceOk, Subscribe, SubscribeError, SubscribeOk};
 use moq_transport::{object, Object, VarInt};
 use webtransport_generic::Session as WTSession;
 use crate::model::{segment, track};
 use crate::relay::{
 	message::{Component, Distribute},
 	Broker, BrokerUpdate,
 };
 pub struct Session<S: WTSession> {
 	// Objects are sent to the client
 	objects: object::Sender<S>,
 	// Used to send and receive control messages.
 	control: Component<Distribute>,
 	// Globally announced namespaces, which can be subscribed to.
 	broker: Broker,
 	// A list of tasks that are currently running.
 	run_subscribes: JoinSet<SubscribeError>, // run subscriptions, sending the returned error if they fail
 }
 impl<S: WTSession> Session<S> {
 	pub fn new(objects: object::Sender<S>, control: Component<Distribute>, broker: Broker) -> Self {
 		Self {
 			objects,
 			control,
 			broker,
 			run_subscribes: JoinSet::new(),
 		}
 	}
 	pub async fn run(mut self) -> anyhow::Result<()> {
 		// Announce all available tracks and get a stream of updates.
 		let (available, mut updates) = self.broker.available();
 		for namespace in available {
 			self.on_available(BrokerUpdate::Insert(namespace)).await?;
 		}
 		loop {
 			tokio::select! {
 				res = self.run_subscribes.join_next(), if !self.run_subscribes.is_empty() => {
 					let res = res.expect("no tasks").expect("task aborted");
 					self.control.send(res).await?;
 				},
 				delta = updates.next() => {
 					let delta = delta.expect("no more broadcasts");
 					self.on_available(delta).await?;
 				},
 				msg = self.control.recv() => {
 					let msg = msg.context("failed to receive control message")?;
 					self.receive_message(msg).await?;
 				},
 			}
 		}
 	}
 	async fn receive_message(&mut self, msg: Distribute) -> anyhow::Result<()> {
 		match msg {
 			Distribute::AnnounceOk(msg) => self.receive_announce_ok(msg),
 			Distribute::AnnounceError(msg) => self.receive_announce_error(msg),
 			Distribute::Subscribe(msg) => self.receive_subscribe(msg).await,
 		}
 	}
 	fn receive_announce_ok(&mut self, _msg: AnnounceOk) -> anyhow::Result<()> {
 		// TODO make sure we sent this announce
 		Ok(())
 	}
 	fn receive_announce_error(&mut self, msg: AnnounceError) -> anyhow::Result<()> {
 		// TODO make sure we sent this announce
 		// TODO remove this from the list of subscribable broadcasts.
 		log::warn!("received error {:?}", msg);
 		Ok(())
 	}
 	async fn receive_subscribe(&mut self, msg: Subscribe) -> anyhow::Result<()> {
 		match self.receive_subscribe_inner(&msg).await {
 			Ok(()) => {
 				self.control
 					.send(SubscribeOk {
 						track_id: msg.track_id,
 						expires: None,
 					})
 					.await
 			}
 			Err(e) => {
 				self.control
 					.send(SubscribeError {
 						track_id: msg.track_id,
 						code: VarInt::from_u32(1),
 						reason: e.to_string(),
 					})
 					.await
 			}
 		}
 	}
 	async fn receive_subscribe_inner(&mut self, msg: &Subscribe) -> anyhow::Result<()> {
 		let track = self
 			.broker
 			.subscribe(&msg.track_namespace, &msg.track_name)
 			.context("could not find broadcast")?;
 		// TODO can we just clone self?
 		let objects = self.objects.clone();
 		let track_id = msg.track_id;
 		self.run_subscribes
 			.spawn(async move { Self::run_subscribe(objects, track_id, track).await });
 		Ok(())
 	}
 	async fn run_subscribe(
 		objects: object::Sender<S>,
 		track_id: VarInt,
 		mut track: track::Subscriber,
 	) -> SubscribeError {
 		let mut tasks = JoinSet::new();
 		let mut result = None;
 		loop {
 			tokio::select! {
 				// Accept new segments added to the track.
 				segment = track.next_segment(), if result.is_none() => {
 					match segment {
 						Ok(segment) => {
 							let objects = objects.clone();
 							tasks.spawn(async move { Self::serve_group(objects, track_id, segment).await });
 						},
 						Err(e) => {
 							result = Some(SubscribeError {
 								track_id,
 								code: e.code,
 								reason: e.reason,
 							})
 						},
 					}
 				},
 				// Poll any pending segments until they exit.
 				res = tasks.join_next(), if !tasks.is_empty() => {
 					let res = res.expect("no tasks").expect("task aborted");
 					if let Err(err) = res {
 						log::error!("failed to serve segment: {:?}", err);
 					}
 				},
 				else => return result.unwrap()
 			}
 		}
 	}
 	async fn serve_group(
 		mut objects: object::Sender<S>,
 		track_id: VarInt,
 		mut segment: segment::Subscriber,
 	) -> anyhow::Result<()> {
 		let object = Object {
 			track: track_id,
 			group: segment.sequence,
 			sequence: VarInt::from_u32(0), // Always zero since we send an entire group as an object
 			send_order: segment.send_order,
 		};
 		let mut stream = objects.open(object).await?;
 		// Write each fragment as they are available.
 		while let Some(fragment) = segment.fragments.next().await {
 			stream.write_all(&fragment).await?;
 		}
 		// NOTE: stream is automatically closed when dropped
 		Ok(())
 	}
 	async fn on_available(&mut self, delta: BrokerUpdate) -> anyhow::Result<()> {
 		match delta {
 			BrokerUpdate::Insert(name) => {
 				self.control
 					.send(Announce {
 						track_namespace: name.clone(),
 					})
 					.await
 			}
 			BrokerUpdate::Remove(name, error) => {
 				self.control
 					.send(AnnounceError {
 						track_namespace: name,
 						code: error.code,
 						reason: error.reason,
 					})
 					.await
 			}
 		}
 	}
 }
--- a/moq-warp/src/relay/message.rs
+++ b/moq-warp/src/relay/message.rs
@ -1,127 +0,0 @@
 use tokio::sync::mpsc;
 use moq_transport::message::{
 	self, Announce, AnnounceError, AnnounceOk, Message, Subscribe, SubscribeError, SubscribeOk,
 };
 use webtransport_generic::Session;
 pub struct Main<S: Session> {
 	send_control: message::Sender<S::SendStream>,
 	recv_control: message::Receiver<S::RecvStream>,
 	outgoing: mpsc::Receiver<Message>,
 	contribute: mpsc::Sender<Contribute>,
 	distribute: mpsc::Sender<Distribute>,
 }
 impl<S: Session> Main<S> {
 	pub async fn run(mut self) -> anyhow::Result<()> {
 		loop {
 			tokio::select! {
 				Some(msg) = self.outgoing.recv() => self.send_control.send(msg).await?,
 				Ok(msg) = self.recv_control.recv() => self.handle(msg).await?,
 			}
 		}
 	}
 	pub async fn handle(&mut self, msg: Message) -> anyhow::Result<()> {
 		match msg.try_into() {
 			Ok(msg) => self.contribute.send(msg).await?,
 			Err(msg) => match msg.try_into() {
 				Ok(msg) => self.distribute.send(msg).await?,
 				Err(msg) => anyhow::bail!("unsupported control message: {:?}", msg),
 			},
 		}
 		Ok(())
 	}
 }
 pub struct Component<T> {
 	incoming: mpsc::Receiver<T>,
 	outgoing: mpsc::Sender<Message>,
 }
 impl<T> Component<T> {
 	pub async fn send<M: Into<Message>>(&mut self, msg: M) -> anyhow::Result<()> {
 		self.outgoing.send(msg.into()).await?;
 		Ok(())
 	}
 	pub async fn recv(&mut self) -> Option<T> {
 		self.incoming.recv().await
 	}
 }
 // Splits a control stream into two components, based on if it's a message for contribution or distribution.
 pub fn split<S: Session>(
 	send_control: message::Sender<S::SendStream>,
 	recv_control: message::Receiver<S::RecvStream>,
 ) -> (Main<S>, Component<Contribute>, Component<Distribute>) {
 	let (outgoing_tx, outgoing_rx) = mpsc::channel(1);
 	let (contribute_tx, contribute_rx) = mpsc::channel(1);
 	let (distribute_tx, distribute_rx) = mpsc::channel(1);
 	let control = Main {
 		send_control,
 		recv_control,
 		outgoing: outgoing_rx,
 		contribute: contribute_tx,
 		distribute: distribute_tx,
 	};
 	let contribute = Component {
 		incoming: contribute_rx,
 		outgoing: outgoing_tx.clone(),
 	};
 	let distribute = Component {
 		incoming: distribute_rx,
 		outgoing: outgoing_tx,
 	};
 	(control, contribute, distribute)
 }
 // Messages we expect to receive from the client for contribution.
 #[derive(Debug)]
 pub enum Contribute {
 	Announce(Announce),
 	SubscribeOk(SubscribeOk),
 	SubscribeError(SubscribeError),
 }
 impl TryFrom<Message> for Contribute {
 	type Error = Message;
 	fn try_from(msg: Message) -> Result<Self, Self::Error> {
 		match msg {
 			Message::Announce(msg) => Ok(Self::Announce(msg)),
 			Message::SubscribeOk(msg) => Ok(Self::SubscribeOk(msg)),
 			Message::SubscribeError(msg) => Ok(Self::SubscribeError(msg)),
 			_ => Err(msg),
 		}
 	}
 }
 // Messages we expect to receive from the client for distribution.
 #[derive(Debug)]
 pub enum Distribute {
 	AnnounceOk(AnnounceOk),
 	AnnounceError(AnnounceError),
 	Subscribe(Subscribe),
 }
 impl TryFrom<Message> for Distribute {
 	type Error = Message;
 	fn try_from(value: Message) -> Result<Self, Self::Error> {
 		match value {
 			Message::AnnounceOk(msg) => Ok(Self::AnnounceOk(msg)),
 			Message::AnnounceError(msg) => Ok(Self::AnnounceError(msg)),
 			Message::Subscribe(msg) => Ok(Self::Subscribe(msg)),
 			_ => Err(value),
 		}
 	}
 }
--- a/moq-warp/src/relay/mod.rs
+++ b/moq-warp/src/relay/mod.rs
@ -1,8 +0,0 @@
 mod broker;
 mod contribute;
 mod distribute;
 mod message;
 mod session;
 pub use broker::*;
 pub use session::*;
--- a/moq-warp/src/relay/session.rs
+++ b/moq-warp/src/relay/session.rs
@ -1,37 +0,0 @@
 use crate::relay::{contribute, distribute, message, Broker};
 use webtransport_generic::Session as WTSession;
 pub struct Session<S: WTSession> {
 	// Split logic into contribution/distribution to reduce the problem space.
 	contribute: contribute::Session<S>,
 	distribute: distribute::Session<S>,
 	// Used to receive control messages and forward to contribute/distribute.
 	control: message::Main<S>,
 }
 impl<S: WTSession> Session<S> {
 	pub fn new(session: moq_transport::Session<S>, broker: Broker) -> Self {
 		let (control, contribute, distribute) = message::split(session.send_control, session.recv_control);
 		let contribute = contribute::Session::new(session.recv_objects, contribute, broker.clone());
 		let distribute = distribute::Session::new(session.send_objects, distribute, broker);
 		Self {
 			control,
 			contribute,
 			distribute,
 		}
 	}
 	pub async fn run(self) -> anyhow::Result<()> {
 		let control = self.control.run();
 		let contribute = self.contribute.run();
 		let distribute = self.distribute.run();
 		tokio::try_join!(control, contribute, distribute)?;
 		Ok(())
 	}
 }