@blockcast/mmt-container 2.2.0-main.f480a7ede8b1 → 2.2.0-main.fb5c7dfbe2de

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. package/dist/browser-runtime.js +891 -141
  2. package/dist/browser-runtime.js.map +3 -3
  3. package/dist/delta-fallback-config.js.map +1 -1
  4. package/dist/fec-manager.d.ts +67 -11
  5. package/dist/fec-manager.d.ts.map +1 -1
  6. package/dist/fec-manager.js +283 -54
  7. package/dist/fec-manager.js.map +2 -2
  8. package/dist/fec-worker-setup.js.map +1 -1
  9. package/dist/index.d.ts +1 -1
  10. package/dist/index.d.ts.map +1 -1
  11. package/dist/index.js.map +2 -2
  12. package/dist/iso-block-locator.d.ts +39 -13
  13. package/dist/iso-block-locator.d.ts.map +1 -1
  14. package/dist/iso-block-locator.js +80 -25
  15. package/dist/iso-block-locator.js.map +2 -2
  16. package/dist/media-router.js.map +1 -1
  17. package/dist/mmtp-container-parser.d.ts +42 -8
  18. package/dist/mmtp-container-parser.d.ts.map +1 -1
  19. package/dist/mmtp-container-parser.js +121 -17
  20. package/dist/mmtp-container-parser.js.map +2 -2
  21. package/dist/mmtp-container-parser.no-modules.js +120 -18
  22. package/dist/mmtp-container-parser.no-modules.js.map +2 -2
  23. package/dist/mmtp-decode-pipeline.js +121 -17
  24. package/dist/mmtp-decode-pipeline.js.map +2 -2
  25. package/dist/mmtp-router.d.ts +28 -8
  26. package/dist/mmtp-router.d.ts.map +1 -1
  27. package/dist/mmtp-router.js +407 -52
  28. package/dist/mmtp-router.js.map +2 -2
  29. package/dist/multicast-manager.d.ts +13 -3
  30. package/dist/multicast-manager.d.ts.map +1 -1
  31. package/dist/multicast-manager.js +712 -115
  32. package/dist/multicast-manager.js.map +2 -2
  33. package/dist/multicast-transport.js +2 -2
  34. package/dist/multicast-transport.js.map +2 -2
  35. package/dist/no-modules.js +121 -17
  36. package/dist/no-modules.js.map +2 -2
  37. package/dist/repair-fetch.d.ts +36 -8
  38. package/dist/repair-fetch.d.ts.map +1 -1
  39. package/dist/repair-fetch.js +285 -26
  40. package/dist/repair-fetch.js.map +3 -3
  41. package/dist/track-session.d.ts.map +1 -1
  42. package/dist/track-session.js +1 -0
  43. package/dist/track-session.js.map +2 -2
  44. package/dist/wasm-mmtp-container-parser.js +121 -17
  45. package/dist/wasm-mmtp-container-parser.js.map +2 -2
  46. package/package.json +5 -5
  47. package/src/fec-manager.ts +304 -28
  48. package/src/index.ts +2 -0
  49. package/src/iso-block-locator.ts +114 -31
  50. package/src/mmtp-container-parser.ts +210 -21
  51. package/src/mmtp-router.ts +488 -45
  52. package/src/multicast-manager.ts +44 -6
  53. package/src/repair-fetch.ts +363 -49
  54. package/src/track-session.ts +3 -0
@@ -8023,6 +8023,9 @@ function authoredGap(before, after) {
8023
8023
  function ssIdAfter(a, b) {
8024
8024
  return (a - b | 0) > 0;
8025
8025
  }
8026
+ function holdsRebuilt(stream) {
8027
+ return stream.buf.some(({ meta }) => meta.fecSbnFirst !== void 0);
8028
+ }
8026
8029
  var FecReleaseSequencer = class {
8027
8030
  #streams = /* @__PURE__ */ new Map();
8028
8031
  #gate;
@@ -8085,6 +8088,7 @@ var FecReleaseSequencer = class {
8085
8088
  stream.lastSbn = void 0;
8086
8089
  stream.discontinuity = false;
8087
8090
  stream.rapSsId = void 0;
8091
+ stream.sourced = false;
8088
8092
  }
8089
8093
  if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
8090
8094
  this.#recordStat("droppedStale");
@@ -8111,6 +8115,7 @@ var FecReleaseSequencer = class {
8111
8115
  if (compareFrameOrder(stream.buf[mid], frame) < 0) lo = mid + 1;
8112
8116
  else hi = mid;
8113
8117
  }
8118
+ if (stream.buf[lo]?.passed === true) frame.passed = true;
8114
8119
  stream.buf.splice(lo, 0, frame);
8115
8120
  this.#drainUnlessDeferred(stream);
8116
8121
  }
@@ -8146,6 +8151,41 @@ var FecReleaseSequencer = class {
8146
8151
  }
8147
8152
  return false;
8148
8153
  }
8154
+ /**
8155
+ * These streams' sink is being replaced by one that has seen no source
8156
+ * frame yet. First, from a stream that holds a frame the overlay rebuilt,
8157
+ * release to the sink being replaced the frames the unanchored path had
8158
+ * already released to it (#cursorPassed): there they waited in its queue,
8159
+ * which its replacement flushes. A stream that holds none is not drained:
8160
+ * it holds nothing the anchor kept back, and a drain would still force out
8161
+ * a frame held past the hold limit, which before the anchor waited for the
8162
+ * next push. Then treat the streams as unsourced until a source frame is
8163
+ * released.
8164
+ */
8165
+ unsource(packetId, catalogTrackName) {
8166
+ for (const stream of this.#streams.values()) {
8167
+ if (stream.packetId === packetId && (catalogTrackName === void 0 || stream.catalogTrackName === catalogTrackName)) {
8168
+ if (stream.draining === 0 && holdsRebuilt(stream)) {
8169
+ if (this.#deferDepth > 0) this.#deferredStreams.add(stream);
8170
+ else this.#drain(stream, true);
8171
+ }
8172
+ stream.sourced = false;
8173
+ }
8174
+ }
8175
+ }
8176
+ /**
8177
+ * Whether a stream of `packetId` holds a frame the keyframe overlay rebuilt
8178
+ * (FrameMeta.fecSbnFirst). Without `catalogTrackName`, every stream of the
8179
+ * packetId.
8180
+ */
8181
+ holdsRebuilt(packetId, catalogTrackName) {
8182
+ for (const stream of this.#streams.values()) {
8183
+ if (stream.packetId !== packetId) continue;
8184
+ if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
8185
+ if (holdsRebuilt(stream)) return true;
8186
+ }
8187
+ return false;
8188
+ }
8149
8189
  /** Re-evaluate held gaps after FEC state changed. */
8150
8190
  poke(streamKey) {
8151
8191
  if (streamKey !== void 0) {
@@ -8237,16 +8277,32 @@ var FecReleaseSequencer = class {
8237
8277
  last: null,
8238
8278
  lastSbn: void 0,
8239
8279
  discontinuity: false,
8240
- rapSsId: void 0
8280
+ rapSsId: void 0,
8281
+ sourced: false,
8282
+ draining: 0
8241
8283
  };
8242
8284
  this.#streams.set(streamKey, stream);
8243
8285
  }
8244
8286
  return stream;
8245
8287
  }
8246
- #drain(stream) {
8288
+ /** `asUnanchored`: release overlay-rebuilt frames when unanchored did (#cursorPassed). */
8289
+ #drain(stream, asUnanchored = false) {
8290
+ stream.draining++;
8291
+ try {
8292
+ this.#drainLoop(stream, asUnanchored);
8293
+ } finally {
8294
+ stream.draining--;
8295
+ }
8296
+ }
8297
+ #drainLoop(stream, asUnanchored) {
8247
8298
  while (stream.buf.length > 0 && stream.last !== null) {
8248
8299
  const head = stream.buf[0];
8249
8300
  const last = stream.last;
8301
+ if (compareFrameOrder(head, last) <= 0) {
8302
+ stream.buf.shift();
8303
+ this.#release(stream, head, void 0);
8304
+ continue;
8305
+ }
8250
8306
  if (stream.discontinuity) {
8251
8307
  stream.discontinuity = false;
8252
8308
  stream.buf.shift();
@@ -8260,9 +8316,10 @@ var FecReleaseSequencer = class {
8260
8316
  }
8261
8317
  const headSbn = head.meta.fecSbn;
8262
8318
  const from = stream.lastSbn ?? headSbn;
8263
- const to = headSbn ?? stream.lastSbn;
8319
+ const to = head.meta.fecSbnFirst ?? headSbn ?? stream.lastSbn;
8264
8320
  let lost = [];
8265
8321
  const unanchored = from === void 0 && to === void 0;
8322
+ let unresolved = false;
8266
8323
  if (from !== void 0 && to !== void 0) {
8267
8324
  const resolved = this.#gate.resolvedLoss(
8268
8325
  stream.packetId,
@@ -8271,7 +8328,8 @@ var FecReleaseSequencer = class {
8271
8328
  Math.max(from, to),
8272
8329
  from
8273
8330
  );
8274
- if (resolved === null) {
8331
+ unresolved = resolved === null;
8332
+ if (unresolved && !this.#cursorPassed(stream, asUnanchored)) {
8275
8333
  const heldMs = performance.now() - head.arrivedAtMs;
8276
8334
  if (heldMs <= this.#gate.holdLimitMs(stream.packetId, stream.catalogTrackName)) return;
8277
8335
  this.#recordStat("forcedWindowFlushes");
@@ -8279,22 +8337,56 @@ var FecReleaseSequencer = class {
8279
8337
  this.#release(stream, head, this.#gate.decide(last, head, [], true));
8280
8338
  continue;
8281
8339
  }
8282
- lost = resolved;
8340
+ lost = resolved ?? [];
8283
8341
  }
8284
8342
  stream.buf.shift();
8285
8343
  this.#release(
8286
8344
  stream,
8287
8345
  head,
8288
- lost.length > 0 || unanchored || authoredGap(last.meta, head.meta) ? this.#gate.decide(last, head, lost, false) : void 0
8346
+ lost.length > 0 || unanchored || unresolved || authoredGap(last.meta, head.meta) ? this.#gate.decide(last, head, lost, false) : void 0
8289
8347
  );
8290
8348
  }
8291
8349
  }
8350
+ /**
8351
+ * An overlay-rebuilt frame (fecSbnFirst) waits no longer than the BLO-53342
8352
+ * source cursor holds it unanchored, and neither does a later frame behind
8353
+ * it. Unanchored, a frame that waits on no block (fecSbnFirst set, or no
8354
+ * fecSbn) left the gate once every frame ahead of it had: mark it `passed`,
8355
+ * like each frame that arrived in front of it since (stale there). The head
8356
+ * then goes, decided as it would be unanchored, once a frame the base path
8357
+ * delivered (a source frame, or one base FEC recovered) is buffered after a
8358
+ * marked one: the base path has passed that one, so a frame still missing
8359
+ * before it can only come from a repair. It also goes while no source frame
8360
+ * has been released, when the direct path shows a recovered frame at once.
8361
+ * And it goes at once while a staged switch decides on when frames arrive
8362
+ * (FecReleaseGate.releaseUnanchored), and when unsource releases into a
8363
+ * sink being replaced: unanchored, it had already reached the sink.
8364
+ * The scan also writes: the `passed` marks it sets stay on the frames,
8365
+ * and push marks a frame it inserts in front of a marked one from them.
8366
+ */
8367
+ #cursorPassed(stream, asUnanchored) {
8368
+ let at = -1;
8369
+ for (let i = 0; i < stream.buf.length; i++) {
8370
+ const frame = stream.buf[i];
8371
+ if (frame.meta.fecSbnFirst !== void 0 || frame.meta.fecSbn === void 0) {
8372
+ frame.passed = true;
8373
+ if (at < 0) at = i;
8374
+ } else if (frame.passed !== true) break;
8375
+ }
8376
+ if (at < 0) return false;
8377
+ return asUnanchored || !stream.sourced || this.#gate.releaseUnanchored?.(stream.packetId, stream.catalogTrackName) === true || stream.buf.some(({ meta }, i) => i > at && meta.fecSbnFirst === void 0 && (meta.recovered !== true || meta.fecSbn !== void 0));
8378
+ }
8292
8379
  #release(stream, frame, decision) {
8380
+ const stale = stream.last !== null && compareFrameOrder(frame, stream.last) <= 0;
8381
+ if (stale) this.#recordStat("droppedStale");
8293
8382
  if (decision) frame.meta.gapBefore = decision;
8294
8383
  stream.last = frame;
8295
- if (frame.meta.fecSbn !== void 0) stream.lastSbn = frame.meta.fecSbn;
8384
+ if (frame.meta.fecSbn !== void 0 && (frame.meta.fecSbnFirst === void 0 || stream.lastSbn !== void 0)) {
8385
+ stream.lastSbn = frame.meta.fecSbn;
8386
+ }
8387
+ if (frame.meta.recovered !== true) stream.sourced = true;
8296
8388
  this.#gate.onReleased?.(frame.data, frame.meta);
8297
- this.#emit(frame.data, frame.meta);
8389
+ if (!stale) this.#emit(frame.data, frame.meta);
8298
8390
  }
8299
8391
  };
8300
8392
  var FMPU_BOX_TYPES = /* @__PURE__ */ new Set(["ftyp", "moov", "moof"]);
@@ -8555,11 +8647,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
8555
8647
  /**
8556
8648
  * Typed view of the ISO-BMFF timing-sample budget.
8557
8649
  *
8558
- * This is the acceptance signal for the budget ratchet: `pending` walking
8559
- * to `capacity` while `rejectedMovieFragments` climbs is the stream wedging,
8560
- * and it is observable here rather than only as media silently stopping.
8561
- * Per repo policy this is a producer-owned counter -- never infer budget
8562
- * state by parsing logs.
8650
+ * Each stream admits timing against its own window of `capacity` slots
8651
+ * (BLO-52085). A stream at capacity displaces its own oldest timing to
8652
+ * admit the moof in hand, and `evicted` counts the slots so displaced:
8653
+ * timing a stream declared and never delivered shows up there. `pending`
8654
+ * sums every stream, so it can exceed `capacity`. Per repo policy this is
8655
+ * a producer-owned counter -- never infer budget state by parsing logs.
8563
8656
  */
8564
8657
  get timingBudgetStats() {
8565
8658
  return {
@@ -8619,6 +8712,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
8619
8712
  fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
8620
8713
  return this.#fecSequencer?.rapAbove(packetId, catalogTrackName, ssId) ?? false;
8621
8714
  }
8715
+ /** See FecReleaseSequencer.unsource. */
8716
+ unsourceFecRelease(packetId, catalogTrackName) {
8717
+ this.#fecSequencer?.unsource(packetId, catalogTrackName);
8718
+ }
8719
+ /** See FecReleaseSequencer.holdsRebuilt. */
8720
+ fecReleaseHoldsRebuilt(packetId, catalogTrackName) {
8721
+ return this.#fecSequencer?.holdsRebuilt(packetId, catalogTrackName) ?? false;
8722
+ }
8622
8723
  /** Re-evaluate held gaps after FEC block state changed. */
8623
8724
  pokeFecRelease(packetId, catalogTrackName) {
8624
8725
  if (!this.#fecSequencer) return;
@@ -8872,7 +8973,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
8872
8973
  if (!resolver2?.initialized) return this.#drop("fragment-no-resolver");
8873
8974
  const pendingBefore = resolver2.pendingSampleCount;
8874
8975
  const evictedBefore = resolver2.evictedSampleCount;
8875
- const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples;
8976
+ const remaining = this.#maxPendingTimingSamples - resolver2.pendingSampleCount;
8876
8977
  const admitted = resolver2.addMovieFragment(
8877
8978
  mpu.mpuSequenceNumber,
8878
8979
  data,
@@ -8945,7 +9046,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
8945
9046
  info,
8946
9047
  resolver,
8947
9048
  options?.recovered === true,
8948
- options?.fecSbn
9049
+ options?.fecSbn,
9050
+ options?.fecSbnFirst
8949
9051
  );
8950
9052
  if (deferred.record === void 0) this.#countDeferredOutcome(deferred.reason);
8951
9053
  }
@@ -9038,7 +9140,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
9038
9140
  info,
9039
9141
  resolver,
9040
9142
  options?.recovered === true,
9041
- options?.fecSbn
9143
+ options?.fecSbn,
9144
+ options?.fecSbnFirst
9042
9145
  );
9043
9146
  if (outcome.record !== void 0) return outcome.record;
9044
9147
  return this.#drop(outcome.reason);
@@ -9058,7 +9161,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
9058
9161
  * attribution exists to keep readable. Leaving the choice at the call site
9059
9162
  * is what keeps both true.
9060
9163
  */
9061
- #emitCombinedSample(combined, info, resolver, recovered, fecSbn) {
9164
+ #emitCombinedSample(combined, info, resolver, recovered, fecSbn, fecSbnFirst) {
9062
9165
  const timing = resolver.sampleTiming(
9063
9166
  combined.mpuSequenceNumber,
9064
9167
  combined.movieFragmentSequenceNumber,
@@ -9075,6 +9178,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
9075
9178
  );
9076
9179
  if (!meta) return { reason: "combined-meta-build-failed" };
9077
9180
  if (fecSbn !== void 0) meta.fecSbn = fecSbn;
9181
+ if (fecSbnFirst !== void 0) meta.fecSbnFirst = fecSbnFirst;
9078
9182
  if (!resolver.consumeSample(
9079
9183
  combined.mpuSequenceNumber,
9080
9184
  combined.movieFragmentSequenceNumber,
@@ -9914,7 +10018,18 @@ function keyframeOverlaySsId(header) {
9914
10018
  if (ext?.type !== KEYFRAME_OVERLAY_EXTENSION_TYPE || ext.data.length !== 4) return void 0;
9915
10019
  return new DataView(ext.data.buffer, ext.data.byteOffset, 4).getUint32(0);
9916
10020
  }
10021
+ function overlayBaseSsId(anchor, overlaySsId, restoredPsn, headerPsn) {
10022
+ if (anchor.baseSsId === void 0 || headerPsn !== restoredPsn) return void 0;
10023
+ return serial32Add(anchor.baseSsId, overlaySsId - anchor.overlaySsId | 0);
10024
+ }
10025
+ function unstampedBaseSsId(offset, unstampedOffset, headerPsn) {
10026
+ if (offset === void 0 || offset !== unstampedOffset) return void 0;
10027
+ return headerPsn + offset >>> 0;
10028
+ }
10029
+ var OVERLAY_ROUTED_LIMIT = 1024;
10030
+ var OVERLAY_PENDING_LIMIT = 256;
9917
10031
  var OVERLAY_OFFSET_MPUS = 16;
10032
+ var OVERLAY_REBUILT_LIMIT = 256;
9918
10033
  var OVERLAY_MOQ_HORIZON_BLOCKS = 64;
9919
10034
  function assertStreamIdentity(role, stream) {
9920
10035
  if (stream === void 0 || !Number.isInteger(stream.packetId) || stream.packetId <= MMTP_SIGNALING_PACKET_ID || typeof stream.catalogTrackName !== "string" || stream.catalogTrackName.length === 0) {
@@ -10025,6 +10140,7 @@ var MmtpRouter = class {
10025
10140
  #provenance = /* @__PURE__ */ new Map();
10026
10141
  #onFlowProtected = null;
10027
10142
  #unadmittedListedDrops = 0;
10143
+ #admittedSourceDatagrams = 0;
10028
10144
  #unlistedRepairSetAside = 0;
10029
10145
  #assistBlocks = /* @__PURE__ */ new Map();
10030
10146
  #assistFailures = /* @__PURE__ */ new Map();
@@ -10081,6 +10197,26 @@ var MmtpRouter = class {
10081
10197
  * sequence is its SS_ID minus this; see #routeProcessedFecSymbols.
10082
10198
  */
10083
10199
  #ssIdSeqOffsetByStream = /* @__PURE__ */ new Map();
10200
+ /**
10201
+ * Per stream, the SS_ID offset at which a base recovery last showed the
10202
+ * sender's own packet_sequence_number: a recovered packet's header psn
10203
+ * equal to its SS_ID minus that offset. While it equals the stream's
10204
+ * current offset, no hop re-stamps the stream, and a packet's protected psn
10205
+ * names its base SS_ID within unstampedBaseSsId's limits (joint decoding of
10206
+ * an MPU no member of which arrived).
10207
+ */
10208
+ #unstampedSsIdSeqOffsetByStream = /* @__PURE__ */ new Map();
10209
+ /**
10210
+ * The same, shown by the overlay alone, before any base recovery did: a
10211
+ * packet it rebuilt whose base copy carries its protected psn
10212
+ * (#feedOverlaySource), or whose protected psn passes overlayBaseSsId's
10213
+ * test at that offset (#routeOverlayRecovered). A base SS_ID placed by it
10214
+ * anchors the release gate only (BLO-52085 D3): fed to the base, it would
10215
+ * make the base drop a late base copy of a keyframe the overlay never
10216
+ * finished, and lift a block's late-source cut, which nothing before
10217
+ * this offset did.
10218
+ */
10219
+ #overlayUnstampedSsIdSeqOffsetByStream = /* @__PURE__ */ new Map();
10084
10220
  /**
10085
10221
  * Streams whose multicast leg delivered a RAP-flagged source packet that was
10086
10222
  * not parsed, typically because its overlap copy was parsed first
@@ -10150,7 +10286,9 @@ var MmtpRouter = class {
10150
10286
  recovered: 0,
10151
10287
  restarts: 0,
10152
10288
  unsequencedDropped: 0,
10153
- protectedDropped: 0
10289
+ protectedDropped: 0,
10290
+ baseFed: 0,
10291
+ baseUndetermined: 0
10154
10292
  };
10155
10293
  /** Callback fired when a delta-track FEC block completes or fails. */
10156
10294
  #onDeltaBlockCompleteCb = null;
@@ -10356,13 +10494,18 @@ var MmtpRouter = class {
10356
10494
  this.#onDeltaBlockCompleteCb?.(packetId, false);
10357
10495
  }
10358
10496
  };
10359
- this.#fecManager.onBlockFailed = (sbn, packetId, catalogTrackName, blockClass) => {
10497
+ this.#fecManager.onBlockFailed = (sbn, packetId, catalogTrackName, blockClass, span) => {
10360
10498
  this.#mseAssemblerFor(packetId, catalogTrackName)?.failBlock(sbn);
10361
10499
  if (this.#isCatalogTrackUnambiguous(packetId, catalogTrackName) && this.#packetIdRoles.get(packetId) === "delta") {
10362
10500
  this.#onDeltaBlockCompleteCb?.(packetId, true);
10363
10501
  }
10364
- onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
10365
- this.#onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
10502
+ if (span === void 0) {
10503
+ onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
10504
+ this.#onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
10505
+ } else {
10506
+ onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass, span);
10507
+ this.#onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass, span);
10508
+ }
10366
10509
  };
10367
10510
  }
10368
10511
  }
@@ -10407,8 +10550,9 @@ var MmtpRouter = class {
10407
10550
  }
10408
10551
  /**
10409
10552
  * FEC-recovered source symbols whose reconstructed header named a
10410
- * packet_sequence_number other than the wire sequence their SS_ID maps to:
10411
- * a hop re-stamped the sequence after the sender protected the packet.
10553
+ * packet_sequence_number other than the wire sequence their SS_ID maps to,
10554
+ * or, rebuilt by the overlay, than their base copy carries: a hop
10555
+ * re-stamped the sequence after the sender protected the packet.
10412
10556
  */
10413
10557
  get restampedRecoveredSequenceCount() {
10414
10558
  return this.#restampedRecoveredSeqs;
@@ -10587,6 +10731,7 @@ var MmtpRouter = class {
10587
10731
  enableMseAssembler(packetId, config, catalogTrackName) {
10588
10732
  const assemblerKey = this.#mseAssemblerKey(packetId, catalogTrackName);
10589
10733
  const previous = this.#mseAssemblers.get(assemblerKey);
10734
+ this.#parser.unsourceFecRelease(packetId, catalogTrackName);
10590
10735
  if (previous) {
10591
10736
  previous.flush();
10592
10737
  previous.dispose();
@@ -10737,7 +10882,8 @@ var MmtpRouter = class {
10737
10882
  fec,
10738
10883
  k,
10739
10884
  offsets: /* @__PURE__ */ new Map(),
10740
- moqBlocks: /* @__PURE__ */ new Set()
10885
+ moqBlocks: /* @__PURE__ */ new Set(),
10886
+ rebuilt: /* @__PURE__ */ new Map()
10741
10887
  };
10742
10888
  this.#overlays.set(repairPacketId, inst);
10743
10889
  return () => {
@@ -10767,12 +10913,18 @@ var MmtpRouter = class {
10767
10913
  */
10768
10914
  resetKeyframeOverlays(sourcePacketId, catalogTrackName) {
10769
10915
  for (const inst of this.#overlaysForSource(sourcePacketId, catalogTrackName)) this.#resetOverlay(inst);
10916
+ for (const [name, stream] of this.#streams.get(sourcePacketId) ?? []) {
10917
+ if (catalogTrackName !== void 0 && name !== catalogTrackName) continue;
10918
+ stream.overlayToBase.routed.clear();
10919
+ stream.overlayToBase.pending.clear();
10920
+ }
10770
10921
  }
10771
10922
  #resetOverlay(inst) {
10772
10923
  inst.fec.resetTrack(inst.repairPacketId, inst.streamName);
10773
10924
  inst.last = void 0;
10774
10925
  inst.offsets.clear();
10775
10926
  inst.moqBlocks.clear();
10927
+ inst.rebuilt.clear();
10776
10928
  }
10777
10929
  #overlaysForSource(sourcePacketId, catalogTrackName) {
10778
10930
  return [...this.#overlays.values()].filter(({ leg }) => leg.sourcePacketId === sourcePacketId && (catalogTrackName === void 0 || leg.sourceCatalogTrackName === void 0 || leg.sourceCatalogTrackName === catalogTrackName));
@@ -10823,18 +10975,33 @@ var MmtpRouter = class {
10823
10975
  * A source packet that carries a 0x8B01 overlay SS_ID is also a symbol of
10824
10976
  * every overlay installed for its source, at that SS_ID, with the bytes the
10825
10977
  * base protects: the packet minus its 4-byte SS_ID trailer, extension
10826
- * included (7.1, 7.4.3).
10827
- */
10828
- #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source) {
10978
+ * included (7.1, 7.4.3). `baseSsId` is that trailer's SS_ID, when the base
10979
+ * FEC reads it.
10980
+ *
10981
+ * The base copy of a packet an overlay rebuilt with no base SS_ID shows
10982
+ * what a base recovery of it would (#routeProcessedFecSymbols, BLO-52085):
10983
+ * its wire packet_sequence_number equal to the protected one rebuilt shows
10984
+ * the stream unstamped at the SS_ID offset it states, for the release gate
10985
+ * (#overlayUnstampedSsIdSeqOffsetByStream); any other shows a hop that
10986
+ * re-stamps it, which is counted (restampedRecoveredSequenceCount).
10987
+ */
10988
+ #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source, baseSsId) {
10829
10989
  if (this.#overlays.size === 0) return;
10830
10990
  const ssId = keyframeOverlaySsId(header);
10831
10991
  if (ssId === void 0) return;
10992
+ let rebuiltPsn;
10832
10993
  for (const inst of this.#overlaysForSource(packetId, catalogTrackName)) {
10833
10994
  this.#noteOverlaySsId(inst, ssId, sequenceNumber);
10995
+ rebuiltPsn ??= inst.rebuilt.get(ssId);
10996
+ inst.rebuilt.delete(ssId);
10834
10997
  const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
10835
10998
  if (identity !== null) {
10836
10999
  inst.offsets.delete(identity.mpuSequenceNumber);
10837
- inst.offsets.set(identity.mpuSequenceNumber, ssId - sequenceNumber >>> 0);
11000
+ inst.offsets.set(identity.mpuSequenceNumber, {
11001
+ psnOffset: ssId - sequenceNumber >>> 0,
11002
+ overlaySsId: ssId,
11003
+ ...baseSsId === void 0 ? {} : { baseSsId }
11004
+ });
10838
11005
  if (inst.offsets.size > OVERLAY_OFFSET_MPUS) inst.offsets.delete(inst.offsets.keys().next().value);
10839
11006
  }
10840
11007
  const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -10856,6 +11023,14 @@ var MmtpRouter = class {
10856
11023
  const recovered = fec.feedSourceSymbol(pid, ssId, symbolData, name);
10857
11024
  if (recovered && !alreadyCompleted) this.#routeOverlayRecovered(inst, coords.sbn, recovered);
10858
11025
  }
11026
+ if (rebuiltPsn === void 0 || this.#classifyPacketId(packetId) === null) return;
11027
+ const streamKey = this.#mediaStreamKey(packetId, catalogTrackName);
11028
+ if (rebuiltPsn !== sequenceNumber) {
11029
+ this.#restampedRecoveredSeqs++;
11030
+ } else if (baseSsId !== void 0) {
11031
+ const offset = this.#ssIdSeqOffsetByStream.get(streamKey);
11032
+ if (offset === baseSsId - sequenceNumber >>> 0) this.#overlayUnstampedSsIdSeqOffsetByStream.set(streamKey, offset);
11033
+ }
10859
11034
  }
10860
11035
  #noteOverlayMoqBlock(inst, blockStart) {
10861
11036
  inst.moqBlocks.add(blockStart);
@@ -10889,11 +11064,16 @@ var MmtpRouter = class {
10889
11064
  }
10890
11065
  /**
10891
11066
  * Route an overlay-recovered block's packets as source media of the
10892
- * overlay's source (7.2: an overlay coordinate yields no base SS_ID). No
10893
- * base-SS_ID derivation runs: no release-gate anchor, no parse ledger, no
10894
- * base re-stamp, no block advance. Each packet's wire sequence is restored
10895
- * from its keyframe's own offset; without one, a stream the base never
10896
- * re-stamped keeps the header's sequence and any other drops the packet.
11067
+ * overlay's source (7.2: an overlay coordinate yields no base SS_ID). A
11068
+ * packet whose base SS_ID is determined independently (overlayBaseSsId,
11069
+ * unstampedBaseSsId) enters the release gate at that SS_ID, as a packet
11070
+ * base FEC recovered does, so it waits behind base frames still in flight,
11071
+ * though not for its own MPU's packets (FrameMeta.fecSbnFirst) and no
11072
+ * longer than unanchored; one whose base SS_ID is undetermined has no
11073
+ * release-gate anchor. No parse ledger, no base re-stamp, no block
11074
+ * advance. Each packet's wire sequence is restored from its keyframe's own
11075
+ * offset; without one, a stream the base never re-stamped keeps the
11076
+ * header's sequence and any other drops the packet.
10897
11077
  */
10898
11078
  #routeOverlayRecovered(inst, blockStart, recovered) {
10899
11079
  const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -10913,22 +11093,139 @@ var MmtpRouter = class {
10913
11093
  const streamKey = this.#mediaStreamKey(sourcePacketId, sourceName);
10914
11094
  const restamped = this.#restampedStreams.has(streamKey);
10915
11095
  const restored = /* @__PURE__ */ new Set();
11096
+ const baseSsIds = /* @__PURE__ */ new Map();
11097
+ const gateOnly = /* @__PURE__ */ new Set();
10916
11098
  const symbols = result.symbols.flatMap((sym) => {
10917
- const offset = inst.offsets.get(sym.fragment.mpuSequenceNumber);
10918
- if (offset !== void 0) {
10919
- const packetSequenceNumber = serial32Add(blockStart, sym.index) - offset >>> 0;
11099
+ const overlaySsId = serial32Add(blockStart, sym.index);
11100
+ const anchor = inst.offsets.get(sym.fragment.mpuSequenceNumber);
11101
+ if (anchor !== void 0) {
11102
+ const packetSequenceNumber = overlaySsId - anchor.psnOffset >>> 0;
10920
11103
  restored.add(packetSequenceNumber);
10921
- return [{ ...sym, packetSequenceNumber }];
11104
+ const out = { ...sym, packetSequenceNumber };
11105
+ const baseSsId = overlayBaseSsId(anchor, overlaySsId, packetSequenceNumber, sym.packetSequenceNumber);
11106
+ if (baseSsId !== void 0) {
11107
+ baseSsIds.set(sym.index, baseSsId);
11108
+ const offset = this.#ssIdSeqOffsetByStream.get(streamKey);
11109
+ if (!this.#sourceSeqReceived(sourcePacketId, packetSequenceNumber, sourceName) && offset === baseSsId - packetSequenceNumber >>> 0) {
11110
+ this.#overlayUnstampedSsIdSeqOffsetByStream.set(streamKey, offset);
11111
+ }
11112
+ }
11113
+ return [out];
11114
+ }
11115
+ if (!restamped) {
11116
+ const offset = this.#ssIdSeqOffsetByStream.get(streamKey);
11117
+ const fedSsId = unstampedBaseSsId(offset, this.#unstampedSsIdSeqOffsetByStream.get(streamKey), sym.packetSequenceNumber);
11118
+ const baseSsId = fedSsId ?? unstampedBaseSsId(offset, this.#overlayUnstampedSsIdSeqOffsetByStream.get(streamKey), sym.packetSequenceNumber);
11119
+ if (baseSsId !== void 0) {
11120
+ baseSsIds.set(sym.index, baseSsId);
11121
+ if (fedSsId === void 0) gateOnly.add(sym.index);
11122
+ } else {
11123
+ inst.rebuilt.set(overlaySsId, sym.packetSequenceNumber);
11124
+ if (inst.rebuilt.size > OVERLAY_REBUILT_LIMIT) inst.rebuilt.delete(inst.rebuilt.keys().next().value);
11125
+ }
11126
+ return [sym];
10922
11127
  }
10923
- if (!restamped) return [sym];
10924
11128
  this.#overlayStats.unsequencedDropped++;
10925
11129
  return [];
10926
11130
  });
10927
11131
  this.#overlayStats.recovered++;
11132
+ const mpuFirst = /* @__PURE__ */ new Map();
11133
+ for (const sym of symbols) {
11134
+ const ssId = baseSsIds.get(sym.index);
11135
+ const mpu = sym.fragment.mpuSequenceNumber;
11136
+ const first = mpuFirst.get(mpu);
11137
+ if (ssId !== void 0 && (first === void 0 || serial32Precedes(ssId, first))) mpuFirst.set(mpu, ssId);
11138
+ }
11139
+ const firstSsIds = /* @__PURE__ */ new Map();
11140
+ for (const sym of symbols) {
11141
+ if (baseSsIds.has(sym.index)) firstSsIds.set(sym.index, mpuFirst.get(sym.fragment.mpuSequenceNumber));
11142
+ }
10928
11143
  this.#routeProcessedFecSymbols(blockStart, { ...result, symbols }, sourcePacketId, sourceName, {
10929
- deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast"
11144
+ deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast",
11145
+ baseSsIds,
11146
+ firstSsIds
10930
11147
  });
10931
11148
  this.#noteOverlayRecoveredRaps(sourcePacketId, sourceName, streamKey, symbols.filter((sym) => restored.has(sym.packetSequenceNumber)));
11149
+ this.#feedOverlayRecoveredToBase(inst, blockStart, symbols, gateOnly.size === 0 ? baseSsIds : new Map([...baseSsIds].filter(([index]) => !gateOnly.has(index))));
11150
+ }
11151
+ /**
11152
+ * Joint decoding (BLO-52085). A packet the overlay rebuilt is a source of
11153
+ * its base block too, once its base SS_ID is determined (overlayBaseSsId,
11154
+ * from a received member of its MPU, else unstampedBaseSsId at an offset a
11155
+ * base recovery showed; `baseSsIds` holds no other),
11156
+ * so it is fed to the base decoder as a rebuilt source
11157
+ * (FECManager.feedRebuiltSourceSymbol): the base block has one erasure
11158
+ * fewer to solve, and its repair can recover the block's other packets.
11159
+ * A base block no repair has stated yet takes it when one does
11160
+ * (#feedPendingRebuilt).
11161
+ *
11162
+ * The overlay route already handled each packet fed (delivered it, or
11163
+ * held an untimed head for its FT=1), so a base recovery routes none of
11164
+ * them again (#routeVerifiedFecSymbols): a second recovered copy of a
11165
+ * held head would wait in the parser for timing its first copy consumed.
11166
+ * Only an overlay block decoded from multicast symbols alone is fed: with
11167
+ * a MoQ symbol in it, the base block's recovery would depend on bytes
11168
+ * that crossed no multicast socket, which the provenance counted from the
11169
+ * block's own arrivals cannot show.
11170
+ */
11171
+ #feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds) {
11172
+ const fec = this.#fecManager;
11173
+ const owner = inst.leg.sourcePacketId;
11174
+ const name = inst.leg.sourceCatalogTrackName;
11175
+ if (!fec?.feedRebuiltSourceSymbol || inst.moqBlocks.has(blockStart)) return;
11176
+ if (this.#classifyPacketId(owner) === null || fec.isTrackConfigured?.(owner) === false) return;
11177
+ const { duplicates, overlayToBase: { routed } } = this.#stream(owner, name);
11178
+ const feeds = [];
11179
+ for (const sym of symbols) {
11180
+ if (duplicates.sourceSeqs.has(sym.packetSequenceNumber)) continue;
11181
+ const ssId = baseSsIds.get(sym.index);
11182
+ if (ssId === void 0) {
11183
+ this.#overlayStats.baseUndetermined++;
11184
+ continue;
11185
+ }
11186
+ routed.delete(ssId);
11187
+ routed.add(ssId);
11188
+ if (routed.size > OVERLAY_ROUTED_LIMIT) routed.delete(routed.values().next().value);
11189
+ feeds.push([ssId, sym.rawSymbol]);
11190
+ }
11191
+ for (const [ssId, symbolData] of feeds) {
11192
+ if (this.#classifyPacketId(owner) === null) return;
11193
+ this.#feedRebuiltToBase(owner, name, ssId, symbolData);
11194
+ }
11195
+ }
11196
+ /** Feed one rebuilt source to its base block, or keep it until a repair states that block. */
11197
+ #feedRebuiltToBase(owner, name, ssId, symbolData) {
11198
+ const fec = this.#fecManager;
11199
+ if (!fec?.feedRebuiltSourceSymbol) return;
11200
+ const coords = fec.locateIsoSource?.(owner, name, ssId);
11201
+ if (coords == null) {
11202
+ const pending = this.#stream(owner, name).overlayToBase.pending;
11203
+ pending.delete(ssId);
11204
+ pending.set(ssId, symbolData.slice());
11205
+ if (pending.size > OVERLAY_PENDING_LIMIT) pending.delete(pending.keys().next().value);
11206
+ return;
11207
+ }
11208
+ const fed = fec.feedRebuiltSourceSymbol(owner, ssId, symbolData, name);
11209
+ if (!fed.taken) return;
11210
+ this.#overlayStats.baseFed++;
11211
+ if (fed.recovered === null) return;
11212
+ const sbn = coords.sbn;
11213
+ this.#routeRecoveredBlock(sbn, fed.recovered, owner, name, () => {
11214
+ fec.cancelBlockTimeout(sbn, owner, name);
11215
+ fec.countRecovery(owner, sbn, name);
11216
+ fec.markBlockCompleted(sbn, owner, name);
11217
+ });
11218
+ }
11219
+ /** A repair stated `block`: the rebuilt sources that waited for it join it now. */
11220
+ #feedPendingRebuilt(owner, name, block) {
11221
+ const pending = this.#streams.get(owner)?.get(name)?.overlayToBase.pending;
11222
+ if (pending === void 0 || pending.size === 0) return;
11223
+ for (const [ssId, symbolData] of [...pending]) {
11224
+ if (this.#classifyPacketId(owner) === null) return;
11225
+ if (serial32Distance(block.start, ssId) >= block.length) continue;
11226
+ pending.delete(ssId);
11227
+ this.#feedRebuiltToBase(owner, name, ssId, symbolData);
11228
+ }
10932
11229
  }
10933
11230
  /** fec-multicast-00 §6.6: report each base block whose RAP MFU fragments
10934
11231
  * the overlay restored, when the keyframe's FT=0 and FT=1 are held too. A
@@ -11068,6 +11365,10 @@ var MmtpRouter = class {
11068
11365
  get unadmittedListedDropCount() {
11069
11366
  return this.#unadmittedListedDrops;
11070
11367
  }
11368
+ /** Source datagrams (multicast or MoQ) a protected flow's bc-provenance v2 receiver released: admitted at once or held, then admitted by a record. Repair symbols and user-agent-admitted datagrams are not counted. Counted at release, before this router's own track checks: a released datagram those drop, which only a track change between hold and release can cause, still counts, so this is not a count of routed media. */
11369
+ get admittedSourceDatagramCount() {
11370
+ return this.#admittedSourceDatagrams;
11371
+ }
11071
11372
  /** MoQ repair symbols of an unlisted track kept out of a governed FEC instance (7.2.7 step 2). */
11072
11373
  get unlistedRepairSetAsideCount() {
11073
11374
  return this.#unlistedRepairSetAside;
@@ -11554,6 +11855,8 @@ var MmtpRouter = class {
11554
11855
  )) return;
11555
11856
  fec.noteBlockActivity?.(blockStart, ownerPacketId, catalogTrackName);
11556
11857
  fec.noteRepairGroupLength?.(blockStart, ownerPacketId, repair.rsbLength, catalogTrackName);
11858
+ this.#feedPendingRebuilt(ownerPacketId, catalogTrackName, placement.block);
11859
+ if (this.#classifyPacketId(ownerPacketId) === null) return;
11557
11860
  const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
11558
11861
  const recovered = fec.feedRepairSymbol(
11559
11862
  ownerPacketId,
@@ -11604,7 +11907,7 @@ var MmtpRouter = class {
11604
11907
  catalogTrackName
11605
11908
  )) continue;
11606
11909
  if (fec.isTrackConfigured?.(ownerPacketId) !== false) {
11607
- fec.trackBlock(blockStart, ownerPacketId, catalogTrackName, esi, payload.evidence);
11910
+ fec.trackBlock(blockStart, ownerPacketId, catalogTrackName, esi, payload.evidence, true);
11608
11911
  this.#requestFecPoke(ownerPacketId, catalogTrackName);
11609
11912
  }
11610
11913
  if (payload.oversized) continue;
@@ -11691,6 +11994,8 @@ var MmtpRouter = class {
11691
11994
  this.#droppedPreSyncVideo.delete(streamKey);
11692
11995
  this.#latestVideoSeqByStream.delete(streamKey);
11693
11996
  this.#ssIdSeqOffsetByStream.delete(streamKey);
11997
+ this.#unstampedSsIdSeqOffsetByStream.delete(streamKey);
11998
+ this.#overlayUnstampedSsIdSeqOffsetByStream.delete(streamKey);
11694
11999
  this.#multicastRapTwinByStream.delete(streamKey);
11695
12000
  this.#lastDirectSourceVideoTsByStream.delete(streamKey);
11696
12001
  this.#lastDirectEmittedVideoTsByStream.delete(streamKey);
@@ -11817,6 +12122,12 @@ var MmtpRouter = class {
11817
12122
  * the outgoing stream stops. The hold is bounded by the incoming stream's
11818
12123
  * own RAP cadence, so no timer is involved.
11819
12124
  *
12125
+ * While the switch is staged, the FEC release gate lets a keyframe the
12126
+ * overlay rebuilt reach it, on either side, when the keyframe did before
12127
+ * the gate anchored it (FecReleaseGate.releaseUnanchored): the switch
12128
+ * decides on what each side delivered, and the commit discards the gate's
12129
+ * frames of the outgoing stream.
12130
+ *
11820
12131
  * The commit is one synchronous transition inside the frame path: the
11821
12132
  * outgoing stream's already-admitted frames are released (its queued FEC
11822
12133
  * gap fills only up to the RAP, since recovery can queue a frame ahead of
@@ -11867,6 +12178,9 @@ var MmtpRouter = class {
11867
12178
  droppedIncomingFrames: 0
11868
12179
  };
11869
12180
  this.#staged = state;
12181
+ if (this.#parser.fecReleaseHoldsRebuilt(from.packetId, from.catalogTrackName)) {
12182
+ this.#requestFecPoke(from.packetId, from.catalogTrackName);
12183
+ }
11870
12184
  return {
11871
12185
  cancel: () => {
11872
12186
  if (this.#staged !== state) return false;
@@ -11949,7 +12263,17 @@ var MmtpRouter = class {
11949
12263
  */
11950
12264
  #routeParsedFrame(data, meta) {
11951
12265
  if (this.#classifyPacketId(meta.packetId) === null) return;
11952
- if (this.#staged !== null && this.#interceptSwitchFrame(data, meta)) return;
12266
+ if (this.#staged !== null) {
12267
+ let consumed = false;
12268
+ this.#fecPokeDepth++;
12269
+ try {
12270
+ consumed = this.#interceptSwitchFrame(data, meta);
12271
+ } finally {
12272
+ this.#fecPokeDepth--;
12273
+ this.#flushPendingFecPokes();
12274
+ }
12275
+ if (consumed) return;
12276
+ }
11953
12277
  this.#deliverParsedFrame(data, meta);
11954
12278
  }
11955
12279
  #commitStreamSwitch(state, rap, reason) {
@@ -12101,12 +12425,16 @@ var MmtpRouter = class {
12101
12425
  this.#parser.deferFecRelease(work);
12102
12426
  } finally {
12103
12427
  this.#fecPokeDepth--;
12104
- if (this.#fecPokeDepth === 0 && this.#pendingFecPokes.size > 0 && !this.#disposed) {
12105
- const pokes = [...this.#pendingFecPokes.values()];
12106
- this.#pendingFecPokes.clear();
12107
- for (const poke of pokes) {
12108
- this.#parser.pokeFecRelease(poke.packetId, poke.catalogTrackName);
12109
- }
12428
+ this.#flushPendingFecPokes();
12429
+ }
12430
+ }
12431
+ /** Run the pokes requested while #fecPokeDepth was raised, once it is 0. */
12432
+ #flushPendingFecPokes() {
12433
+ if (this.#fecPokeDepth === 0 && this.#pendingFecPokes.size > 0 && !this.#disposed) {
12434
+ const pokes = [...this.#pendingFecPokes.values()];
12435
+ this.#pendingFecPokes.clear();
12436
+ for (const poke of pokes) {
12437
+ this.#parser.pokeFecRelease(poke.packetId, poke.catalogTrackName);
12110
12438
  }
12111
12439
  }
12112
12440
  }
@@ -12184,6 +12512,14 @@ var MmtpRouter = class {
12184
12512
  onRap: (packetId, catalogTrackName, ssId) => {
12185
12513
  for (const observer of this.#fecRapObservers) observer(packetId, catalogTrackName, ssId);
12186
12514
  },
12515
+ // A staged switch commits on when each side's frames reach it
12516
+ // (#interceptSwitchFrame): both sides' overlay keyframes reach it when
12517
+ // they did unanchored.
12518
+ releaseUnanchored: (packetId, catalogTrackName) => {
12519
+ const staged = this.#staged;
12520
+ const stream = { packetId, ...catalogTrackName === void 0 ? {} : { catalogTrackName } };
12521
+ return staged !== null && (isStream(stream, staged.from) || isStream(stream, staged.to));
12522
+ },
12187
12523
  onReleased: (data, meta) => {
12188
12524
  if (meta.trackType !== "video" || meta.mpuSequenceNumber === void 0) return;
12189
12525
  const timing = meta.authoredTiming;
@@ -12325,6 +12661,7 @@ var MmtpRouter = class {
12325
12661
  const parsed = this.#parser.parsePacket(packet);
12326
12662
  if (!parsed) return;
12327
12663
  const info = parsed.info;
12664
+ if (manifestAdmitted && !info.isRepair && ingress?.admittedBy !== USER_AGENT_VERIFIED) this.#admittedSourceDatagrams++;
12328
12665
  if (source === "multicast" && !manifestAdmitted) {
12329
12666
  this.#fecManager?.noteMulticastArrival?.(info.packetId, info.sequenceNumber);
12330
12667
  }
@@ -12606,7 +12943,8 @@ var MmtpRouter = class {
12606
12943
  parsed.header,
12607
12944
  info.sequenceNumber,
12608
12945
  info.rapFlag,
12609
- source
12946
+ source,
12947
+ fecPayloadId?.ssId
12610
12948
  );
12611
12949
  }
12612
12950
  }
@@ -12632,7 +12970,8 @@ var MmtpRouter = class {
12632
12970
  source: parserOptions?.source,
12633
12971
  deliveryProvenance: parserOptions?.deliveryProvenance,
12634
12972
  catalogTrackName: parserOptions?.catalogTrackName,
12635
- ...parserOptions?.fecSbn === void 0 ? {} : { fecSbn: parserOptions.fecSbn }
12973
+ ...parserOptions?.fecSbn === void 0 ? {} : { fecSbn: parserOptions.fecSbn },
12974
+ ...parserOptions?.fecSbnFirst === void 0 ? {} : { fecSbnFirst: parserOptions.fecSbnFirst }
12636
12975
  };
12637
12976
  if (parsed) this.#parser.feedParsed(packet, parsed, feedOptions);
12638
12977
  else this.#parser.feed(packet, feedOptions);
@@ -12756,7 +13095,8 @@ var MmtpRouter = class {
12756
13095
  if (stream === void 0) {
12757
13096
  stream = {
12758
13097
  key: JSON.stringify([packetId, catalogTrackName ?? null]),
12759
- duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId))
13098
+ duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId)),
13099
+ overlayToBase: { routed: /* @__PURE__ */ new Set(), pending: /* @__PURE__ */ new Map() }
12760
13100
  };
12761
13101
  byName.set(catalogTrackName, stream);
12762
13102
  }
@@ -13034,6 +13374,13 @@ var MmtpRouter = class {
13034
13374
  * frames by epoch only if pre-protection input ever matters.
13035
13375
  */
13036
13376
  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted = false) {
13377
+ const overlayRouted = ownerPacketId == null ? void 0 : this.#streams.get(ownerPacketId)?.get(catalogTrackName)?.overlayToBase.routed;
13378
+ if (overlayRouted !== void 0 && overlayRouted.size > 0) {
13379
+ result = {
13380
+ ...result,
13381
+ symbols: result.symbols.filter((sym) => !overlayRouted.has(this.#fecAnchorForRecovered(blockId, sym.index)))
13382
+ };
13383
+ }
13037
13384
  const entry = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
13038
13385
  const receiver = entry === void 0 || entry === "ambiguous" ? entry : entry.receiver;
13039
13386
  const userAgent = !assisted && entry !== void 0 && entry !== "ambiguous" && entry.protected === true && entry.userAgent === true;
@@ -13090,7 +13437,12 @@ var MmtpRouter = class {
13090
13437
  #routeProcessedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, overlay) {
13091
13438
  if (ownerPacketId == null) return;
13092
13439
  if (this.#classifyPacketId(ownerPacketId) === null) return;
13093
- const fecSbnOf = (index) => overlay ? {} : { fecSbn: this.#fecAnchorForRecovered(blockId, index) };
13440
+ const fecSbnOf = (index) => {
13441
+ if (!overlay) return { fecSbn: this.#fecAnchorForRecovered(blockId, index) };
13442
+ const fecSbn = overlay.baseSsIds.get(index);
13443
+ const fecSbnFirst = overlay.firstSsIds.get(index);
13444
+ return fecSbn === void 0 || fecSbnFirst === void 0 ? {} : { fecSbn, fecSbnFirst };
13445
+ };
13094
13446
  const streamKey = this.#mediaStreamKey(ownerPacketId, catalogTrackName);
13095
13447
  const ssIdSeqOffset = overlay ? void 0 : this.#ssIdSeqOffsetByStream.get(streamKey);
13096
13448
  if (ssIdSeqOffset !== void 0) {
@@ -13098,7 +13450,10 @@ var MmtpRouter = class {
13098
13450
  ...result,
13099
13451
  symbols: result.symbols.map((sym) => {
13100
13452
  const wire = this.#fecAnchorForRecovered(blockId, sym.index) - ssIdSeqOffset >>> 0;
13101
- if (wire === sym.packetSequenceNumber) return sym;
13453
+ if (wire === sym.packetSequenceNumber) {
13454
+ this.#unstampedSsIdSeqOffsetByStream.set(streamKey, ssIdSeqOffset);
13455
+ return sym;
13456
+ }
13102
13457
  this.#restampedRecoveredSeqs++;
13103
13458
  this.#restampedStreams.add(streamKey);
13104
13459
  return { ...sym, packetSequenceNumber: wire };