@blockcast/mmt-container 0.1.0 → 0.3.0

package/dist/fec-manager.js

@@ -0,0 +1,3899 @@
+// src/track-session.ts
+import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
+function computeFecDeliveryWindowMs(config) {
+  const fecInterleaveMs = config.interleaveDepthMs;
+  const fecK = config.sourceSymbols;
+  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
+    throw new Error(
+      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+    );
+  }
+  if (!Number.isFinite(fecK) || fecK <= 0) {
+    throw new Error(
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+    );
+  }
+  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
+  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
+}
+
+// src/delivery-gap.ts
+var DeliveryGapEstimator = class {
+  /** Most recent arrival, or undefined before the first one since reset. */
+  #lastArrivalMs;
+  /** Last MMTP packet_sequence_number seen per packet_id. */
+  #lastSequence = /* @__PURE__ */ new Map();
+  /**
+   * Monotonic deque of (arrivalMs, gapMs): gaps strictly decrease from head to
+   * tail, so the head is the window maximum. Amortized O(1) per arrival.
+   */
+  #times = [];
+  #gaps = [];
+  #head = 0;
+  #windowMs;
+  /**
+   * @param windowMs trailing window in ms, which also caps the reported gap,
+   *   or undefined when the catalog gives none (no gap is reported).
+   */
+  setWindowMs(windowMs) {
+    if (windowMs !== void 0 && !(Number.isFinite(windowMs) && windowMs > 0)) {
+      throw new Error(
+        `[DeliveryGap] window must be a finite positive ms value or undefined (got ${windowMs})`
+      );
+    }
+    this.#windowMs = windowMs;
+  }
+  get windowMs() {
+    return this.#windowMs;
+  }
+  /**
+   * Record one multicast datagram arrival at receiver time `nowMs`, carrying
+   * MMTP `packetSequenceNumber` (32-bit, per packet_id) on `packetId`.
+   */
+  noteArrival(nowMs, packetId, packetSequenceNumber) {
+    const last = this.#lastArrivalMs;
+    const previousSequence = this.#lastSequence.get(packetId);
+    this.#lastArrivalMs = nowMs;
+    this.#lastSequence.set(packetId, packetSequenceNumber);
+    if (last === void 0 || previousSequence === void 0) return;
+    if (this.#windowMs === void 0) return;
+    if (previousSequence + 1 >>> 0 !== packetSequenceNumber >>> 0) return;
+    const gap = nowMs - last;
+    this.#evict(nowMs);
+    while (this.#gaps.length > this.#head && this.#gaps[this.#gaps.length - 1] <= gap) {
+      this.#gaps.pop();
+      this.#times.pop();
+    }
+    this.#gaps.push(gap);
+    this.#times.push(nowMs);
+    this.#compact();
+  }
+  /**
+   * Largest gap observed within the window ending at `nowMs`, at most the
+   * window itself; 0 if none or when no window is set.
+   */
+  peakGapMs(nowMs) {
+    const windowMs = this.#windowMs;
+    if (windowMs === void 0) return 0;
+    this.#evict(nowMs);
+    return this.#gaps.length > this.#head ? Math.min(this.#gaps[this.#head], windowMs) : 0;
+  }
+  /** Forget everything: a new delivery path starts with no measurement. */
+  reset() {
+    this.#lastArrivalMs = void 0;
+    this.#lastSequence.clear();
+    this.#times = [];
+    this.#gaps = [];
+    this.#head = 0;
+  }
+  #evict(nowMs) {
+    const windowMs = this.#windowMs;
+    if (windowMs === void 0) return;
+    while (this.#times.length > this.#head && this.#times[this.#head] < nowMs - windowMs) {
+      this.#head++;
+    }
+  }
+  #compact() {
+    if (this.#head > 0 && this.#head * 2 >= this.#times.length) {
+      this.#times = this.#times.slice(this.#head);
+      this.#gaps = this.#gaps.slice(this.#head);
+      this.#head = 0;
+    }
+  }
+};
+
+// src/fec-manager.ts
+import {
+  deriveFecInterleaveDepth as deriveFecInterleaveDepth2,
+  deriveFecRetentionBlocks,
+  tryDeriveFecRetentionBlocks
+} from "@blockcast/mmt-fec";
+
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// ../mmt-base/dist/mmtp.js
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/serial-number.js
+var SERIAL32_SPAN = 4294967296;
+var SERIAL32_HALF = 2147483648;
+function assertUint32(value, name) {
+  if (!Number.isInteger(value) || value < 0 || value >= SERIAL32_SPAN) {
+    throw new RangeError(`${name} must be a uint32 (got ${value})`);
+  }
+}
+function serial32Add(s, n) {
+  assertUint32(s, "s");
+  if (!Number.isInteger(n) || n <= -SERIAL32_HALF || n >= SERIAL32_HALF) {
+    throw new RangeError(`serial addend must lie in (-2^31, 2^31) (got ${n})`);
+  }
+  return (s + n + SERIAL32_SPAN) % SERIAL32_SPAN;
+}
+function serial32Distance(from, to) {
+  return to - from >>> 0;
+}
+function serial32Precedes(a, b) {
+  const distance = serial32Distance(a, b);
+  return distance !== 0 && distance < SERIAL32_HALF;
+}
+function kStrideBlockStart(sbn, k) {
+  assertUint32(sbn, "sbn");
+  if (!Number.isInteger(k) || k < 1 || k >= SERIAL32_HALF) {
+    throw new RangeError(`k must be a positive integer below 2^31 (got ${k})`);
+  }
+  const high = Math.floor(sbn / 65536);
+  const low = sbn % 65536;
+  return (high * k % SERIAL32_SPAN * 65536 + low * k) % SERIAL32_SPAN;
+}
+function kStrideBlockPrecedes(a, b, k) {
+  return serial32Precedes(kStrideBlockStart(a, k), kStrideBlockStart(b, k));
+}
+function kStrideBlocksBehind(a, b, k) {
+  const from = kStrideBlockStart(a, k);
+  const to = kStrideBlockStart(b, k);
+  if (!serial32Precedes(from, to))
+    return 0;
+  return Math.ceil(serial32Distance(from, to) / k);
+}
+function isKStrideBlock(sbn, k) {
+  return Number.isInteger(sbn) && sbn >= 0 && sbn < SERIAL32_SPAN && Number.isInteger(k) && k >= 1 && k < SERIAL32_HALF;
+}
+function kStrideNextBlock(sbn, k) {
+  assertUint32(sbn, "sbn");
+  kStrideBlockStart(sbn, k);
+  return (sbn + 1) * k >= SERIAL32_SPAN ? 0 : sbn + 1;
+}
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+function isFecBlockProfile(value) {
+  return value === "k-padded-v1" || value === "iso-ssbg1-v1";
+}
+function parseFecBlockProfile(value, where) {
+  if (isFecBlockProfile(value))
+    return value;
+  if (value === void 0) {
+    throw new Error(`${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`);
+  }
+  throw new Error(`${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
+}
+var SSBG1_LENGTH_FIELD_BYTES = 2;
+function ssbg1MaxPacketLength(symbolSize) {
+  return symbolSize - SSBG1_LENGTH_FIELD_BYTES;
+}
+function ssbg1FitsSymbol(packetLength, symbolSize) {
+  return Number.isSafeInteger(packetLength) && packetLength >= 0 && packetLength <= ssbg1MaxPacketLength(symbolSize) && packetLength <= 65535;
+}
+function isoBlockEnd(ssStart, ssbLength) {
+  return serial32Add(ssStart, ssbLength);
+}
+function isoBlockContains(ssStart, ssbLength, ssId) {
+  return serial32Distance(ssStart, ssId) < ssbLength;
+}
+function isoBlocksBehindLowerBound(a, b, kMax) {
+  if (!Number.isSafeInteger(kMax) || kMax <= 0) {
+    throw new Error(`iso-ssbg1-v1 block horizon needs a positive maximum K (got ${kMax})`);
+  }
+  return serial32Precedes(a, b) ? Math.floor(serial32Distance(a, b) / kMax) : 0;
+}
+
+// src/iso-block-locator.ts
+var IsoBlockLocator = class _IsoBlockLocator {
+  /** Known blocks and spans, in serial order of their start. */
+  #blocks = [];
+  /** Held first-arrival sources whose block no repair has stated yet. */
+  #held = /* @__PURE__ */ new Map();
+  /** End of contiguous coverage: the SS_ID the next unknown block starts at. */
+  #coverageEnd;
+  #kMax;
+  #retentionBlocks;
+  #heldEvicted = 0;
+  #newest;
+  /**
+   * @param kMax the catalog maximum K (`sourceSymbols`), the bound on SSB_length.
+   * @param retentionBlocks how many blocks behind the newest position the
+   *   locator keeps, derived by its owner from catalog timing; required, so
+   *   no locator exists without retention.
+   */
+  constructor(kMax, retentionBlocks) {
+    if (!Number.isSafeInteger(kMax) || kMax <= 0) {
+      throw new Error(`[IsoBlockLocator] maximum K must be a positive integer (got ${kMax})`);
+    }
+    this.#kMax = kMax;
+    this.#retentionBlocks = _IsoBlockLocator.#checkedRetention(retentionBlocks);
+  }
+  static #checkedRetention(retentionBlocks) {
+    if (!Number.isSafeInteger(retentionBlocks) || retentionBlocks <= 0) {
+      throw new Error(
+        `[IsoBlockLocator] retention must be a positive integer number of blocks (got ${retentionBlocks})`
+      );
+    }
+    return retentionBlocks;
+  }
+  get kMax() {
+    return this.#kMax;
+  }
+  /** Blocks behind the newest position the locator keeps. */
+  get retentionBlocks() {
+    return this.#retentionBlocks;
+  }
+  /** Update the retention when the catalog timing it derives from changes. */
+  set retentionBlocks(retentionBlocks) {
+    this.#retentionBlocks = _IsoBlockLocator.#checkedRetention(retentionBlocks);
+  }
+  /** The most sources held at once: the SS_IDs the retention horizon spans. */
+  get heldCapacity() {
+    return (this.#retentionBlocks + 1) * this.#kMax;
+  }
+  /**
+   * The newest position the stream has reached (RFC 1982 order): the newest
+   * SS_ID of a source held, or fed once located (`observe`), or SS_Start of a
+   * placed repair, so no source the stream has fed follows it. Undefined
+   * before the first one.
+   */
+  get newest() {
+    return this.#newest;
+  }
+  /** Advance `newest` to `position` if it is newer; retires nothing. */
+  observe(position) {
+    if (this.#newest === void 0 || serial32Precedes(this.#newest, position)) this.#newest = position;
+  }
+  /** Held sources evicted by `heldCapacity` (never by the horizon itself). */
+  get heldEvicted() {
+    return this.#heldEvicted;
+  }
+  /** Number of known blocks and spans. */
+  get blockCount() {
+    return this.#blocks.length;
+  }
+  /** End of contiguous coverage, or undefined before the first repair. */
+  get coverageEnd() {
+    return this.#coverageEnd;
+  }
+  /** Number of sources held for a block no repair has stated yet. */
+  get heldCount() {
+    return this.#held.size;
+  }
+  /** The known block or span containing `ssId`, with its ESI. */
+  locate(ssId) {
+    for (let i = this.#blocks.length - 1; i >= 0; i--) {
+      const block = this.#blocks[i];
+      if (isoBlockContains(block.start, block.length, ssId)) {
+        return { block, esi: serial32Distance(block.start, ssId) };
+      }
+    }
+    return null;
+  }
+  /** The known block or span starting exactly at `start`. */
+  blockAt(start) {
+    return this.#blocks.find((block) => block.start === start);
+  }
+  /** Known blocks and spans overlapping the SS_IDs strictly between `a` and `b`. */
+  blocksBetween(a, b) {
+    const first = a + 1 >>> 0;
+    const count = serial32Distance(a, b) - 1;
+    if (!serial32Precedes(a, b) || count <= 0) return [];
+    return this.#blocks.filter((block) => {
+      const toBlock = serial32Distance(first, block.start);
+      const fromBlock = serial32Distance(block.start, first);
+      return toBlock < count || fromBlock < block.length;
+    });
+  }
+  /**
+   * Whether every SS_ID strictly between `a` and `b` lies in known coverage,
+   * so no block that could hold them is still to be stated by a repair.
+   */
+  coversBetween(a, b) {
+    if (this.#coverageEnd === void 0) return false;
+    if (!serial32Precedes(a, b) || serial32Distance(a, b) <= 1) return true;
+    return serial32Precedes(b - 1 >>> 0, this.#coverageEnd);
+  }
+  /**
+   * Hold a first-arrival source symbol whose block is not yet known. Returns
+   * false for a second copy of an SS_ID already held, so the first copy wins.
+   * Retires behind `ssId` (see the class note).
+   */
+  hold(ssId, payload) {
+    if (this.#held.has(ssId)) return false;
+    this.#held.set(ssId, payload);
+    this.retireBehind(ssId);
+    for (const oldest of this.#held.keys()) {
+      if (this.#held.size <= this.heldCapacity) break;
+      this.#held.delete(oldest);
+      this.#heldEvicted++;
+    }
+    return true;
+  }
+  /** Whether `ssId` is held unplaced. */
+  isHeld(ssId) {
+    return this.#held.has(ssId);
+  }
+  /**
+   * Apply one repair symbol's `(SS_Start, SSB_length)`. The first repair of a
+   * block states its range and places every held source in it; later repair
+   * symbols of the same block change nothing. A range that contradicts a
+   * known block (a different length, or an overlap with another block or a
+   * span) fails closed: the repair symbol is dropped and no block changes.
+   * A newly stated block retires behind its SS_Start (see the class note).
+   */
+  placeRepair(start, length) {
+    if (!Number.isSafeInteger(length) || length <= 0 || length > this.#kMax) {
+      return { status: "conflict", reason: `SSB_length ${length} is outside 1..${this.#kMax}` };
+    }
+    const known = this.blockAt(start);
+    if (known !== void 0) {
+      if (known.span) {
+        return { status: "overlap", reason: `repair block ${start}+${length} falls inside a repair-less span` };
+      }
+      if (known.length !== length) {
+        return {
+          status: "conflict",
+          reason: `repair SSB_length ${length} conflicts with ${known.length} for SS_Start ${start}`
+        };
+      }
+      return { status: "placed", block: known, placed: [] };
+    }
+    for (const block2 of this.#blocks) {
+      if (isoBlockContains(block2.start, block2.length, start) || isoBlockContains(start, length, block2.start)) {
+        return {
+          status: "overlap",
+          reason: `repair block ${start}+${length} overlaps known block ${block2.start}+${block2.length}`
+        };
+      }
+    }
+    let span;
+    if (this.#coverageEnd === void 0) {
+      for (const ssId of this.#held.keys()) {
+        if (serial32Precedes(ssId, start)) this.#held.delete(ssId);
+      }
+      this.#coverageEnd = start;
+    } else if (serial32Precedes(start, this.#coverageEnd)) {
+      return { status: "stale", reason: `repair block ${start}+${length} precedes known coverage` };
+    } else if (start !== this.#coverageEnd) {
+      const spanBlock = {
+        start: this.#coverageEnd,
+        length: serial32Distance(this.#coverageEnd, start),
+        span: true
+      };
+      span = { block: spanBlock, placed: this.#claim(spanBlock) };
+      this.#blocks.push(spanBlock);
+    }
+    const block = { start, length, span: false };
+    const placed = this.#claim(block);
+    this.#blocks.push(block);
+    this.#coverageEnd = isoBlockEnd(start, length);
+    this.retireBehind(start);
+    return span === void 0 ? { status: "placed", block, placed } : { status: "placed", block, placed, span };
+  }
+  /**
+   * Retire every block and span whose last SS_ID, and every held source,
+   * lies more than `retentionBlocks` blocks behind `position`, with the shared
+   * lower-bound metric (`isoBlocksBehindLowerBound`) every ISO interleave
+   * horizon uses. Returns the retired block starts.
+   */
+  retireBehind(position) {
+    this.observe(position);
+    const horizon = this.#retentionBlocks;
+    const retired = [];
+    for (let i = this.#blocks.length - 1; i >= 0; i--) {
+      const block = this.#blocks[i];
+      const last = serial32Add(block.start, block.length - 1);
+      if (isoBlocksBehindLowerBound(last, position, this.#kMax) > horizon) {
+        retired.push(block.start);
+        this.#blocks.splice(i, 1);
+      }
+    }
+    for (const ssId of [...this.#held.keys()]) {
+      if (isoBlocksBehindLowerBound(ssId, position, this.#kMax) > horizon) this.#held.delete(ssId);
+    }
+    return retired;
+  }
+  /** Forget everything (publisher restart, track reset). */
+  reset() {
+    this.#blocks.length = 0;
+    this.#held.clear();
+    this.#coverageEnd = void 0;
+    this.#newest = void 0;
+  }
+  #claim(block) {
+    const placed = [];
+    for (const [ssId, payload] of this.#held) {
+      if (!isoBlockContains(block.start, block.length, ssId)) continue;
+      placed.push({ ssId, esi: serial32Distance(block.start, ssId), payload });
+      this.#held.delete(ssId);
+    }
+    placed.sort((x, y) => x.esi - y.esi);
+    return placed;
+  }
+};
+
+// src/fec-state.ts
+var MIN_INTERLEAVE_DEPTH_MS = 33;
+var FEC_INACTIVE_REASONS = Object.freeze([
+  "no-catalog-fec",
+  "reliable-moq",
+  "no-multicast-bridge"
+]);
+var INACTIVE = Object.freeze({
+  "no-catalog-fec": Object.freeze({ state: "inactive", reason: "no-catalog-fec" }),
+  "reliable-moq": Object.freeze({ state: "inactive", reason: "reliable-moq" }),
+  "no-multicast-bridge": Object.freeze({ state: "inactive", reason: "no-multicast-bridge" })
+});
+
+// src/block-policy.ts
+import { deriveFecInterleaveDepth } from "@blockcast/mmt-fec";
+function keyframeIntervalMediaTicks(geometry, mediaTimescale) {
+  if (geometry.trackKind !== "video" || geometry.mode !== "classifying") return null;
+  if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0) return null;
+  const { ticks, timescale } = geometry.keyframeInterval;
+  if (!Number.isSafeInteger(ticks) || !Number.isSafeInteger(timescale)) return null;
+  const scaled = BigInt(ticks) * BigInt(mediaTimescale);
+  const divisor = BigInt(timescale);
+  if (scaled % divisor !== 0n) return null;
+  return scaled / divisor;
+}
+function compareDataUnitStarts(a, b) {
+  return a.movieFragment - b.movieFragment || a.idx - b.idx || a.offset - b.offset;
+}
+var BlockClassifier = class {
+  #geometry;
+  #mode;
+  #reason;
+  /**
+   * False once the stream showed that an MPU boundary does not bound its
+   * RAPs (a RAP inside an MPU, or an MPU longer than a GOP). Recorded in
+   * every mode: the stall/conceal decision relies on it even when the
+   * catalog geometry already runs the classifier `all-protected`.
+   */
+  #mpuBoundsRaps = true;
+  #blocks = /* @__PURE__ */ new Map();
+  /**
+   * P1 ledger, kept for the MPUs within the classification horizon (the
+   * highest MPU seen and the one before it): the SBN span of every source
+   * packet of each MPU, and each MPU's data-unit starts in authored order.
+   * Valid only within one continuous SBN sequence; a source discontinuity
+   * clears it (`noteSourceDiscontinuity`).
+   */
+  #mpuSbnSpans = /* @__PURE__ */ new Map();
+  #dataUnitStarts = /* @__PURE__ */ new Map();
+  #highestMpu = null;
+  /** MPU → movie_fragment_sequence_number observed in it. */
+  #mpuFragments = /* @__PURE__ */ new Map();
+  #lastRap = null;
+  constructor(geometry) {
+    this.#geometry = geometry;
+    this.#mode = "classifying";
+    this.#reason = null;
+    this.reset(geometry);
+  }
+  get geometry() {
+    return this.#geometry;
+  }
+  get mode() {
+    return this.#mode;
+  }
+  get reason() {
+    return this.#reason;
+  }
+  /**
+   * Whether "same MPU on both sides of a gap" still proves the gap held no
+   * RAP. It stops holding for the rest of the epoch once a RAP was received
+   * inside an MPU or an MPU ran longer than a GOP.
+   */
+  get mpuBoundsRaps() {
+    return this.#mpuBoundsRaps;
+  }
+  /** Begin a fresh epoch (catalog change or track reset). */
+  reset(geometry = this.#geometry) {
+    this.#geometry = geometry;
+    this.#blocks.clear();
+    this.#clearContiguityLedger();
+    this.#mpuFragments.clear();
+    this.#lastRap = null;
+    this.#mpuBoundsRaps = true;
+    if (geometry.trackKind === "video" && geometry.mode === "all-protected") {
+      this.#mode = "all-protected";
+      this.#reason = geometry.reason;
+    } else {
+      this.#mode = "classifying";
+      this.#reason = null;
+    }
+  }
+  /**
+   * Retire this classifier (its stream moves to a new catalog epoch). Every
+   * block it had classified `delta` loses the evidence behind that class and
+   * reads `unknown` from now on; the returned changes say so.
+   */
+  retire() {
+    const changes = [];
+    for (const [sbn, block] of this.#blocks) {
+      if (block.cls !== "delta") continue;
+      block.cls = "unknown";
+      changes.push({
+        kind: "reclassified",
+        sbn,
+        from: "delta",
+        to: "unknown",
+        evidence: "classifier-disabled"
+      });
+    }
+    return changes;
+  }
+  /**
+   * The stream's SBN sequence restarted (FECManager source discontinuity:
+   * a publisher restart, or the SS_ID space wrapped). Authored order and SBN
+   * order are comparable only within one continuous sequence, so the P1
+   * ledger starts again.
+   */
+  noteSourceDiscontinuity() {
+    this.#clearContiguityLedger();
+  }
+  /** Register a block that exists without evidence (a vanished block). */
+  touch(sbn) {
+    this.#blockFor(sbn);
+  }
+  /** Forget a resolved block. */
+  forget(sbn) {
+    this.#blocks.delete(sbn);
+  }
+  classOf(sbn) {
+    if (this.#geometry.trackKind === "audio") return "audio";
+    return this.#blocks.get(sbn)?.cls ?? "unknown";
+  }
+  /** Record one first-arrival source symbol's evidence for block `sbn`. */
+  observe(sbn, evidence) {
+    if (this.#geometry.trackKind === "audio") return [];
+    const changes = [];
+    const block = this.#blockFor(sbn);
+    if (evidence.rap) block.rapSeen = true;
+    if (evidence.mpu !== void 0) block.mpus.add(evidence.mpu);
+    if (evidence.idx !== void 0) {
+      block.idxMin = block.idxMin === void 0 ? evidence.idx : Math.min(block.idxMin, evidence.idx);
+      block.idxMax = block.idxMax === void 0 ? evidence.idx : Math.max(block.idxMax, evidence.idx);
+    }
+    if (evidence.rap && evidence.idx !== void 0 && evidence.idx !== 0) {
+      this.#mpuBoundsRaps = false;
+    }
+    const violation = this.#checkInvariants(sbn, block, evidence);
+    if (violation !== null) changes.push(...this.#disable(violation));
+    const next = this.#classify(block);
+    if (next !== block.cls && this.#allowed(block.cls, next)) {
+      changes.push({
+        kind: "reclassified",
+        sbn,
+        from: block.cls,
+        to: next,
+        evidence: this.#evidenceFor(block, next)
+      });
+      block.cls = next;
+    }
+    return changes;
+  }
+  /**
+   * Record a RAP frame released in order. Released MPU-start RAPs of MPUs m
+   * and m+n must be exactly n keyframe intervals apart in the media
+   * timescale, compared as integers.
+   *
+   * Comparing only consecutive MPUs would miss exactly the case the window
+   * rule cannot survive: a short MPU whose successor's RAP was lost (that
+   * RAP-bearing block is the one a wrong G calls delta), because the next
+   * released RAP then belongs to m+2. Every MPU is one interval long, so the
+   * span to any later released RAP proves or refutes all MPUs in between.
+   */
+  noteReleasedRap(mpu, presentationTime, mediaTimescale) {
+    if (this.#geometry.trackKind === "audio" || this.#mode === "all-protected") {
+      return [];
+    }
+    const interval = keyframeIntervalMediaTicks(this.#geometry, mediaTimescale);
+    if (interval === null) return this.#disable("keyframe-interval-not-media-integral");
+    const previous = this.#lastRap;
+    if (previous !== null && previous.mpu === mpu && previous.mediaTimescale === mediaTimescale) {
+      return [];
+    }
+    this.#lastRap = { mpu, presentationTime, mediaTimescale };
+    if (previous === null || mpu < previous.mpu || previous.mediaTimescale !== mediaTimescale) {
+      return [];
+    }
+    if (presentationTime - previous.presentationTime === interval * BigInt(mpu - previous.mpu)) {
+      return [];
+    }
+    return this.#disable("rap-spacing-mismatch");
+  }
+  #blockFor(sbn) {
+    let block = this.#blocks.get(sbn);
+    if (!block) {
+      block = { rapSeen: false, mpus: /* @__PURE__ */ new Set(), cls: "unknown" };
+      this.#blocks.set(sbn, block);
+    }
+    return block;
+  }
+  #checkInvariants(sbn, block, evidence) {
+    if (this.#mode === "all-protected" || this.#geometry.trackKind !== "video") return null;
+    const geometry = this.#geometry;
+    if (geometry.mode !== "classifying") return null;
+    if (evidence.rap && evidence.idx !== void 0 && evidence.idx !== 0) {
+      return "rap-not-mpu-start";
+    }
+    if (evidence.idx !== void 0 && evidence.idx >= geometry.gopFrames) {
+      return "mpu-longer-than-gop";
+    }
+    if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0 && block.idxMax - block.idxMin >= geometry.interleaveUnits) {
+      return "block-wider-than-interleave";
+    }
+    if (evidence.mpu !== void 0 && evidence.movieFragment !== void 0) {
+      const fragment = this.#mpuFragments.get(evidence.mpu);
+      if (fragment === void 0) {
+        this.#mpuFragments.set(evidence.mpu, evidence.movieFragment);
+        for (const mpu of this.#mpuFragments.keys()) {
+          if (mpu + 1 < evidence.mpu) this.#mpuFragments.delete(mpu);
+        }
+      } else if (fragment !== evidence.movieFragment) {
+        return "mpu-multiple-fragments";
+      }
+    }
+    if (evidence.mpu !== void 0 && this.#contradictsAuthoredOrder(sbn, evidence.mpu, evidence)) {
+      return "block-not-contiguous";
+    }
+    return null;
+  }
+  #clearContiguityLedger() {
+    this.#mpuSbnSpans.clear();
+    this.#dataUnitStarts.clear();
+    this.#highestMpu = null;
+  }
+  /**
+   * P1 check for one source packet of MPU `mpu` in block `sbn`, then record
+   * it. True when some recorded packet's authored order and SBN order
+   * disagree with this one's (see the class comment). Only positions the
+   * wire states are compared: MPU order for every packet, and data-unit
+   * order for packets that carry a DU header. A packet of one data unit
+   * that continues into the next block carries no DU header and so only
+   * takes part through its MPU, which is exactly what makes an adjacent
+   * straddle consistent.
+   */
+  #contradictsAuthoredOrder(sbn, mpu, evidence) {
+    for (const [other, span2] of this.#mpuSbnSpans) {
+      if (other < mpu && span2.max > sbn) return true;
+      if (other > mpu && span2.min < sbn) return true;
+    }
+    const inHorizon = this.#highestMpu === null || mpu + 1 >= this.#highestMpu;
+    let insertAt = -1;
+    let starts;
+    let start;
+    if (evidence.idx !== void 0) {
+      start = {
+        movieFragment: evidence.movieFragment ?? 0,
+        idx: evidence.idx,
+        offset: evidence.offset ?? 0,
+        sbn
+      };
+      starts = this.#dataUnitStarts.get(mpu);
+      if (starts !== void 0) {
+        let lo = 0;
+        let hi = starts.length;
+        while (lo < hi) {
+          const mid = lo + hi >>> 1;
+          if (compareDataUnitStarts(starts[mid], start) < 0) lo = mid + 1;
+          else hi = mid;
+        }
+        const at = starts[lo];
+        if (at !== void 0 && compareDataUnitStarts(at, start) === 0) {
+          if (at.sbn !== sbn) return true;
+        } else {
+          const before = starts[lo - 1];
+          if (before !== void 0 && before.sbn > sbn) return true;
+          if (at !== void 0 && at.sbn < sbn) return true;
+          insertAt = lo;
+        }
+      }
+    }
+    if (!inHorizon) return false;
+    const span = this.#mpuSbnSpans.get(mpu);
+    if (span === void 0) this.#mpuSbnSpans.set(mpu, { min: sbn, max: sbn });
+    else {
+      if (sbn < span.min) span.min = sbn;
+      if (sbn > span.max) span.max = sbn;
+    }
+    if (start !== void 0) {
+      if (starts === void 0) this.#dataUnitStarts.set(mpu, [start]);
+      else if (insertAt >= 0) starts.splice(insertAt, 0, start);
+    }
+    if (this.#highestMpu === null || mpu > this.#highestMpu) {
+      this.#highestMpu = mpu;
+      for (const other of [...this.#mpuSbnSpans.keys()]) {
+        if (other + 1 < mpu) {
+          this.#mpuSbnSpans.delete(other);
+          this.#dataUnitStarts.delete(other);
+        }
+      }
+    }
+    return false;
+  }
+  #disable(reason) {
+    if (reason === "rap-not-mpu-start" || reason === "mpu-longer-than-gop") {
+      this.#mpuBoundsRaps = false;
+    }
+    if (this.#mode === "all-protected") return [];
+    this.#mode = "all-protected";
+    this.#reason = reason;
+    const changes = [{ kind: "mode", mode: "all-protected", reason }];
+    for (const [sbn, block] of this.#blocks) {
+      if (block.cls !== "delta") continue;
+      block.cls = "unknown";
+      changes.push({
+        kind: "reclassified",
+        sbn,
+        from: "delta",
+        to: "unknown",
+        evidence: "classifier-disabled"
+      });
+    }
+    return changes;
+  }
+  #classify(block) {
+    if (block.rapSeen || block.mpus.size >= 2) return "keyframe";
+    if (this.#mode === "all-protected") return "unknown";
+    const geometry = this.#geometry;
+    if (geometry.trackKind !== "video" || geometry.mode !== "classifying") return "unknown";
+    if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0) {
+      const span = geometry.interleaveUnits - 1;
+      if (block.idxMax - span >= 1 && block.idxMin + span <= geometry.gopFrames - 1) {
+        return "delta";
+      }
+    }
+    return "unknown";
+  }
+  #allowed(from, to) {
+    if (from === "keyframe") return false;
+    if (from === "unknown") return to === "delta" || to === "keyframe";
+    if (from === "delta") return to === "keyframe";
+    return false;
+  }
+  #evidenceFor(block, to) {
+    if (to === "delta") return "window";
+    return block.rapSeen ? "rap" : "mpu-span";
+  }
+};
+
+// src/fec-manager.ts
+var WORKER_ERROR_LOG_CAP = 5;
+var WORKER_ERROR_KIND_CAP = 32;
+var WORKER_ERROR_OVERFLOW_KIND = "other";
+var STARTUP_REPAIR_WAIT_SOURCE_BOUNDARIES = 2;
+function isMulticastSymbolDelivery(value) {
+  return value === "datagram" || value === "ordered-relay";
+}
+function newFecCounters() {
+  return {
+    sourcePackets: 0,
+    repairPackets: 0,
+    duplicateSymbols: 0,
+    blocksClean: 0,
+    blocksRecovered: 0,
+    blocksFailed: 0
+  };
+}
+function dropOldest(collection, count) {
+  const dropped = [];
+  for (const key of collection.keys()) {
+    if (dropped.length >= count) break;
+    dropped.push(key);
+  }
+  for (const key of dropped) collection.delete(key);
+  return dropped;
+}
+var TerminalQueue = class {
+  #records = [];
+  #head = 0;
+  push(record) {
+    this.#records.push(record);
+  }
+  peek() {
+    return this.#records[this.#head];
+  }
+  shift() {
+    this.#head++;
+    if (this.#head * 2 >= this.#records.length) {
+      this.#records = this.#records.slice(this.#head);
+      this.#head = 0;
+    }
+  }
+};
+var FECManager = class _FECManager {
+  constructor() {
+    // Per-track WASM RaptorQ decoders, keyed by physical stream identity.
+    this.#fecDecoders = /* @__PURE__ */ new Map();
+    /** @deprecated Use setFecDecoder(packetId, ...). Backwards-compat shim. */
+    // Per-track Worker-backed FEC decoders, keyed by physical stream identity.
+    // Worker-backed tracks use async decode — recovered frames arrive via onFrame callback,
+    // not synchronous return from feedSourceSymbol/feedRepairSymbol.
+    this.#workerClients = /* @__PURE__ */ new Map();
+    // Worker clients whose streams releasePacket ended. A Worker posts
+    // asynchronously, so a message it sent before its reset can still arrive;
+    // the stream it describes is gone, and letting it in would rebuild state
+    // (block ledgers, statistics, lifecycle events) for a retired packet ID.
+    this.#releasedWorkerClients = /* @__PURE__ */ new WeakSet();
+    // Worker setup can finish while an interleaved block is already collecting
+    // on the sync decoder. Keep that block on its original decoder so later
+    // source/repair symbols do not split across two RaptorQ states.
+    this.#syncDecoderBlockOwners = /* @__PURE__ */ new Map();
+    this.#decoderBlockOwners = /* @__PURE__ */ new WeakMap();
+    this.#fecK = 4;
+    this.#fecSymbolSize = 0;
+    this.#fecTimeoutMs = 500;
+    // default 500ms; refined by setFramerate() when fps known
+    this.#trackConfigs = /* @__PURE__ */ new Map();
+    this.#fecStats = newFecCounters();
+    this.#fecTrackStats = /* @__PURE__ */ new Map();
+    this.#fecWorkerStats = /* @__PURE__ */ new Map();
+    this.#fecStatsObservers = /* @__PURE__ */ new Set();
+    // Block inactivity tracking: (packetId, SBN) -> the one armed timer. The
+    // deadline is derived from catalog geometry and refreshed on progress; only
+    // an idle block fails. #activeBlockDeadlinesMs is the authoritative
+    // deadline; the timer re-checks it when it fires (see DeadlineTimer).
+    this.#activeBlocks = /* @__PURE__ */ new Map();
+    this.#activeBlockDeadlinesMs = /* @__PURE__ */ new Map();
+    // The two terms #activeBlockDeadlinesMs is the later of (BLO-35597):
+    // - the multicast late-symbol wait, refreshed by every accepted symbol;
+    // - a D-28 repair hold, set by the repair scheduler only while a repair
+    //   FETCH it admitted can still land before the block's presentation
+    //   deadline. The multicast span elapsing never ends a fetch the scheduler
+    //   judged able to arrive in time.
+    this.#blockWaitDeadlinesMs = /* @__PURE__ */ new Map();
+    this.#repairHoldUntilMs = /* @__PURE__ */ new Map();
+    // Receiver-measured multicast delivery gap: the late-symbol wait's jitter
+    // term (see DeliveryGapEstimator for the statistic and why).
+    this.#deliveryGaps = new DeliveryGapEstimator();
+    this.#lifecycleTrace = [];
+    // Worker-backed timeouts enqueue cleanup behind all prior symbol messages.
+    // Failure remains pending until cleanupComplete acknowledges that queue drain.
+    this.#pendingWorkerCleanups = /* @__PURE__ */ new Set();
+    this.#pendingWorkerCleanupClients = /* @__PURE__ */ new Map();
+    // One bound per owed cleanup: the acknowledgement is awaited for at most one
+    // catalog-derived block lifetime (fail bound plus repair grace).
+    // A Worker that hangs or drops one message must not leave the block
+    // 'pending' forever, which would park every later frame of its stream in
+    // the in-order release gate. Each entry owns its handle; the callback
+    // checks it still owns the key, so a settled or reset key is never touched.
+    this.#pendingWorkerCleanupBounds = /* @__PURE__ */ new Map();
+    // Source symbol count per track-scoped block — marks complete when K symbols arrive.
+    this.#blockSourceCounts = /* @__PURE__ */ new Map();
+    this.#blockSourceEsis = /* @__PURE__ */ new Map();
+    // Authored SSB_length per block (ISO/IEC 23008-1 §C.5.3), learned from the
+    // first repair symbol. The FFmpeg moq_mmt publisher closes a block every D
+    // media units, usually before it holds K symbols, and fec-raptorq
+    // force_complete() encodes it as a K-symbol RaptorQ block whose ESIs
+    // SSB_length..K-1 are zero padding that is never sent. Such a block is clean
+    // at SSB_length source arrivals and recoverable from SSB_length received
+    // symbols; waiting for K fails every one of them.
+    this.#blockAuthoredLengths = /* @__PURE__ */ new Map();
+    this.#ssbLengthConflictCount = 0;
+    this.#blockRepairRsIds = /* @__PURE__ */ new Map();
+    // Blocks already recovered — prevents late source symbols from restarting timeouts.
+    // WASM removes blocks after recovery; late symbols create empty blocks returning null,
+    // which would falsely start new timeouts without this guard.
+    //
+    // Every insertion goes through #markTerminal, which retires the key once its
+    // catalog-derived retention window (terminalRetentionMsForPacket) passes. The
+    // previous bound (trim to 500 at 1000) lived in cancelBlockTimeout alone, so
+    // a stream whose blocks only failed grew this set without limit (BLO-36599).
+    this.#completedBlocks = /* @__PURE__ */ new Set();
+    this.#terminalExpiryMs = /* @__PURE__ */ new Map();
+    this.#terminalQueues = /* @__PURE__ */ new Map();
+    // sbn -> (block key -> packetId) for every key held by #activeBlocks,
+    // #blockSourceCounts, #blockCatalogTrackNames or #completedBlocks. A lookup
+    // without a catalog name used to string-parse every key of all of those on
+    // each source packet, which is O(retained blocks) per packet (BLO-36599).
+    this.#blockKeysBySbn = /* @__PURE__ */ new Map();
+    // Stable per-name encodings for stream and block keys, bounded by the
+    // catalog's track names; #blockKey is built several times per packet.
+    this.#encodedTrackNames = /* @__PURE__ */ new Map();
+    // The last block and stream key built. One packet asks for the same block's
+    // key from every FECManager entry point it passes through (~6 per source
+    // symbol), so each key is built once per packet rather than once per call
+    // (BLO-36599). Both keys are pure functions of their arguments.
+    this.#lastBlockKeySbn = -1;
+    this.#lastBlockKeyPacketId = -1;
+    this.#lastBlockKeyTrackName = void 0;
+    this.#lastBlockKey = "";
+    this.#lastStreamKeyPacketId = -1;
+    this.#lastStreamKeyTrackName = void 0;
+    this.#lastStreamKey = "";
+    this.#seenSymbols = /* @__PURE__ */ new Set();
+    this.#blockPathCounts = /* @__PURE__ */ new Map();
+    // Receiver-local first-accepted-symbol time per block, bounded like
+    // #blockPathCounts (see blockAnchorAtMs).
+    this.#blockAnchorsMs = /* @__PURE__ */ new Map();
+    // Exact catalog identity observed on accepted symbols for each FEC block.
+    // Conflicting identities collapse to null so recovery fails closed.
+    this.#blockCatalogTrackNames = /* @__PURE__ */ new Map();
+    // A receiver joins an already-running live stream in the middle of D
+    // interleaved source blocks. This applies to both multicast and reliable MoQ:
+    // a MoQ group boundary is not an FEC ESI=0 boundary. Those blocks are not
+    // packet loss because their earlier ESIs predate the subscription. Ignore
+    // each such block until ESI=0 establishes a complete boundary for the track.
+    // After that boundary, a first observed ESI>0 is real delivery loss and must
+    // continue through normal FEC recovery/failure accounting.
+    this.#startupAlignedPackets = /* @__PURE__ */ new Set();
+    this.#startupPartialBlocks = /* @__PURE__ */ new Set();
+    // A live multicast join can observe an ESI=0 source boundary before the
+    // repair lane catches up. Returning false here also drops that media packet
+    // at MmtpRouter, so the readiness probe is multicast-only and bounded: an
+    // actual multicast repair unlocks the next boundary, while a second source
+    // boundary fails open. Reliable MoQ media continues through normal startup
+    // alignment and retained MoQ repair cannot prove multicast readiness.
+    this.#startupRequireRepairReady = false;
+    this.#startupRepairReadyPackets = /* @__PURE__ */ new Set();
+    this.#startupRepairBoundaryCounts = /* @__PURE__ */ new Map();
+    this.#startupRepairFailOpenPackets = /* @__PURE__ */ new Set();
+    // SBNs that reached K source-symbol arrivals via trackBlock. Used by the
+    // worker recovery suppression check (see onFrame handler below) so we only
+    // suppress `recovered=true` emits for blocks that ALSO completed cleanly
+    // via source symbols. Separating this from #completedBlocks (which is also
+    // populated by every worker frame emit, by failed timeouts, and by external
+    // callers) was the BLO-3323 L15 fix: the prior predicate caused blocksRecovered
+    // to stay at 0 because the SBN was always in #completedBlocks by the time the
+    // worker fired recovered=true.
+    this.#cleanlyCompletedBlocks = /* @__PURE__ */ new Set();
+    // D-28: blocks whose repair deadline already fired onRepairNeeded. At most
+    // one repair request per block; entries are removed when the block
+    // completes, recovers, or fails.
+    this.#repairRequestedBlocks = /* @__PURE__ */ new Set();
+    // D-28: repair deadlines refreshed by accepted source progress until the
+    // first repair request. A `null` value marks a deadline that already fired
+    // and requested repair (never re-armed). At most K accepted source symbols
+    // can refresh the horizon, so browser scheduling delay cannot create an
+    // early loss signal and repair traffic cannot keep a block alive
+    // indefinitely. #repairDeadlineAtMs is the authoritative deadline; the one
+    // armed timer re-checks it when it fires (see DeadlineTimer).
+    this.#repairDeadlines = /* @__PURE__ */ new Map();
+    this.#repairDeadlineAtMs = /* @__PURE__ */ new Map();
+    // Worker recovery emits all K source symbols. Track recovery once per block
+    // while routing only ESI slots that were absent from the direct source path.
+    this.#workerRecoveredBlocks = /* @__PURE__ */ new Set();
+    // How the multicast leg delivers symbols (see MulticastSymbolDelivery). The
+    // provider declares it per transport join; absence keeps datagram semantics.
+    this.#multicastSymbolDelivery = "datagram";
+    // ordered-relay: per stream, the highest SBN any multicast symbol carried.
+    // The relay preserves the receiving socket's order, so every block more than
+    // the decoder's interleave horizon behind this frontier has received every
+    // symbol it will ever receive over multicast.
+    this.#orderedFrontiers = /* @__PURE__ */ new Map();
+    // ordered-relay: blocks with multicast symbols that are neither terminal nor
+    // handed to a decoder cleanup, per stream, keyed by SBN. They carry no
+    // timer; the frontier settles them. At most one interleave horizon of blocks
+    // per stream is ever here.
+    this.#orderedPendingBlocks = /* @__PURE__ */ new Map();
+    // ── Keyframe-protected repair policy (block-policy.ts) ──
+    // One classifier per physical stream, built from that stream's geometry.
+    this.#classifiers = /* @__PURE__ */ new Map();
+    // Geometry a stream-scoped configuration gave one stream (streamKey). ABR
+    // rungs can share a packetId with a different framerate or GOP, so the
+    // packet-level geometry is only the geometry of a packet whose streams
+    // were never configured apart (see #geometryFor).
+    this.#streamGeometries = /* @__PURE__ */ new Map();
+    // Terminal outcomes retained for in-order frame release: a failed block is
+    // resolved-with-loss, a completed one resolved-clean.
+    this.#failedBlocks = /* @__PURE__ */ new Set();
+    // A block's class at resolution, so events emitted after the classifier
+    // forgot the block (the router counts a recovery after cancelling the
+    // block) still carry it.
+    this.#resolvedBlockClasses = /* @__PURE__ */ new Map();
+    // Blocks already reported through onBlockRepaired (once per block).
+    this.#repairedBlocks = /* @__PURE__ */ new Set();
+    // Blocks created without any symbol because every symbol vanished.
+    this.#materializedBlocks = /* @__PURE__ */ new Set();
+    // packetIds whose ordered-relay horizon became underivable and fell back to
+    // the datagram deadline. Bounds the warn in #derivableOrderedHorizon to once
+    // per stream. Not only throws: the ordinary out-of-range case is detected by
+    // arithmetic and never throws at all.
+    this.#orderedHorizonWarnedFor = /* @__PURE__ */ new Set();
+    // Highest SBN seen per stream and when, for vanished-block detection.
+    this.#highestSbn = /* @__PURE__ */ new Map();
+    // iso-ssbg1-v1 block location per stream (streamKey). A source belongs to a
+    // block only once a repair symbol stated the block's (SS_Start, SSB_length).
+    this.#isoLocators = /* @__PURE__ */ new Map();
+    this.#isoRepairRefusedCount = 0;
+    this.#isoSourceOversizeCount = 0;
+    // Held sources a locator's capacity cap evicted (IsoBlockLocator.heldCapacity):
+    // only a stream whose SS_IDs are not consecutive reaches it. Cumulative,
+    // unlike the locators, which a reset discards.
+    this.#isoHeldEvictedCount = 0;
+    // Sources a synchronous decoder held unplaced and retired at its horizon
+    // (WasmFecDecoder.retire_unplaced): placed sources whose block's repair
+    // never reached that decoder. Cumulative.
+    this.#isoDecoderUnplacedRetired = 0;
+    // Failed retire_unplaced calls. The sweep runs on every feed, so its warn is
+    // rate-limited like the other per-symbol warns here. Cumulative.
+    this.#isoDecoderUnplacedRetireFailed = 0;
+    // The latest source symbol per stream that carried its MMTP
+    // packet_sequence_number: the anchor that bounds how many blocks the
+    // producer can have started before a later source symbol.
+    this.#sourceAnchors = /* @__PURE__ */ new Map();
+    // Catalog/reset epoch per packetId. Gap decisions carry it for fencing.
+    this.#packetEpochs = /* @__PURE__ */ new Map();
+    // Framerate detection state
+    this.#fpsDetected = false;
+    this.#fecInterleaveDepthMs = 0;
+    // Worker error log rate-limiter — bounds console.warn output and exported
+    // error cardinality when the FEC Worker emits the same failure repeatedly
+    // with volatile packet details (e.g. ssStart) in the message text.
+    // Stable Worker codes aggregate those messages; uncoded/legacy messages are
+    // capped into an `other` bucket. This also covers wasm-bindgen
+    // "recursive use of an object" bubbled from add_source/add_repair during
+    // overlapping message processing). Without this, Point 5 of the 7-point
+    // validation harness — which caps headless warnings at 500 — fails even
+    // though the errors are duplicates of a single underlying event.
+    this.#workerErrorCounts = /* @__PURE__ */ new Map();
+    this.#decoderUnavailableEvents = 0;
+    this.#repairSymbolSizeMismatchCount = 0;
+    // Event callbacks — block lifecycle notifications for MmtpRouter wiring.
+    // NOTE: For sync WASM path, recovery routing is handled by MmtpRouter from
+    // feedSourceSymbol/feedRepairSymbol return values. For Worker path, recovery
+    // arrives via onBlockRecovered callback.
+    this.onBlockStarted = null;
+    this.onBlockComplete = null;
+    /** A block reached its fail bound. `blockClass` is its class at failure. */
+    this.onBlockFailed = null;
+    /**
+     * Fired once per stream when its Worker decoder stops being routable.
+     * `reason` is 'cleared' when clearFecWorker() removed it and 'disposed' when
+     * a symbol or reset found the registered client already disposed and
+     * evicted it. `fallbackDecoder` is 'sync' when a synchronous WASM decoder
+     * registered for the same stream keeps decoding its symbols, and 'none'
+     * when nothing does. Only 'none' leaves the stream unprotected: the host
+     * must then register a decoder again or leave the stream, because counting
+     * its symbols as handled would hide the loss.
+     */
+    this.onDecoderUnavailable = null;
+    // D-28 on-demand repair callbacks. When onRepairNeeded is registered, each
+    // block arms a one-shot repair deadline after the derived K-symbol source
+    // horizon; a block still short of K when it fires requests a per-SBN MoQ
+    // repair fetch upstream. The inactivity fail bound is unchanged either way —
+    // repair and failure are orthogonal timers, so wiring D-28 never delays
+    // failure accounting. onRepairResolved fires when a repair-requested block
+    // leaves the active set, with the outcome ("completed" after clean completion
+    // or recovery, "failed" at the fail bound) so the upstream in-flight slot
+    // (MulticastManager.clearRepairForBlock) can be released and logged.
+    this.onRepairNeeded = null;
+    this.onRepairResolved = null;
+    /**
+     * A block that could not complete from its first-arrival source symbols
+     * alone was completed anyway: by FEC decode (in-band or QUIC repair
+     * symbols) or, after a D-28 request, by late symbols. Fired once per block.
+     */
+    this.onBlockRepaired = null;
+    /** A block's class changed on new evidence or when classification was disabled. */
+    this.onBlockReclassified = null;
+    /** A video stream's classifier mode was established or changed. */
+    this.onClassifierMode = null;
+    /** A block every symbol of which vanished was created by SBN evidence. */
+    this.onBlockVanished = null;
+    /** A block reached a terminal state (completed, recovered, or failed). */
+    this.onBlockResolved = null;
+    /** A stream's SBN went backwards (or jumped implausibly): the source restarted. */
+    this.onSourceDiscontinuity = null;
+    // Worker-path callbacks — async recovery and stats from FecWorkerClient.
+    this.onBlockRecovered = null;
+    this.onFecStatsUpdate = null;
+  }
+  #fecDecoders;
+  #workerClients;
+  #releasedWorkerClients;
+  #syncDecoderBlockOwners;
+  #decoderBlockOwners;
+  #fecK;
+  #fecSymbolSize;
+  #fecTimeoutMs;
+  #trackConfigs;
+  #fecStats;
+  #fecTrackStats;
+  #fecWorkerStats;
+  #fecStatsObservers;
+  #activeBlocks;
+  #activeBlockDeadlinesMs;
+  #blockWaitDeadlinesMs;
+  #repairHoldUntilMs;
+  #deliveryGaps;
+  #lifecycleTrace;
+  #pendingWorkerCleanups;
+  #pendingWorkerCleanupClients;
+  #pendingWorkerCleanupBounds;
+  #blockSourceCounts;
+  #blockSourceEsis;
+  #blockAuthoredLengths;
+  #ssbLengthConflictCount;
+  #blockRepairRsIds;
+  #completedBlocks;
+  #terminalExpiryMs;
+  #terminalQueues;
+  #blockKeysBySbn;
+  #encodedTrackNames;
+  #lastBlockKeySbn;
+  #lastBlockKeyPacketId;
+  #lastBlockKeyTrackName;
+  #lastBlockKey;
+  #lastStreamKeyPacketId;
+  #lastStreamKeyTrackName;
+  #lastStreamKey;
+  #seenSymbols;
+  #blockPathCounts;
+  #blockAnchorsMs;
+  #blockCatalogTrackNames;
+  #startupAlignedPackets;
+  #startupPartialBlocks;
+  #startupRequireRepairReady;
+  #startupRepairReadyPackets;
+  #startupRepairBoundaryCounts;
+  #startupRepairFailOpenPackets;
+  #cleanlyCompletedBlocks;
+  #repairRequestedBlocks;
+  #repairDeadlines;
+  #repairDeadlineAtMs;
+  #workerRecoveredBlocks;
+  #multicastSymbolDelivery;
+  #orderedFrontiers;
+  #orderedPendingBlocks;
+  #classifiers;
+  #streamGeometries;
+  #failedBlocks;
+  #resolvedBlockClasses;
+  #repairedBlocks;
+  #materializedBlocks;
+  #orderedHorizonWarnedFor;
+  #highestSbn;
+  #isoLocators;
+  #isoRepairRefusedCount;
+  #isoSourceOversizeCount;
+  #isoHeldEvictedCount;
+  #isoDecoderUnplacedRetired;
+  #isoDecoderUnplacedRetireFailed;
+  #sourceAnchors;
+  #packetEpochs;
+  #fpsDetected;
+  #fecFps;
+  #fecInterleaveDepthMs;
+  #workerErrorCounts;
+  #decoderUnavailableEvents;
+  #repairSymbolSizeMismatchCount;
+  #encodeTrackName(catalogTrackName) {
+    let encoded = this.#encodedTrackNames.get(catalogTrackName);
+    if (encoded === void 0) {
+      encoded = encodeURIComponent(catalogTrackName);
+      this.#encodedTrackNames.set(catalogTrackName, encoded);
+    }
+    return encoded;
+  }
+  #streamKey(packetId, catalogTrackName) {
+    if (packetId === this.#lastStreamKeyPacketId && catalogTrackName === this.#lastStreamKeyTrackName) {
+      return this.#lastStreamKey;
+    }
+    const key = catalogTrackName === void 0 ? `${packetId}` : `${packetId}:${this.#encodeTrackName(catalogTrackName)}`;
+    this.#lastStreamKeyPacketId = packetId;
+    this.#lastStreamKeyTrackName = catalogTrackName;
+    this.#lastStreamKey = key;
+    return key;
+  }
+  #belongsToPacket(key, packetId) {
+    return Number(key.split(":", 1)[0]) === packetId;
+  }
+  #belongsToStream(key, packetId, catalogTrackName) {
+    if (!this.#belongsToPacket(key, packetId)) return false;
+    const parts = key.split(":");
+    const encodedTrackName = this.#encodeTrackName(catalogTrackName);
+    if (parts.length === 2) return parts[1] === encodedTrackName;
+    if (parts.length >= 3) return parts[2] === encodedTrackName;
+    return false;
+  }
+  #packetIdsForStreamKeys(keys) {
+    return [...new Set([...keys].map((key) => Number(key.split(":", 1)[0])))];
+  }
+  #parseStreamKey(key) {
+    const separator = key.indexOf(":");
+    if (separator < 0) return { packetId: Number(key) || 0 };
+    return {
+      packetId: Number(key.slice(0, separator)) || 0,
+      catalogTrackName: decodeURIComponent(key.slice(separator + 1))
+    };
+  }
+  #blockKey(sbn, packetId, catalogTrackName) {
+    if (sbn === this.#lastBlockKeySbn && packetId === this.#lastBlockKeyPacketId && catalogTrackName === this.#lastBlockKeyTrackName) {
+      return this.#lastBlockKey;
+    }
+    const base = `${packetId}:${sbn}`;
+    const key = catalogTrackName === void 0 ? base : `${base}:${this.#encodeTrackName(catalogTrackName)}`;
+    this.#lastBlockKeySbn = sbn;
+    this.#lastBlockKeyPacketId = packetId;
+    this.#lastBlockKeyTrackName = catalogTrackName;
+    this.#lastBlockKey = key;
+    return key;
+  }
+  /** Record that `key` (block `sbn` on `packetId`) is held by a lookup set. */
+  #indexBlockKey(key, sbn, packetId) {
+    let keys = this.#blockKeysBySbn.get(sbn);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Map();
+      this.#blockKeysBySbn.set(sbn, keys);
+    }
+    keys.set(key, packetId);
+  }
+  /** True while any set a catalog-name-less lookup consults still holds `key`. */
+  #isBlockKeyHeld(key) {
+    return this.#activeBlocks.has(key) || this.#blockSourceCounts.has(key) || this.#blockCatalogTrackNames.has(key) || this.#completedBlocks.has(key);
+  }
+  /** Drop `key` from the SBN index once no lookup set holds it any more. */
+  #unindexBlockKey(key) {
+    if (this.#isBlockKeyHeld(key)) return;
+    const sbn = this.#parseBlockKey(key).sbn;
+    const keys = this.#blockKeysBySbn.get(sbn);
+    if (!keys) return;
+    keys.delete(key);
+    if (keys.size === 0) this.#blockKeysBySbn.delete(sbn);
+  }
+  /**
+   * Make `key` terminal: late symbols for it are duplicates from now on. The
+   * key is retired terminalRetentionMsForPacket later, when no copy of any of
+   * its symbols can still be in flight on either transport and no frame can
+   * still be held behind it. Retirement is swept lazily here, on the stream's
+   * own terminal events, so it needs no timer.
+   */
+  #markTerminal(key, sbn, packetId, clean) {
+    const nowMs = performance.now();
+    this.#retireTerminalBlocks(packetId, nowMs);
+    this.#forgetOrderedPending(key);
+    this.#completedBlocks.add(key);
+    if (clean) this.#cleanlyCompletedBlocks.add(key);
+    this.#indexBlockKey(key, sbn, packetId);
+    const expiresAtMs = nowMs + this.terminalRetentionMsForPacket(packetId);
+    this.#terminalExpiryMs.set(key, expiresAtMs);
+    let queue = this.#terminalQueues.get(packetId);
+    if (!queue) {
+      queue = new TerminalQueue();
+      this.#terminalQueues.set(packetId, queue);
+    }
+    queue.push({ key, expiresAtMs });
+  }
+  #retireTerminalBlocks(packetId, nowMs) {
+    const queue = this.#terminalQueues.get(packetId);
+    if (!queue) return;
+    for (let record = queue.peek(); record !== void 0; record = queue.peek()) {
+      if (record.expiresAtMs > nowMs) return;
+      const current = this.#terminalExpiryMs.get(record.key) === record.expiresAtMs;
+      if (current && this.#withinOrderedHorizon(record.key)) return;
+      queue.shift();
+      if (!current) continue;
+      this.#terminalExpiryMs.delete(record.key);
+      this.#completedBlocks.delete(record.key);
+      this.#cleanlyCompletedBlocks.delete(record.key);
+      this.#workerRecoveredBlocks.delete(record.key);
+      this.#failedBlocks.delete(record.key);
+      this.#resolvedBlockClasses.delete(record.key);
+      this.#repairedBlocks.delete(record.key);
+      this.#unindexBlockKey(record.key);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Ordered-relay settlement (MulticastSymbolDelivery 'ordered-relay')
+  // -----------------------------------------------------------------------
+  /**
+   * The decoder's interleave horizon for one stream, in blocks: the same
+   * retention the Worker and the WASM decoder are configured with, because it
+   * comes from the same function they do (`deriveFecRetentionBlocks`, over the
+   * block's delivery window and its span). The decoder retires every block
+   * more than this many SBNs behind the newest one it saw (`cleanup_by_sbn`),
+   * so settling earlier than this would decide a block the decoder would still
+   * have recovered.
+   *
+   * This used to call `deriveFecInterleaveDepth`, which returns D -- MEDIA
+   * UNITS per block, not a block count -- and a comment here asserted the two
+   * matched. They did, only while the decoder's retention was also (wrongly)
+   * sized in D. Once BLO-35597 sized retention as a real block count this
+   * settled 2-5 blocks early on the live ISS catalog at reorderToleranceMs=100
+   * (720p 1 vs 6, audio 2 vs 5), making the manager the binding constraint and
+   * the decoder fix inert on ordered relays. Both sides now consume one
+   * derivation; do not re-derive a horizon at either call site.
+   */
+  #orderedHorizonBlocksFor(packetId, config) {
+    if (!_FECManager.#hasOrderedGeometry(config)) {
+      throw new Error(
+        `[FECManager] packetId=${packetId}: ordered-relay settlement derives the decoder's interleave horizon from the catalog interleaveDepthMs (>= ${MIN_INTERLEAVE_DEPTH_MS}ms), the media-unit rate and the block delivery window; got interleaveDepthMs=${config.interleaveDepthMs} fps=${String(config.fps)} timeoutMs=${config.timeoutMs}.`
+      );
+    }
+    return deriveFecRetentionBlocks(config.timeoutMs, config.interleaveDepthMs);
+  }
+  /**
+   * Whether a stream's geometry can define an ordered-relay horizon at all.
+   * One definition, shared by the config-time and packet-feed callers, so the
+   * two can never disagree about which streams settle by stream order.
+   */
+  static #hasOrderedGeometry(config) {
+    return config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS && // `fps` is no longer an input to the horizon, but it still gates WHICH
+    // streams settle by stream order at all: a track with no usable
+    // media-unit rate fell back to datagram semantics before this and must
+    // keep doing so. Removing this widens ordered-relay settlement to streams
+    // that never had it. Load-bearing — do not drop it as unused.
+    config.fps !== void 0 && Number.isFinite(config.fps) && config.fps > 0 && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0;
+  }
+  /**
+   * The horizon for one stream, or undefined when its geometry cannot define
+   * one.
+   *
+   * `config.timeoutMs` is the block's delivery window. On the live path
+   * multicast-manager computes it with `jitterBufferMs: fec.reorderToleranceMs`
+   * and passes it to configure(), which is the same `deliveryWindowMs`
+   * fec-worker-setup sizes decoder retention from, so the two horizons are
+   * equal there.
+   *
+   * They are NOT equal on the fallback path, and the skew runs in the
+   * direction this file's invariant calls unsafe. `jitterBufferMs` reaches
+   * fec-manager only inside an explicit configure({timeoutMs}); all four of
+   * its own computeFecDeliveryWindowMs calls (one in #computeTimeout, one in
+   * configure(), two in setFramerate) omit it, so a manager-derived
+   * timeoutMs is tolerance-free and yields a
+   * horizon NARROWER than the decoder's retention — the direction that settles
+   * a block the decoder would still have recovered. At 720p/33ms the decoder
+   * retains ceil(133/33)+1 = 6 while a tolerance-free 33ms window gives
+   * ceil(33/33)+1 = 2. Two writes can also raise a validated timeoutMs
+   * afterwards without re-validating (configure()'s widening loop and
+   * setFramerate).
+   *
+   * Not fixed here: the real fix is to thread the tolerance into those four
+   * calls so both sides derive from the same quantity, which is a change to
+   * inputs fec-manager does not currently receive. Tracked in BLO-38250. The
+   * live ISS path does not hit it — multicast-manager always supplies both
+   * `timeoutMs` and `fps`, and setFramerate skips tracks that already carry
+   * `fps` — so this is a latent skew on the fallback, not a live defect. Do
+   * not read the old "can only skew narrower, never wider" note as a safety
+   * argument: narrower IS the failing direction.
+   */
+  #derivableOrderedHorizon(config, packetId) {
+    if (!_FECManager.#hasOrderedGeometry(config)) return void 0;
+    try {
+      const blocks = tryDeriveFecRetentionBlocks(config.timeoutMs, config.interleaveDepthMs);
+      if (blocks === void 0) {
+        this.#noteLeftOrderedSettlement(
+          packetId,
+          `geometry cannot define a retention horizon within the 255-block ceiling (timeoutMs=${config.timeoutMs}ms over interleaveDepthMs=${config.interleaveDepthMs}ms)`
+        );
+      }
+      return blocks;
+    } catch (error) {
+      this.#noteLeftOrderedSettlement(packetId, String(error));
+      return void 0;
+    }
+  }
+  /**
+   * Warn once per stream that it dropped from ordered-relay settlement to the
+   * datagram deadline. Swallowing is right for the packet-feed contract, but a
+   * configured stream changing settlement mid-flight is a behavioural change,
+   * and it is otherwise indistinguishable from a stream that never had
+   * geometry.
+   */
+  #noteLeftOrderedSettlement(packetId, reason) {
+    if (this.#orderedHorizonWarnedFor.has(packetId)) return;
+    this.#orderedHorizonWarnedFor.add(packetId);
+    console.warn(
+      `[FECManager] packetId=${packetId} left ordered-relay settlement for the datagram deadline: ${reason}`
+    );
+  }
+  /**
+   * The stream's interleave horizon, or undefined when its geometry cannot
+   * define one. Two different streams reach that case, with different causes:
+   * a packetId that was never configured, and so resolves to the manager
+   * defaults (explicitly configured tracks are refused an underivable geometry
+   * at config time — #upsertTrackConfig, setMulticastSymbolDelivery); or a
+   * configured track whose timeoutMs was later widened past the 255-block
+   * ceiling without re-validating, which #derivableOrderedHorizon catches
+   * rather than throwing from the packet-feed path. Either way the stream
+   * keeps datagram semantics instead of throwing. The manager defaults can
+   * also change under a stream that already holds blocks, so a caller cannot
+   * assume a horizon that was defined when a block was held is still defined
+   * (see #advanceOrderedFrontier).
+   */
+  #orderedHorizonBlocks(packetId) {
+    return this.#derivableOrderedHorizon(this.#resolveTrackConfig(packetId), packetId);
+  }
+  /** True while a block of an ordered-relay stream can still receive symbols. */
+  #withinOrderedHorizon(key) {
+    if (this.#multicastSymbolDelivery !== "ordered-relay") return false;
+    const block = this.#parseBlockKey(key);
+    const frontier = this.#orderedFrontiers.get(
+      this.#streamKey(block.packetId, block.catalogTrackName)
+    );
+    if (frontier === void 0) return false;
+    const horizon = this.#orderedHorizonBlocks(block.packetId);
+    if (horizon === void 0) return false;
+    return this.#blocksBehind(block.sbn, frontier, block.packetId) <= horizon;
+  }
+  /** Whether a block's fate is decided by stream order rather than a timer. */
+  #settlesByOrder(key) {
+    return this.#multicastSymbolDelivery === "ordered-relay" && (this.#blockPathCounts.get(key)?.multicastSymbols ?? 0) > 0 && this.#orderedHorizonBlocks(this.#parseBlockKey(key).packetId) !== void 0;
+  }
+  #forgetOrderedPending(key) {
+    if (this.#orderedPendingBlocks.size === 0) return;
+    const block = this.#parseBlockKey(key);
+    const streamKey = this.#streamKey(block.packetId, block.catalogTrackName);
+    const pending = this.#orderedPendingBlocks.get(streamKey);
+    if (pending?.get(block.sbn) !== key) return;
+    pending.delete(block.sbn);
+    if (pending.size === 0) this.#orderedPendingBlocks.delete(streamKey);
+  }
+  /**
+   * Record the stream position of a multicast symbol and settle every pending
+   * block it proves final: a block more than the interleave horizon behind the
+   * frontier has already been handed every symbol the relay will deliver.
+   */
+  #advanceOrderedFrontier(streamKey, sbn, packetId, catalogTrackName) {
+    const previous = this.#orderedFrontiers.get(streamKey);
+    const frontier = previous === void 0 || this.#blockPrecedes(previous, sbn, packetId) ? sbn : previous;
+    if (frontier !== previous) this.#orderedFrontiers.set(streamKey, frontier);
+    const pending = this.#orderedPendingBlocks.get(streamKey);
+    if (!pending) return;
+    const blocks = this.#orderedHorizonBlocks(packetId);
+    if (blocks === void 0) {
+      this.#orderedPendingBlocks.delete(streamKey);
+      for (const pendingSbn of pending.keys()) {
+        this.noteBlockActivity(pendingSbn, packetId, catalogTrackName);
+      }
+      return;
+    }
+    for (const [pendingSbn, key] of pending) {
+      if (this.#blocksBehind(pendingSbn, frontier, packetId) <= blocks) continue;
+      pending.delete(pendingSbn);
+      this.#settleOrderedBlock(key, pendingSbn, packetId, catalogTrackName);
+    }
+    if (pending.size === 0 && this.#orderedPendingBlocks.get(streamKey) === pending) {
+      this.#orderedPendingBlocks.delete(streamKey);
+    }
+  }
+  /**
+   * Decide a block the ordered relay has finished delivering. Its accounting
+   * is final: SSB_length (from any repair symbol) against the source and
+   * repair symbols it holds says whether the decoder can still recover it.
+   * A block short of that asks for repair when D-28 is wired, under the same
+   * post-request fetch budget the datagram path grants; otherwise, and for a
+   * block the decoder holds enough symbols for, the decoder finalizes it
+   * exactly as a datagram deadline would (a Worker acknowledges the cleanup
+   * only after every earlier symbol, so an in-flight recovery still wins).
+   */
+  #settleOrderedBlock(key, sbn, packetId, catalogTrackName) {
+    if (this.#completedBlocks.has(key) || this.#pendingWorkerCleanups.has(key) || this.#repairRequestedBlocks.has(key)) return;
+    const authoredLength = this.#blockAuthoredLengths.get(key);
+    const received = (this.#blockSourceCounts.get(key) ?? 0) + (this.#blockRepairRsIds.get(key)?.size ?? 0);
+    if (this.onRepairNeeded && (authoredLength === void 0 || received < authoredLength)) {
+      this.#requestRepair(sbn, packetId, catalogTrackName, true);
+      return;
+    }
+    this.#traceLifecycle("horizon-settled", sbn, packetId, catalogTrackName);
+    this.#finalizeExpiredBlock(sbn, packetId, catalogTrackName);
+  }
+  /** Register a block whose multicast symbols arrive over an ordered relay. */
+  #holdForOrderedSettlement(key, sbn, packetId, catalogTrackName) {
+    this.#clearRepairDeadline(key);
+    if (this.#activeBlocks.has(key)) {
+      this.#clearBlockTimer(key);
+      this.#unindexBlockKey(key);
+    }
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    let pending = this.#orderedPendingBlocks.get(streamKey);
+    if (!pending) {
+      pending = /* @__PURE__ */ new Map();
+      this.#orderedPendingBlocks.set(streamKey, pending);
+    }
+    pending.set(sbn, key);
+  }
+  /** Cancel and forget a block's inactivity timer and deadline. */
+  #clearBlockTimer(key) {
+    const timer = this.#activeBlocks.get(key);
+    if (timer?.handle != null) clearTimeout(timer.handle);
+    this.#activeBlocks.delete(key);
+    this.#activeBlockDeadlinesMs.delete(key);
+    this.#blockWaitDeadlinesMs.delete(key);
+    this.#repairHoldUntilMs.delete(key);
+  }
+  #parseBlockKey(key) {
+    const [packetIdText, sbnText, ...catalogParts] = key.split(":");
+    const catalogTrackName = catalogParts.length > 0 ? decodeURIComponent(catalogParts.join(":")) : void 0;
+    return {
+      packetId: Number(packetIdText) || 0,
+      sbn: Number(sbnText) || 0,
+      ...catalogTrackName === void 0 ? {} : { catalogTrackName }
+    };
+  }
+  #decoderForPacket(packetId, catalogTrackName) {
+    return this.#fecDecoders.get(this.#streamKey(packetId, catalogTrackName)) ?? this.#fecDecoders.get(this.#streamKey(packetId));
+  }
+  #workerForPacket(packetId, catalogTrackName) {
+    return this.#workerClients.get(this.#streamKey(packetId, catalogTrackName)) ?? this.#workerClients.get(this.#streamKey(packetId));
+  }
+  /**
+   * The stream's Worker client for routing, or undefined after evicting a
+   * registered client that was already disposed. A disposed client throws on
+   * every command, so it leaves routing here before a symbol reaches it and
+   * the stream reports its decoder unavailable instead.
+   */
+  #routableWorkerForPacket(packetId, catalogTrackName) {
+    const client = this.#workerForPacket(packetId, catalogTrackName);
+    if (client === void 0 || client.disposed !== true) return client;
+    this.#evictDisposedWorker(client);
+    return void 0;
+  }
+  #claimDecoderBlock(client, sbn, catalogTrackName) {
+    let blocks = this.#decoderBlockOwners.get(client);
+    if (!blocks) {
+      blocks = /* @__PURE__ */ new Map();
+      this.#decoderBlockOwners.set(client, blocks);
+    }
+    const owner = blocks.get(sbn);
+    if (!owner) {
+      blocks.set(sbn, { catalogTrackName, conflicted: false });
+      if (blocks.size > 512) {
+        const stale = [...blocks.keys()].slice(0, 256);
+        for (const key of stale) blocks.delete(key);
+      }
+      return true;
+    }
+    if (owner.conflicted) return false;
+    if (owner.catalogTrackName === catalogTrackName) return true;
+    owner.conflicted = true;
+    return false;
+  }
+  #decoderBlockCatalogTrackName(client, sbn) {
+    const owner = this.#decoderBlockOwners.get(client)?.get(sbn);
+    return owner?.conflicted ? void 0 : owner?.catalogTrackName;
+  }
+  #resetDecoderBlockOwners(client, catalogTrackName) {
+    const blocks = this.#decoderBlockOwners.get(client);
+    if (!blocks) return;
+    for (const [sbn, owner] of blocks) {
+      if (owner.catalogTrackName === catalogTrackName || owner.conflicted) {
+        blocks.delete(sbn);
+      }
+    }
+    if (blocks.size === 0) this.#decoderBlockOwners.delete(client);
+  }
+  #discardFecDecoderClient(client) {
+    for (const [key, entry] of this.#fecDecoders) {
+      if (entry.client === client) this.#fecDecoders.delete(key);
+    }
+    this.#decoderBlockOwners.delete(client);
+  }
+  #assertExclusiveDecoderClient(streamKey, client, registrations, kind) {
+    for (const [registeredKey, registeredClient] of registrations) {
+      if (registeredClient !== client || registeredKey === streamKey) continue;
+      throw new Error(
+        `[FECManager] ${kind} client is already registered for stream ${registeredKey}; create one client per physical stream`
+      );
+    }
+  }
+  #statsForPacket(packetId) {
+    let stats = this.#fecTrackStats.get(packetId);
+    if (!stats) {
+      stats = newFecCounters();
+      this.#fecTrackStats.set(packetId, stats);
+    }
+    return stats;
+  }
+  #markPathBlockComplete(sbn, packetId, catalogTrackName) {
+    const block = this.#blockPathCounts.get(this.#blockKey(sbn, packetId, catalogTrackName));
+    if (block) block.complete = true;
+  }
+  /** Cancel and forget a block's D-28 repair-deadline timer. */
+  #clearRepairDeadline(key) {
+    const timer = this.#repairDeadlines.get(key);
+    if (timer?.handle != null) clearTimeout(timer.handle);
+    this.#repairDeadlines.delete(key);
+    this.#repairDeadlineAtMs.delete(key);
+  }
+  /**
+   * Move a block's D-28 repair deadline to `delayMs` from now. The timer
+   * already armed for an earlier moment fires first and re-arms for the
+   * remainder, so repeated source progress costs no timer operation.
+   */
+  #armRepairDeadline(key, sbn, packetId, catalogTrackName, delayMs) {
+    const deadlineMs = performance.now() + delayMs;
+    this.#repairDeadlineAtMs.set(key, deadlineMs);
+    const armed = this.#repairDeadlines.get(key);
+    if (armed?.handle != null) {
+      if (armed.fireAtMs <= deadlineMs) return;
+      clearTimeout(armed.handle);
+    }
+    const timer = { handle: null, fireAtMs: deadlineMs };
+    const onFire = () => {
+      if (this.#repairDeadlines.get(key) !== timer) return;
+      const currentDeadlineMs = this.#repairDeadlineAtMs.get(key);
+      const nowMs = performance.now();
+      if (currentDeadlineMs !== void 0 && currentDeadlineMs > nowMs) {
+        timer.fireAtMs = currentDeadlineMs;
+        timer.handle = setTimeout(onFire, Math.ceil(currentDeadlineMs - nowMs));
+        return;
+      }
+      timer.handle = null;
+      this.#requestRepair(sbn, packetId, catalogTrackName);
+    };
+    timer.handle = setTimeout(onFire, delayMs);
+    this.#repairDeadlines.set(key, timer);
+  }
+  #requestRepair(sbn, packetId, catalogTrackName, settledByOrder = false) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#completedBlocks.has(key) || !this.onRepairNeeded || this.#repairRequestedBlocks.has(key)) return;
+    const deadline = this.#repairDeadlines.get(key);
+    if (deadline?.handle != null) clearTimeout(deadline.handle);
+    this.#repairDeadlines.set(key, null);
+    this.#repairDeadlineAtMs.delete(key);
+    this.#repairRequestedBlocks.add(key);
+    if (settledByOrder) this.#armBlockTimeout(sbn, packetId, catalogTrackName, 0);
+    this.#traceLifecycle("repair-requested", sbn, packetId, catalogTrackName);
+    this.onRepairNeeded(
+      sbn,
+      packetId,
+      catalogTrackName,
+      this.blockClassFor(sbn, packetId, catalogTrackName)
+    );
+  }
+  // ── Keyframe-protected repair policy ──
+  /**
+   * The classifier geometry of one stream. A stream-scoped configuration
+   * wins. Once any stream of a packetId was configured with its own geometry,
+   * a sibling stream without one has none that provably belongs to it: the
+   * packet-level geometry may be another rung's (a different framerate or
+   * GOP), so it runs all-protected (`stream-geometry-absent`).
+   */
+  #geometryFor(packetId, catalogTrackName) {
+    const own = this.#streamGeometries.get(this.#streamKey(packetId, catalogTrackName));
+    if (own) return own;
+    const config = this.#trackConfigs.get(packetId);
+    if (config?.trackKind === "audio") return { trackKind: "audio" };
+    for (const key of this.#streamGeometries.keys()) {
+      if (this.#belongsToPacket(key, packetId)) {
+        return { trackKind: "video", mode: "all-protected", reason: "stream-geometry-absent" };
+      }
+    }
+    if (config?.geometry) return config.geometry;
+    return { trackKind: "video", mode: "all-protected", reason: "keyframe-cadence-absent" };
+  }
+  #classifierFor(packetId, catalogTrackName) {
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    let classifier = this.#classifiers.get(streamKey);
+    if (!classifier) {
+      classifier = new BlockClassifier(this.#geometryFor(packetId, catalogTrackName));
+      this.#classifiers.set(streamKey, classifier);
+      if (classifier.geometry.trackKind === "video") {
+        this.onClassifierMode?.(packetId, catalogTrackName, classifier.mode, classifier.reason);
+      }
+    }
+    return classifier;
+  }
+  #applyClassifierChanges(packetId, catalogTrackName, changes) {
+    for (const change of changes) {
+      if (change.kind === "mode") {
+        this.onClassifierMode?.(packetId, catalogTrackName, change.mode, change.reason);
+      } else {
+        this.onBlockReclassified?.(
+          change.sbn,
+          packetId,
+          catalogTrackName,
+          change.from,
+          change.to,
+          change.evidence
+        );
+      }
+    }
+  }
+  /**
+   * Freeze a block's class at resolution and drop its classifier state. The
+   * frozen class answers every later query (a recovery counted after the
+   * block was cancelled, a failure event) exactly.
+   */
+  #retireBlockClass(key, sbn, packetId, catalogTrackName) {
+    const frozen = this.#resolvedBlockClasses.get(key);
+    if (frozen !== void 0) return frozen;
+    const blockClass = this.#peekClass(sbn, packetId, catalogTrackName);
+    this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))?.forget(sbn);
+    this.#resolvedBlockClasses.set(key, blockClass);
+    this.#materializedBlocks.delete(key);
+    return blockClass;
+  }
+  /** A block's live class without creating classifier state for the stream. */
+  #peekClass(sbn, packetId, catalogTrackName) {
+    const classifier = this.#classifiers.get(this.#streamKey(packetId, catalogTrackName));
+    if (classifier) return classifier.classOf(sbn);
+    return this.#geometryFor(packetId, catalogTrackName).trackKind === "audio" ? "audio" : "unknown";
+  }
+  #viaFor(key) {
+    return (this.#blockPathCounts.get(key)?.moqSymbols ?? 0) > 0 ? "quic" : "inband";
+  }
+  #noteBlockRepaired(key, sbn, packetId, catalogTrackName) {
+    if (this.#repairedBlocks.has(key)) return;
+    this.#repairedBlocks.add(key);
+    this.onBlockRepaired?.(
+      sbn,
+      packetId,
+      catalogTrackName,
+      this.blockClassFor(sbn, packetId, catalogTrackName),
+      this.#viaFor(key)
+    );
+  }
+  // Deliberately one block tighter than deriveFecRetentionBlocks over the same
+  // inputs (that function's `+ 1`). Different question: the retention horizon
+  // asks how long the decoder still ACCEPTS symbols for a block, this asks how
+  // far back a block that vanished entirely may still be repairable (see
+  // #noteSbnSeen).
+  // The extra block of retention is slack for a block still being fed; a block
+  // nothing has been heard from does not get it. Not the units defect — but it
+  // is the next place the two can drift, so change both or neither.
+  #liveWindowBlocks(config) {
+    if (config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS || config.timeoutMs <= 0) return null;
+    return Math.ceil(config.timeoutMs / config.interleaveDepthMs);
+  }
+  /**
+   * Record that a symbol for block `sbn` arrived and materialise any blocks
+   * that vanished entirely between the stream's highest SBN and this one.
+   *
+   * The newest ceil(timeoutMs / interleaveDepthMs) vanished blocks may still
+   * be repairable, so they get the normal repair and fail deadlines, armed
+   * from now. Older ones are already past their fail bound and fail now, as
+   * class `unknown`. A SOURCE symbol whose SBN goes back further than one
+   * live window, or jumps further than the stream could have produced since
+   * its last symbol, is a source discontinuity, not loss. A repair symbol can
+   * only advance the frontier: a D-28 fetch legitimately answers for an old
+   * block, so it never signals a discontinuity.
+   *
+   * The producer closes a block at its Dth media-unit boundary OR when K
+   * source symbols filled it, so one interleave span can start several
+   * blocks (every large keyframe does). What bounds a forward jump is
+   * therefore packet evidence, not a block rate: with the MMTP
+   * packet_sequence_number (contiguous per packet_id, ISO/IEC 23008-1) of
+   * both source symbols, every block strictly between them holds at least one
+   * of the packets sent strictly between them, and K-closes can add at most
+   * one block per K of those packets on top of the D-closes elapsed time
+   * allows. Without it, only the D-close rate is known.
+   */
+  #noteSbnSeen(sbn, packetId, catalogTrackName, symbol, packetSequenceNumber) {
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    const now = performance.now();
+    const previous = this.#highestSbn.get(streamKey);
+    const anchor = this.#sourceAnchors.get(streamKey);
+    const psn = symbol === "source" && packetSequenceNumber !== void 0 && Number.isSafeInteger(packetSequenceNumber) && packetSequenceNumber >= 0 && packetSequenceNumber <= 4294967295 ? packetSequenceNumber : void 0;
+    const anchorHere = () => {
+      if (psn !== void 0 && (anchor === void 0 || !this.#blockPrecedes(sbn, anchor.sbn, packetId))) {
+        this.#sourceAnchors.set(streamKey, { sbn, psn, atMs: now });
+      }
+    };
+    const discontinuity = () => {
+      this.#classifiers.get(streamKey)?.noteSourceDiscontinuity();
+      this.#highestSbn.set(streamKey, { sbn, atMs: now });
+      if (psn === void 0) this.#sourceAnchors.delete(streamKey);
+      else this.#sourceAnchors.set(streamKey, { sbn, psn, atMs: now });
+      this.onSourceDiscontinuity?.(packetId, catalogTrackName);
+    };
+    if (previous === void 0) {
+      this.#highestSbn.set(streamKey, { sbn, atMs: now });
+      anchorHere();
+      return;
+    }
+    const config = this.#resolveTrackConfig(packetId);
+    const window = this.#liveWindowBlocks(config);
+    if (!this.#blockPrecedes(previous.sbn, sbn, packetId)) {
+      if (symbol === "source" && window !== null && this.#blocksBehind(sbn, previous.sbn, packetId) > window) {
+        discontinuity();
+        return;
+      }
+      anchorHere();
+      return;
+    }
+    const missing = this.#blocksBehind(previous.sbn, sbn, packetId) - 1;
+    let plausible = true;
+    if (window !== null) {
+      if (this.#isIso(packetId) && psn !== void 0 && anchor !== void 0 && this.#blockPrecedes(anchor.sbn, sbn, packetId) && psn !== anchor.psn) {
+        const sent = psn - anchor.psn >>> 0;
+        plausible = sent <= 2147483647 && serial32Distance(anchor.sbn, sbn) <= sent + config.k;
+      } else if (psn !== void 0 && anchor !== void 0 && this.#blockPrecedes(anchor.sbn, sbn, packetId) && psn !== anchor.psn) {
+        const sent = psn - anchor.psn >>> 0;
+        const between = this.#blocksBehind(anchor.sbn, sbn, packetId) - 1;
+        const dCloses = window + Math.ceil((now - anchor.atMs) / config.interleaveDepthMs);
+        const kCloses = config.k > 0 ? Math.ceil(sent / config.k) : sent;
+        plausible = sent <= 2147483647 && between <= sent - 1 && between <= dCloses + kCloses;
+      } else {
+        plausible = missing <= window + Math.ceil((now - previous.atMs) / config.interleaveDepthMs);
+      }
+    }
+    if (!plausible) {
+      if (symbol === "repair") return;
+      discontinuity();
+      return;
+    }
+    this.#highestSbn.set(streamKey, { sbn, atMs: now });
+    anchorHere();
+    if (this.#isIso(packetId)) return;
+    if (missing <= 0 || window === null) return;
+    let vanished = previous.sbn;
+    for (let i = 0; i < missing; i++) {
+      vanished = this.#nextBlock(vanished, packetId);
+      this.#materializeBlock(
+        vanished,
+        packetId,
+        catalogTrackName,
+        this.#blocksBehind(vanished, sbn, packetId) <= window
+      );
+    }
+  }
+  /*
+   * Block order for one stream (BLO-35597 iso:5). SS_ID is a 32-bit serial
+   * number (ISO/IEC 23008-1 C.5.2), so blocks are ordered by RFC 1982
+   * comparison of their first SS_ID (sbn * K mod 2^32). That is identical to
+   * comparing SBNs with < for every stream that has not wrapped SS_ID; only
+   * the order across the wrap changes. A block outside K-stride geometry has
+   * no SS_ID position, so it keeps the SBN order it always had.
+   */
+  #blockPrecedes(a, b, packetId) {
+    if (this.#isIso(packetId)) return serial32Precedes(a, b);
+    const k = this.kForPacket(packetId);
+    return isKStrideBlock(a, k) && isKStrideBlock(b, k) ? kStrideBlockPrecedes(a, b, k) : a < b;
+  }
+  /** Blocks `a` lies behind `b` (0 when it does not precede it). */
+  #blocksBehind(a, b, packetId) {
+    if (this.#isIso(packetId)) return isoBlocksBehindLowerBound(a, b, this.kForPacket(packetId));
+    const k = this.kForPacket(packetId);
+    return isKStrideBlock(a, k) && isKStrideBlock(b, k) ? kStrideBlocksBehind(a, b, k) : Math.max(0, b - a);
+  }
+  /** The block after `sbn`, stepping to block 0 where SS_ID wraps. */
+  #nextBlock(sbn, packetId) {
+    const k = this.kForPacket(packetId);
+    return isKStrideBlock(sbn, k) ? kStrideNextBlock(sbn, k) : sbn + 1;
+  }
+  #materializeBlock(sbn, packetId, catalogTrackName, repairable) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#blockResolutionFor(key) !== "untracked") return;
+    this.#materializedBlocks.add(key);
+    this.#classifierFor(packetId, catalogTrackName).touch(sbn);
+    this.onBlockVanished?.(sbn, packetId, catalogTrackName);
+    if (repairable) {
+      this.noteBlockActivity(sbn, packetId, catalogTrackName, true);
+    } else {
+      this.#failBlock(sbn, packetId, catalogTrackName);
+    }
+  }
+  #blockResolutionFor(key) {
+    if (this.#failedBlocks.has(key)) return "failed";
+    if (this.#completedBlocks.has(key)) return "complete";
+    if (this.#activeBlocks.has(key) || this.#pendingWorkerCleanups.has(key) || this.#repairDeadlines.has(key) || this.#blockSourceCounts.has(key) || this.#blockRepairRsIds.has(key) || this.#materializedBlocks.has(key)) {
+      return "pending";
+    }
+    return "untracked";
+  }
+  #bumpEpoch(packetId) {
+    this.#packetEpochs.set(packetId, (this.#packetEpochs.get(packetId) ?? 0) + 1);
+  }
+  #traceLifecycle(event, sbn, packetId, catalogTrackName, rsId) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    const deadline = this.#activeBlockDeadlinesMs.get(key);
+    const decoderPath = this.#syncDecoderBlockOwners.has(key) ? "sync" : this.#workerForPacket(packetId, catalogTrackName) ? "worker" : this.#decoderForPacket(packetId, catalogTrackName) ? "sync" : "none";
+    this.#lifecycleTrace.push({
+      atMs: Date.now(),
+      event,
+      packetId,
+      sbn,
+      ...catalogTrackName === void 0 ? {} : { catalogTrackName },
+      sourceCount: this.#blockSourceCounts.get(key) ?? 0,
+      sourceEsis: [...this.#blockSourceEsis.get(key) ?? []].sort((a, b) => a - b),
+      repairRsIds: [...this.#blockRepairRsIds.get(key) ?? []].sort((a, b) => a - b),
+      decoderPath,
+      ...deadline === void 0 ? {} : { deadlineRemainingMs: Math.max(0, deadline - performance.now()) },
+      pendingCleanup: this.#pendingWorkerCleanups.has(key),
+      ...rsId === void 0 ? {} : { rsId }
+    });
+    if (this.#lifecycleTrace.length > 64) this.#lifecycleTrace.splice(0, 32);
+  }
+  #defaultTrackConfig() {
+    return {
+      k: this.#fecK,
+      symbolSize: this.#fecSymbolSize,
+      interleaveDepthMs: this.#fecInterleaveDepthMs,
+      fps: this.#fecFps,
+      timeoutMs: this.#fecTimeoutMs
+    };
+  }
+  #resolveTrackConfig(packetId) {
+    return this.#trackConfigs.get(packetId) ?? this.#defaultTrackConfig();
+  }
+  #computeTimeout(config) {
+    if (config.timeoutMs && config.timeoutMs > 0) return config.timeoutMs;
+    if (config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+      return Math.max(
+        this.#fecTimeoutMs,
+        computeFecDeliveryWindowMs({
+          interleaveDepthMs: config.interleaveDepthMs,
+          sourceSymbols: config.k,
+          mediaUnitsPerSecond: config.fps
+        })
+      );
+    }
+    return this.#fecTimeoutMs;
+  }
+  /**
+   * The delivery-gap window is the longest catalog keyframe interval among
+   * the configured video streams. A failed video block costs every frame up
+   * to the next keyframe, so a receiver must remember a stall for at least
+   * that long: forgetting it sooner would let the next recurrence fail a
+   * block whose damage outlives the memory of the stall that caused it. It
+   * comes from the catalog's `keyframeIntervalTicks`/`keyframeIntervalMs`
+   * (via the classifier geometry), never from a constant. It also caps the
+   * gap the wait may absorb; with no catalog cadence no gap is reported and
+   * the catalog tolerance alone applies (see DeliveryGapEstimator).
+   */
+  #refreshDeliveryGapWindow() {
+    let windowMs;
+    const consider = (geometry) => {
+      if (geometry?.trackKind !== "video" || geometry.mode !== "classifying") return;
+      const { ticks, timescale } = geometry.keyframeInterval;
+      const ms = ticks / timescale * 1e3;
+      if (Number.isFinite(ms) && ms > 0 && (windowMs === void 0 || ms > windowMs)) windowMs = ms;
+    };
+    for (const geometry of this.#streamGeometries.values()) consider(geometry);
+    for (const config of this.#trackConfigs.values()) consider(config.geometry);
+    this.#deliveryGaps.setWindowMs(windowMs);
+  }
+  /**
+   * The multicast late-symbol wait: the block span plus the larger of the
+   * catalog's signaled tolerance and the receiver-measured delivery gap.
+   *
+   * `config.timeoutMs` already is span + `fec.reorderToleranceMs` (or the
+   * wider envelope configure() applies), so it stays the floor; the measured
+   * gap widens it only when the path stalls for longer than the catalog
+   * allowed for. Datagram delivery only: an ordered relay settles blocks by
+   * stream order and never feeds the estimator.
+   */
+  #multicastWaitMs(config) {
+    return this.#waitForGapMs(config, this.#deliveryGaps.peakGapMs(performance.now()));
+  }
+  /**
+   * The widest #multicastWaitMs can become: the estimator reports at most its
+   * catalog window, so this is a catalog quantity that no measurement moves.
+   */
+  #maxMulticastWaitMs(config) {
+    return this.#waitForGapMs(config, this.#deliveryGaps.windowMs ?? 0);
+  }
+  #waitForGapMs(config, gapMs) {
+    if (!(gapMs > 0) || !(config.interleaveDepthMs > 0)) return config.timeoutMs;
+    return Math.max(config.timeoutMs, Math.ceil(config.interleaveDepthMs + gapMs));
+  }
+  #repairDeadlineMs(config, waitMs = this.#multicastWaitMs(config)) {
+    const halfFailBoundMs = Math.ceil(waitMs / 2);
+    if (config.k > 0 && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS && config.fps !== void 0 && Number.isFinite(config.fps) && config.fps > 0) {
+      const mediaUnitMs = 1e3 / config.fps;
+      const interleaveUnits = deriveFecInterleaveDepth2(
+        config.interleaveDepthMs,
+        mediaUnitMs
+      );
+      const sourceHorizonMs = Math.ceil(config.k * interleaveUnits * mediaUnitMs);
+      if (sourceHorizonMs < waitMs) return sourceHorizonMs;
+    }
+    return halfFailBoundMs;
+  }
+  /**
+   * One block lifetime: the inactivity fail bound plus the D-28 repair grace,
+   * at the widest wait the catalog allows (#maxMulticastWaitMs). Everything
+   * derived from it (terminal retention, the release gate's hold ceiling, the
+   * duplicate ledgers, the owed-cleanup bound) is compared across time, so it
+   * must not follow the live measurement.
+   */
+  #blockLifetimeMs(config) {
+    const waitMs = this.#maxMulticastWaitMs(config);
+    return waitMs + this.#repairGraceMs(config, waitMs);
+  }
+  /**
+   * The lifetime at the live wait, capped at #blockLifetimeMs: lifetime is not
+   * monotone in the wait (the repair deadline switches from half the wait to
+   * the source horizon), so the cap is what keeps it inside the retention.
+   */
+  #liveBlockLifetimeMs(config) {
+    const waitMs = this.#multicastWaitMs(config);
+    return Math.min(waitMs + this.#repairGraceMs(config, waitMs), this.#blockLifetimeMs(config));
+  }
+  #repairGraceMs(config, waitMs) {
+    return Math.max(1, waitMs - this.#repairDeadlineMs(config, waitMs));
+  }
+  #armBlockTimeout(sbn, packetId, catalogTrackName, delayMs) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    const waitAtMs = performance.now() + Math.max(1, Math.ceil(delayMs));
+    const holdAtMs = this.#repairHoldUntilMs.get(key);
+    this.#blockWaitDeadlinesMs.set(key, holdAtMs === void 0 ? waitAtMs : Math.min(waitAtMs, holdAtMs));
+    this.#applyBlockDeadline(key, sbn, packetId, catalogTrackName);
+  }
+  /**
+   * Arm (or move) a block's one fail timer at the later of its multicast
+   * wait and its repair hold. Moving it later costs no timer operation: the
+   * armed timer wakes no later than the new deadline and re-arms for the
+   * remainder.
+   */
+  #applyBlockDeadline(key, sbn, packetId, catalogTrackName) {
+    const nowMs = performance.now();
+    const deadlineMs = Math.max(
+      this.#blockWaitDeadlinesMs.get(key) ?? nowMs + 1,
+      this.#repairHoldUntilMs.get(key) ?? -Infinity
+    );
+    this.#activeBlockDeadlinesMs.set(key, deadlineMs);
+    const armed = this.#activeBlocks.get(key);
+    if (armed?.handle != null) {
+      if (armed.fireAtMs <= deadlineMs) return;
+      clearTimeout(armed.handle);
+    }
+    const timer = { handle: null, fireAtMs: deadlineMs };
+    const onFire = () => {
+      if (this.#activeBlocks.get(key) !== timer) return;
+      const currentDeadlineMs = this.#activeBlockDeadlinesMs.get(key);
+      const firedAtMs = performance.now();
+      if (currentDeadlineMs !== void 0 && currentDeadlineMs > firedAtMs) {
+        timer.fireAtMs = currentDeadlineMs;
+        timer.handle = setTimeout(onFire, Math.ceil(currentDeadlineMs - firedAtMs));
+        return;
+      }
+      this.#activeBlocks.delete(key);
+      this.#activeBlockDeadlinesMs.delete(key);
+      this.#blockWaitDeadlinesMs.delete(key);
+      this.#repairHoldUntilMs.delete(key);
+      this.#traceLifecycle("timeout-queued", sbn, packetId, catalogTrackName);
+      this.#finalizeExpiredBlock(sbn, packetId, catalogTrackName);
+    };
+    timer.handle = setTimeout(onFire, Math.max(1, Math.ceil(deadlineMs - nowMs)));
+    this.#activeBlocks.set(key, timer);
+    this.#indexBlockKey(key, sbn, packetId);
+  }
+  /**
+   * Hand a block whose delivery is over to its decoder for finalization: the
+   * datagram deadline fired, or the ordered relay moved past it.
+   */
+  #finalizeExpiredBlock(sbn, packetId, catalogTrackName) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#materializedBlocks.has(key) && !this.#blockPathCounts.has(key)) {
+      this.#failBlock(sbn, packetId, catalogTrackName);
+      return;
+    }
+    const syncOwner = this.#syncDecoderBlockOwners.get(key);
+    if (syncOwner) {
+      this.#routeSyncCleanup(syncOwner, sbn, packetId, catalogTrackName);
+      this.#failBlock(sbn, packetId, catalogTrackName);
+      return;
+    }
+    const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName);
+    if (workerClient) {
+      this.#pendingWorkerCleanups.add(key);
+      this.#pendingWorkerCleanupClients.set(key, workerClient);
+      this.#boundOwedCleanup(key, packetId, workerClient);
+      workerClient.cleanup(sbn);
+    } else {
+      const decoder = this.#decoderForPacket(packetId, catalogTrackName)?.client;
+      if (decoder) {
+        this.#routeSyncCleanup(decoder, sbn, packetId, catalogTrackName);
+        this.#failBlock(sbn, packetId, catalogTrackName);
+      } else {
+        this.#failBlock(sbn, packetId, catalogTrackName);
+      }
+    }
+  }
+  /**
+   * Upsert one packetId's track configuration. With `catalogTrackName`, the
+   * classifier geometry in `config` is that stream's own and is kept per
+   * stream; every other field stays per packetId.
+   */
+  #upsertTrackConfig(packetId, config, catalogTrackName) {
+    const previous = this.#trackConfigs.get(packetId) ?? this.#defaultTrackConfig();
+    const streamScopedGeometry = catalogTrackName !== void 0 && config.geometry !== void 0 ? config.geometry : void 0;
+    if (streamScopedGeometry !== void 0) {
+      const { geometry: _streamGeometry, ...packetLevel } = config;
+      config = packetLevel;
+    }
+    const timingChanged = config.k !== void 0 || config.interleaveDepthMs !== void 0 || config.fps !== void 0;
+    if (config.blockProfile !== void 0) {
+      parseFecBlockProfile(config.blockProfile, `packetId=${packetId} fec.blockProfile`);
+    }
+    const blockProfile = config.blockProfile ?? previous.blockProfile;
+    if (blockProfile === void 0) {
+      throw new Error(
+        `[FECManager] packetId=${packetId}: fec.blockProfile is required ("k-padded-v1" or "iso-ssbg1-v1"); configure the track from its catalog`
+      );
+    }
+    if (blockProfile === "iso-ssbg1-v1") {
+      const ownInterleaveDepthMs = config.interleaveDepthMs ?? this.#trackConfigs.get(packetId)?.interleaveDepthMs;
+      if (ownInterleaveDepthMs === void 0 || !Number.isFinite(ownInterleaveDepthMs) || ownInterleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) {
+        throw new Error(
+          `[FECManager] packetId=${packetId}: iso-ssbg1-v1 requires the catalog fec.interleaveDepthMs (>= ${MIN_INTERLEAVE_DEPTH_MS} ms; got ${String(ownInterleaveDepthMs)}): it bounds how long block location keeps stated blocks and held sources`
+        );
+      }
+    }
+    const next = {
+      blockProfile,
+      k: config.k ?? previous.k,
+      symbolSize: config.symbolSize != null && config.symbolSize > 0 ? config.symbolSize : previous.symbolSize,
+      interleaveDepthMs: config.interleaveDepthMs ?? previous.interleaveDepthMs,
+      fps: config.fps ?? previous.fps,
+      timeoutMs: config.timeoutMs ?? (timingChanged ? 0 : previous.timeoutMs),
+      ...(config.trackKind ?? previous.trackKind) === void 0 ? {} : { trackKind: config.trackKind ?? previous.trackKind },
+      ...(config.codec ?? previous.codec) === void 0 ? {} : { codec: config.codec ?? previous.codec },
+      ...(config.geometry ?? previous.geometry) === void 0 ? {} : { geometry: config.geometry ?? previous.geometry }
+    };
+    next.timeoutMs = this.#computeTimeout(next);
+    if (this.#multicastSymbolDelivery === "ordered-relay") {
+      this.#orderedHorizonBlocksFor(packetId, next);
+    }
+    if (previous.blockProfile !== void 0 && (previous.blockProfile !== blockProfile || blockProfile === "iso-ssbg1-v1" && previous.k !== next.k)) {
+      this.#dropIsoLocators(packetId);
+    }
+    this.#trackConfigs.set(packetId, next);
+    this.#refreshDeliveryGapWindow();
+    let policyChanged = config.geometry !== void 0 && JSON.stringify(config.geometry) !== JSON.stringify(previous.geometry) || config.trackKind !== void 0 && config.trackKind !== previous.trackKind;
+    if (streamScopedGeometry !== void 0) {
+      const streamKey = this.#streamKey(packetId, catalogTrackName);
+      if (JSON.stringify(streamScopedGeometry) !== JSON.stringify(this.#streamGeometries.get(streamKey))) {
+        this.#streamGeometries.set(streamKey, streamScopedGeometry);
+        this.#refreshDeliveryGapWindow();
+        policyChanged = true;
+      }
+    }
+    if (policyChanged) {
+      this.#bumpEpoch(packetId);
+      for (const [key, classifier] of [...this.#classifiers]) {
+        if (!this.#belongsToPacket(key, packetId)) continue;
+        const stream = this.#parseStreamKey(key);
+        const geometry = this.#geometryFor(stream.packetId, stream.catalogTrackName);
+        if (JSON.stringify(geometry) === JSON.stringify(classifier.geometry)) continue;
+        this.#classifiers.delete(key);
+        this.#applyClassifierChanges(stream.packetId, stream.catalogTrackName, classifier.retire());
+      }
+    }
+    return next;
+  }
+  #normalizeSymbolData(packetId, data) {
+    const symbolSize = this.symbolSizeForPacket(packetId);
+    if (symbolSize <= 0 || data.byteLength === symbolSize) return data;
+    const normalized = new Uint8Array(symbolSize);
+    normalized.set(data.subarray(0, symbolSize));
+    return normalized;
+  }
+  #blockKeysFor(sbn, packetId, catalogTrackName) {
+    if (packetId != null && catalogTrackName !== void 0) {
+      return [this.#blockKey(sbn, packetId, catalogTrackName)];
+    }
+    const keys = [];
+    const candidates = this.#blockKeysBySbn.get(sbn);
+    if (candidates) {
+      for (const [key, keyPacketId] of candidates) {
+        if (packetId !== void 0 && keyPacketId !== packetId) continue;
+        if (!this.#isBlockKeyHeld(key)) {
+          candidates.delete(key);
+          continue;
+        }
+        keys.push(key);
+      }
+      if (candidates.size === 0) this.#blockKeysBySbn.delete(sbn);
+    }
+    if (packetId !== void 0) {
+      if (keys.length === 0) return [this.#blockKey(sbn, packetId)];
+      return keys.length === 1 ? keys : [];
+    }
+    return keys.length > 0 ? keys : [this.#blockKey(sbn, 0, catalogTrackName)];
+  }
+  // -----------------------------------------------------------------------
+  // Accessors
+  // -----------------------------------------------------------------------
+  /** Internal state for diagnostics — not part of the public stats API. */
+  get diagnostics() {
+    return {
+      timeoutMs: this.#fecTimeoutMs,
+      activeBlocks: this.#activeBlocks.size,
+      completedBlocks: this.#completedBlocks.size,
+      cleanlyCompletedBlocks: this.#cleanlyCompletedBlocks.size,
+      pendingCounts: Object.fromEntries(this.#blockSourceCounts),
+      fpsDetected: this.#fpsDetected,
+      interleaveDepthMs: this.#fecInterleaveDepthMs,
+      startupAlignedPackets: this.#packetIdsForStreamKeys(this.#startupAlignedPackets),
+      startupPartialBlocks: this.#startupPartialBlocks.size,
+      startupRepairReadyPackets: this.#packetIdsForStreamKeys(this.#startupRepairReadyPackets),
+      startupRepairFailOpenPackets: this.#packetIdsForStreamKeys(this.#startupRepairFailOpenPackets),
+      pendingWorkerCleanups: this.#pendingWorkerCleanups.size,
+      decoderUnavailableEvents: this.#decoderUnavailableEvents,
+      repairTrackedBlocks: this.#blockRepairRsIds.size,
+      multicastSymbolDelivery: this.#multicastSymbolDelivery,
+      orderedFrontiers: Object.fromEntries(this.#orderedFrontiers),
+      orderedPendingBlocks: [...this.#orderedPendingBlocks.values()].reduce((total, pending) => total + pending.size, 0),
+      lifecycleTrace: this.#lifecycleTrace.map((entry) => ({ ...entry }))
+    };
+  }
+  get fecStats() {
+    const s = this.#fecStats;
+    const affected = s.blocksRecovered + s.blocksFailed;
+    const total = s.blocksClean + affected;
+    const tracks = [...this.#fecTrackStats.entries()].sort(([left], [right]) => left - right).map(([packetId, stats]) => {
+      const trackAffected = stats.blocksRecovered + stats.blocksFailed;
+      const trackTotal = stats.blocksClean + trackAffected;
+      return {
+        ...stats,
+        packetId,
+        blocksComplete: trackTotal,
+        k: this.#resolveTrackConfig(packetId).k,
+        recoveryRate: trackAffected > 0 ? stats.blocksRecovered / trackAffected * 100 : 100,
+        packetLossRate: trackTotal > 0 ? trackAffected / trackTotal * 100 : 0
+      };
+    });
+    return {
+      ...s,
+      blocksComplete: total,
+      mixedPathBlocks: Array.from(this.#blockPathCounts.values()).filter(
+        (block) => block.multicastSymbols > 0 && block.moqSymbols > 0
+      ).length,
+      recentBlockPathCounts: Array.from(this.#blockPathCounts.values()).slice(-24),
+      k: this.#fecK,
+      // True recovery rate: of blocks that HAD loss, how many were recovered?
+      recoveryRate: affected > 0 ? s.blocksRecovered / affected * 100 : 100,
+      packetLossRate: total > 0 ? affected / total * 100 : 0,
+      tracks,
+      workers: [...this.#fecWorkerStats.entries()].sort(([left], [right]) => left - right).map(([packetId, stats]) => ({
+        ...stats,
+        config: {
+          ...stats.config,
+          resolution: stats.config.resolution ? { ...stats.config.resolution } : void 0
+        },
+        blocks: stats.blocks.map((block) => ({ ...block })),
+        decoder: stats.decoder ? { ...stats.decoder } : void 0,
+        altaFailedDetails: stats.altaFailedDetails?.map((detail) => ({ ...detail })),
+        packetId
+      })),
+      repairSymbolSizeMismatches: this.#repairSymbolSizeMismatchCount,
+      workerErrors: Object.fromEntries(this.#workerErrorCounts)
+    };
+  }
+  /**
+   * Observe Worker-backed per-track snapshots without taking ownership of the
+   * legacy single-callback slot. Infrastructure diagnostics and a player may
+   * therefore consume the same source event without wrapping or replacing one
+   * another's callback.
+   */
+  addFecStatsObserver(observer) {
+    this.#fecStatsObservers.add(observer);
+    return () => this.#fecStatsObservers.delete(observer);
+  }
+  /** Start a new multicast transport join without discarding track/decoder state. */
+  beginMulticastJoin() {
+    this.#orderedFrontiers.clear();
+    this.#startupAlignedPackets.clear();
+    this.#startupPartialBlocks.clear();
+    this.#startupRequireRepairReady = true;
+    this.#startupRepairReadyPackets.clear();
+    this.#startupRepairBoundaryCounts.clear();
+    this.#startupRepairFailOpenPackets.clear();
+  }
+  /** How the multicast leg currently delivers symbols. */
+  get multicastSymbolDelivery() {
+    return this.#multicastSymbolDelivery;
+  }
+  /**
+   * Declare how the multicast leg delivers symbols (see
+   * MulticastSymbolDelivery). The multicast provider owns this fact:
+   * MulticastManager applies what the window.multicast subscription declares
+   * on every join, and a consumer feeding packets itself declares its own leg.
+   *
+   * Switching to 'ordered-relay' requires every configured track to define
+   * its interleave horizon and throws otherwise. Switching back to 'datagram'
+   * gives every block awaiting ordered settlement the datagram inactivity
+   * deadline from now.
+   */
+  setMulticastSymbolDelivery(delivery) {
+    if (!isMulticastSymbolDelivery(delivery)) {
+      throw new Error(
+        `[FECManager] multicast symbol delivery must be 'datagram' or 'ordered-relay', got ${String(delivery)}`
+      );
+    }
+    if (delivery === this.#multicastSymbolDelivery) return;
+    this.#deliveryGaps.reset();
+    if (delivery === "ordered-relay") {
+      for (const [packetId, config] of this.#trackConfigs) {
+        this.#orderedHorizonBlocksFor(packetId, config);
+      }
+      this.#multicastSymbolDelivery = delivery;
+      return;
+    }
+    this.#multicastSymbolDelivery = delivery;
+    const pending = [...this.#orderedPendingBlocks.values()].flatMap((blocks) => [...blocks.values()]);
+    this.#orderedPendingBlocks.clear();
+    this.#orderedFrontiers.clear();
+    for (const key of pending) {
+      const block = this.#parseBlockKey(key);
+      this.noteBlockActivity(block.sbn, block.packetId, block.catalogTrackName);
+    }
+  }
+  /** Begin a fresh decode epoch for one physical stream. */
+  resetTrack(packetId, catalogTrackName) {
+    if (!Number.isInteger(packetId) || packetId < 0) {
+      throw new Error(`[FECManager] invalid packetId for reset: ${packetId}`);
+    }
+    if (!catalogTrackName) {
+      throw new Error("[FECManager] catalogTrackName is required for track reset");
+    }
+    const resetMap = (map) => {
+      for (const key of map.keys()) {
+        if (!this.#belongsToStream(key, packetId, catalogTrackName)) continue;
+        map.delete(key);
+      }
+    };
+    const resetTimerMap = (map) => {
+      for (const [key, timer] of map) {
+        if (!this.#belongsToStream(key, packetId, catalogTrackName)) continue;
+        if (timer?.handle != null) clearTimeout(timer.handle);
+        map.delete(key);
+      }
+    };
+    const resetSet = (set) => {
+      for (const key of set) {
+        if (this.#belongsToStream(key, packetId, catalogTrackName)) set.delete(key);
+      }
+    };
+    resetTimerMap(this.#activeBlocks);
+    resetTimerMap(this.#repairDeadlines);
+    resetMap(this.#activeBlockDeadlinesMs);
+    resetMap(this.#blockWaitDeadlinesMs);
+    resetMap(this.#repairHoldUntilMs);
+    resetMap(this.#repairDeadlineAtMs);
+    resetMap(this.#terminalExpiryMs);
+    resetMap(this.#pendingWorkerCleanupClients);
+    for (const key of [...this.#pendingWorkerCleanupBounds.keys()]) {
+      if (this.#belongsToStream(key, packetId, catalogTrackName)) this.#clearOwedCleanupBound(key);
+    }
+    resetMap(this.#blockSourceCounts);
+    resetMap(this.#blockSourceEsis);
+    resetMap(this.#blockAuthoredLengths);
+    resetMap(this.#blockRepairRsIds);
+    resetMap(this.#blockPathCounts);
+    resetMap(this.#blockAnchorsMs);
+    resetMap(this.#blockCatalogTrackNames);
+    resetMap(this.#syncDecoderBlockOwners);
+    resetMap(this.#startupRepairBoundaryCounts);
+    resetMap(this.#orderedFrontiers);
+    resetMap(this.#orderedPendingBlocks);
+    resetSet(this.#pendingWorkerCleanups);
+    resetSet(this.#completedBlocks);
+    resetSet(this.#cleanlyCompletedBlocks);
+    resetSet(this.#repairRequestedBlocks);
+    resetSet(this.#workerRecoveredBlocks);
+    resetSet(this.#startupAlignedPackets);
+    resetSet(this.#startupPartialBlocks);
+    resetSet(this.#startupRepairReadyPackets);
+    resetSet(this.#startupRepairFailOpenPackets);
+    resetSet(this.#seenSymbols);
+    resetSet(this.#failedBlocks);
+    resetSet(this.#repairedBlocks);
+    resetSet(this.#materializedBlocks);
+    resetMap(this.#resolvedBlockClasses);
+    resetMap(this.#highestSbn);
+    resetMap(this.#isoLocators);
+    resetMap(this.#sourceAnchors);
+    this.#classifiers.delete(this.#streamKey(packetId, catalogTrackName));
+    this.#bumpEpoch(packetId);
+    for (const [sbn, keys] of this.#blockKeysBySbn) {
+      for (const key of keys.keys()) {
+        if (this.#belongsToStream(key, packetId, catalogTrackName)) keys.delete(key);
+      }
+      if (keys.size === 0) this.#blockKeysBySbn.delete(sbn);
+    }
+    const decoderClients = /* @__PURE__ */ new Set();
+    for (const [key, entry] of this.#fecDecoders) {
+      if (this.#belongsToStream(key, packetId, catalogTrackName)) {
+        decoderClients.add(entry.client);
+      }
+    }
+    const clients = /* @__PURE__ */ new Set();
+    for (const client of decoderClients) {
+      if (typeof client.flush === "function" && typeof client.reset_stats === "function") {
+        try {
+          client.flush();
+          client.reset_stats();
+          clients.add(client);
+        } catch {
+          this.#discardFecDecoderClient(client);
+        }
+      } else {
+        this.#discardFecDecoderClient(client);
+      }
+    }
+    for (const [key, client] of [...this.#workerClients]) {
+      if (!this.#belongsToStream(key, packetId, catalogTrackName)) continue;
+      if (client.disposed === true) {
+        this.#evictDisposedWorker(client);
+        continue;
+      }
+      client.reset();
+      clients.add(client);
+    }
+    for (const client of clients) this.#resetDecoderBlockOwners(client, catalogTrackName);
+  }
+  /**
+   * Retire one packet ID, drop-only: forget every stream on it (block
+   * ledgers, deadlines and their timers, repair holds, terminal records,
+   * classifiers, stream geometry), its per-packet configuration and
+   * statistics, and take its decoders out of routing.
+   *
+   * This is the end of the packet ID's streams, not a new epoch of them (that
+   * is resetTrack): afterwards isTrackConfigured() is false and nothing about
+   * it remains until it is configured again. Nothing is reported, because
+   * nothing happened to the media: no block fails, recovers or resolves, no
+   * repair resolves, and no decoder becomes "unavailable" (a retired stream
+   * has no symbols left to decode, so a decoder-unavailable event would
+   * describe lost protection that no stream suffers). The epoch still
+   * advances, so a gap decision made before the retirement never matches a
+   * stream later configured on the same packet ID.
+   *
+   * Decoder and Worker clients stay caller-owned: each is flushed or reset so
+   * it holds no block of the retired streams, then released from routing;
+   * dispose it after this returns. Cumulative totals in fecStats keep what
+   * the retired streams contributed.
+   */
+  releasePacket(packetId) {
+    if (!Number.isInteger(packetId) || packetId < 0) {
+      throw new Error(`[FECManager] invalid packetId for release: ${packetId}`);
+    }
+    const onPacket = (key) => this.#belongsToPacket(key, packetId);
+    const dropMap = (map) => {
+      for (const key of [...map.keys()]) if (onPacket(key)) map.delete(key);
+    };
+    const dropTimerMap = (map) => {
+      for (const [key, timer] of [...map]) {
+        if (!onPacket(key)) continue;
+        if (timer?.handle != null) clearTimeout(timer.handle);
+        map.delete(key);
+      }
+    };
+    const dropSet = (set) => {
+      for (const key of [...set]) if (onPacket(key)) set.delete(key);
+    };
+    dropTimerMap(this.#activeBlocks);
+    dropTimerMap(this.#repairDeadlines);
+    for (const key of [...this.#pendingWorkerCleanupBounds.keys()]) {
+      if (onPacket(key)) this.#clearOwedCleanupBound(key);
+    }
+    dropMap(this.#activeBlockDeadlinesMs);
+    dropMap(this.#blockWaitDeadlinesMs);
+    dropMap(this.#repairHoldUntilMs);
+    dropMap(this.#repairDeadlineAtMs);
+    dropMap(this.#terminalExpiryMs);
+    dropMap(this.#pendingWorkerCleanupClients);
+    dropMap(this.#blockSourceCounts);
+    dropMap(this.#blockSourceEsis);
+    dropMap(this.#blockAuthoredLengths);
+    dropMap(this.#blockRepairRsIds);
+    dropMap(this.#blockPathCounts);
+    dropMap(this.#blockAnchorsMs);
+    dropMap(this.#blockCatalogTrackNames);
+    dropMap(this.#syncDecoderBlockOwners);
+    dropMap(this.#startupRepairBoundaryCounts);
+    dropMap(this.#orderedFrontiers);
+    dropMap(this.#orderedPendingBlocks);
+    dropMap(this.#resolvedBlockClasses);
+    dropMap(this.#highestSbn);
+    dropMap(this.#isoLocators);
+    dropMap(this.#sourceAnchors);
+    dropMap(this.#classifiers);
+    dropMap(this.#streamGeometries);
+    dropSet(this.#pendingWorkerCleanups);
+    dropSet(this.#completedBlocks);
+    dropSet(this.#cleanlyCompletedBlocks);
+    dropSet(this.#repairRequestedBlocks);
+    dropSet(this.#workerRecoveredBlocks);
+    dropSet(this.#startupAlignedPackets);
+    dropSet(this.#startupPartialBlocks);
+    dropSet(this.#startupRepairReadyPackets);
+    dropSet(this.#startupRepairFailOpenPackets);
+    dropSet(this.#seenSymbols);
+    dropSet(this.#failedBlocks);
+    dropSet(this.#repairedBlocks);
+    dropSet(this.#materializedBlocks);
+    for (const [sbn, keys] of [...this.#blockKeysBySbn]) {
+      for (const [key, keyPacketId] of [...keys]) {
+        if (keyPacketId === packetId) keys.delete(key);
+      }
+      if (keys.size === 0) this.#blockKeysBySbn.delete(sbn);
+    }
+    this.#terminalQueues.delete(packetId);
+    this.#trackConfigs.delete(packetId);
+    this.#fecTrackStats.delete(packetId);
+    this.#fecWorkerStats.delete(packetId);
+    this.#bumpEpoch(packetId);
+    this.#refreshDeliveryGapWindow();
+    for (const [key, entry] of [...this.#fecDecoders]) {
+      if (!onPacket(key)) continue;
+      this.#fecDecoders.delete(key);
+      this.#decoderBlockOwners.delete(entry.client);
+      try {
+        entry.client.flush?.();
+      } catch {
+      }
+    }
+    for (const [key, client] of [...this.#workerClients]) {
+      if (!onPacket(key)) continue;
+      this.#workerClients.delete(key);
+      this.#decoderBlockOwners.delete(client);
+      this.#releasedWorkerClients.add(client);
+      try {
+        if (client.disposed !== true) client.reset();
+      } catch {
+      }
+    }
+  }
+  /** Record a transport symbol and reject later duplicates of the same packetId/SBN/ESI. */
+  feedSymbolFromSource(packetId, sbn, esi, _data, source, catalogTrackName) {
+    const blockKey = this.#blockKey(sbn, packetId, catalogTrackName);
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    if (source === "multicast" && this.#multicastSymbolDelivery === "ordered-relay") {
+      this.#advanceOrderedFrontier(streamKey, sbn, packetId, catalogTrackName);
+    }
+    const k = this.kForPacket(packetId);
+    const sourceSymbols = this.#isIso(packetId) ? this.#isoLocatorFor(packetId, catalogTrackName).blockAt(sbn)?.length ?? k : k;
+    const isSourceSymbol = esi >= 0 && esi < sourceSymbols;
+    const isStartupPartial = this.#startupPartialBlocks.has(blockKey);
+    const isReadyMulticastRepair = this.#startupRequireRepairReady && source === "multicast" && !isSourceSymbol && this.#startupRepairReadyPackets.has(streamKey);
+    const awaitingMulticastRepair = this.#startupRequireRepairReady && source === "multicast" && !this.#startupRepairReadyPackets.has(streamKey) && !this.#startupRepairFailOpenPackets.has(streamKey);
+    if (awaitingMulticastRepair) {
+      if (!isSourceSymbol) {
+        this.#startupRepairReadyPackets.add(streamKey);
+        this.#startupRepairBoundaryCounts.delete(streamKey);
+        this.#markStartupPartial(blockKey);
+        return false;
+      }
+      if (esi === 0) {
+        const boundaries = (this.#startupRepairBoundaryCounts.get(streamKey) ?? 0) + 1;
+        this.#startupRepairBoundaryCounts.set(streamKey, boundaries);
+        if (boundaries >= STARTUP_REPAIR_WAIT_SOURCE_BOUNDARIES) {
+          this.#startupRepairBoundaryCounts.delete(streamKey);
+          this.#startupRepairFailOpenPackets.add(streamKey);
+        } else {
+          this.#markStartupPartial(blockKey);
+          return false;
+        }
+      } else {
+        this.#markStartupPartial(blockKey);
+        return false;
+      }
+    }
+    if (isSourceSymbol && esi === 0) {
+      this.#startupPartialBlocks.delete(blockKey);
+      this.#startupAlignedPackets.add(streamKey);
+    } else if (isStartupPartial && !isReadyMulticastRepair || !this.#startupAlignedPackets.has(streamKey) && !isReadyMulticastRepair) {
+      this.#markStartupPartial(blockKey);
+      return false;
+    }
+    if (this.#completedBlocks.has(blockKey)) {
+      this.#fecStats.duplicateSymbols++;
+      this.#statsForPacket(packetId).duplicateSymbols++;
+      return false;
+    }
+    const symbolKey = `${blockKey}:${esi}`;
+    if (this.#seenSymbols.has(symbolKey)) {
+      this.#fecStats.duplicateSymbols++;
+      this.#statsForPacket(packetId).duplicateSymbols++;
+      return false;
+    }
+    this.#seenSymbols.add(symbolKey);
+    const counts = this.#blockPathCounts.get(blockKey) ?? {
+      packetId,
+      sbn,
+      ...catalogTrackName === void 0 ? {} : { catalogTrackName },
+      multicastSymbols: 0,
+      moqSymbols: 0,
+      complete: false
+    };
+    if (!this.#blockAnchorsMs.has(blockKey)) this.#blockAnchorsMs.set(blockKey, performance.now());
+    if (source === "multicast") counts.multicastSymbols++;
+    else counts.moqSymbols++;
+    this.#blockPathCounts.set(blockKey, counts);
+    this.#observeBlockCatalogTrackName(blockKey, sbn, packetId, catalogTrackName);
+    if (this.#seenSymbols.size > 4096) {
+      dropOldest(this.#seenSymbols, this.#seenSymbols.size - 2048);
+    }
+    if (this.#blockPathCounts.size > 512) {
+      dropOldest(this.#blockPathCounts, this.#blockPathCounts.size - 256);
+    }
+    if (this.#blockAnchorsMs.size > 512) {
+      dropOldest(this.#blockAnchorsMs, this.#blockAnchorsMs.size - 256);
+    }
+    if (this.#blockCatalogTrackNames.size > 512) {
+      for (const key of dropOldest(
+        this.#blockCatalogTrackNames,
+        this.#blockCatalogTrackNames.size - 256
+      )) {
+        this.#unindexBlockKey(key);
+      }
+    }
+    return true;
+  }
+  #observeBlockCatalogTrackName(blockKey, sbn, packetId, catalogTrackName) {
+    if (catalogTrackName === void 0) return;
+    if (!this.#blockCatalogTrackNames.has(blockKey)) {
+      this.#blockCatalogTrackNames.set(blockKey, catalogTrackName);
+      this.#indexBlockKey(blockKey, sbn, packetId);
+      return;
+    }
+    if (this.#blockCatalogTrackNames.get(blockKey) !== catalogTrackName) {
+      this.#blockCatalogTrackNames.set(blockKey, null);
+    }
+  }
+  /** Exact catalog identity retained for async recovery, if unambiguous. */
+  catalogTrackNameForBlock(sbn, packetId, catalogTrackName) {
+    if (catalogTrackName !== void 0) {
+      return this.#blockCatalogTrackNames.get(
+        this.#blockKey(sbn, packetId, catalogTrackName)
+      ) ?? void 0;
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const [key, name] of this.#blockCatalogTrackNames) {
+      const block = this.#parseBlockKey(key);
+      if (block.packetId === packetId && block.sbn === sbn && name !== null) names.add(name);
+    }
+    return names.size === 1 ? [...names][0] : void 0;
+  }
+  #markStartupPartial(blockKey) {
+    this.#startupPartialBlocks.add(blockKey);
+    if (this.#startupPartialBlocks.size > 128) {
+      this.#startupPartialBlocks = new Set(
+        Array.from(this.#startupPartialBlocks).slice(-64)
+      );
+    }
+  }
+  /** Per-block state snapshot for FecBlockGrid visualization.
+   *  Returns the most recent blocks (active + recently completed). */
+  getBlockStates() {
+    const blocks = [];
+    for (const [key] of this.#activeBlocks) {
+      const { packetId, sbn } = this.#parseBlockKey(key);
+      const count = this.#blockSourceCounts.get(key) ?? 0;
+      const k = this.#blockAuthoredLengths.get(key) ?? this.kForPacket(packetId);
+      blocks.push({ sbn, packetId, state: "collecting", sourceCount: count, k, progress: k > 0 ? Math.min(count / k, 1) : 0 });
+    }
+    const completed = [...this.#completedBlocks].slice(-16);
+    for (const key of completed) {
+      const { packetId, sbn } = this.#parseBlockKey(key);
+      if (!this.#activeBlocks.has(key)) {
+        const k = this.kForPacket(packetId);
+        blocks.push({ sbn, packetId, state: "complete", sourceCount: k, k, progress: 1 });
+      }
+    }
+    blocks.sort((a, b) => a.sbn - b.sbn || (a.packetId ?? 0) - (b.packetId ?? 0));
+    return blocks.slice(-24);
+  }
+  /** The raw WASM decoder for stats access (first registered decoder) */
+  get wasmDecoder() {
+    return this.#fecDecoders.values().next().value?.client ?? null;
+  }
+  get k() {
+    return this.#fecK;
+  }
+  kForPacket(packetId) {
+    return this.#resolveTrackConfig(packetId).k;
+  }
+  /** FEC symbol size in bytes. */
+  get symbolSize() {
+    return this.#fecSymbolSize;
+  }
+  symbolSizeForPacket(packetId) {
+    return this.#resolveTrackConfig(packetId).symbolSize;
+  }
+  /** FEC block span in milliseconds (0 = no interleaving). */
+  get interleaveDepthMs() {
+    return this.#fecInterleaveDepthMs;
+  }
+  interleaveDepthMsForPacket(packetId) {
+    return this.#resolveTrackConfig(packetId).interleaveDepthMs;
+  }
+  /**
+   * Record one multicast MMTP packet arrival (every packet of the leg, FEC
+   * symbol or not) for the delivery-gap measurement. `packetSequenceNumber`
+   * is the MMTP packet_sequence_number, which increments by one per packet of
+   * a packet_id: it is what separates a stall from a loss (see
+   * DeliveryGapEstimator). Datagram delivery only.
+   */
+  noteMulticastArrival(packetId, packetSequenceNumber) {
+    if (this.#multicastSymbolDelivery !== "datagram") return;
+    this.#deliveryGaps.noteArrival(performance.now(), packetId, packetSequenceNumber);
+  }
+  /**
+   * Resolved per-track multicast late-symbol wait in milliseconds: the span
+   * plus the larger of the catalog tolerance and the measured delivery gap.
+   */
+  timeoutMsForPacket(packetId) {
+    return this.#multicastWaitMs(this.#resolveTrackConfig(packetId));
+  }
+  /**
+   * Largest multicast delivery gap measured over the current window (ms), and
+   * that window (undefined: held since the last reset). Diagnostics.
+   */
+  multicastDeliveryGap() {
+    return {
+      peakGapMs: this.#deliveryGaps.peakGapMs(performance.now()),
+      windowMs: this.#deliveryGaps.windowMs
+    };
+  }
+  /**
+   * Receiver-local time of a block's first accepted symbol, or undefined for
+   * a block no symbol reached (one materialized because a later SBN arrived).
+   */
+  blockAnchorAtMs(sbn, packetId, catalogTrackName) {
+    return this.#blockAnchorsMs.get(this.#blockKey(sbn, packetId, catalogTrackName));
+  }
+  /** Absolute fail deadline of a still-open block, or undefined. */
+  blockDeadlineAtMs(sbn, packetId, catalogTrackName) {
+    return this.#activeBlockDeadlinesMs.get(this.#blockKey(sbn, packetId, catalogTrackName));
+  }
+  /**
+   * Keep a block open until `untilAtMs` while a repair FETCH the scheduler
+   * admitted is in flight. Never shortens the multicast wait already armed;
+   * while set, the hold is the block's whole deadline, so no later symbol
+   * extends it. Returns false when the block is no longer open (resolved, or
+   * not yet tracked).
+   */
+  holdBlockForRepair(sbn, packetId, catalogTrackName, untilAtMs) {
+    if (!Number.isFinite(untilAtMs)) {
+      throw new Error(`[FECManager] repair hold must be a finite time (got ${untilAtMs})`);
+    }
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (!this.#activeBlocks.has(key)) return false;
+    const previous = this.#repairHoldUntilMs.get(key);
+    if (previous !== void 0 && previous >= untilAtMs) return true;
+    this.#repairHoldUntilMs.set(
+      key,
+      Math.max(untilAtMs, this.#blockWaitDeadlinesMs.get(key) ?? -Infinity)
+    );
+    this.#applyBlockDeadline(key, sbn, packetId, catalogTrackName);
+    return true;
+  }
+  /**
+   * Drop a block's repair hold: its FETCH ended without delivering. The block
+   * falls back to its multicast wait, which may already have passed.
+   */
+  releaseRepairHold(sbn, packetId, catalogTrackName) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (!this.#repairHoldUntilMs.delete(key) || !this.#activeBlocks.has(key)) return;
+    this.#applyBlockDeadline(key, sbn, packetId, catalogTrackName);
+  }
+  /** Resolved per-track D-28 repair request deadline in milliseconds. */
+  repairDeadlineMsForPacket(packetId) {
+    return this.#repairDeadlineMs(this.#resolveTrackConfig(packetId));
+  }
+  /**
+   * One block lifetime: the longest a block stays open after its last symbol
+   * (inactivity fail bound plus D-28 repair grace).
+   */
+  blockLifetimeMsForPacket(packetId) {
+    return this.#blockLifetimeMs(this.#resolveTrackConfig(packetId));
+  }
+  /**
+   * How long a terminal (clean, recovered or failed) block stays authoritative,
+   * for late symbols and for the in-order release gate. It is also the gate's
+   * hold ceiling (MmtpRouter's holdLimitMs): a retired block reads back as
+   * untracked, which the gate counts as lost, so no frame may still be waiting
+   * on a block that can retire. The window is one interleave depth for a gap's
+   * last block to finish arriving, one block lifetime to fail it, and one more
+   * for an owed Worker cleanup that can keep a failing block pending. Every
+   * term comes from the track's catalog geometry; there is no separate cap.
+   */
+  terminalRetentionMsForPacket(packetId) {
+    const config = this.#resolveTrackConfig(packetId);
+    return config.interleaveDepthMs + 2 * this.#blockLifetimeMs(config);
+  }
+  /** Remaining fetch budget for a specific repair-requested block. */
+  repairFetchTimeoutMsForBlock(sbn, packetId, catalogTrackName) {
+    const deadlineMs = this.#activeBlockDeadlinesMs.get(
+      this.#blockKey(sbn, packetId, catalogTrackName)
+    );
+    if (deadlineMs !== void 0) {
+      return Math.max(1, Math.ceil(deadlineMs - performance.now()));
+    }
+    const trackConfig = this.#resolveTrackConfig(packetId);
+    return Math.max(1, trackConfig.timeoutMs - this.#repairDeadlineMs(trackConfig));
+  }
+  /** True once configureTrack/setFecDecoder/setFecWorker configured this packetId. */
+  // -----------------------------------------------------------------------
+  // iso-ssbg1-v1 block location (BLO-35597 iso:2/iso:3)
+  // -----------------------------------------------------------------------
+  /** The configured `fec.blockProfile` of a packetId (undefined until configured). */
+  blockProfileForPacket(packetId) {
+    return this.#trackConfigs.get(packetId)?.blockProfile;
+  }
+  #isIso(packetId) {
+    return this.#trackConfigs.get(packetId)?.blockProfile === "iso-ssbg1-v1";
+  }
+  #isoLocatorFor(packetId, catalogTrackName) {
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    let locator = this.#isoLocators.get(streamKey);
+    if (!locator) {
+      locator = new IsoBlockLocator(this.kForPacket(packetId), this.#isoRetentionBlocks(packetId));
+      this.#isoLocators.set(streamKey, locator);
+    }
+    return locator;
+  }
+  /**
+   * The locator a call is about to grow, with its retention brought up to
+   * date: the horizon follows catalog timing, which a later configuration
+   * (this track's or another video track's keyframe cadence) can change.
+   */
+  #growingIsoLocatorFor(packetId, catalogTrackName) {
+    const locator = this.#isoLocatorFor(packetId, catalogTrackName);
+    locator.retentionBlocks = this.#isoRetentionBlocks(packetId);
+    return locator;
+  }
+  #dropIsoLocators(packetId) {
+    for (const key of [...this.#isoLocators.keys()]) {
+      if (this.#belongsToPacket(key, packetId)) this.#isoLocators.delete(key);
+    }
+  }
+  /**
+   * The iso-ssbg1-v1 locator horizon in blocks: every block the manager can
+   * still hold terminal state for (`terminalRetentionMsForPacket`) over the
+   * block span, plus the block being filled, measured with the shared
+   * lower-bound metric so a retained block is never forgotten early. Every
+   * term is the packet's catalog geometry, which configuration validated
+   * (#upsertTrackConfig), so this never falls back: an underivable horizon
+   * throws rather than leave the locator without retention.
+   */
+  #isoRetentionBlocks(packetId) {
+    const config = this.#trackConfigs.get(packetId);
+    if (config?.blockProfile !== "iso-ssbg1-v1" || !(config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS)) {
+      throw new Error(
+        `[FECManager] packetId=${packetId} has no iso-ssbg1-v1 block span to derive block-location retention from`
+      );
+    }
+    const blocks = Math.ceil(this.terminalRetentionMsForPacket(packetId) / config.interleaveDepthMs) + 1;
+    if (!Number.isSafeInteger(blocks) || blocks <= 0) {
+      throw new Error(`[FECManager] packetId=${packetId} iso-ssbg1-v1 retention of ${blocks} blocks is not derivable`);
+    }
+    return blocks;
+  }
+  /** Whether an iso-ssbg1-v1 protected packet fits one ssbg_mode1 symbol (len + 2 <= T). */
+  isoSourceFits(packetId, packetLength) {
+    return ssbg1FitsSymbol(packetLength, this.symbolSizeForPacket(packetId));
+  }
+  /**
+   * Locate an iso-ssbg1-v1 source by range membership in a block a repair
+   * already stated. Null while its block is unknown: hold it (holdIsoSource).
+   */
+  locateIsoSource(packetId, catalogTrackName, ssId) {
+    const located = this.#isoLocatorFor(packetId, catalogTrackName).locate(ssId);
+    return located === null ? null : { sbn: located.block.start, esi: located.esi };
+  }
+  /**
+   * Hold a first-arrival iso-ssbg1-v1 source whose block no repair has stated
+   * yet. Returns false for a later copy of an SS_ID already held.
+   */
+  holdIsoSource(packetId, catalogTrackName, ssId, source) {
+    const locator = this.#growingIsoLocatorFor(packetId, catalogTrackName);
+    const evictedBefore = locator.heldEvicted;
+    const held = locator.hold(ssId, source);
+    const evicted = locator.heldEvicted - evictedBefore;
+    if (evicted > 0) {
+      const before = this.#isoHeldEvictedCount;
+      this.#isoHeldEvictedCount += evicted;
+      if (before < 5 || Math.floor(before / 100) !== Math.floor(this.#isoHeldEvictedCount / 100)) {
+        console.warn(
+          `[FECManager] packetId=${packetId} iso-ssbg1-v1 held-source cap (${locator.heldCapacity}) evicted ${evicted} unplaced source(s); SS_IDs are not consecutive (C.5.2)`
+        );
+      }
+    }
+    return held;
+  }
+  /**
+   * Apply an iso-ssbg1-v1 repair symbol's `(SS_Start, SSB_length)`: states the
+   * block, and hands back the held sources it (and any repair-less span in
+   * front of it) now places. The caller feeds them as first-arrival sources,
+   * then the repair symbol, the order they had on the wire. A repair that
+   * contradicts a known block is refused (counted) and must be dropped.
+   */
+  placeIsoRepair(packetId, catalogTrackName, ssStart, ssbLength) {
+    const placement = this.#growingIsoLocatorFor(packetId, catalogTrackName).placeRepair(ssStart, ssbLength);
+    if (placement.status !== "placed") {
+      this.#isoRepairRefusedCount++;
+      if (this.#isoRepairRefusedCount <= 5 || this.#isoRepairRefusedCount % 100 === 0) {
+        console.warn(`[FECManager] packetId=${packetId} iso-ssbg1-v1 repair refused (${placement.status}): ${placement.reason}`);
+      }
+      return placement;
+    }
+    if (placement.span !== void 0) {
+      const key = this.#blockKey(placement.span.block.start, packetId, catalogTrackName);
+      if (!this.#blockAuthoredLengths.has(key)) this.#blockAuthoredLengths.set(key, placement.span.block.length);
+    }
+    if (placement.span !== void 0 && placement.span.placed.length === 0) {
+      this.#materializeBlock(placement.span.block.start, packetId, catalogTrackName, true);
+    }
+    return placement;
+  }
+  /**
+   * Resolution of the SS_IDs strictly between two released frames' SS_IDs on
+   * an iso-ssbg1-v1 stream, for in-order frame release: null while a block
+   * that could hold them is pending or not yet stated by a repair, else the
+   * starts of the blocks that failed or vanished.
+   *
+   * `untracked` reads exactly as in the k-padded-v1 release gate
+   * (MmtpRouter #createFecReleaseGate): a block holding either released
+   * frame's SS_ID (`fromSsId` or `toSsId`) delivered that frame, so untracked
+   * there means it resolved and retired; a block starting after the stream's frontier (`highestSbn`,
+   * an SS_Start here) may still be heard from; a block at or behind the
+   * frontier that no symbol of this manager ever reached vanished, and its
+   * media is lost.
+   */
+  isoSpanResolution(packetId, catalogTrackName, fromSsId, toSsId) {
+    if (!serial32Precedes(fromSsId, toSsId) || serial32Distance(fromSsId, toSsId) <= 1) return [];
+    const locator = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName));
+    if (!locator || !locator.coversBetween(fromSsId, toSsId)) return null;
+    const highest = this.highestSbn(packetId, catalogTrackName);
+    const lost = [];
+    for (const block of locator.blocksBetween(fromSsId, toSsId)) {
+      const resolution = this.blockResolution(block.start, packetId, catalogTrackName);
+      if (resolution === "pending") return null;
+      if (resolution === "failed") {
+        lost.push(block.start);
+      } else if (resolution === "untracked") {
+        if (isoBlockContains(block.start, block.length, fromSsId) || isoBlockContains(block.start, block.length, toSsId)) {
+          continue;
+        }
+        if (highest === void 0 || serial32Precedes(highest, block.start)) return null;
+        lost.push(block.start);
+      }
+    }
+    return lost;
+  }
+  /**
+   * iso-ssbg1-v1 block location: repair symbols it refused, oversize sources,
+   * the sources held now for a block no repair has stated yet, and the held
+   * sources the capacity cap evicted (cumulative), and the sources a
+   * synchronous decoder held unplaced and retired at its horizon (cumulative).
+   */
+  get isoDiagnostics() {
+    let heldSources = 0;
+    for (const locator of this.#isoLocators.values()) heldSources += locator.heldCount;
+    return {
+      repairRefused: this.#isoRepairRefusedCount,
+      sourceOversize: this.#isoSourceOversizeCount,
+      heldSources,
+      heldEvicted: this.#isoHeldEvictedCount,
+      decoderUnplacedRetired: this.#isoDecoderUnplacedRetired,
+      decoderUnplacedRetireFailed: this.#isoDecoderUnplacedRetireFailed
+    };
+  }
+  isTrackConfigured(packetId) {
+    return this.#trackConfigs.has(packetId);
+  }
+  /** Catalog/reset epoch of a packet's streams; gap decisions carry it. */
+  epochFor(packetId) {
+    return this.#packetEpochs.get(packetId) ?? 0;
+  }
+  /** Configured media kind of a packetId, when known. */
+  trackKindFor(packetId) {
+    return this.#trackConfigs.get(packetId)?.trackKind;
+  }
+  /** Configured codec of a packetId, when known. */
+  codecFor(packetId) {
+    return this.#trackConfigs.get(packetId)?.codec;
+  }
+  /**
+   * Block classifier geometry of one stream: its own stream-scoped geometry,
+   * else the packet's (fail-closed when absent, or when a sibling stream of
+   * the packet has its own geometry and this one has none).
+   */
+  geometryFor(packetId, catalogTrackName) {
+    return this.#geometryFor(packetId, catalogTrackName);
+  }
+  /** Current classifier mode of a stream. */
+  classifierModeFor(packetId, catalogTrackName) {
+    const classifier = this.#classifierFor(packetId, catalogTrackName);
+    return { mode: classifier.mode, reason: classifier.reason };
+  }
+  /**
+   * Whether an MPU boundary still bounds this stream's RAPs (see
+   * `BlockClassifier.mpuBoundsRaps`). Gap decisions drop MPU evidence once
+   * it does not. A stream with no classifier yet has shown nothing against it.
+   */
+  mpuBoundsRapsFor(packetId, catalogTrackName) {
+    return this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))?.mpuBoundsRaps ?? true;
+  }
+  /** A block's class now, or frozen at its resolution. */
+  blockClassFor(sbn, packetId, catalogTrackName) {
+    const frozen = this.#resolvedBlockClasses.get(this.#blockKey(sbn, packetId, catalogTrackName));
+    if (frozen !== void 0) return frozen;
+    return this.#peekClass(sbn, packetId, catalogTrackName);
+  }
+  /**
+   * Lifecycle resolution of one block for in-order frame release: `pending`
+   * while it can still complete, `complete`/`failed` once terminal, and
+   * `untracked` when no symbol of it was ever accepted.
+   */
+  blockResolution(sbn, packetId, catalogTrackName) {
+    return this.#blockResolutionFor(this.#blockKey(sbn, packetId, catalogTrackName));
+  }
+  /** Highest SBN any symbol of this stream carried in the current epoch. */
+  highestSbn(packetId, catalogTrackName) {
+    return this.#highestSbn.get(this.#streamKey(packetId, catalogTrackName))?.sbn;
+  }
+  /**
+   * Record a RAP frame released in order, for the classifier's RAP-spacing
+   * invariant (consecutive MPUs exactly one keyframe interval apart).
+   */
+  noteReleasedRap(packetId, catalogTrackName, mpu, presentationTime, mediaTimescale) {
+    if (!this.#trackConfigs.has(packetId)) return;
+    this.#applyClassifierChanges(
+      packetId,
+      catalogTrackName,
+      this.#classifierFor(packetId, catalogTrackName).noteReleasedRap(
+        mpu,
+        presentationTime,
+        mediaTimescale
+      )
+    );
+  }
+  // -----------------------------------------------------------------------
+  // Configuration
+  // -----------------------------------------------------------------------
+  /** Configure FEC parameters. */
+  configure(config) {
+    if (config.k != null) this.#fecK = config.k;
+    if (config.symbolSize != null && config.symbolSize > 0) this.#fecSymbolSize = config.symbolSize;
+    if (config.interleaveDepthMs != null) this.#fecInterleaveDepthMs = config.interleaveDepthMs;
+    if (config.fps != null && Number.isFinite(config.fps) && config.fps > 0) {
+      this.#fecFps = config.fps;
+    }
+    if (config.interleaveDepthMs != null && config.interleaveDepthMs > 0 && config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) {
+      console.warn(`[FECManager] interleaveDepthMs=${config.interleaveDepthMs} looks like frame count, not milliseconds (\xA75.1 requires ms). Expected range: ${MIN_INTERLEAVE_DEPTH_MS}-10000ms.`);
+    }
+    if (config.timeoutMs != null && config.timeoutMs > 0) {
+      this.#fecTimeoutMs = config.timeoutMs;
+    } else if (config.interleaveDepthMs != null && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+      this.#fecTimeoutMs = computeFecDeliveryWindowMs({
+        interleaveDepthMs: config.interleaveDepthMs,
+        sourceSymbols: this.#fecK,
+        symbolSize: this.#fecSymbolSize,
+        mediaUnitsPerSecond: config.fps
+      });
+    }
+    for (const [packetId, track] of this.#trackConfigs) {
+      if (track.timeoutMs < this.#fecTimeoutMs) {
+        this.#trackConfigs.set(packetId, { ...track, timeoutMs: this.#fecTimeoutMs });
+      }
+    }
+  }
+  /**
+   * Configure FEC parameters for one packetId without changing legacy
+   * defaults. With `catalogTrackName`, `config.geometry` is that stream's
+   * own classifier geometry (ABR rungs that share a packetId each get
+   * theirs); K, T, timing, kind and codec stay per packetId.
+   */
+  configureTrack(packetId, config, catalogTrackName) {
+    this.#upsertTrackConfig(packetId, config, catalogTrackName);
+  }
+  /** Register a FEC decoder for a specific packetId (track). */
+  setFecDecoder(packetId, client, k, config, catalogTrackName) {
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    this.#assertExclusiveDecoderClient(
+      streamKey,
+      client,
+      [...this.#fecDecoders].map(([key, entry]) => [key, entry.client]),
+      "decoder"
+    );
+    const trackConfig = this.#upsertTrackConfig(packetId, { ...config, k }, catalogTrackName);
+    this.#fecDecoders.set(streamKey, { client, k: trackConfig.k });
+  }
+  /**
+   * Register a Worker-backed FEC decoder for a specific packetId (track).
+   *
+   * Worker-backed tracks decode asynchronously — feedSourceSymbol/feedRepairSymbol
+   * return null immediately, and recovered frames arrive via the onBlockRecovered callback.
+   *
+   * Takes precedence over sync WASM decoders for the same packetId.
+   */
+  setFecWorker(packetId, client, config, catalogTrackName) {
+    const k = config?.k;
+    if (k === void 0 || !Number.isFinite(k) || k <= 0) {
+      throw new Error(`[FECManager] packetId=${packetId} Worker requires an explicit positive k`);
+    }
+    const symbolSize = config.symbolSize;
+    if (symbolSize === void 0 || !Number.isFinite(symbolSize) || symbolSize <= 0) {
+      throw new Error(
+        `[FECManager] packetId=${packetId} Worker requires an explicit positive symbolSize`
+      );
+    }
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    this.#assertExclusiveDecoderClient(
+      streamKey,
+      client,
+      this.#workerClients,
+      "worker"
+    );
+    const incumbent = this.#workerClients.get(streamKey);
+    if (incumbent !== void 0 && incumbent !== client) {
+      throw new Error(
+        `[FECManager] stream ${streamKey} already routes to a Worker; call clearFecWorker before registering another`
+      );
+    }
+    if (config) this.#upsertTrackConfig(packetId, config, catalogTrackName);
+    const workerK = this.#resolveTrackConfig(packetId).k;
+    this.#workerClients.set(streamKey, client);
+    this.#releasedWorkerClients.delete(client);
+    client.onFrame((data, meta) => {
+      if (this.#releasedWorkerClients.has(client)) return;
+      if (meta.recovered) {
+        if (!Number.isInteger(meta.ssbLength) || meta.ssbLength <= 0 || meta.ssbLength > workerK) {
+          const kind = "recovered-symbol-ssb-length-invalid";
+          const seen = this.#workerErrorCounts.get(kind) ?? 0;
+          this.#workerErrorCounts.set(kind, seen + 1);
+          if (seen < WORKER_ERROR_LOG_CAP) {
+            console.warn(
+              `[FECManager] Dropping recovered symbol with invalid SSB_length: pid=${packetId} sbn=${meta.sbn} ssbLength=${String(meta.ssbLength)}`
+            );
+          }
+          return;
+        }
+        if (!Number.isInteger(meta.esi) || meta.esi < 0 || meta.esi >= meta.ssbLength) {
+          const kind = "recovered-symbol-missing-esi";
+          const seen = this.#workerErrorCounts.get(kind) ?? 0;
+          this.#workerErrorCounts.set(kind, seen + 1);
+          if (seen < WORKER_ERROR_LOG_CAP) {
+            console.warn(
+              `[FECManager] Dropping recovered symbol without valid ESI: pid=${packetId} sbn=${meta.sbn} esi=${String(meta.esi)} ssbLength=${String(meta.ssbLength)}`
+            );
+          }
+          return;
+        }
+        const esi = meta.esi;
+        const recoveredCatalogTrackName = catalogTrackName ?? this.#decoderBlockCatalogTrackName(client, meta.sbn);
+        if (!this.#claimDecoderBlock(client, meta.sbn, recoveredCatalogTrackName)) return;
+        const blockKey = this.#blockKey(meta.sbn, packetId, recoveredCatalogTrackName);
+        const cleanlyCompleted = this.#cleanlyCompletedBlocks.has(blockKey);
+        if (!cleanlyCompleted) {
+          if (!this.#workerRecoveredBlocks.has(blockKey)) {
+            this.#traceLifecycle(
+              "recovered",
+              meta.sbn,
+              packetId,
+              recoveredCatalogTrackName
+            );
+            this.#workerRecoveredBlocks.add(blockKey);
+            this.#fecStats.blocksRecovered++;
+            this.#statsForPacket(packetId).blocksRecovered++;
+            if (this.#workerRecoveredBlocks.size > 1e3) {
+              dropOldest(this.#workerRecoveredBlocks, 500);
+            }
+            this.#noteBlockRepaired(blockKey, meta.sbn, packetId, recoveredCatalogTrackName);
+          }
+          const symbolKey = `${blockKey}:${esi}`;
+          if (!this.#seenSymbols.has(symbolKey)) {
+            this.#seenSymbols.add(symbolKey);
+            this.onBlockRecovered?.(
+              meta.sbn,
+              packetId,
+              data,
+              meta,
+              recoveredCatalogTrackName
+            );
+          }
+        }
+        if (esi >= meta.ssbLength - 1 && !this.#completedBlocks.has(blockKey)) {
+          this.cancelBlockTimeout(meta.sbn, packetId, recoveredCatalogTrackName);
+          if (recoveredCatalogTrackName === void 0) {
+            this.onBlockComplete?.(meta.sbn, packetId);
+          } else {
+            this.onBlockComplete?.(
+              meta.sbn,
+              packetId,
+              recoveredCatalogTrackName
+            );
+          }
+        }
+      } else {
+        const completedCatalogTrackName = catalogTrackName ?? this.#decoderBlockCatalogTrackName(client, meta.sbn);
+        this.markBlockCompleted(meta.sbn, packetId, completedCatalogTrackName);
+      }
+    });
+    client.onSnapshot((stats) => {
+      if (this.#releasedWorkerClients.has(client)) return;
+      this.#fecWorkerStats.set(packetId, stats);
+      try {
+        this.onFecStatsUpdate?.(packetId, stats);
+      } catch (error) {
+        console.warn("[FECManager] FEC stats callback failed:", error);
+      }
+      for (const observer of this.#fecStatsObservers) {
+        try {
+          observer(packetId, stats);
+        } catch (error) {
+          console.warn("[FECManager] FEC stats observer failed:", error);
+        }
+      }
+    });
+    client.onCleanupComplete((sbn) => {
+      if (this.#releasedWorkerClients.has(client)) return;
+      const cleanupKeys = [...this.#pendingWorkerCleanups].filter((key) => {
+        const block = this.#parseBlockKey(key);
+        return block.packetId === packetId && block.sbn === sbn && this.#pendingWorkerCleanupClients.get(key) === client;
+      });
+      for (const key of cleanupKeys) this.#settleOwedCleanup(key, "cleanup-ack");
+    });
+    client.onError((msg, code) => {
+      const requestedKind = code ?? msg;
+      const kind = this.#workerErrorCounts.has(requestedKind) || this.#workerErrorCounts.size < WORKER_ERROR_KIND_CAP - 1 ? requestedKind : WORKER_ERROR_OVERFLOW_KIND;
+      const seen = this.#workerErrorCounts.get(kind) ?? 0;
+      this.#workerErrorCounts.set(kind, seen + 1);
+      if (seen < WORKER_ERROR_LOG_CAP) {
+        console.warn("[FECManager] Worker error:", msg);
+      } else if (seen === WORKER_ERROR_LOG_CAP) {
+        console.warn(
+          `[FECManager] Worker error (suppressing further copies of ${kind}): ${msg}`
+        );
+      }
+    });
+  }
+  /**
+   * Remove a stream's Worker decoder from routing.
+   *
+   * Returns false when no Worker is registered under that exact stream key.
+   * On success every cleanup acknowledgement still owed by the client is
+   * resolved by failing its block now (a Worker that is going away cannot
+   * post it), the client's block ownership is released, and
+   * onDecoderUnavailable fires once with reason 'cleared' and the decoder
+   * that remains for the stream ('sync' or 'none'). Call this before
+   * disposing the client; a client disposed while still registered is
+   * evicted on its next symbol or reset with reason 'disposed'.
+   */
+  clearFecWorker(packetId, catalogTrackName) {
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    const client = this.#workerClients.get(streamKey);
+    if (!client) return false;
+    this.#retireWorker(streamKey, client, "cleared");
+    return true;
+  }
+  /**
+   * Take a Worker client out of routing under one stream key, fail the blocks
+   * whose completion it still owed, and report the stream's decoder
+   * unavailable together with whatever still decodes the stream.
+   */
+  #retireWorker(streamKey, client, reason) {
+    this.#workerClients.delete(streamKey);
+    this.#releaseWorkerClient(client);
+    this.#decoderUnavailableEvents++;
+    const stream = this.#parseStreamKey(streamKey);
+    const fallbackDecoder = this.#decoderForPacket(stream.packetId, stream.catalogTrackName) ? "sync" : "none";
+    this.onDecoderUnavailable?.({
+      packetId: stream.packetId,
+      ...stream.catalogTrackName === void 0 ? {} : { catalogTrackName: stream.catalogTrackName },
+      reason,
+      fallbackDecoder
+    });
+  }
+  /**
+   * Fail every block whose Worker cleanup acknowledgement is owed by `client`
+   * and drop its block ownership, so no block waits on a message the Worker
+   * will never post.
+   */
+  #releaseWorkerClient(client) {
+    const owed = [...this.#pendingWorkerCleanupClients].filter(([, owner]) => owner === client).map(([key]) => key);
+    for (const key of owed) this.#settleOwedCleanup(key, "decoder-unavailable");
+    this.#decoderBlockOwners.delete(client);
+  }
+  /**
+   * Bound the wait for one Worker cleanup acknowledgement by the block's
+   * catalog-derived terminal lifetime. When it elapses with the cleanup still
+   * owed to the same client, the block fails as if the ack had arrived: its
+   * fail deadline already passed, so failing it is the decision that deadline
+   * made. A late ack then finds nothing owed and is a no-op.
+   */
+  #boundOwedCleanup(key, packetId, client) {
+    this.#clearOwedCleanupBound(key);
+    const bound = {
+      handle: setTimeout(() => {
+        if (this.#pendingWorkerCleanupBounds.get(key) !== bound) return;
+        this.#pendingWorkerCleanupBounds.delete(key);
+        if (!this.#pendingWorkerCleanups.has(key) || this.#pendingWorkerCleanupClients.get(key) !== client) {
+          return;
+        }
+        this.#settleOwedCleanup(key, "cleanup-ack-timeout");
+      }, Math.ceil(this.#liveBlockLifetimeMs(this.#resolveTrackConfig(packetId))))
+    };
+    this.#pendingWorkerCleanupBounds.set(key, bound);
+  }
+  #clearOwedCleanupBound(key) {
+    const bound = this.#pendingWorkerCleanupBounds.get(key);
+    if (!bound) return;
+    clearTimeout(bound.handle);
+    this.#pendingWorkerCleanupBounds.delete(key);
+  }
+  /**
+   * Resolve one owed Worker cleanup: drop the pending entry and fail the block
+   * unless it already completed. Shared by the cleanup acknowledgement and by
+   * Worker retirement, so the two paths cannot drift in their bookkeeping.
+   */
+  #settleOwedCleanup(key, event) {
+    this.#clearOwedCleanupBound(key);
+    this.#pendingWorkerCleanups.delete(key);
+    this.#pendingWorkerCleanupClients.delete(key);
+    if (this.#completedBlocks.has(key)) return;
+    const block = this.#parseBlockKey(key);
+    this.#traceLifecycle(event, block.sbn, block.packetId, block.catalogTrackName);
+    this.#failBlock(block.sbn, block.packetId, block.catalogTrackName);
+  }
+  /** Evict a disposed client under every stream key that still maps to it. */
+  #evictDisposedWorker(client) {
+    for (const [key, registered] of [...this.#workerClients]) {
+      if (registered !== client) continue;
+      const stream = this.#parseStreamKey(key);
+      const track = stream.catalogTrackName === void 0 ? "" : ` track=${stream.catalogTrackName}`;
+      console.warn(
+        `[FECManager] packetId=${stream.packetId}${track} Worker decoder was disposed while still registered; evicting it`
+      );
+      this.#retireWorker(key, client, "disposed");
+    }
+  }
+  /** Called by player when framerate is known (from decoder output). Refines FEC block timeout. */
+  setFramerate(fps) {
+    if (this.#fpsDetected || fps <= 0) return;
+    this.#fpsDetected = true;
+    this.#fecFps = fps;
+    if (this.#fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+      this.#fecTimeoutMs = computeFecDeliveryWindowMs({
+        interleaveDepthMs: this.#fecInterleaveDepthMs,
+        sourceSymbols: this.#fecK,
+        symbolSize: this.#fecSymbolSize,
+        mediaUnitsPerSecond: fps
+      });
+    }
+    for (const [packetId, config] of this.#trackConfigs) {
+      if (config.fps !== void 0 || config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) continue;
+      this.#trackConfigs.set(packetId, {
+        ...config,
+        fps,
+        timeoutMs: Math.max(
+          this.#fecTimeoutMs,
+          computeFecDeliveryWindowMs({
+            interleaveDepthMs: config.interleaveDepthMs,
+            sourceSymbols: config.k,
+            symbolSize: config.symbolSize,
+            mediaUnitsPerSecond: fps
+          })
+        )
+      });
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Symbol feeding (codec-agnostic)
+  // -----------------------------------------------------------------------
+  /**
+   * Feed a source symbol to the WASM FEC decoder.
+   *
+   * Does NOT track block source counts or fire lifecycle events — call
+   * `trackBlock()` separately BEFORE this method (MmtpRouter does this).
+   *
+   * @returns Recovered block data if WASM completed the block, else null.
+   *          Caller is responsible for routing recovered data and updating
+   *          block completion state via `markBlockCompleted()`.
+   */
+  feedSourceSymbol(packetId, ssId, symbolData, alta, catalogTrackName) {
+    this.#fecStats.sourcePackets++;
+    this.#statsForPacket(packetId).sourcePackets++;
+    let sbn;
+    let fecData;
+    if (this.#isIso(packetId)) {
+      const locator = this.#isoLocatorFor(packetId, catalogTrackName);
+      const located = locator.locate(ssId);
+      if (located === null) {
+        throw new Error(
+          `[FECManager] iso-ssbg1-v1 source SS_ID=${ssId} (packetId=${packetId}) has no stated block; hold it until a repair places it (placeIsoRepair)`
+        );
+      }
+      locator.observe(ssId);
+      if (!ssbg1FitsSymbol(symbolData.byteLength, this.symbolSizeForPacket(packetId))) {
+        this.#isoSourceOversizeCount++;
+        return null;
+      }
+      sbn = located.block.start;
+      fecData = symbolData;
+    } else {
+      fecData = this.#normalizeSymbolData(packetId, symbolData);
+      sbn = Math.floor(ssId / this.kForPacket(packetId));
+    }
+    const blockKey = this.#blockKey(sbn, packetId, catalogTrackName);
+    const syncBlockOwner = this.#syncDecoderBlockOwners.get(blockKey);
+    const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName);
+    if (workerClient && !syncBlockOwner) {
+      if (!this.#claimDecoderBlock(workerClient, sbn, catalogTrackName)) return null;
+      const buf = fecData !== symbolData ? fecData.buffer : fecData.buffer.slice(
+        fecData.byteOffset,
+        fecData.byteOffset + fecData.byteLength
+      );
+      if (alta) {
+        const authBuf = alta.auth.buffer.slice(
+          alta.auth.byteOffset,
+          alta.auth.byteOffset + alta.auth.byteLength
+        );
+        workerClient.feedSource(ssId, buf, performance.now(), {
+          auth: authBuf,
+          payloadEnd: alta.payloadEnd
+        });
+      } else {
+        workerClient.feedSource(ssId, buf, performance.now());
+      }
+      return null;
+    }
+    const entry = this.#decoderForPacket(packetId, catalogTrackName);
+    const client = syncBlockOwner ?? entry?.client;
+    if (!client) return null;
+    if (!this.#claimDecoderBlock(client, sbn, catalogTrackName)) return null;
+    this.#syncDecoderBlockOwners.set(blockKey, client);
+    let recovered = null;
+    try {
+      recovered = client.add_source(ssId, fecData, performance.now());
+    } catch {
+    }
+    this.#retireIsoUnplaced(client, packetId, catalogTrackName);
+    if (recovered || this.#completedBlocks.has(blockKey)) {
+      this.#syncDecoderBlockOwners.delete(blockKey);
+    }
+    return recovered;
+  }
+  /**
+   * Feed a repair symbol to the WASM FEC decoder.
+   *
+   * @returns Recovered block data if repair completed the block, else null.
+   *          Caller is responsible for routing recovered data and updating
+   *          block completion state via `markBlockCompleted()`.
+   */
+  feedRepairSymbol(packetId, ssStart, ssbLength, rsId, repairData, catalogTrackName) {
+    this.#fecStats.repairPackets++;
+    this.#statsForPacket(packetId).repairPackets++;
+    const symbolSize = this.symbolSizeForPacket(packetId);
+    if (symbolSize > 0 && repairData.byteLength !== symbolSize) {
+      this.#repairSymbolSizeMismatchCount++;
+      if (this.#repairSymbolSizeMismatchCount <= 5 || this.#repairSymbolSizeMismatchCount % 100 === 0) {
+        console.warn(
+          `[FECManager] Dropping repair symbol with invalid size: got ${repairData.byteLength}B, expected ${symbolSize}B (packetId=${packetId}, ssStart=${ssStart}, ssbLength=${ssbLength}, rsId=${rsId})`
+        );
+      }
+      return null;
+    }
+    const fecData = repairData;
+    const k = this.kForPacket(packetId);
+    let sbn;
+    if (this.#isIso(packetId)) {
+      const block = this.#isoLocatorFor(packetId, catalogTrackName).blockAt(ssStart);
+      if (ssbLength <= 0 || ssbLength > k || block === void 0 || block.span || block.length !== ssbLength) {
+        return null;
+      }
+      sbn = ssStart;
+    } else {
+      if (ssbLength <= 0 || ssbLength > k || ssStart % k !== 0) return null;
+      sbn = Math.floor(ssStart / k);
+    }
+    this.#noteSbnSeen(sbn, packetId, catalogTrackName, "repair");
+    this.noteBlockActivity(sbn, packetId, catalogTrackName);
+    const blockKey = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#completedBlocks.has(blockKey)) return null;
+    if (!this.#noteAuthoredLength(blockKey, sbn, packetId, ssbLength, catalogTrackName)) {
+      return null;
+    }
+    let repairIds = this.#blockRepairRsIds.get(blockKey);
+    if (!repairIds) {
+      repairIds = /* @__PURE__ */ new Set();
+      this.#blockRepairRsIds.set(blockKey, repairIds);
+    }
+    repairIds.add(rsId);
+    if (this.#repairRequestedBlocks.has(blockKey)) {
+      this.#traceLifecycle("repair-arrived", sbn, packetId, catalogTrackName, rsId);
+    }
+    const cleanOnArrival = (this.#blockSourceCounts.get(blockKey) ?? 0) >= ssbLength;
+    const recovered = this.#dispatchRepairSymbol(
+      blockKey,
+      sbn,
+      packetId,
+      ssStart,
+      ssbLength,
+      rsId,
+      fecData,
+      catalogTrackName
+    );
+    if (cleanOnArrival) {
+      this.#completeCleanBlock(blockKey, sbn, packetId, catalogTrackName);
+      return null;
+    }
+    return recovered;
+  }
+  /**
+   * Record a block's authored SSB_length from a repair symbol. Returns false,
+   * leaving the block unchanged, when the symbol contradicts the block: a
+   * different SSB_length than an earlier repair symbol declared is dropped,
+   * and an SSB_length that places an already-received source ESI inside the
+   * zero padding fails the block, since its geometry can no longer be trusted.
+   */
+  #noteAuthoredLength(blockKey, sbn, packetId, ssbLength, catalogTrackName) {
+    const known = this.#blockAuthoredLengths.get(blockKey);
+    if (known === ssbLength) return true;
+    if (known !== void 0) {
+      this.#ssbLengthConflictCount++;
+      if (this.#ssbLengthConflictCount <= 5 || this.#ssbLengthConflictCount % 100 === 0) {
+        console.warn(
+          `[FECManager] Dropping repair symbol whose SSB_length ${ssbLength} conflicts with ${known} for packetId=${packetId} sbn=${sbn}`
+        );
+      }
+      return false;
+    }
+    const sourceEsis = this.#blockSourceEsis.get(blockKey);
+    if (sourceEsis && [...sourceEsis].some((esi) => esi >= ssbLength)) {
+      this.#failBlock(sbn, packetId, catalogTrackName);
+      return false;
+    }
+    this.#blockAuthoredLengths.set(blockKey, ssbLength);
+    return true;
+  }
+  #dispatchRepairSymbol(blockKey, sbn, packetId, ssStart, ssbLength, rsId, fecData, catalogTrackName) {
+    const syncBlockOwner = this.#syncDecoderBlockOwners.get(blockKey);
+    const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName);
+    if (workerClient && !syncBlockOwner) {
+      if (!this.#claimDecoderBlock(workerClient, sbn, catalogTrackName)) return null;
+      const buf = fecData.buffer.slice(
+        fecData.byteOffset,
+        fecData.byteOffset + fecData.byteLength
+      );
+      workerClient.feedRepair(ssStart, ssbLength, rsId, buf, performance.now());
+      return null;
+    }
+    const entry = this.#decoderForPacket(packetId, catalogTrackName);
+    const client = syncBlockOwner ?? entry?.client;
+    if (!client) return null;
+    if (!this.#claimDecoderBlock(client, sbn, catalogTrackName)) return null;
+    this.#syncDecoderBlockOwners.set(blockKey, client);
+    let recovered = null;
+    try {
+      recovered = client.add_repair(ssStart, ssbLength, rsId, fecData, performance.now());
+    } catch {
+    }
+    this.#retireIsoUnplaced(client, packetId, catalogTrackName);
+    if (recovered) this.#syncDecoderBlockOwners.delete(blockKey);
+    return recovered;
+  }
+  #routeSyncCleanup(decoder, sbn, packetId, catalogTrackName) {
+    try {
+      decoder.cleanup_blocks_detailed(Uint32Array.of(sbn));
+    } catch (error) {
+      console.warn(`[FECManager] Scoped cleanup failed for SBN ${sbn}:`, error);
+    }
+    this.#retireIsoUnplaced(decoder, packetId, catalogTrackName);
+  }
+  /**
+   * iso-ssbg1-v1: a placed source the decoder took before its block's repair
+   * (fed in wire order, sources first) waits unplaced in the decoder; one
+   * whose repair never reaches it, such as a source of a repair-less span,
+   * would stay there. Retire those by the decoder's horizon behind the newest
+   * SS_ID the stream's locator has seen. Run after every feed that grows the
+   * decoder and when a block is retired, as the fec-worker sweeps its own
+   * pool: a stream that loses only repair symbols never expires a block, so
+   * a sweep tied to expiry alone would never run there.
+   */
+  #retireIsoUnplaced(decoder, packetId, catalogTrackName) {
+    if (!this.#isIso(packetId)) return;
+    const newest = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName))?.newest;
+    if (newest === void 0) return;
+    try {
+      this.#isoDecoderUnplacedRetired += decoder.retire_unplaced(newest);
+    } catch (error) {
+      this.#isoDecoderUnplacedRetireFailed++;
+      const failed = this.#isoDecoderUnplacedRetireFailed;
+      if (failed <= 5 || failed % 100 === 0) {
+        console.warn(
+          `[FECManager] iso-ssbg1-v1 unplaced retirement failed for packetId=${packetId} (${failed} total):`,
+          error
+        );
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Block lifecycle
+  // -----------------------------------------------------------------------
+  /**
+   * Track a first-arrival network source symbol for an FEC block. Refreshes
+   * the inactivity deadline on each symbol, records the symbol's in-band
+   * classification evidence, and marks the block clean when all of its
+   * authored source symbols arrived: the SSB_length a repair symbol declared,
+   * otherwise K.
+   *
+   * Throws for a packetId that was never configured, so a classified block
+   * never reads the manager-global K or timeout.
+   */
+  trackBlock(sbn, packetId, catalogTrackName, esi, evidence) {
+    const trackConfig = this.#trackConfigs.get(packetId);
+    if (trackConfig === void 0) {
+      throw new Error(
+        `[FECManager] trackBlock for packetId=${packetId}, which was never configured; configure the track from its catalog (configureTrack/setFecWorker/setFecDecoder) first`
+      );
+    }
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    const k = trackConfig.k;
+    if (this.#completedBlocks.has(key)) return;
+    this.#noteSbnSeen(sbn, packetId, catalogTrackName, "source", evidence.packetSequenceNumber);
+    const authoredLength = this.#blockAuthoredLengths.get(key) ?? k;
+    if (Number.isInteger(esi) && esi >= authoredLength) {
+      this.#failBlock(sbn, packetId, catalogTrackName);
+      return;
+    }
+    this.#applyClassifierChanges(
+      packetId,
+      catalogTrackName,
+      this.#classifierFor(packetId, catalogTrackName).observe(sbn, evidence)
+    );
+    const count = (this.#blockSourceCounts.get(key) ?? 0) + 1;
+    this.#blockSourceCounts.set(key, count);
+    if (count === 1) this.#indexBlockKey(key, sbn, packetId);
+    if (Number.isInteger(esi) && esi >= 0 && esi < k) {
+      let sourceEsis = this.#blockSourceEsis.get(key);
+      if (!sourceEsis) {
+        sourceEsis = /* @__PURE__ */ new Set();
+        this.#blockSourceEsis.set(key, sourceEsis);
+      }
+      sourceEsis.add(esi);
+    }
+    if (count === 1) {
+      if (catalogTrackName === void 0) {
+        this.onBlockStarted?.(sbn, packetId);
+      } else {
+        this.onBlockStarted?.(sbn, packetId, catalogTrackName);
+      }
+    }
+    if (k > 0 && count >= authoredLength) {
+      this.#completeCleanBlock(key, sbn, packetId, catalogTrackName);
+      return;
+    }
+    this.noteBlockActivity(sbn, packetId, catalogTrackName, true);
+  }
+  #completeCleanBlock(key, sbn, packetId, catalogTrackName) {
+    this.#fecStats.blocksClean++;
+    this.#statsForPacket(packetId).blocksClean++;
+    this.cancelBlockTimeout(sbn, packetId, catalogTrackName);
+    this.#blockSourceCounts.delete(key);
+    this.#blockSourceEsis.delete(key);
+    this.#blockAuthoredLengths.delete(key);
+    this.#blockRepairRsIds.delete(key);
+    this.#markTerminal(key, sbn, packetId, true);
+    this.#markPathBlockComplete(sbn, packetId, catalogTrackName);
+    if (catalogTrackName === void 0) {
+      this.onBlockComplete?.(sbn, packetId);
+    } else {
+      this.onBlockComplete?.(sbn, packetId, catalogTrackName);
+    }
+    queueMicrotask(() => this.#syncDecoderBlockOwners.delete(key));
+  }
+  /** Refresh deadlines after accepted block activity. */
+  noteBlockActivity(sbn, packetId, catalogTrackName, sourceProgress = false) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#completedBlocks.has(key)) return;
+    if (this.#pendingWorkerCleanups.has(key)) return;
+    const repairRequested = this.#repairRequestedBlocks.has(key);
+    if (repairRequested && this.#settlesByOrder(key)) return;
+    if (this.#settlesByOrder(key)) {
+      this.#holdForOrderedSettlement(key, sbn, packetId, catalogTrackName);
+      return;
+    }
+    const trackConfig = this.#resolveTrackConfig(packetId);
+    const timeoutMs = this.#multicastWaitMs(trackConfig);
+    if (!(timeoutMs > 0)) {
+      throw new Error(`[FECManager] packetId=${packetId} has no positive fail bound (timeoutMs=${timeoutMs})`);
+    }
+    const repairDeadline = this.#repairDeadlines.get(key);
+    if (this.onRepairNeeded && !repairRequested && (repairDeadline === void 0 || sourceProgress)) {
+      this.#armRepairDeadline(
+        key,
+        sbn,
+        packetId,
+        catalogTrackName,
+        this.#repairDeadlineMs(trackConfig)
+      );
+    }
+    this.#armBlockTimeout(sbn, packetId, catalogTrackName, timeoutMs);
+  }
+  #failBlock(sbn, packetId, catalogTrackName) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    this.#traceLifecycle("failed", sbn, packetId, catalogTrackName);
+    this.#clearRepairDeadline(key);
+    this.#clearBlockTimer(key);
+    const blockClass = this.#retireBlockClass(key, sbn, packetId, catalogTrackName);
+    if (this.#repairRequestedBlocks.delete(key)) {
+      this.onRepairResolved?.(sbn, packetId, "failed", catalogTrackName, null);
+    }
+    this.#blockSourceCounts.delete(key);
+    this.#blockSourceEsis.delete(key);
+    this.#blockAuthoredLengths.delete(key);
+    this.#blockRepairRsIds.delete(key);
+    this.#syncDecoderBlockOwners.delete(key);
+    this.#markTerminal(key, sbn, packetId, false);
+    this.#failedBlocks.add(key);
+    this.#markPathBlockComplete(sbn, packetId, catalogTrackName);
+    this.#fecStats.blocksFailed++;
+    this.#statsForPacket(packetId).blocksFailed++;
+    this.onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
+    this.onBlockResolved?.(sbn, packetId, catalogTrackName);
+  }
+  /**
+   * Resolve a block as completed (clean, recovered, or externally marked).
+   * A block that had a D-28 repair outstanding counts as repaired: it was
+   * short of its source at the repair deadline and completed anyway.
+   */
+  #resolveCompleted(key) {
+    const block = this.#parseBlockKey(key);
+    this.#markTerminal(key, block.sbn, block.packetId, false);
+    this.#clearOwedCleanupBound(key);
+    this.#pendingWorkerCleanups.delete(key);
+    this.#pendingWorkerCleanupClients.delete(key);
+    this.#markPathBlockComplete(block.sbn, block.packetId, block.catalogTrackName);
+    this.#clearRepairDeadline(key);
+    if (this.#repairRequestedBlocks.delete(key)) {
+      this.#noteBlockRepaired(key, block.sbn, block.packetId, block.catalogTrackName);
+      this.onRepairResolved?.(
+        block.sbn,
+        block.packetId,
+        "completed",
+        block.catalogTrackName,
+        this.#viaFor(key)
+      );
+    }
+    this.#retireBlockClass(key, block.sbn, block.packetId, block.catalogTrackName);
+    this.#blockSourceCounts.delete(key);
+    this.#blockSourceEsis.delete(key);
+    this.#blockAuthoredLengths.delete(key);
+    this.#blockRepairRsIds.delete(key);
+    this.#clearBlockTimer(key);
+    this.onBlockResolved?.(block.sbn, block.packetId, block.catalogTrackName);
+  }
+  /** Check whether a block has already been completed (clean or recovered). */
+  isBlockCompleted(sbn, packetId, catalogTrackName) {
+    return this.#blockKeysFor(sbn, packetId, catalogTrackName).some((key) => this.#completedBlocks.has(key));
+  }
+  /** Mark a block as completed externally (e.g., after routing recovered data). */
+  markBlockCompleted(sbn, packetId, catalogTrackName) {
+    for (const key of this.#blockKeysFor(sbn, packetId, catalogTrackName)) {
+      this.#resolveCompleted(key);
+    }
+  }
+  /**
+   * Increment blocksRecovered (called by MmtpRouter after routing a
+   * synchronous recovery). With the block's coordinates the recovery is also
+   * reported through onBlockRepaired, once per block.
+   */
+  countRecovery(packetId, sbn, catalogTrackName) {
+    this.#fecStats.blocksRecovered++;
+    if (packetId != null) this.#statsForPacket(packetId).blocksRecovered++;
+    if (packetId != null && sbn != null) {
+      this.#noteBlockRepaired(
+        this.#blockKey(sbn, packetId, catalogTrackName),
+        sbn,
+        packetId,
+        catalogTrackName
+      );
+    }
+  }
+  /**
+   * Strict delivery provenance for one FEC block.
+   *
+   * A recovered symbol is a function of every symbol that entered its block,
+   * so it can only be attributed to multicast when NO symbol in that block
+   * arrived over MoQ. Repair symbols routinely arrive over reliable QUIC
+   * (`MmtpRouter.feedRepairPacket`), so a block that recovered with MoQ help
+   * produced bytes that never crossed a multicast socket.
+   *
+   * An untracked block returns 'unknown' rather than a guess: absence of
+   * evidence is not evidence of multicast.
+   */
+  blockDeliveryProvenance(sbn, packetId, catalogTrackName) {
+    const counts = this.blockPathCount(sbn, packetId, catalogTrackName);
+    if (!counts) return "unknown";
+    if (counts.moqSymbols > 0) return "mixed";
+    if (counts.multicastSymbols > 0) return "multicast";
+    return "unknown";
+  }
+  /** Per-path symbol counts for one block (D-28 gate logging), if tracked. */
+  blockPathCount(sbn, packetId, catalogTrackName) {
+    return this.#blockPathCounts.get(
+      this.#blockKey(sbn, packetId, catalogTrackName)
+    ) ?? null;
+  }
+  /** Cancel block timeout (block completed via clean reception or FEC recovery). */
+  cancelBlockTimeout(sbn, packetId, catalogTrackName) {
+    for (const key of this.#blockKeysFor(sbn, packetId, catalogTrackName)) {
+      this.#resolveCompleted(key);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Cleanup
+  // -----------------------------------------------------------------------
+  dispose() {
+    for (const timer of this.#activeBlocks.values()) {
+      if (timer.handle != null) clearTimeout(timer.handle);
+    }
+    this.#activeBlocks.clear();
+    this.#activeBlockDeadlinesMs.clear();
+    this.#blockWaitDeadlinesMs.clear();
+    this.#repairHoldUntilMs.clear();
+    this.#deliveryGaps.reset();
+    this.#pendingWorkerCleanups.clear();
+    this.#pendingWorkerCleanupClients.clear();
+    for (const bound of this.#pendingWorkerCleanupBounds.values()) clearTimeout(bound.handle);
+    this.#pendingWorkerCleanupBounds.clear();
+    for (const timer of this.#repairDeadlines.values()) {
+      if (timer?.handle != null) clearTimeout(timer.handle);
+    }
+    this.#repairDeadlines.clear();
+    this.#repairDeadlineAtMs.clear();
+    this.#terminalExpiryMs.clear();
+    this.#terminalQueues.clear();
+    this.#blockKeysBySbn.clear();
+    this.#blockSourceCounts.clear();
+    this.#blockSourceEsis.clear();
+    this.#blockAuthoredLengths.clear();
+    this.#blockRepairRsIds.clear();
+    this.#completedBlocks.clear();
+    this.#cleanlyCompletedBlocks.clear();
+    this.#repairRequestedBlocks.clear();
+    this.#workerRecoveredBlocks.clear();
+    this.#syncDecoderBlockOwners.clear();
+    this.#startupAlignedPackets.clear();
+    this.#startupPartialBlocks.clear();
+    this.#startupRequireRepairReady = false;
+    this.#startupRepairReadyPackets.clear();
+    this.#startupRepairBoundaryCounts.clear();
+    this.#startupRepairFailOpenPackets.clear();
+    this.#orderedFrontiers.clear();
+    this.#orderedPendingBlocks.clear();
+    this.#seenSymbols.clear();
+    this.#blockPathCounts.clear();
+    this.#blockAnchorsMs.clear();
+    this.#blockCatalogTrackNames.clear();
+    this.#classifiers.clear();
+    this.#streamGeometries.clear();
+    this.#failedBlocks.clear();
+    this.#resolvedBlockClasses.clear();
+    this.#repairedBlocks.clear();
+    this.#materializedBlocks.clear();
+    this.#highestSbn.clear();
+    this.#isoLocators.clear();
+    this.#sourceAnchors.clear();
+    this.#trackConfigs.clear();
+    this.#fecDecoders.clear();
+    for (const client of new Set(this.#workerClients.values())) client.dispose();
+    this.#workerClients.clear();
+  }
+};
+export {
+  FECManager,
+  MIN_INTERLEAVE_DEPTH_MS
+};
+//# sourceMappingURL=fec-manager.js.map