@blockcast/mmt-container 2.1.0 → 2.2.0-main.02321582f1ca

package/dist/browser-runtime.js

@@ -489,6 +489,8 @@ var PACKET_TYPE_SIGNALING = 2;
 var PACKET_TYPE_REPAIR = 3;
 var MMTP_SIGNALING_PACKET_ID = 0;
 var MMTP_PACKET_ID_MAX = 65535;
+var FEC_CODE_REED_SOLOMON = 1;
+var FEC_CODE_RAPTORQ = 3;
 function parseMMTPHeader(buffer) {
   if (buffer.length < MMTP_HEADER_SIZE) {
     throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
@@ -655,30 +657,26 @@ function isEmptyOrExactLegacyTrailer(payload, start, end) {
   const authLength = view2.getUint16(2, false);
   return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end;
 }
-function resolveDeclaredTrailers(payload, declaredEnd, fecType, options, rapFlag = false) {
+function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
   if (declaredEnd > payload.length)
     return null;
   if (options?.skipFecId) {
-    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false, hasOverlayFecId: false } : null;
+    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
   }
-  const overlay = options?.overlayDeclared === true && rapFlag;
   if (fecType === 1) {
-    const fecStart = payload.length - sourceFecTrailerSize(overlay);
+    const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
     if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
       return null;
     }
-    return { hasFecId: true, hasOverlayFecId: overlay };
+    return { hasFecId: true };
   }
-  if (fecType !== 0 || overlay)
+  if (fecType !== 0)
     return null;
   if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
-    return { hasFecId: false, hasOverlayFecId: false };
+    return { hasFecId: false };
   }
   return null;
 }
-function sourceFecTrailerSize(overlay) {
-  return overlay ? 2 * SOURCE_FEC_PAYLOAD_ID_SIZE : SOURCE_FEC_PAYLOAD_ID_SIZE;
-}
 function extractNALUnit(mmtpPacket) {
   const extraction = extractMFUPayload(mmtpPacket);
   if (!extraction)
@@ -737,11 +735,11 @@ function planMfuExtraction(mmtpPacket, options, parsedHeader) {
   if ("rejection" in layoutResult)
     return layoutResult;
   const { layout } = layoutResult;
-  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options, header.rapFlag);
+  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options);
   if (!trailerLayout) {
     if (!options?.skipFecId && header.fecType === 1) {
       const observed = payload.length - layout.dataEnd;
-      const expected = sourceFecTrailerSize(options?.overlayDeclared === true && header.rapFlag);
+      const expected = SOURCE_FEC_PAYLOAD_ID_SIZE;
       if (observed !== expected) {
         return {
           rejection: {
@@ -776,13 +774,10 @@ function extractPlannedMfu(mmtpPacket, result) {
   const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE) : null;
   const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE, 4).getUint32(0, false) : null;
   const data = payload.subarray(mfuOffset, dataEnd);
-  const trailerStart = mmtpPacket.length - sourceFecTrailerSize(trailerLayout.hasOverlayFecId);
-  const ssIdAt = (offset) => ({
-    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + offset, 4).getUint32(0, false)
-  });
-  const fecPayloadId = trailerLayout.hasFecId ? ssIdAt(trailerStart) : null;
-  const overlayFecPayloadId = trailerLayout.hasOverlayFecId ? ssIdAt(trailerStart + SOURCE_FEC_PAYLOAD_ID_SIZE) : null;
-  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId, overlayFecPayloadId };
+  const fecPayloadId = trailerLayout.hasFecId ? {
+    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, 4).getUint32(0, false)
+  } : null;
+  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
 }
 function extractTimestamp(mmtpPacket) {
   const { header } = unwrapMMTP(mmtpPacket);
@@ -903,6 +898,50 @@ 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/signalling.js
+var FEC_CODING_STRUCTURE_ONE_STAGE = 1;
+var SSBG_MODE_1 = 1;
+var RAPTORQ_MAX_SOURCE_SYMBOLS = 56403;
+var REPAIR_SYMBOL_ID_MAX = 16777215;
+var MIN_REPAIR_SYMBOL_SIZE = 14;
+var REED_SOLOMON_MAX_BLOCK = 255;
+function alFecRaptorQFlowConfig(flow) {
+  if (flow.fecCodingStructure !== FEC_CODING_STRUCTURE_ONE_STAGE || flow.repairFlows.length !== 1)
+    return null;
+  if (flow.ssbgMode !== SSBG_MODE_1 || flow.ffsrptsFlag !== 0 || flow.fecPayloadIdMode !== 0)
+    return null;
+  if (flow.packetIds.length !== 1)
+    return null;
+  const repair = flow.repairFlows[0];
+  const { fecCodeId, maximumK: k, maximumP: p } = repair;
+  const t = flow.repairSymbolSize;
+  if (t < MIN_REPAIR_SYMBOL_SIZE || k < 1 || p < 1 || k + p - 1 > REPAIR_SYMBOL_ID_MAX)
+    return null;
+  if (fecCodeId === FEC_CODE_RAPTORQ) {
+    if (t % 8 !== 0 || k > RAPTORQ_MAX_SOURCE_SYMBOLS)
+      return null;
+  } else if (fecCodeId === FEC_CODE_REED_SOLOMON) {
+    if (k + p > REED_SOLOMON_MAX_BLOCK)
+      return null;
+  } else {
+    return null;
+  }
+  if (repair.repairFlowId === MMTP_SIGNALING_PACKET_ID || repair.repairFlowId === flow.packetIds[0])
+    return null;
+  return {
+    sourcePacketIds: [...flow.packetIds],
+    repairFlowId: repair.repairFlowId,
+    fecCodeId,
+    ssbgMode: flow.ssbgMode,
+    fecPayloadIdMode: flow.fecPayloadIdMode,
+    repairSymbolSize: t,
+    maximumK: k,
+    maximumP: p,
+    protectionWindowTime: repair.protectionWindowTime,
+    protectionWindowSize: repair.protectionWindowSize
+  };
+}
+
 // ../mmt-base/dist/serial-number.js
 var SERIAL32_SPAN = 4294967296;
 var SERIAL32_HALF = 2147483648;
@@ -7457,11 +7496,33 @@ var AdaptiveBitrateController = class {
 };
 
 // node_modules/@blockcast/mmt-base/dist/mmtp.js
+var MMTP_HEADER_SIZE2 = 12;
 var MPU_HEADER_SIZE2 = 8;
 var MPU_LENGTH_FIELD_SIZE2 = 2;
 var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
 var MMTP_SIGNALING_PACKET_ID2 = 0;
 var MMTP_PACKET_ID_MAX2 = 65535;
+function readMMTPPacketId2(buffer) {
+  if (buffer.length < MMTP_HEADER_SIZE2)
+    return null;
+  const flags = buffer[0];
+  if ((flags >> 6 & 3) !== 0)
+    return null;
+  let offset = MMTP_HEADER_SIZE2;
+  if ((flags & 32) !== 0) {
+    if (offset + 4 > buffer.length)
+      return null;
+    offset += 4;
+  }
+  if ((flags & 2) !== 0) {
+    if (offset + 4 > buffer.length)
+      return null;
+    const length = buffer[offset + 2] << 8 | buffer[offset + 3];
+    if (offset + 4 + length > buffer.length)
+      return null;
+  }
+  return buffer[2] << 8 | buffer[3];
+}
 
 // node_modules/@blockcast/mmt-base/dist/net-constants.js
 var DEFAULT_AMT_RELAY_PORT2 = 2268;
@@ -7927,8 +7988,8 @@ var MulticastSubscriptionPool = class {
       record.claims--;
       return this.acquire(gateway, config, consumer);
     }
-    const token = Symbol(key);
-    entry.consumers.set(token, consumer);
+    const token2 = Symbol(key);
+    entry.consumers.set(token2, consumer);
     let released = false;
     return {
       key,
@@ -7936,7 +7997,7 @@ var MulticastSubscriptionPool = class {
         if (released)
           return;
         released = true;
-        entry.consumers.delete(token);
+        entry.consumers.delete(token2);
         record.claims--;
         if (record.claims > 0)
           return;
@@ -8447,6 +8508,205 @@ var TransportManager = class {
 };
 var transportManager = new TransportManager();
 
+// node_modules/@blockcast/mmt-transport/dist/multicast-receiver-gateway.js
+var REGISTRY = /* @__PURE__ */ Symbol.for("@blockcast/mmt-transport/native-provider-registry/v1");
+var USER_AGENT_VERIFIED = /* @__PURE__ */ Symbol.for("@blockcast/mmt-transport/user-agent-verified/v1");
+var INTEGRITY_SCHEME = "manifest-ed25519-2";
+var MulticastError = class extends Error {
+  code;
+  constructor(code, message, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.name = "MulticastError";
+    this.code = code;
+  }
+};
+function datagramsOf(chunk) {
+  const list = Array.isArray(chunk) ? chunk : chunk?.datagrams ?? [];
+  const out = [];
+  for (const d of list) {
+    const data = d instanceof Uint8Array || d instanceof ArrayBuffer ? d : d?.data;
+    if (data instanceof Uint8Array)
+      out.push(data);
+    else if (data instanceof ArrayBuffer)
+      out.push(new Uint8Array(data));
+  }
+  return out;
+}
+function reasonOf(value) {
+  return typeof value === "object" && value !== null && "reason" in value ? value.reason : value;
+}
+function registry() {
+  const g = globalThis;
+  if (g[REGISTRY] === void 0) {
+    const providers = /* @__PURE__ */ new WeakSet();
+    const byScope = /* @__PURE__ */ new WeakMap();
+    Object.defineProperty(g, REGISTRY, {
+      value: Object.freeze({
+        isProvider: (x) => typeof x === "object" && x !== null && providers.has(x),
+        providerFor: (scope) => {
+          let provider = byScope.get(scope);
+          if (provider === void 0) {
+            provider = createProvider(scope);
+            providers.add(provider);
+            byScope.set(scope, provider);
+          }
+          return provider;
+        }
+      }),
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+  return g[REGISTRY];
+}
+function resolveMulticastGateway(scope = globalThis) {
+  const s = scope;
+  if (typeof s.MulticastReceiver === "function")
+    return registry().providerFor(scope);
+  if (typeof s.multicast?.subscribe === "function")
+    return s.multicast;
+  return void 0;
+}
+function isUserAgentVerifiedGateway(gateway) {
+  return registry().isProvider(gateway);
+}
+function userAgentVerifiedIngress(ingress, gateway) {
+  if (isUserAgentVerifiedGateway(gateway))
+    return { ...ingress, admittedBy: USER_AGENT_VERIFIED };
+  if (!("admittedBy" in ingress))
+    return ingress;
+  const { admittedBy: _, ...rest } = ingress;
+  return rest;
+}
+function unsupported(message, cause) {
+  return new MulticastError("capability-unsupported", message, cause);
+}
+function createProvider(scope) {
+  const Receiver = scope.MulticastReceiver;
+  let gate = null;
+  return {
+    capabilities: () => Promise.resolve({ consumeModes: ["bytes"] }),
+    subscribe: async (config) => {
+      const c = config;
+      if (c.consume !== "bytes")
+        throw unsupported(`consume mode ${String(c.consume)} is not supported`);
+      const origin = c.origin ?? "ip-multicast";
+      if (origin !== "ip-multicast" && !(origin === "amt" && c.discovery === "driad")) {
+        throw unsupported(`origin ${String(origin)} is not supported by MulticastReceiver`);
+      }
+      if (c.relay !== void 0)
+        throw unsupported("MulticastReceiver picks its own AMT relay");
+      if (!c.source)
+        throw unsupported("MulticastReceiver needs an SSM source");
+      if (c.senderAddress !== void 0 && c.senderAddress !== c.source) {
+        throw unsupported("MulticastReceiver filters by source only");
+      }
+      const options = { sourceAddress: c.source, groupAddress: c.group, localPort: c.port };
+      if (gate !== null)
+        await gate;
+      let rx;
+      try {
+        rx = new Receiver(options);
+      } catch (error) {
+        throw unsupported("MulticastReceiver refused the request", error);
+      }
+      const opened = rx.opened;
+      if (gate === null)
+        gate = opened.then(() => void 0, () => void 0);
+      return openSubscription(rx, opened, options, c.packetIds);
+    }
+  };
+}
+async function openSubscription(rx, openedPromise, options, packetIds) {
+  let opened;
+  try {
+    opened = await openedPromise;
+  } catch (error) {
+    throw new MulticastError("subscription-failed", "MulticastReceiver did not open", error);
+  }
+  if (rx.integrityScheme !== INTEGRITY_SCHEME) {
+    await rx.close();
+    throw unsupported(`integrity scheme ${String(rx.integrityScheme)} is not ${INTEGRITY_SCHEME}`);
+  }
+  const events = new EventTarget();
+  let state = "connected";
+  let filter = packetIds?.length ? new Set(packetIds) : null;
+  let closing = false;
+  const setState = (next) => {
+    if (state === next)
+      return;
+    state = next;
+    events.dispatchEvent(new CustomEvent("state", { detail: next }));
+  };
+  const sourceAddress = options.sourceAddress;
+  const subscription = {
+    id: `${options.sourceAddress}|${options.groupAddress}|${options.localPort}`,
+    get state() {
+      return state;
+    },
+    delivery: "datagram",
+    eventTypes: Object.freeze(["bytes", "packets", "state", "error"]),
+    setPacketIds(ids) {
+      filter = ids.length ? new Set(ids) : null;
+    },
+    addEventListener: events.addEventListener.bind(events),
+    removeEventListener: events.removeEventListener.bind(events),
+    async unsubscribe() {
+      closing = true;
+      await rx.close();
+      setState("closed");
+    }
+  };
+  void (async () => {
+    const reader = opened.readable.getReader();
+    try {
+      for (; ; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        const packets = [];
+        for (const data of datagramsOf(value)) {
+          if (filter !== null) {
+            const id = readMMTPPacketId2(data);
+            if (id === null || !filter.has(id))
+              continue;
+          }
+          const copy = data.slice().buffer;
+          packets.push(copy);
+          events.dispatchEvent(Object.assign(new CustomEvent("bytes", { detail: copy }), { sourceAddress }));
+        }
+        if (packets.length > 0)
+          events.dispatchEvent(new CustomEvent("packets", { detail: packets }));
+      }
+    } catch {
+    }
+  })();
+  void rx.closed.then((value) => {
+    const reason = reasonOf(value);
+    if (!closing) {
+      if (reason === "consent-withdrawn") {
+        events.dispatchEvent(new CustomEvent("error", {
+          detail: new MulticastError("origin-not-trusted", "multicast consent withdrawn")
+        }));
+      } else if (reason === "oversubscribed" || reason === "network") {
+        events.dispatchEvent(new CustomEvent("error", {
+          detail: new MulticastError("subscription-failed", `MulticastReceiver closed: ${reason}`)
+        }));
+      }
+    }
+    setState("closed");
+  }, (error) => {
+    if (!closing) {
+      events.dispatchEvent(new CustomEvent("error", {
+        detail: new MulticastError("subscription-failed", "MulticastReceiver failed", error)
+      }));
+    }
+    setState("closed");
+  });
+  return subscription;
+}
+
 // node_modules/@blockcast/mmt-transport/dist/moqt-priority.js
 var MAX_MOQT_PRIORITY = 255;
 function moqtPriority(value, field) {
@@ -8486,14 +8746,15 @@ var MOQT_PUBLISHER_PRIORITY = Object.freeze({
 });
 
 // node_modules/@blockcast/mmt-transport/dist/amt-gateway.js
+var MAX_PENDING_PACKETS = 256;
 var AMTGatewayManager = class {
   subscriptions = /* @__PURE__ */ new Map();
   messageHandler;
+  messageListenerRegistered = false;
   pendingPackets = /* @__PURE__ */ new Map();
   constructor() {
     this.messageHandler = (event) => {
       const data = event.data;
-      console.log(`[AMT] SW message received:`, data.type);
       if (data.type === "UDP_PACKET") {
         this.handlePacket(data);
       } else if (data.type === "SOCKET_ERROR") {
@@ -8502,12 +8763,22 @@ var AMTGatewayManager = class {
         console.log(`[AMT SW Debug] ${data.message}`);
       }
     };
-    if (typeof navigator !== "undefined" && navigator.serviceWorker) {
-      navigator.serviceWorker.addEventListener("message", this.messageHandler);
-      console.log("[AMT] Registered service worker message handler");
-    } else {
-      console.warn("[AMT] Service worker not available");
+  }
+  ensureMessageListener() {
+    if (this.messageListenerRegistered || typeof navigator === "undefined" || !navigator.serviceWorker || !this.messageHandler) {
+      return;
+    }
+    navigator.serviceWorker.addEventListener("message", this.messageHandler);
+    this.messageListenerRegistered = true;
+    console.log("[AMT] Registered service worker message handler");
+  }
+  removeMessageListener() {
+    if (!this.messageListenerRegistered)
+      return;
+    if (this.messageHandler && typeof navigator !== "undefined" && navigator.serviceWorker) {
+      navigator.serviceWorker.removeEventListener("message", this.messageHandler);
     }
+    this.messageListenerRegistered = false;
   }
   /**
    * Subscribe via AMT tunnel
@@ -8517,6 +8788,7 @@ var AMTGatewayManager = class {
     if (config.protected) {
       throw new Error("AMTGatewayManager refuses a protected join: it reports no per-datagram sender (multicast-02 7.2.7)");
     }
+    this.ensureMessageListener();
     const keyStr = this.getKeyString(key);
     if (this.subscriptions.has(keyStr)) {
       console.log(`[AMT] Reusing existing subscription to ${keyStr}`);
@@ -8552,6 +8824,8 @@ var AMTGatewayManager = class {
         this.subscriptions.delete(keyStr);
         this.pendingPackets.delete(subscription.subscriptionId);
       }
+      if (this.subscriptions.size === 0)
+        this.removeMessageListener();
       throw new Error(`Failed to subscribe via AMT: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
@@ -8573,6 +8847,8 @@ var AMTGatewayManager = class {
     } finally {
       this.subscriptions.delete(handle);
       this.pendingPackets.delete(subscription.subscriptionId);
+      if (this.subscriptions.size === 0)
+        this.removeMessageListener();
     }
   }
   /**
@@ -8589,14 +8865,12 @@ var AMTGatewayManager = class {
     if (!subscriptionId)
       return;
     const subscription = this.subscriptions.get(subscriptionId);
-    if (!subscription) {
-      console.warn(`[AMT] Received packet for unknown subscription: ${subscriptionId}`);
+    if (!subscription)
       return;
-    }
     if (!subscription.handshakeComplete) {
       const queue = this.pendingPackets.get(subscriptionId);
       const packetData2 = data;
-      if (queue) {
+      if (queue && queue.length < MAX_PENDING_PACKETS) {
         queue.push({
           data: packetData2.data,
           remoteAddress: packetData2.remoteAddress,
@@ -8622,19 +8896,15 @@ var AMTGatewayManager = class {
     if (!subscriptionId)
       return;
     const subscription = this.subscriptions.get(subscriptionId);
-    if (!subscription) {
-      console.warn(`[AMT] Received error for unknown subscription: ${subscriptionId}`);
+    if (!subscription)
       return;
-    }
     subscription.config.onError(new Error(error || "Unknown error"));
   }
   /**
    * Cleanup on destroy
    */
   destroy() {
-    if (this.messageHandler && typeof navigator !== "undefined" && navigator.serviceWorker) {
-      navigator.serviceWorker.removeEventListener("message", this.messageHandler);
-    }
+    this.removeMessageListener();
     const handles = Array.from(this.subscriptions.keys());
     for (const handle of handles) {
       this.unsubscribe(handle).catch((err) => {
@@ -8733,9 +9003,9 @@ function validateTemplatePair(mediaUriTemplate, mediaObjectTemplate, path) {
 }
 function validateMmtpDashTemplate(template, path) {
   const variables = [...template.matchAll(TEMPLATE_VARIABLE)].map((match) => match[1]);
-  const unsupported = variables.find((variable) => variable !== "Number" && variable !== "RepresentationID");
-  if (unsupported !== void 0) {
-    throw new Error(`${path} contains unsupported MMTP-backed DASH template variable $${unsupported}$`);
+  const unsupported2 = variables.find((variable) => variable !== "Number" && variable !== "RepresentationID");
+  if (unsupported2 !== void 0) {
+    throw new Error(`${path} contains unsupported MMTP-backed DASH template variable $${unsupported2}$`);
   }
   if (variables.filter((variable) => variable === "Number").length !== 1) {
     throw new Error(`${path} must contain exactly one $Number$ for MMTP-backed DASH`);
@@ -12679,6 +12949,7 @@ var IsoBlockLocator = class _IsoBlockLocator {
   #retentionBlocks;
   #heldEvicted;
   #newest;
+  #newestSource;
   #holes;
   static #checkedRetention(retentionBlocks) {
     if (!Number.isSafeInteger(retentionBlocks) || retentionBlocks <= 0) {
@@ -12716,6 +12987,21 @@ var IsoBlockLocator = class _IsoBlockLocator {
   observe(position) {
     if (this.#newest === void 0 || serial32Precedes(this.#newest, position)) this.#newest = position;
   }
+  /**
+   * The newest source SS_ID noted with `noteSource` (RFC 1982 order). Unlike
+   * `newest`, a repair never moves it: a repair can run ahead of its sources,
+   * a source cannot run ahead of the sources sent before it except by
+   * reordering.
+   */
+  get newestSource() {
+    return this.#newestSource;
+  }
+  /** Note a received source's SS_ID; true when it is the newest one yet. */
+  noteSource(ssId) {
+    if (this.#newestSource !== void 0 && !serial32Precedes(this.#newestSource, ssId)) return false;
+    this.#newestSource = ssId;
+    return true;
+  }
   /** Held sources evicted by `heldCapacity` (never by the horizon itself). */
   get heldEvicted() {
     return this.#heldEvicted;
@@ -12948,6 +13234,7 @@ var IsoBlockLocator = class _IsoBlockLocator {
     this.#held.clear();
     this.#coverageEnd = void 0;
     this.#newest = void 0;
+    this.#newestSource = void 0;
   }
   #claim(block) {
     const placed = [];
@@ -13567,6 +13854,7 @@ 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;
+var NOT_TAKEN = Object.freeze({ taken: false, recovered: null });
 function isMulticastSymbolDelivery(value) {
   return value === "datagram" || value === "ordered-relay";
 }
@@ -13664,6 +13952,10 @@ var FECManager = class _FECManager {
     // Source symbol count per track-scoped block — marks complete when K symbols arrive.
     this.#blockSourceCounts = /* @__PURE__ */ new Map();
     this.#blockSourceEsis = /* @__PURE__ */ new Map();
+    // Source ESIs per block that another FEC instance rebuilt and fed in
+    // (feedRebuiltSourceSymbol). Kept apart from #blockSourceEsis: they are
+    // not network arrivals and never make a block clean.
+    this.#blockRebuiltEsis = /* @__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; under iso-ssbg1-v1
@@ -13792,6 +14084,10 @@ var FECManager = class _FECManager {
     // ── Keyframe-protected repair policy (block-policy.ts) ──
     // One classifier per physical stream, built from that stream's geometry.
     this.#classifiers = /* @__PURE__ */ new Map();
+    // A stream without catalog timing has no classifier, so the last RAP it
+    // released stands in for one: "an MPU boundary bounds its RAPs" holds until
+    // a second RAP is released inside one MPU (BLO-52085).
+    this.#noSpanRaps = /* @__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
@@ -13949,6 +14245,7 @@ var FECManager = class _FECManager {
   #pendingWorkerCleanupBounds;
   #blockSourceCounts;
   #blockSourceEsis;
+  #blockRebuiltEsis;
   #blockAuthoredLengths;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
@@ -13991,6 +14288,7 @@ var FECManager = class _FECManager {
   #orderedFrontiers;
   #orderedPendingBlocks;
   #classifiers;
+  #noSpanRaps;
   #streamGeometries;
   #failedBlocks;
   #resolvedBlockClasses;
@@ -14652,6 +14950,7 @@ var FECManager = class _FECManager {
     };
     const discontinuity = () => {
       this.#classifiers.get(streamKey)?.noteSourceDiscontinuity();
+      this.#noSpanRaps.delete(streamKey);
       this.#highestSbn.set(streamKey, { sbn, atMs: now });
       this.#sourceFrontiers.set(streamKey, { sbn, atMs: now });
       if (psn === void 0) this.#sourceAnchors.delete(streamKey);
@@ -15064,6 +15363,9 @@ var FECManager = class _FECManager {
     }
     if (policyChanged) {
       this.#bumpEpoch(packetId);
+      for (const key of [...this.#noSpanRaps.keys()]) {
+        if (this.#belongsToPacket(key, packetId)) this.#noSpanRaps.delete(key);
+      }
       for (const [key, classifier] of [...this.#classifiers]) {
         if (!this.#belongsToPacket(key, packetId)) continue;
         const stream = this.#parseStreamKey(key);
@@ -15266,6 +15568,7 @@ var FECManager = class _FECManager {
     }
     resetMap(this.#blockSourceCounts);
     resetMap(this.#blockSourceEsis);
+    resetMap(this.#blockRebuiltEsis);
     resetMap(this.#blockAuthoredLengths);
     resetMap(this.#blockRepairRsIds);
     resetMap(this.#blockRsbLengths);
@@ -15299,6 +15602,7 @@ var FECManager = class _FECManager {
     resetMap(this.#isoLocators);
     resetMap(this.#sourceAnchors);
     this.#classifiers.delete(this.#streamKey(packetId, catalogTrackName));
+    this.#noSpanRaps.delete(this.#streamKey(packetId, catalogTrackName));
     this.#bumpEpoch(packetId);
     for (const [sbn, keys] of this.#blockKeysBySbn) {
       for (const key of keys.keys()) {
@@ -15389,6 +15693,7 @@ var FECManager = class _FECManager {
     dropMap(this.#pendingWorkerCleanupClients);
     dropMap(this.#blockSourceCounts);
     dropMap(this.#blockSourceEsis);
+    dropMap(this.#blockRebuiltEsis);
     dropMap(this.#blockAuthoredLengths);
     dropMap(this.#blockRepairRsIds);
     dropMap(this.#blockRsbLengths);
@@ -15405,6 +15710,7 @@ var FECManager = class _FECManager {
     dropMap(this.#isoLocators);
     dropMap(this.#sourceAnchors);
     dropMap(this.#classifiers);
+    dropMap(this.#noSpanRaps);
     dropMap(this.#streamGeometries);
     dropSet(this.#pendingWorkerCleanups);
     dropSet(this.#completedBlocks);
@@ -15550,6 +15856,9 @@ var FECManager = class _FECManager {
         this.#unindexBlockKey(key);
       }
     }
+    if (isSourceSymbol && source === "multicast") {
+      this.#noteMulticastSource(this.#isoLocatorFor(packetId, catalogTrackName), sbn + esi >>> 0, packetId, catalogTrackName);
+    }
     return true;
   }
   #observeBlockCatalogTrackName(blockKey, sbn, packetId, catalogTrackName) {
@@ -15867,6 +16176,7 @@ var FECManager = class _FECManager {
     const locator = this.#growingIsoLocatorFor(packetId, catalogTrackName);
     const evictedBefore = locator.heldEvicted;
     const held = locator.hold(ssId, source);
+    if (held && source.source === "multicast") this.#noteMulticastSource(locator, ssId, packetId, catalogTrackName);
     const evicted = locator.heldEvicted - evictedBefore;
     if (evicted > 0) {
       const before = this.#isoHeldEvictedCount;
@@ -16035,11 +16345,14 @@ var FECManager = class _FECManager {
   /**
    * 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.
+   * it does not. A stream with no classifier yet has shown nothing against it,
+   * and neither has a stream without catalog timing until it releases two
+   * RAPs inside one MPU.
    */
   mpuBoundsRapsFor(packetId, catalogTrackName) {
-    if (!this.#hasCatalogTimingForPacket(packetId)) return false;
-    return this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))?.mpuBoundsRaps ?? true;
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    if (!this.#hasCatalogTimingForPacket(packetId)) return this.#noSpanRaps.get(streamKey)?.inside !== true;
+    return this.#classifiers.get(streamKey)?.mpuBoundsRaps ?? true;
   }
   /** A block's class now, or frozen at its resolution. */
   blockClassFor(sbn, packetId, catalogTrackName) {
@@ -16065,7 +16378,14 @@ var FECManager = class _FECManager {
    * invariant (consecutive MPUs exactly one keyframe interval apart).
    */
   noteReleasedRap(packetId, catalogTrackName, mpu, presentationTime, mediaTimescale) {
-    if (!this.#trackConfigs.has(packetId) || !this.#hasCatalogTimingForPacket(packetId)) return;
+    if (!this.#trackConfigs.has(packetId)) return;
+    if (!this.#hasCatalogTimingForPacket(packetId)) {
+      const streamKey = this.#streamKey(packetId, catalogTrackName);
+      const last = this.#noSpanRaps.get(streamKey);
+      const inside = last?.inside === true || last?.mpu === mpu && last.presentationTime !== presentationTime;
+      this.#noSpanRaps.set(streamKey, { mpu, presentationTime, inside });
+      return;
+    }
     this.#applyClassifierChanges(
       packetId,
       catalogTrackName,
@@ -16452,7 +16772,15 @@ var FECManager = class _FECManager {
       this.#isoSourceOversizeCount++;
       return null;
     }
-    const sbn = located.block.start;
+    return this.#feedDecoderSource(packetId, ssId, symbolData, catalogTrackName, located.block.start);
+  }
+  /**
+   * Hand one placed source symbol to the stream's decoder: its Worker, which
+   * answers through onFrame (null here), or its synchronous decoder, whose
+   * recovered block is returned. `sbn` is the SS_Start of the block a repair
+   * stated for `ssId`.
+   */
+  #feedDecoderSource(packetId, ssId, symbolData, catalogTrackName, sbn) {
     const blockKey = this.#blockKey(sbn, packetId, catalogTrackName);
     const syncBlockOwner = this.#syncDecoderBlockOwners.get(blockKey);
     const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName);
@@ -16481,6 +16809,68 @@ var FECManager = class _FECManager {
     }
     return recovered;
   }
+  /**
+   * Feed a source symbol of this stream that another FEC instance over the
+   * same packets rebuilt: a keyframe overlay recovery whose base SS_ID the
+   * caller determined (draft-ramadan-moq-mmt-02 7.1, 7.4.4; joint decoding,
+   * BLO-52085). It joins its block's decoder as a received source would, so
+   * it reduces the erasures the block still has to solve, but it is not a
+   * network arrival: no transport accounting, no classification evidence,
+   * no deadline refresh, and it never makes a block clean.
+   *
+   * Only a block a repair stated takes one (a repair-less span has no
+   * decoder block). A block that is terminal, or already holds that source,
+   * does not. The symbol is the exact protected packet, unpadded, as
+   * feedSourceSymbol takes it.
+   *
+   * `recovered` is the block the synchronous decoder completed with it; the
+   * caller routes it and completes the block, as for any recovery. When
+   * every source of the block is then present, received or rebuilt, and no
+   * decoder returned it (a Worker answers asynchronously, and reports such a
+   * block as clean on its own side), the block is completed here as
+   * recovered, with nothing left to route.
+   */
+  feedRebuiltSourceSymbol(packetId, ssId, symbolData, catalogTrackName) {
+    if (!this.#hasBlockProfile(packetId)) return NOT_TAKEN;
+    const located = this.#isoLocatorFor(packetId, catalogTrackName).locate(ssId);
+    if (located === null || located.block.span) return NOT_TAKEN;
+    if (!ssbg1FitsSymbol(symbolData.byteLength, this.#trackConfig(packetId).symbolSize)) return NOT_TAKEN;
+    const sbn = located.block.start;
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#completedBlocks.has(key) || this.#blockSourceEsis.get(key)?.has(located.esi)) return NOT_TAKEN;
+    let rebuilt = this.#blockRebuiltEsis.get(key);
+    if (rebuilt?.has(located.esi)) return NOT_TAKEN;
+    if (rebuilt === void 0) {
+      rebuilt = /* @__PURE__ */ new Set();
+      this.#blockRebuiltEsis.set(key, rebuilt);
+    }
+    rebuilt.add(located.esi);
+    const recovered = this.#feedDecoderSource(packetId, ssId, symbolData, catalogTrackName, sbn);
+    if (recovered === null) this.#completeWhenSourcesPresent(key, sbn, located.block.length, packetId, catalogTrackName);
+    return { taken: true, recovered };
+  }
+  /**
+   * A block that holds every one of its `length` sources, received or
+   * rebuilt by another instance, with at least one rebuilt, is recovered:
+   * every packet of it was delivered, by its own arrival or by the instance
+   * that rebuilt it, so nothing is routed. Returns whether it completed it.
+   */
+  #completeWhenSourcesPresent(key, sbn, length, packetId, catalogTrackName) {
+    const rebuilt = this.#blockRebuiltEsis.get(key);
+    if (rebuilt === void 0 || this.#completedBlocks.has(key)) return false;
+    let present = rebuilt.size;
+    for (const esi of this.#blockSourceEsis.get(key) ?? []) if (!rebuilt.has(esi)) present++;
+    if (present < length) return false;
+    this.#traceLifecycle("recovered", sbn, packetId, catalogTrackName);
+    this.countRecovery(packetId, sbn, catalogTrackName);
+    this.cancelBlockTimeout(sbn, packetId, catalogTrackName);
+    if (catalogTrackName === void 0) {
+      this.onBlockComplete?.(sbn, packetId);
+    } else {
+      this.onBlockComplete?.(sbn, packetId, catalogTrackName);
+    }
+    return true;
+  }
   /**
    * fec-01 4.5: a reed-solomon repair packet whose SSB_length + RSB_length
    * exceeds 255, or whose RS_ID is not below RSB_length, is discarded with the
@@ -16683,8 +17073,72 @@ var FECManager = class _FECManager {
       this.#completeCleanBlock(blockKey, sbn, packetId, catalogTrackName);
       return null;
     }
+    if (recovered === null) this.#shortenUnrecoverableWait(blockKey, sbn, packetId, catalogTrackName);
     return recovered;
   }
+  /**
+   * A first-arrival multicast source, held or placed. A datagram flow keeps
+   * its sources in send order, so one that moves the stream's newest source
+   * position past a block leaves the sources that block still misses
+   * reordered behind it at best: it shortens the wait of every block it
+   * passed that only a late source can complete. MoQ is left out: its streams
+   * can overtake one another, so a MoQ source shows nothing about the sources
+   * sent before it.
+   */
+  #noteMulticastSource(locator, ssId, packetId, catalogTrackName) {
+    const previous = locator.newestSource;
+    if (!locator.noteSource(ssId) || previous === void 0) return;
+    for (const block of locator.blocksBetween(previous - 1 >>> 0, ssId)) {
+      if (block.span || !serial32Precedes(serial32Add(block.start, block.length - 1), ssId)) continue;
+      this.#shortenUnrecoverableWait(
+        this.#blockKey(block.start, packetId, catalogTrackName),
+        block.start,
+        packetId,
+        catalogTrackName
+      );
+    }
+  }
+  /**
+   * The wait of a block that only a late source can complete (BLO-52085): a
+   * repair stated it, its received sources plus every symbol its repair group
+   * carries (RSB_length) are short of K' (the repair scheduler's
+   * group-cannot-complete), and a later source of the stream has arrived, so
+   * a source it misses is lost or reordered behind that one. The span, which
+   * covers repair symbols paced after its sources, buys it nothing: it waits
+   * the late-symbol allowance alone, the multicast wait less the span (the
+   * catalog tolerance or the measured delivery gap). Undefined for any other
+   * block.
+   */
+  #lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config) {
+    const authoredLength = this.#blockAuthoredLengths.get(key);
+    const rsbLength = this.#blockRsbLengths.get(key);
+    if (authoredLength === void 0 || rsbLength === void 0) return void 0;
+    if ((this.#blockSourceCounts.get(key) ?? 0) + rsbLength >= authoredLength) return void 0;
+    const newestSource = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName))?.newestSource;
+    if (newestSource === void 0 || !serial32Precedes(serial32Add(sbn, authoredLength - 1), newestSource)) {
+      return void 0;
+    }
+    return this.#multicastWaitMs(config) - config.interleaveDepthMs;
+  }
+  /**
+   * Bring an open block's wait in to its late-source wait, when it has one.
+   * Never later than it is armed: only a source can complete such a block,
+   * so a repair of its group (paced across the span) must not keep it open.
+   */
+  #shortenUnrecoverableWait(key, sbn, packetId, catalogTrackName) {
+    if (!this.#activeBlocks.has(key)) return;
+    const config = this.#trackConfigs.get(packetId);
+    if (config === void 0) return;
+    const waitMs = this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config);
+    if (waitMs === void 0) return;
+    const armedAtMs = this.#blockWaitDeadlinesMs.get(key);
+    this.#armBlockTimeout(
+      sbn,
+      packetId,
+      catalogTrackName,
+      armedAtMs === void 0 ? waitMs : Math.min(waitMs, armedAtMs - this.#receiptNow())
+    );
+  }
   /**
    * Record a block's authored SSB_length from a repair symbol. Returns false,
    * leaving the block unchanged, when the symbol contradicts the block: a
@@ -16839,6 +17293,15 @@ var FECManager = class _FECManager {
       this.#completeCleanBlock(key, sbn, packetId, catalogTrackName);
       return;
     }
+    if (this.#blockRebuiltEsis.has(key) && this.#completeWhenSourcesPresent(
+      key,
+      sbn,
+      this.#isoLocatorFor(packetId, catalogTrackName).blockAt(sbn)?.length ?? authoredLength,
+      packetId,
+      catalogTrackName
+    )) {
+      return;
+    }
     this.noteBlockActivity(sbn, packetId, catalogTrackName, true);
   }
   #completeCleanBlock(key, sbn, packetId, catalogTrackName) {
@@ -16847,6 +17310,7 @@ var FECManager = class _FECManager {
     this.cancelBlockTimeout(sbn, packetId, catalogTrackName);
     this.#blockSourceCounts.delete(key);
     this.#blockSourceEsis.delete(key);
+    this.#blockRebuiltEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
@@ -16913,7 +17377,16 @@ var FECManager = class _FECManager {
         this.#repairDeadlineMs(trackConfig)
       );
     }
-    this.#armBlockTimeout(sbn, packetId, catalogTrackName, timeoutMs);
+    if (!sourceProgress && this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, trackConfig) !== void 0) {
+      this.#shortenUnrecoverableWait(key, sbn, packetId, catalogTrackName);
+      return;
+    }
+    this.#armBlockTimeout(
+      sbn,
+      packetId,
+      catalogTrackName,
+      this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, trackConfig) ?? timeoutMs
+    );
   }
   #failBlock(sbn, packetId, catalogTrackName) {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
@@ -16926,6 +17399,7 @@ var FECManager = class _FECManager {
     }
     this.#blockSourceCounts.delete(key);
     this.#blockSourceEsis.delete(key);
+    this.#blockRebuiltEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
@@ -16964,6 +17438,7 @@ var FECManager = class _FECManager {
     this.#retireBlockClass(key, block.sbn, block.packetId, block.catalogTrackName);
     this.#blockSourceCounts.delete(key);
     this.#blockSourceEsis.delete(key);
+    this.#blockRebuiltEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
@@ -17055,6 +17530,7 @@ var FECManager = class _FECManager {
     this.#blockKeysBySbn.clear();
     this.#blockSourceCounts.clear();
     this.#blockSourceEsis.clear();
+    this.#blockRebuiltEsis.clear();
     this.#blockAuthoredLengths.clear();
     this.#blockRepairRsIds.clear();
     this.#blockRsbLengths.clear();
@@ -17080,6 +17556,7 @@ var FECManager = class _FECManager {
     this.#blockAnchorsMs.clear();
     this.#blockCatalogTrackNames.clear();
     this.#classifiers.clear();
+    this.#noSpanRaps.clear();
     this.#streamGeometries.clear();
     this.#failedBlocks.clear();
     this.#resolvedBlockClasses.clear();
@@ -17098,17 +17575,17 @@ var FECManager = class _FECManager {
 
 // src/mfu-reassembly-policy.ts
 function validateReliableMoqOptionShape(value) {
-  const unsupported = Object.keys(value).filter(
+  const unsupported2 = Object.keys(value).filter(
     (key) => key !== "transport" && key !== "startsAtRandomAccessGroup"
   );
-  if (unsupported.length > 0) {
-    if (unsupported.includes("maxRacingGroups")) {
+  if (unsupported2.length > 0) {
+    if (unsupported2.includes("maxRacingGroups")) {
       throw new Error(
         "[MFU reassembly] maxRacingGroups was removed; reliable MoQ completion is transport-owned"
       );
     }
     throw new Error(
-      `[MFU reassembly] unsupported reliable MoQ option(s): ${unsupported.join(", ")}`
+      `[MFU reassembly] unsupported reliable MoQ option(s): ${unsupported2.join(", ")}`
     );
   }
   const startsAtRandomAccessGroup = value["startsAtRandomAccessGroup"];
@@ -17152,12 +17629,12 @@ function assertValidMfuReassemblyPolicy(policy) {
     return;
   }
   if (value["transport"] === "datagram") {
-    const unsupported = Object.keys(value).filter(
+    const unsupported2 = Object.keys(value).filter(
       (key) => key !== "transport" && key !== "deadlineMs"
     );
-    if (unsupported.length > 0) {
+    if (unsupported2.length > 0) {
       throw new Error(
-        `[MFU reassembly] unsupported datagram option(s): ${unsupported.join(", ")}`
+        `[MFU reassembly] unsupported datagram option(s): ${unsupported2.join(", ")}`
       );
     }
     assertValidDatagramDeadline(value["deadlineMs"]);
@@ -17610,9 +18087,21 @@ var IsoBmffTimingResolver = class {
   }
   #track = null;
   #fragments = /* @__PURE__ */ new Map();
+  /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+  #firstSamples = /* @__PURE__ */ new Map();
+  /**
+   * First sample and sample count of the newest fragments whose every slot was
+   * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+   * matches the combiner, since it retires an abandoned sample as well.
+   */
+  #delivered = /* @__PURE__ */ new Map();
   #pendingSamples = 0;
   #evictedSamples = 0;
   #lastMovieFragmentRejection = null;
+  /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+  get initialized() {
+    return this.#track !== null;
+  }
   get pendingSampleCount() {
     return this.#pendingSamples;
   }
@@ -17636,7 +18125,14 @@ var IsoBmffTimingResolver = class {
     this.#track = timing;
     return true;
   }
-  addMovieFragment(mpuSequenceNumber2, data, additionalSampleLimit = this.maxPendingSamples) {
+  /**
+   * `recovered` marks an FEC-recovered copy. A recovered block hands back
+   * every FT=1 it holds, the received ones included, so a recovered copy of a
+   * fragment whose samples are all done is a duplicate: admitting it again
+   * would charge stale timing and could displace the live MPU's. A source
+   * copy is still admitted again (a rendition switch re-arms timing that way).
+   */
+  addMovieFragment(mpuSequenceNumber2, data, additionalSampleLimit = this.maxPendingSamples, recovered = false) {
     this.#lastMovieFragmentRejection = null;
     if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
       this.#lastMovieFragmentRejection = "invalid";
@@ -17662,6 +18158,8 @@ var IsoBmffTimingResolver = class {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
       );
     }
+    const delivered = recovered ? this.#delivered.get(key) : void 0;
+    if (delivered && delivered.sampleCount === parsed.samples.length && sameSample(delivered.first, parsed.samples[0])) return true;
     let freed = 0;
     while (this.#fragments.size > 0 && (this.#pendingSamples + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
       freed += this.#evictOldestFragment();
@@ -17675,6 +18173,7 @@ var IsoBmffTimingResolver = class {
       return false;
     }
     this.#fragments.set(key, [...parsed.samples]);
+    this.#firstSamples.set(key, parsed.samples[0]);
     this.#pendingSamples += parsed.samples.length;
     return true;
   }
@@ -17732,6 +18231,7 @@ var IsoBmffTimingResolver = class {
     let live = 0;
     for (const sample of samples) if (sample !== null) live++;
     this.#fragments.delete(oldest);
+    this.#firstSamples.delete(oldest);
     this.#pendingSamples -= live;
     this.#evictedSamples += live;
     return live;
@@ -17747,12 +18247,23 @@ var IsoBmffTimingResolver = class {
     if (!samples || !samples[index]) return false;
     samples[index] = null;
     this.#pendingSamples--;
-    if (samples.every((value) => value === null)) this.#fragments.delete(key);
+    if (samples.every((value) => value === null)) {
+      this.#fragments.delete(key);
+      const first = this.#firstSamples.get(key);
+      this.#firstSamples.delete(key);
+      this.#delivered.delete(key);
+      this.#delivered.set(key, { first, sampleCount: samples.length });
+      if (this.#delivered.size > this.maxPendingSamples) {
+        this.#delivered.delete(this.#delivered.keys().next().value);
+      }
+    }
     return true;
   }
   reset() {
     this.#track = null;
     this.#fragments.clear();
+    this.#firstSamples.clear();
+    this.#delivered.clear();
     this.#pendingSamples = 0;
   }
 };
@@ -18234,6 +18745,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
     this.#reclaimedTimingSamples = 0;
     this.#evictedTimingSamples = 0;
     this.#rejectedMovieFragments = 0;
+    this.#recoveredHeadsAwaitingTiming = {
+      held: 0,
+      expired: 0,
+      discarded: 0,
+      superseded: 0
+    };
     this.#sequencers = /* @__PURE__ */ new Map();
     this.#fecGate = null;
     this.#fecSequencer = null;
@@ -18342,6 +18859,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
   #reclaimedTimingSamples;
   #evictedTimingSamples;
   #rejectedMovieFragments;
+  #recoveredHeadsAwaitingTiming;
   #sequencers;
   #fecGate;
   #fecSequencer;
@@ -18462,6 +18980,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
       rejectedMovieFragments: this.#rejectedMovieFragments
     };
   }
+  /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+  get recoveredHeadsAwaitingTiming() {
+    let pending = 0;
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) if (head.options?.recovered) pending++;
+    }
+    return { ...this.#recoveredHeadsAwaitingTiming, pending };
+  }
   get reorderStats() {
     let bufferedFrames = this.#fecSequencer?.buffered ?? 0;
     for (const { sequencer } of this.#sequencers.values()) bufferedFrames += sequencer.buffered;
@@ -18590,10 +19116,10 @@ var MmtpContainerParser = class _MmtpContainerParser {
   get reassemblerDataUnitsReturned() {
     return this.#reassemblerDataUnitsReturned;
   }
-  #countOutcome(token) {
-    const count = (this.#feedOutcomes.get(token) ?? 0) + 1;
-    this.#feedOutcomes.set(token, count);
-    this.#lastOutcome = token;
+  #countOutcome(token2) {
+    const count = (this.#feedOutcomes.get(token2) ?? 0) + 1;
+    this.#feedOutcomes.set(token2, count);
+    this.#lastOutcome = token2;
     this.#lastOutcomeCount = count;
   }
   #countDeferredOutcome(reason) {
@@ -18635,7 +19161,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const now = Date.now();
     for (const { awaitingTiming } of this.#timingStreams.values()) {
       while (awaitingTiming.length > 0 && now - awaitingTiming[0].arrivedAt > timeoutMs) {
-        awaitingTiming.shift();
+        this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
       }
     }
   }
@@ -18753,11 +19279,16 @@ var MmtpContainerParser = class _MmtpContainerParser {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return this.#drop("fragment-unexpected-fragmentation");
       const resolver2 = this.#timingResolver(streamKey, info.packetId, false);
-      if (!resolver2) return this.#drop("fragment-no-resolver");
+      if (!resolver2?.initialized) return this.#drop("fragment-no-resolver");
       const pendingBefore = resolver2.pendingSampleCount;
       const evictedBefore = resolver2.evictedSampleCount;
       const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples;
-      const admitted = resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining);
+      const admitted = resolver2.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true
+      );
       this.#pendingTimingSamples += resolver2.pendingSampleCount - pendingBefore;
       this.#evictedTimingSamples += resolver2.evictedSampleCount - evictedBefore;
       if (!admitted) {
@@ -18777,7 +19308,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
       };
     }
     if (fragmentType !== 2) return this.#drop("unknown-fragment-type");
-    const resolver = this.#timingResolver(streamKey, info.packetId, false);
+    const resolver = this.#timingResolver(streamKey, info.packetId, true);
     if (!resolver) return this.#drop("mfu-no-resolver");
     if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
       return this.#drop("mfu-empty-payload");
@@ -18798,6 +19329,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now()
         });
         return this.#drop("mfu-sample-timing-missing");
@@ -19121,6 +19653,10 @@ var MmtpContainerParser = class _MmtpContainerParser {
     }
     this.#emitFrame(data, meta);
   }
+  /** Whether FT=1 metadata already names this sample, without claiming it. */
+  hasAuthoredTimingFor(packetId, mpuSequenceNumber2, movieFragmentSequenceNumber, sampleNumber, catalogTrackName) {
+    return this.#timingResolver(this.#streamKey(packetId, catalogTrackName), packetId, false)?.sampleTiming(mpuSequenceNumber2, movieFragmentSequenceNumber, sampleNumber) != null;
+  }
   /**
    * Claim and return the authored timing for a recovered sample. Recovery does
    * not pass through the ordinary `feed()` completion path, so it must retire
@@ -19182,6 +19718,9 @@ var MmtpContainerParser = class _MmtpContainerParser {
     for (const { sequencer } of this.#sequencers.values()) sequencer.discard();
     this.#sequencers.clear();
     this.#fecSequencer?.discard();
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
+    }
     this.#timingStreams.clear();
     this.#pendingTimingSamples = 0;
     this.#reliableMoqStartupGate.clear();
@@ -19200,10 +19739,23 @@ var MmtpContainerParser = class _MmtpContainerParser {
     return resolver;
   }
   #awaitTiming(streamKey, head) {
-    const awaitingTiming = this.#timingStreams.get(streamKey)?.awaitingTiming;
-    if (!awaitingTiming) return;
+    const state = this.#timingStreams.get(streamKey);
+    if (!state) return;
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter((queued) => !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber);
+      this.#recoveredHeadsAwaitingTiming.superseded += state.awaitingTiming.length - kept.length;
+      state.awaitingTiming = kept;
+    }
+    const awaitingTiming = state.awaitingTiming;
     awaitingTiming.push(head);
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift();
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming.held++;
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
+    }
+  }
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  #leaveAwaitingTiming(head, outcome) {
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming[outcome]++;
   }
   /**
    * Feed again the heads whose timing the FT=1 just admitted declares. That
@@ -19231,6 +19783,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const state = this.#timingStreams.get(streamKey);
     if (!state) return;
     this.#timingStreams.delete(streamKey);
+    for (const head of state.awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
     this.#pendingTimingSamples -= state.resolver.pendingSampleCount;
     if (this.#pendingTimingSamples < 0) {
       throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");
@@ -22437,6 +22990,16 @@ function keyframeOverlaySsId(header) {
   if (ext?.type !== KEYFRAME_OVERLAY_EXTENSION_TYPE || ext.data.length !== 4) return void 0;
   return new DataView(ext.data.buffer, ext.data.byteOffset, 4).getUint32(0);
 }
+function overlayBaseSsId(anchor, overlaySsId, restoredPsn, headerPsn) {
+  if (anchor.baseSsId === void 0 || headerPsn !== restoredPsn) return void 0;
+  return serial32Add(anchor.baseSsId, overlaySsId - anchor.overlaySsId | 0);
+}
+function unstampedBaseSsId(offset, unstampedOffset, headerPsn) {
+  if (offset === void 0 || offset !== unstampedOffset) return void 0;
+  return headerPsn + offset >>> 0;
+}
+var OVERLAY_ROUTED_LIMIT = 1024;
+var OVERLAY_PENDING_LIMIT = 256;
 var OVERLAY_OFFSET_MPUS = 16;
 var OVERLAY_MOQ_HORIZON_BLOCKS = 64;
 function assertStreamIdentity(role, stream) {
@@ -22604,6 +23167,14 @@ var MmtpRouter = class {
    * sequence is its SS_ID minus this; see #routeProcessedFecSymbols.
    */
   #ssIdSeqOffsetByStream = /* @__PURE__ */ new Map();
+  /**
+   * Per stream, the SS_ID offset at which a base recovery last showed the
+   * sender's own packet_sequence_number: a recovered packet's header psn
+   * equal to its SS_ID minus that offset. While it equals the stream's
+   * current offset, no hop re-stamps the stream and a packet's protected psn
+   * names its base SS_ID (joint decoding of an MPU no member of which arrived).
+   */
+  #unstampedSsIdSeqOffsetByStream = /* @__PURE__ */ new Map();
   /**
    * Streams whose multicast leg delivered a RAP-flagged source packet that was
    * not parsed, typically because its overlap copy was parsed first
@@ -22673,7 +23244,9 @@ var MmtpRouter = class {
     recovered: 0,
     restarts: 0,
     unsequencedDropped: 0,
-    protectedDropped: 0
+    protectedDropped: 0,
+    baseFed: 0,
+    baseUndetermined: 0
   };
   /** Callback fired when a delta-track FEC block completes or fails. */
   #onDeltaBlockCompleteCb = null;
@@ -22846,7 +23419,7 @@ var MmtpRouter = class {
     const cb = this.#getFrameCallback(packetId);
     if (isVideo && !assembler) {
       if (frameMeta.recovered) {
-        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb);
+        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb, meta.fecSbn);
       } else {
         this.#routeDirectSourceVideo(packetId, data, frameMeta, cb);
       }
@@ -23236,6 +23809,10 @@ var MmtpRouter = class {
   get keyframeOverlayStats() {
     return { ...this.#overlayStats };
   }
+  /** Recovered FT=2 heads held for their FT=1, and how each left the wait (BLO-53369). */
+  get recoveredHeadsAwaitingTiming() {
+    return this.#parser.recoveredHeadsAwaitingTiming;
+  }
   #isOverlayRepair(repairPacketId, repairTrackName) {
     return this.#overlayLegs.has(repairPacketId) || repairTrackName !== void 0 && this.#overlayRepairNames.has(repairTrackName);
   }
@@ -23286,6 +23863,11 @@ var MmtpRouter = class {
    */
   resetKeyframeOverlays(sourcePacketId, catalogTrackName) {
     for (const inst of this.#overlaysForSource(sourcePacketId, catalogTrackName)) this.#resetOverlay(inst);
+    for (const [name, stream] of this.#streams.get(sourcePacketId) ?? []) {
+      if (catalogTrackName !== void 0 && name !== catalogTrackName) continue;
+      stream.overlayToBase.routed.clear();
+      stream.overlayToBase.pending.clear();
+    }
   }
   #resetOverlay(inst) {
     inst.fec.resetTrack(inst.repairPacketId, inst.streamName);
@@ -23342,9 +23924,10 @@ var MmtpRouter = class {
    * A source packet that carries a 0x8B01 overlay SS_ID is also a symbol of
    * every overlay installed for its source, at that SS_ID, with the bytes the
    * base protects: the packet minus its 4-byte SS_ID trailer, extension
-   * included (7.1, 7.4.3).
+   * included (7.1, 7.4.3). `baseSsId` is that trailer's SS_ID, when the base
+   * FEC reads it.
    */
-  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source) {
+  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source, baseSsId) {
     if (this.#overlays.size === 0) return;
     const ssId = keyframeOverlaySsId(header);
     if (ssId === void 0) return;
@@ -23353,7 +23936,11 @@ var MmtpRouter = class {
       const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
       if (identity !== null) {
         inst.offsets.delete(identity.mpuSequenceNumber);
-        inst.offsets.set(identity.mpuSequenceNumber, ssId - sequenceNumber >>> 0);
+        inst.offsets.set(identity.mpuSequenceNumber, {
+          psnOffset: ssId - sequenceNumber >>> 0,
+          overlaySsId: ssId,
+          ...baseSsId === void 0 ? {} : { baseSsId }
+        });
         if (inst.offsets.size > OVERLAY_OFFSET_MPUS) inst.offsets.delete(inst.offsets.keys().next().value);
       }
       const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -23432,14 +24019,27 @@ var MmtpRouter = class {
     const streamKey = this.#mediaStreamKey(sourcePacketId, sourceName);
     const restamped = this.#restampedStreams.has(streamKey);
     const restored = /* @__PURE__ */ new Set();
+    const baseSsIds = /* @__PURE__ */ new Map();
     const symbols = result.symbols.flatMap((sym) => {
-      const offset = inst.offsets.get(sym.fragment.mpuSequenceNumber);
-      if (offset !== void 0) {
-        const packetSequenceNumber = serial32Add(blockStart, sym.index) - offset >>> 0;
+      const anchor = inst.offsets.get(sym.fragment.mpuSequenceNumber);
+      if (anchor !== void 0) {
+        const overlaySsId = serial32Add(blockStart, sym.index);
+        const packetSequenceNumber = overlaySsId - anchor.psnOffset >>> 0;
         restored.add(packetSequenceNumber);
-        return [{ ...sym, packetSequenceNumber }];
+        const out = { ...sym, packetSequenceNumber };
+        const baseSsId = overlayBaseSsId(anchor, overlaySsId, packetSequenceNumber, sym.packetSequenceNumber);
+        if (baseSsId !== void 0) baseSsIds.set(out, baseSsId);
+        return [out];
+      }
+      if (!restamped) {
+        const baseSsId = unstampedBaseSsId(
+          this.#ssIdSeqOffsetByStream.get(streamKey),
+          this.#unstampedSsIdSeqOffsetByStream.get(streamKey),
+          sym.packetSequenceNumber
+        );
+        if (baseSsId !== void 0) baseSsIds.set(sym, baseSsId);
+        return [sym];
       }
-      if (!restamped) return [sym];
       this.#overlayStats.unsequencedDropped++;
       return [];
     });
@@ -23448,6 +24048,85 @@ var MmtpRouter = class {
       deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast"
     });
     this.#noteOverlayRecoveredRaps(sourcePacketId, sourceName, streamKey, symbols.filter((sym) => restored.has(sym.packetSequenceNumber)));
+    this.#feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds);
+  }
+  /**
+   * Joint decoding (BLO-52085). A packet the overlay rebuilt is a source of
+   * its base block too, once its base SS_ID is determined (overlayBaseSsId,
+   * from a received member of its MPU, else unstampedBaseSsId),
+   * so it is fed to the base decoder as a rebuilt source
+   * (FECManager.feedRebuiltSourceSymbol): the base block has one erasure
+   * fewer to solve, and its repair can recover the block's other packets.
+   * A base block no repair has stated yet takes it when one does
+   * (#feedPendingRebuilt).
+   *
+   * The overlay route already handled each packet fed (delivered it, or
+   * held an untimed head for its FT=1), so a base recovery routes none of
+   * them again (#routeVerifiedFecSymbols): a second recovered copy of a
+   * held head would wait in the parser for timing its first copy consumed.
+   * Only an overlay block decoded from multicast symbols alone is fed: with
+   * a MoQ symbol in it, the base block's recovery would depend on bytes
+   * that crossed no multicast socket, which the provenance counted from the
+   * block's own arrivals cannot show.
+   */
+  #feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds) {
+    const fec = this.#fecManager;
+    const owner = inst.leg.sourcePacketId;
+    const name = inst.leg.sourceCatalogTrackName;
+    if (!fec?.feedRebuiltSourceSymbol || inst.moqBlocks.has(blockStart)) return;
+    if (this.#classifyPacketId(owner) === null || fec.isTrackConfigured?.(owner) === false) return;
+    const { duplicates, overlayToBase: { routed } } = this.#stream(owner, name);
+    const feeds = [];
+    for (const sym of symbols) {
+      if (duplicates.sourceSeqs.has(sym.packetSequenceNumber)) continue;
+      const ssId = baseSsIds.get(sym);
+      if (ssId === void 0) {
+        this.#overlayStats.baseUndetermined++;
+        continue;
+      }
+      routed.delete(ssId);
+      routed.add(ssId);
+      if (routed.size > OVERLAY_ROUTED_LIMIT) routed.delete(routed.values().next().value);
+      feeds.push([ssId, sym.rawSymbol]);
+    }
+    for (const [ssId, symbolData] of feeds) {
+      if (this.#classifyPacketId(owner) === null) return;
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
+  }
+  /** Feed one rebuilt source to its base block, or keep it until a repair states that block. */
+  #feedRebuiltToBase(owner, name, ssId, symbolData) {
+    const fec = this.#fecManager;
+    if (!fec?.feedRebuiltSourceSymbol) return;
+    const coords = fec.locateIsoSource?.(owner, name, ssId);
+    if (coords == null) {
+      const pending = this.#stream(owner, name).overlayToBase.pending;
+      pending.delete(ssId);
+      pending.set(ssId, symbolData.slice());
+      if (pending.size > OVERLAY_PENDING_LIMIT) pending.delete(pending.keys().next().value);
+      return;
+    }
+    const fed = fec.feedRebuiltSourceSymbol(owner, ssId, symbolData, name);
+    if (!fed.taken) return;
+    this.#overlayStats.baseFed++;
+    if (fed.recovered === null) return;
+    const sbn = coords.sbn;
+    this.#routeRecoveredBlock(sbn, fed.recovered, owner, name, () => {
+      fec.cancelBlockTimeout(sbn, owner, name);
+      fec.countRecovery(owner, sbn, name);
+      fec.markBlockCompleted(sbn, owner, name);
+    });
+  }
+  /** A repair stated `block`: the rebuilt sources that waited for it join it now. */
+  #feedPendingRebuilt(owner, name, block) {
+    const pending = this.#streams.get(owner)?.get(name)?.overlayToBase.pending;
+    if (pending === void 0 || pending.size === 0) return;
+    for (const [ssId, symbolData] of [...pending]) {
+      if (this.#classifyPacketId(owner) === null) return;
+      if (serial32Distance(block.start, ssId) >= block.length) continue;
+      pending.delete(ssId);
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
   }
   /** fec-multicast-00 §6.6: report each base block whose RAP MFU fragments
    *  the overlay restored, when the keyframe's FT=0 and FT=1 are held too. A
@@ -23579,10 +24258,11 @@ var MmtpRouter = class {
     if (!entry) return;
     entry.receiver.release();
     entry.protected = false;
+    entry.userAgent = false;
     this.#assistBlocks.clear();
     this.#assistFailures.clear();
   }
-  /** MoQ packets of a track a protected flow lists, dropped on its unicast path: duplicate, overflow, or listed by more than one flow. */
+  /** Packets of a track a protected flow lists, dropped unread: a MoQ copy (duplicate, overflow, or listed by more than one flow) or a multicast source datagram that names no flow, of a track a user-agent-admitted flow lists. */
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
@@ -23623,6 +24303,13 @@ var MmtpRouter = class {
     }
     return false;
   }
+  /** Whether a protected flow the user agent admitted lists `packetId`. */
+  #userAgentGoverns(packetId) {
+    for (const entry of this.#provenance.values()) {
+      if (entry.protected && entry.userAgent && ingressHasPacketId(entry.ingress, packetId)) return true;
+    }
+    return false;
+  }
   /**
    * A MoQ repair symbol no protected flow lists, owned by a source track one
    * does: its FEC instance is governed (7.2.7 step 2) and takes only admitted
@@ -23713,7 +24400,7 @@ var MmtpRouter = class {
       fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
       fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
       fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-    })) {
+    }, true)) {
       this.#unlistedAssistedRecoveries++;
       this.#assistBlocks.delete(key);
       return;
@@ -24065,6 +24752,8 @@ var MmtpRouter = class {
     )) return;
     fec.noteBlockActivity?.(blockStart, ownerPacketId, catalogTrackName);
     fec.noteRepairGroupLength?.(blockStart, ownerPacketId, repair.rsbLength, catalogTrackName);
+    this.#feedPendingRebuilt(ownerPacketId, catalogTrackName, placement.block);
+    if (this.#classifyPacketId(ownerPacketId) === null) return;
     const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
     const recovered = fec.feedRepairSymbol(
       ownerPacketId,
@@ -24202,6 +24891,7 @@ var MmtpRouter = class {
     this.#droppedPreSyncVideo.delete(streamKey);
     this.#latestVideoSeqByStream.delete(streamKey);
     this.#ssIdSeqOffsetByStream.delete(streamKey);
+    this.#unstampedSsIdSeqOffsetByStream.delete(streamKey);
     this.#multicastRapTwinByStream.delete(streamKey);
     this.#lastDirectSourceVideoTsByStream.delete(streamKey);
     this.#lastDirectEmittedVideoTsByStream.delete(streamKey);
@@ -24869,6 +25559,12 @@ var MmtpRouter = class {
         debugRouter(`[MmtpRouter] Dropping multicast packet pid=${info.packetId}: flow ${ingress.flow} has no receiver`);
         return;
       }
+      if (ingress.admittedBy === USER_AGENT_VERIFIED) {
+        this.#noteFlowAdmitted(ingress.flow);
+        protectedFlow.userAgent = true;
+        this.#processMMTP(packet, source, true, ingress, overlapCopy);
+        return;
+      }
       const { verdict } = protectedFlow.receiver.onDatagram(packet, "multicast");
       if (verdict === "admitted") {
         this.#noteFlowAdmitted(ingress.flow);
@@ -24886,6 +25582,11 @@ var MmtpRouter = class {
         return;
       }
     }
+    const flowless = source === "multicast" && !manifestAdmitted && ingress?.flow === void 0;
+    if (flowless && !info.isRepair && this.#userAgentGoverns(info.packetId)) {
+      this.#unadmittedListedDrops++;
+      return;
+    }
     if (info.isRepair) {
       const overlay = this.#overlayRepairTarget(info.packetId, catalogTrackNameForPacket(ingress, info.packetId));
       if (overlay !== void 0) {
@@ -24903,7 +25604,7 @@ var MmtpRouter = class {
       );
       if (!repair) return;
       if (ownerPacketId != null && this.#fecManager) {
-        if (source === "moq" && !manifestAdmitted && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
+        if ((flowless && this.#userAgentGoverns(ownerPacketId) || source === "moq" && !manifestAdmitted) && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
         this.#repairPidCounts[info.packetId] = (this.#repairPidCounts[info.packetId] || 0) + 1;
         const count = this.#repairPidCounts[info.packetId];
         if (count <= 2 || count % 500 === 0) {
@@ -25106,7 +25807,8 @@ var MmtpRouter = class {
           parsed.header,
           info.sequenceNumber,
           info.rapFlag,
-          source
+          source,
+          fecPayloadId?.ssId
         );
       }
     }
@@ -25256,7 +25958,8 @@ var MmtpRouter = class {
     if (stream === void 0) {
       stream = {
         key: JSON.stringify([packetId, catalogTrackName ?? null]),
-        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId))
+        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId)),
+        overlayToBase: { routed: /* @__PURE__ */ new Set(), pending: /* @__PURE__ */ new Map() }
       };
       byName.set(catalogTrackName, stream);
     }
@@ -25371,8 +26074,16 @@ var MmtpRouter = class {
     this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
     this.#emitDirectVideo(packetId, data, meta, cb);
   }
-  #routeDirectRecoveredVideo(packetId, data, meta, cb) {
+  #routeDirectRecoveredVideo(packetId, data, meta, cb, fecSbn) {
     const streamKey = this.#mediaStreamKey(packetId, meta.catalogTrackName);
+    if (this.#isFecTrack(packetId)) {
+      const high = this.#deliveredVideoHighWaterByStream.get(streamKey);
+      if (fecSbn !== void 0 || high !== void 0 && authoredAdjacent(high, meta)) {
+        this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
+        this.#emitDirectVideo(packetId, data, meta, cb);
+        return;
+      }
+    }
     this.#enqueueDirectRecoveredVideo(packetId, data, meta);
     const lastSourceTs = this.#lastDirectSourceVideoTsByStream.get(streamKey);
     this.#drainDirectRecoveredVideo(
@@ -25482,7 +26193,7 @@ var MmtpRouter = class {
   }
   // ── Private: FEC recovery routing ───────────────────────────────
   /** Route WASM-recovered block through appropriate path based on container kind. */
-  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete) {
+  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete, assisted = false) {
     const packetSymbolSize = this.#symbolSizeForPacket(ownerPacketId);
     if (ownerPacketId === void 0) {
       throw new Error("[MmtpRouter] a recovered FEC block needs its owner packetId to read its fec.blockProfile");
@@ -25499,7 +26210,7 @@ var MmtpRouter = class {
       ownerPacketId,
       blockProfile
     });
-    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete);
+    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted);
   }
   /**
    * A recovered source packet of a protected flow is admitted on its own
@@ -25511,9 +26222,31 @@ var MmtpRouter = class {
    * recovered packets is refused is unrecovered (7.2.7): its caller leaves it
    * open, so it reaches its FEC deadline and fails by class. Always true
    * outside a protected flow.
-   */
-  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete) {
-    const receiver = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
+   *
+   * On a flow the user agent admitted, the live decoder's recoveries are kept
+   * without a record: while the flow is protected that decoder takes only
+   * symbols the user agent or a record verified (a flow-less multicast
+   * datagram of a listed track is dropped or set aside in #processMMTP), so
+   * what it recovers is as verified as they are. An `assisted` (scratch-decoder) recovery mixes in
+   * unlisted MoQ repair and still needs a record.
+   * ponytail: per-flow flag; per-block provenance only if a protected flow
+   * ever mixes verified and unverified live inputs.
+   * ponytail: a worker frame computed before the protection reset can still
+   * arrive after it (frames carry no epoch); its inputs are MoQ copies read
+   * and played before protection, so it admits nothing new. Drop pre-reset
+   * frames by epoch only if pre-protection input ever matters.
+   */
+  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted = false) {
+    const overlayRouted = ownerPacketId == null ? void 0 : this.#streams.get(ownerPacketId)?.get(catalogTrackName)?.overlayToBase.routed;
+    if (overlayRouted !== void 0 && overlayRouted.size > 0) {
+      result = {
+        ...result,
+        symbols: result.symbols.filter((sym) => !overlayRouted.has(this.#fecAnchorForRecovered(blockId, sym.index)))
+      };
+    }
+    const entry = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
+    const receiver = entry === void 0 || entry === "ambiguous" ? entry : entry.receiver;
+    const userAgent = !assisted && entry !== void 0 && entry !== "ambiguous" && entry.protected === true && entry.userAgent === true;
     let recovered = true;
     if (receiver) {
       const parsed = this.#stream(ownerPacketId, catalogTrackName).duplicates.parsedSymbols;
@@ -25525,6 +26258,8 @@ var MmtpRouter = class {
           let admitted = false;
           if (receiver === "ambiguous") {
             this.#ambiguousRecoveredDrops++;
+          } else if (userAgent) {
+            admitted = true;
           } else {
             const wire = new Uint8Array(sym.rawSymbol.byteLength + 4);
             wire.set(sym.rawSymbol);
@@ -25552,12 +26287,12 @@ var MmtpRouter = class {
       catalogTrackName === void 0 || !byName ? byName?.values() : byName.has(catalogTrackName) ? [byName.get(catalogTrackName)] : []
     );
     if (flows.size > 1) return "ambiguous";
-    for (const bound of flows) return this.#provenance.get(bound)?.receiver ?? "ambiguous";
+    for (const bound of flows) return this.#provenance.get(bound) ?? "ambiguous";
     let match;
-    for (const { receiver, ingress } of this.#provenance.values()) {
-      if (ingress.tracks.some((t) => t.packetId === packetId && (catalogTrackName === void 0 || t.name === catalogTrackName))) {
+    for (const entry of this.#provenance.values()) {
+      if (entry.ingress.tracks.some((t) => t.packetId === packetId && (catalogTrackName === void 0 || t.name === catalogTrackName))) {
         if (match) return "ambiguous";
-        match = receiver;
+        match = entry;
       }
     }
     return match;
@@ -25573,7 +26308,10 @@ var MmtpRouter = class {
         ...result,
         symbols: result.symbols.map((sym) => {
           const wire = this.#fecAnchorForRecovered(blockId, sym.index) - ssIdSeqOffset >>> 0;
-          if (wire === sym.packetSequenceNumber) return sym;
+          if (wire === sym.packetSequenceNumber) {
+            this.#unstampedSsIdSeqOffsetByStream.set(streamKey, ssIdSeqOffset);
+            return sym;
+          }
           this.#restampedRecoveredSeqs++;
           this.#restampedStreams.add(streamKey);
           return { ...sym, packetSequenceNumber: wire };
@@ -25609,6 +26347,29 @@ var MmtpRouter = class {
         }
       );
     }
+    const untimedHead = (sym) => sym.fragmentType === 2 && sym.fragment.fragmentationIndicator === 1 && sym.fragment.movieFragmentSequenceNumber !== void 0 && sym.fragment.sampleNumber !== void 0 && !this.#parser.hasAuthoredTimingFor(
+      ownerPacketId,
+      sym.fragment.mpuSequenceNumber,
+      sym.fragment.movieFragmentSequenceNumber,
+      sym.fragment.sampleNumber,
+      catalogTrackName
+    );
+    for (const sym of result.symbols) {
+      if (!untimedHead(sym) || this.#sourceSeqReceived(ownerPacketId, sym.packetSequenceNumber, catalogTrackName)) continue;
+      this.#feedViaParser(
+        sym.rawSymbol,
+        { packetId: ownerPacketId, sequenceNumber: sym.packetSequenceNumber },
+        void 0,
+        {
+          skipFecPayloadId: true,
+          recovered: true,
+          deliveryProvenance,
+          ...fecSbnOf(sym.index),
+          ...catalogTrackName === void 0 ? {} : { catalogTrackName }
+        }
+      );
+    }
+    result = { ...result, symbols: result.symbols.filter((sym) => !untimedHead(sym)) };
     const gated = this.#isFecTrack(ownerPacketId);
     const assembler = this.#mseAssemblerFor(ownerPacketId, catalogTrackName);
     if (assembler) {
@@ -26339,11 +27100,8 @@ function providerErrorOf(error) {
   return Object.freeze(typeof code === "string" ? { name, message, code } : { name, message });
 }
 var MAX_TRACKED_DROPPED_PIDS = 16;
-function getMulticastGlobals() {
-  return globalThis;
-}
 function hasMulticastGateway() {
-  return typeof getMulticastGlobals().multicast?.subscribe === "function";
+  return typeof resolveMulticastGateway()?.subscribe === "function";
 }
 function senderOf(event) {
   const sourceAddress = event.sourceAddress;
@@ -26435,6 +27193,9 @@ var MulticastTransport = class {
   // listener closure, so an in-place admission change (setContext) applies
   // from the next packet on without rejoining.
   #context = void 0;
+  #deliveredContext = void 0;
+  /** The live join's gateway, when it is the user agent's MulticastReceiver provider. */
+  #userAgentGateway = void 0;
   // The live join's provider-side filter. An in-place widening must reach it,
   // or the provider never delivers the new ID; null without a live join.
   #providerFilter = null;
@@ -26471,7 +27232,7 @@ var MulticastTransport = class {
     this.#dataPlaneLive = false;
     this.#sender = void 0;
     if (this.#disposed) return this.#declined(generation, "disposed");
-    const gateway = this.#gateway ?? getMulticastGlobals().multicast;
+    const gateway = this.#gateway ?? resolveMulticastGateway();
     if (typeof gateway?.subscribe !== "function") {
       console.warn("[MulticastTransport] Multicast API not available");
       return this.#declined(generation, "unavailable");
@@ -26487,15 +27248,16 @@ var MulticastTransport = class {
       console.log(
         `[MulticastTransport] window.multicast.subscribe(${config.sourceAddress ?? config.senderAddress ?? "*"}, ${config.groupAddress}, ${config.port})`
       );
+      const userAgent = isUserAgentVerifiedGateway(gateway);
       const subscribeConfig = toWindowMulticastSubscribeConfig({
         source: config.sourceAddress,
         senderAddress: config.senderAddress,
         group: config.groupAddress,
         port: config.port,
-        mode: config.mode,
-        amtRelay: config.amtRelay,
-        amtRelayPort: config.amtRelayPort,
-        amtDiscovery: config.amtDiscovery,
+        mode: userAgent ? "native" : config.mode,
+        amtRelay: userAgent ? void 0 : config.amtRelay,
+        amtRelayPort: userAgent ? void 0 : config.amtRelayPort,
+        amtDiscovery: userAgent ? void 0 : config.amtDiscovery,
         packetIds: config.packetIds,
         tracks: config.tracks,
         atsc3: config.atsc3
@@ -26541,7 +27303,8 @@ var MulticastTransport = class {
         acknowledgedUpdate: 0,
         inFlight: 0
       };
-      this.#context = context;
+      this.#userAgentGateway = userAgent ? gateway : void 0;
+      this.#setContext(context);
       if (packetIds) {
         for (const packetId of packetIds) {
           if (!this.#acceptedBytesByPacketId.has(packetId)) {
@@ -26549,7 +27312,7 @@ var MulticastTransport = class {
           }
         }
       }
-      this.#resolvedTransport = subscribeConfig.origin === "amt" ? "amt" : "native";
+      this.#resolvedTransport = userAgent ? "user-agent" : subscribeConfig.origin === "amt" ? "amt" : "native";
       const delivery = subscription.delivery ?? "datagram";
       if (delivery !== "datagram" && delivery !== "ordered-relay") {
         throw new Error(
@@ -26630,7 +27393,7 @@ var MulticastTransport = class {
     }
     if (!this.#acceptPacket(packet, sourceAddress)) return false;
     const liveness = !this.#isRecordCandidate(packet);
-    this.#onPacket(packet, this.#context);
+    this.#onPacket(packet, this.#deliveredContext);
     return liveness;
   }
   #isRecordCandidate(packet) {
@@ -26841,8 +27604,10 @@ var MulticastTransport = class {
     return this.#subscription !== null;
   }
   /**
-   * What the live join delivers with every accepted packet (the join's
-   * `context`, or the last setContext), or undefined without a live join.
+   * The live join's context as the caller gave it (the join's `context`, or
+   * the last setContext), or undefined without a live join. On a native
+   * provider each accepted packet is delivered with a marked copy of it
+   * (`userAgentVerifiedIngress`); this getter never carries the mark.
    */
   get context() {
     return this.#context;
@@ -26866,7 +27631,16 @@ var MulticastTransport = class {
         "[MulticastTransport] setContext needs a live join; join() carries the first context"
       );
     }
+    this.#setContext(context);
+  }
+  /**
+   * The join's context, and what the subscription delivers with each packet:
+   * marked admitted by the user agent when the gateway is its native
+   * MulticastReceiver provider. feedPacket never marks.
+   */
+  #setContext(context) {
     this.#context = context;
+    this.#deliveredContext = this.#userAgentGateway !== void 0 && typeof context === "object" && context !== null ? userAgentVerifiedIngress(context, this.#userAgentGateway) : context;
   }
   /**
    * Replace the live join's packet-ID allow-list in place, without rejoining.
@@ -26998,6 +27772,8 @@ var MulticastTransport = class {
     this.#matchedSource = void 0;
     this.#providerFilter = null;
     this.#context = void 0;
+    this.#deliveredContext = void 0;
+    this.#userAgentGateway = void 0;
     this.#withdrawnPacketIds.clear();
   }
   /** The ingress filter; an accepted packet is counted here, once. */
@@ -28350,8 +29126,17 @@ var MulticastManager = class {
    * repair roles and owners are registered here; in-band owners stay the
    * caller's. Joining is best effort: a group that fails to join is logged
    * and leaves the media join as it was.
-   */
-  joinRepairEndpoints(endpoints, provider) {
+   *
+   * `options.gateway` names the gateway a subscribe callback reads through.
+   * When it is the browser's own MulticastReceiver provider, the callback's
+   * packets are fed as admitted by the user agent
+   * (`userAgentVerifiedIngress`); nothing the callback passes can mark them.
+   * The mark rests on this statement, not on the data path: every packet the
+   * callback delivers must come from a subscription opened on
+   * `options.gateway`. A callback that also merges another source (a MoQ or
+   * WebSocket repair feed) must not name a native provider here.
+   */
+  joinRepairEndpoints(endpoints, provider, options) {
     const releases = [];
     let released = false;
     const safely = (each) => {
@@ -28373,17 +29158,19 @@ var MulticastManager = class {
         ...endpoint.flow === void 0 ? {} : { flow: endpoint.flow }
       };
       let sender;
-      const onPacket = (packet, sourceAddress) => {
+      const feed = (packet, sourceAddress, ingressToFeed) => {
         if (released) return;
         if (sourceAddress !== void 0 && !sameDatagramSource(sourceAddress, this.#transport.sender ?? (sender ??= sourceAddress))) return;
-        this.#router.feedPacket(packet, "multicast", ingress);
+        this.#router.feedPacket(packet, "multicast", ingressToFeed);
       };
       const fail = (error) => console.warn(`[MulticastManager] repair group ${endpoint.group}:${endpoint.port} not joined`, error);
       if (typeof provider === "function") {
+        const marked = userAgentVerifiedIngress(ingress, options?.gateway);
+        const onPacket = (packet, sourceAddress) => feed(packet, sourceAddress, marked);
         Promise.resolve().then(() => provider(endpoint, onPacket)).then((release2) => released ? safely(release2) : releases.push(release2), fail);
         continue;
       }
-      const transport = new MulticastTransport((packet) => onPacket(packet), {
+      const transport = new MulticastTransport((packet, delivered) => feed(packet, void 0, delivered ?? ingress), {
         gateway: provider,
         lockedTo: () => this.#transport.sender
       });
@@ -28395,11 +29182,12 @@ var MulticastManager = class {
         mode: endpoint.mode,
         amtRelay: endpoint.amtRelay,
         amtRelayPort: endpoint.amtRelayPort ?? (endpoint.amtRelay?.trim() ? DEFAULT_AMT_RELAY_PORT : void 0),
+        amtDiscovery: endpoint.amtDiscovery,
         packetIds: endpoint.packetIds,
         tracks: endpoint.tracks.map(({ name, packetId }) => ({ name, packetId })),
         // A protected repair group's records ride in band on its port (7.2.3).
         ...endpoint.flow === void 0 ? {} : { protected: true }
-      }).then((joined) => {
+      }, ingress).then((joined) => {
         if (!joined && !released) fail(transport.lastJoinOutcome);
       });
     }
@@ -29343,7 +30131,7 @@ async function setupFecWorkerForTrack(opts) {
     blockProfile,
     k: opts.fecK,
     // P as this receiver joined it, not the catalog total: the worker snapshot
-    // and CMCD `x-bc-fec-p` are read from this. Identity on a single layer.
+    // and CMCD `com.blockcast-fp` are read from this. Identity on a single layer.
     repairCount: opts.joinedRepairCount ?? opts.fecRepairCount,
     symbolSize: opts.fecSymbolSize,
     interleaveDepth: interleaveDepthBlocks,
@@ -29885,24 +30673,24 @@ var MediaRouter = class {
     if (!this.#multicastVideoKeyed) return;
     if (this.#requireAudio && !this.#multicastAudioReceived) return;
     if (this.#requireAudio && !this.#moqAudioWarmed) return;
-    const token = ++this.#sourceSwitchToken;
+    const token2 = ++this.#sourceSwitchToken;
     const maybeReady = this.#onSourceSwitch?.("multicast");
     if (!maybeReady || typeof maybeReady.then !== "function") {
-      this.#commitMulticastActivation(token);
+      this.#commitMulticastActivation(token2);
       return;
     }
     const ready = Promise.resolve(maybeReady);
-    this.#pendingMulticastToken = token;
+    this.#pendingMulticastToken = token2;
     this.#sourceSwitchReady = ready;
     void ready.then(
-      () => this.#commitMulticastActivation(token),
-      (err) => this.#rejectMulticastActivation(token, err)
+      () => this.#commitMulticastActivation(token2),
+      (err) => this.#rejectMulticastActivation(token2, err)
     ).finally(() => {
       if (this.#sourceSwitchReady === ready) this.#sourceSwitchReady = null;
     });
   }
-  #commitMulticastActivation(token) {
-    if (token !== this.#sourceSwitchToken) return;
+  #commitMulticastActivation(token2) {
+    if (token2 !== this.#sourceSwitchToken) return;
     this.#active = "multicast";
     this.#suppressed = true;
     this.#pendingMulticastToken = null;
@@ -29913,9 +30701,9 @@ var MediaRouter = class {
     if (video) this.#onVideoFrame?.(video.data, video.meta);
     if (audio) this.#onAudioFrame?.(audio.data, audio.meta);
   }
-  #rejectMulticastActivation(token, err) {
-    if (token !== this.#sourceSwitchToken) return;
-    if (this.#pendingMulticastToken === token) this.#pendingMulticastToken = null;
+  #rejectMulticastActivation(token2, err) {
+    if (token2 !== this.#sourceSwitchToken) return;
+    if (this.#pendingMulticastToken === token2) this.#pendingMulticastToken = null;
     this.#pendingMulticastVideo = null;
     this.#pendingMulticastAudio = null;
     console.warn("[MediaRouter] onSourceSwitch(multicast) failed", err);
@@ -30884,63 +31672,65 @@ var FecStarvationDetector = class {
 
 // src/cmcd-producer.ts
 var PLAY_MODES = ["full", "base-only", "single-track"];
-function sanitize(value) {
-  return value.replace(/[,\r\n]/g, "");
-}
-function buildFecParams(stats) {
-  const params = {};
-  const cfg = stats.config;
-  params["x-bc-fec-algo"] = cfg.algorithm;
-  params["x-bc-fec-k"] = cfg.k;
-  params["x-bc-fec-p"] = cfg.repairCount;
-  params["x-bc-fec-recovery"] = parseFloat((stats.recoveryRate / 100).toFixed(4));
-  return params;
-}
-function buildTransportParams(snap) {
-  if (!snap) return {};
-  const params = {};
-  params["x-bc-transport"] = snap.transport;
-  if (snap.multicastGroup != null) {
-    params["x-bc-multicast-group"] = snap.multicastGroup;
-  }
-  if (snap.multicastSource != null) {
-    params["x-bc-multicast-source"] = snap.multicastSource;
-  }
-  if (snap.amtRelay != null) {
-    params["x-bc-amt-relay"] = snap.amtRelay;
-  }
-  return params;
-}
-function formatQueryString(params) {
-  return Object.keys(params).sort().map((key) => {
-    const v = params[key];
-    if (typeof v === "string") return `${key}=${sanitize(v)}`;
-    return `${key}=${v}`;
+var DEFAULT_INTERVAL_MS = 3e4;
+var CUSTOM_PREFIX = "com.blockcast-";
+var MAX_CUSTOM_VALUE = 64;
+var TRANSPORT_TOKEN = {
+  native: "ssm",
+  amt: "amt",
+  moq: "moq"
+};
+function sfString(value) {
+  return `"${value.replace(/[^\x20-\x7e]/g, "").replace(/[\\"]/g, "\\$&")}"`;
+}
+function encodeCmcdRecord(record) {
+  return Object.keys(record).sort().map((key) => {
+    const value = record[key];
+    if (typeof value === "number") return `${key}=${value}`;
+    if (typeof value === "string") return `${key}=${sfString(value)}`;
+    if (Array.isArray(value)) return `${key}=(${value.map(sfString).join(" ")})`;
+    return `${key}=${value.token}`;
   }).join(",");
 }
+var token = (value) => ({ token: value });
+function putCustom(record, name, value) {
+  if (value === void 0) return;
+  if (typeof value === "number") value = String(value);
+  if (typeof value === "string" && value.length > MAX_CUSTOM_VALUE) return;
+  record[CUSTOM_PREFIX + name] = value;
+}
 var CmcdProducer = class {
-  #onCmcdParams;
   #onCmcdPost;
+  #intervalMs;
+  #sessionId;
+  #now;
+  #sn = 0;
+  #lastHeartbeat = null;
   #transport;
   #lastStats;
-  // Phase 14 state — Plan 03 Task 2 (D-12, D-15).
   #playMode = null;
   #deltaFailRate = null;
   #switchMiscount = 0;
   #manifestStats = null;
   #fecFailClosed = null;
+  /** Video-block resolutions from the repair lifecycle; null until the player feeds one. */
+  #lifecycle = null;
   constructor(options) {
-    this.#onCmcdParams = options.onCmcdParams;
     this.#onCmcdPost = options.onCmcdPost;
+    this.#intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    if (!Number.isFinite(this.#intervalMs) || this.#intervalMs <= 0) {
+      throw new Error(`[CmcdProducer] invalid intervalMs "${String(options.intervalMs)}"; expected a positive number`);
+    }
+    this.#sessionId = options.sessionId ?? globalThis.crypto.randomUUID();
+    this.#now = options.now ?? Date.now;
   }
   /** Update the stored transport state. Called by player wiring layer. */
   updateTransport(snapshot) {
     this.#transport = snapshot;
   }
   /**
-   * Set the current play-mode. Emitted as `x-bc-play-mode` on subsequent
-   * snapshots. Throws on any value outside {'full','base-only','single-track'}
-   * (CLAUDE.md: error on bad init).
+   * Set the current play-mode, reported as `com.blockcast-pm`. Throws on any
+   * value outside {'full','base-only','single-track'} (CLAUDE.md: error on bad init).
    */
   updatePlayMode(mode) {
     if (typeof mode !== "string" || !PLAY_MODES.includes(mode)) {
@@ -30951,9 +31741,8 @@ var CmcdProducer = class {
     this.#playMode = mode;
   }
   /**
-   * Set the delta-track FEC block-failure rate (0..1 inclusive). Emitted as
-   * `x-bc-delta-fail-rate` on snapshots when play-mode is 'full' or 'base-only'.
-   * Omitted on single-track streams.
+   * Set the delta-track FEC block-failure rate (0..1 inclusive), reported as
+   * `com.blockcast-dfr` when play-mode is 'full' or 'base-only'.
    */
   updateDeltaFailRate(rate) {
     if (typeof rate !== "number" || !Number.isFinite(rate) || rate < 0 || rate > 1) {
@@ -30963,112 +31752,139 @@ var CmcdProducer = class {
     }
     this.#deltaFailRate = rate;
   }
-  /**
-   * Bump the cumulative switching-set misalignment counter. Emitted as
-   * `x-bc-switch-miscount` on snapshots when the counter is > 0.
-   */
+  /** Bump the cumulative switching-set misalignment counter (`com.blockcast-sm`). */
   incrementSwitchMiscount() {
     this.#switchMiscount += 1;
   }
   /**
-   * Record that FEC failed closed at runtime (fec-01 6.3.9). Every later
-   * snapshot carries `x-bc-fec-fail-closed` (the reason code) and
-   * `x-bc-fec-fail-layer` (the held layer i whose total B_i was undercut), so a
-   * stream playing without FEC is told apart from one with no loss.
+   * Record that FEC failed closed at runtime (fec-01 6.3.9). Reported at once
+   * as `e=e` with the reason code in `ec`, and on every later counter report
+   * as `com.blockcast-ffc` / `com.blockcast-ffl` (the held layer whose total
+   * B_i was undercut), so a stream playing without FEC is told apart from one
+   * with no loss.
    */
   updateFecFailClosed(reason) {
+    const changed = this.#fecFailClosed?.code !== reason.code || this.#fecFailClosed?.layer !== reason.layer;
     this.#fecFailClosed = reason;
+    if (changed) this.#post([{ ...this.#base("e"), ec: [reason.code] }]);
   }
   updateManifestVerification(stats) {
     this.#manifestStats = stats;
   }
   /**
-   * One-shot emit of `x-bc-switch-drift-us` for a single misalignment event.
-   * Does NOT mutate snapshot state — subsequent onSnapshot() calls will not
-   * include the drift key until the next emitSwitchDrift(). Mirrors the
-   * existing onTransition() pattern.
+   * Count a video block's resolution from the repair lifecycle: recovered in
+   * band (`com.blockcast-fbr`), recovered by repair FETCH (`-fbq`), or failed
+   * as a keyframe-class block (`-fbfk`). Audio blocks are not counted, matching
+   * the video-track `-fbf`. Until the player feeds this, the three are absent.
    */
+  onRepairLifecycle(event) {
+    this.#lifecycle ??= { inband: 0, fetch: 0, failedKeyframe: 0 };
+    if (event.type === "recovered" && event.blockClass !== "audio") {
+      if (event.via === "inband") this.#lifecycle.inband++;
+      else this.#lifecycle.fetch++;
+    } else if (event.type === "failed" && event.blockClass === "keyframe") {
+      this.#lifecycle.failedKeyframe++;
+    }
+  }
+  /** One-shot custom event `com.blockcast-switch-drift` for a single misalignment. */
   emitSwitchDrift(driftUs) {
     if (typeof driftUs !== "number" || !Number.isFinite(driftUs) || driftUs < 0) {
       throw new Error(
         `[CmcdProducer] invalid drift-us "${String(driftUs)}"; expected a non-negative finite number`
       );
     }
-    const params = {};
-    if (this.#lastStats) Object.assign(params, buildFecParams(this.#lastStats));
-    Object.assign(params, buildTransportParams(this.#transport));
-    if (this.#switchMiscount > 0) params["x-bc-switch-miscount"] = this.#switchMiscount;
-    params["x-bc-switch-drift-us"] = driftUs;
-    this.#emit(params);
+    const record = { ...this.#base("ce"), cen: CUSTOM_PREFIX + "switch-drift" };
+    putCustom(record, "sdu", Math.round(driftUs));
+    this.#post([record]);
   }
-  /**
-   * Process a FecTrackStats snapshot. Finds the video track, builds
-   * x-bc-* vendor keys, and fires both delivery callbacks.
-   */
+  /** Take a FecTrackStats snapshot (first video track) and send the heartbeat when due. */
   onSnapshot(data) {
     const videoTrack = data.tracks.find((t) => t.config.trackType === "video");
     if (!videoTrack) return;
     this.#lastStats = videoTrack;
-    const params = {
-      ...buildFecParams(videoTrack),
-      ...buildTransportParams(this.#transport)
-    };
-    if (this.#playMode !== null) {
-      params["x-bc-play-mode"] = this.#playMode;
-    }
-    if (this.#fecFailClosed) {
-      params["x-bc-fec-fail-closed"] = this.#fecFailClosed.code;
-      params["x-bc-fec-fail-layer"] = this.#fecFailClosed.layer;
-    }
-    if (this.#playMode !== null && this.#playMode !== "single-track" && this.#deltaFailRate !== null) {
-      params["x-bc-delta-fail-rate"] = parseFloat(this.#deltaFailRate.toFixed(4));
-    }
-    if (this.#switchMiscount > 0) {
-      params["x-bc-switch-miscount"] = this.#switchMiscount;
-    }
-    if (this.#manifestStats) {
-      params["x-bc-manifest-verified"] = this.#manifestStats.verified > 0;
-      params["x-bc-manifest-failures"] = Object.values(this.#manifestStats.failures).reduce((total, count) => total + count, 0);
-    }
-    this.#emit(params);
+    this.#heartbeat();
   }
   /**
-   * Emit transport state without inventing FEC metrics. Cadence is owned by
-   * the caller because only the transport integration knows when state changed.
+   * Take transport state for receivers that do not own FEC stats, and send the
+   * heartbeat when due.
    */
   onTransportSnapshot(data) {
     if (!Number.isFinite(data.timestampMs) || data.timestampMs < 0) {
       throw new Error("[CmcdProducer] transport snapshot timestamp must be a non-negative finite number");
     }
     if (data.playMode !== void 0) this.updatePlayMode(data.playMode);
-    if (data.switchMiscount !== void 0 && (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0)) {
-      throw new Error("[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer");
+    if (data.switchMiscount !== void 0) {
+      if (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0) {
+        throw new Error("[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer");
+      }
+      this.#switchMiscount = data.switchMiscount;
     }
     this.#transport = data.transport;
-    const params = buildTransportParams(data.transport);
-    if (this.#playMode !== null) params["x-bc-play-mode"] = this.#playMode;
-    const switchMiscount = data.switchMiscount ?? this.#switchMiscount;
-    if (switchMiscount > 0) params["x-bc-switch-miscount"] = switchMiscount;
-    this.#emit(params);
+    this.#heartbeat();
   }
-  /**
-   * Signal a transport transition event. Fires an immediate out-of-band
-   * emit with x-bc-ct set. The subsequent onSnapshot() will NOT include
-   * x-bc-ct (one-shot).
-   */
+  /** Report a transport transition at once, as custom event `com.blockcast-ct`. */
   onTransition(event) {
-    const params = {};
-    if (this.#lastStats) {
-      Object.assign(params, buildFecParams(this.#lastStats));
+    const record = { ...this.#base("ce"), cen: CUSTOM_PREFIX + "ct" };
+    putCustom(record, "ct", token(event));
+    this.#putTransport(record);
+    this.#post([record]);
+  }
+  #base(event) {
+    return { e: token(event), sid: this.#sessionId, sn: this.#sn++, ts: Math.floor(this.#now()), v: 2 };
+  }
+  #heartbeat() {
+    const now = this.#now();
+    if (this.#lastHeartbeat !== null && now - this.#lastHeartbeat < this.#intervalMs) return;
+    this.#lastHeartbeat = now;
+    this.#post([this.#base("t"), this.#counters()]);
+  }
+  #putTransport(record) {
+    const snap = this.#transport;
+    if (!snap) return;
+    putCustom(record, "tr", token(TRANSPORT_TOKEN[snap.transport]));
+    if (snap.multicastGroup != null && snap.multicastSource != null) {
+      putCustom(record, "sg", `${snap.multicastGroup}@${snap.multicastSource}`);
+    }
+    putCustom(record, "ar", snap.amtRelay);
+  }
+  /** The `e=ce` counter report. */
+  #counters() {
+    const record = { ...this.#base("ce"), cen: CUSTOM_PREFIX + "fec" };
+    const stats = this.#lastStats;
+    if (stats) {
+      putCustom(record, "fa", stats.config.algorithm);
+      putCustom(record, "fk", stats.config.k);
+      putCustom(record, "fp", stats.config.repairCount);
+      putCustom(record, "pr", stats.sourceSymbols);
+      putCustom(record, "pl", stats.sourcePacketsMissing);
+      putCustom(record, "pu", stats.sourcePacketsUnrecovered);
+      putCustom(record, "fbf", stats.blocksFailed);
+    }
+    if (this.#lifecycle) {
+      putCustom(record, "fbr", this.#lifecycle.inband);
+      putCustom(record, "fbq", this.#lifecycle.fetch);
+      putCustom(record, "fbfk", this.#lifecycle.failedKeyframe);
+    }
+    this.#putTransport(record);
+    if (this.#playMode !== null) {
+      putCustom(record, "pm", token(this.#playMode));
+      if (this.#playMode !== "single-track" && this.#deltaFailRate !== null) {
+        putCustom(record, "dfr", this.#deltaFailRate.toFixed(3));
+      }
+    }
+    if (this.#fecFailClosed) {
+      putCustom(record, "ffc", token(this.#fecFailClosed.code));
+      putCustom(record, "ffl", this.#fecFailClosed.layer);
+    }
+    if (this.#switchMiscount > 0) putCustom(record, "sm", this.#switchMiscount);
+    if (this.#manifestStats) {
+      putCustom(record, "mv", this.#manifestStats.verified);
+      putCustom(record, "mf", Object.values(this.#manifestStats.failures).reduce((a, b) => a + b, 0));
     }
-    Object.assign(params, buildTransportParams(this.#transport));
-    params["x-bc-ct"] = event;
-    this.#emit(params);
+    return record;
   }
-  /** Fire both delivery callbacks with the given params. */
-  #emit(params) {
-    this.#onCmcdParams?.(params);
-    this.#onCmcdPost?.(formatQueryString(params));
+  #post(records) {
+    this.#onCmcdPost?.(records.map(encodeCmcdRecord).join("\n"));
   }
 };
 
@@ -31164,18 +31980,31 @@ function resolveRepairLayers(catalog, source) {
     totalBaseRepairSymbols: binding.totalBaseRepairSymbols
   };
 }
+function valueAt(catalog, pointer) {
+  let node = catalog;
+  for (const segment of pointer.split("/").slice(1)) {
+    if (typeof node !== "object" || node === null) return void 0;
+    node = node[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+  }
+  return node;
+}
+function catalogTrackDeliveryMode(catalog, source) {
+  const binding = bindingOf(catalog, source);
+  const entry = binding ? valueAt(catalog, binding.pointer) : void 0;
+  return entry?.deliveryMode === "stream" ? "stream" : "datagram";
+}
 function moqtPriority2(value) {
   return Number.isSafeInteger(value) && value >= 0 && value <= 255 ? value : null;
 }
 function catalogRepairTarget(catalog, source) {
   const binding = bindingOf(catalog, source);
   if (binding?.status !== "ok" || !(binding.base.interleaveDepthMs ?? 0)) return null;
-  const layerZero = binding.layers[0];
+  const layerZero2 = binding.layers[0];
   const m = /^\/tracks\/(\d+)$/.exec(binding.pointer);
   const tracks = catalog.tracks;
   const entry = m && Array.isArray(tracks) ? tracks[Number(m[1])] : void 0;
   const sourcePriority = entry ? moqtPriority2(entry["priority"]) : null;
-  return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
+  return { repairTrack: layerZero2.repairTrackName, sourcePriority, repairPriority: layerZero2.priority };
 }
 function numericField(value) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
@@ -31207,6 +32036,7 @@ function fecParams(catalog, track, fps, sampleRate) {
     repairTrackName: base.repairTrack,
     repairLayers: repair.baseLayers,
     repairOverlays: repair.overlays,
+    deliveryMode: catalogTrackDeliveryMode(catalog, track),
     ...mediaRate
   };
 }
@@ -31257,7 +32087,14 @@ function resolveCatalogTrackFec(catalog, tracks) {
 var PATH_BITS = { moq: 1, multicast: 2 };
 var MIXED_PATHS = PATH_BITS.moq | PATH_BITS.multicast;
 var MmtpFecSession = class {
+  /** P_0 = B_0, the held total every repair packet is checked against. */
+  get repairSymbols() {
+    return this.#repairSymbols;
+  }
   #decoder;
+  #repairSymbols;
+  /** The message entry a catalog-less session was built from; undefined under a catalog. */
+  #message;
   /** Blocks a repair has defined and that are not settled yet, by SS_Start. */
   #blocks = /* @__PURE__ */ new Map();
   /** SS_Starts of settled blocks, so a later repair for one is refused. */
@@ -31295,6 +32132,24 @@ var MmtpFecSession = class {
    *   `interleaveDepthMs` or `reorderToleranceMs`. None is defaulted.
    */
   constructor(config) {
+    if (config && "alFecFlow" in config) {
+      const message = alFecRaptorQFlowConfig(config.alFecFlow);
+      if (!message) {
+        throw new Error("MmtpFecSession: the AL-FEC entry is outside draft-ramadan-moq-mmt-02 8.3 (iso-ssbg1-v1)");
+      }
+      this.#message = message;
+      this.blockProfile = parseFecBlockProfile("iso-ssbg1-v1", "alFecFlow");
+      this.algorithm = message.fecCodeId === FEC_CODE_RAPTORQ ? "raptorq" : "reed-solomon";
+      this.sourceSymbols = message.maximumK;
+      this.#repairSymbols = message.maximumP;
+      this.symbolSize = message.repairSymbolSize;
+      this.retentionBlocks = requirePositiveInteger(config.retentionBlocks, "retentionBlocks");
+      this.#repairPacketId = message.repairFlowId;
+      this.#heldLayers = layerZero(message.maximumP);
+      this.#anchorHorizon = heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols);
+      this.#decoder = buildDecoder(config.Decoder, this);
+      return;
+    }
     const fec = config?.fec;
     if (!fec || typeof fec !== "object") {
       throw new Error("MmtpFecSession: the catalog fec instance is required");
@@ -31305,7 +32160,7 @@ var MmtpFecSession = class {
     }
     this.algorithm = fec.scheme;
     this.sourceSymbols = requirePositiveInteger(fec.sourceSymbols, "fec.sourceSymbols");
-    this.repairSymbols = requirePositiveInteger(fec.repairSymbols, "fec.repairSymbols");
+    this.#repairSymbols = requirePositiveInteger(fec.repairSymbols, "fec.repairSymbols");
     this.symbolSize = requirePositiveInteger(fec.symbolSize, "fec.symbolSize");
     const interleaveDepthMs = requireNumber(fec.interleaveDepthMs, "fec.interleaveDepthMs");
     const reorderToleranceMs = requireNumber(fec.reorderToleranceMs, "fec.reorderToleranceMs");
@@ -31325,17 +32180,30 @@ var MmtpFecSession = class {
       config.heldLayers
     );
     this.#anchorHorizon = heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols);
-    if (typeof config.Decoder !== "function") {
-      throw new Error("MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required");
-    }
-    const decoder = new config.Decoder(this.retentionBlocks, this.blockProfile, this.algorithm);
-    try {
-      decoder.configure_params(this.sourceSymbols, this.symbolSize);
-    } catch (error) {
-      decoder.free();
-      throw error;
-    }
-    this.#decoder = decoder;
+    this.#decoder = buildDecoder(config.Decoder, this);
+  }
+  /**
+   * A later version of the AL-FEC message, catalog-less sessions only. A
+   * maximum_p_for_repair_flow above the held total raises it (`raised`): the
+   * anchored check restarts at the new total, so a block generated under the
+   * previous one stays valid before the first block carrying the new total
+   * (fec-core-00 7.3.2, mmt-02 8.3). A field at or below it changes nothing
+   * (`unchanged`): no publisher lowers it, and the check catches a wire that
+   * does. An entry with another asset, repair flow, code point, K or T, or
+   * one outside 8.3, is `refused`: that is a new source encoding, which needs
+   * a new session. A latched fail-closed stays latched either way.
+   */
+  updateAlFecFlow(flow) {
+    const held = this.#message;
+    if (!held) throw new Error("MmtpFecSession: updateAlFecFlow() needs a session built from an AL-FEC entry");
+    const next = alFecRaptorQFlowConfig(flow);
+    if (!next || next.sourcePacketIds[0] !== held.sourcePacketIds[0] || next.repairFlowId !== held.repairFlowId || next.fecCodeId !== held.fecCodeId || next.maximumK !== held.maximumK || next.repairSymbolSize !== held.repairSymbolSize) {
+      return "refused";
+    }
+    if (next.maximumP <= this.#repairSymbols) return "unchanged";
+    this.#repairSymbols = next.maximumP;
+    this.#heldLayers = layerZero(next.maximumP);
+    return "raised";
   }
   /** True once release() ran. */
   get released() {
@@ -31430,7 +32298,7 @@ var MmtpFecSession = class {
     }
     if (admission.reject) {
       const verdict2 = this.#heldLayers.failsClosed(
-        repairTrackName,
+        this.#trackFor(repairTrackName),
         frame.ssStart,
         frame.rsbLength,
         this.#anchorHorizon,
@@ -31445,7 +32313,7 @@ var MmtpFecSession = class {
     this.#repairPacketId ??= frame.packetId;
     if (frame.ssbLength > this.sourceSymbols) return this.#drop("repair:ssb-length");
     const verdict = this.#heldLayers.admit(
-      repairTrackName,
+      this.#trackFor(repairTrackName),
       frame.ssStart,
       frame.rsbLength,
       this.#anchorHorizon,
@@ -31504,6 +32372,10 @@ var MmtpFecSession = class {
     decoder.free();
     return true;
   }
+  /** Catalog-less: layer 0 has no own-track clause (mmt-02 8.3), so no track name is judged. */
+  #trackFor(repairTrackName) {
+    return this.#message ? void 0 : repairTrackName;
+  }
   #drop(reason) {
     this.#stats.dropped[reason] = (this.#stats.dropped[reason] ?? 0) + 1;
     return [];
@@ -31625,6 +32497,22 @@ var MmtpFecSession = class {
     }
   }
 };
+function layerZero(total) {
+  return new HeldLayerAdmission([{ layer: 0, repairTrackName: "", rsIdOffset: 0, repairSymbols: total }]);
+}
+function buildDecoder(Decoder, session) {
+  if (typeof Decoder !== "function") {
+    throw new Error("MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required");
+  }
+  const decoder = new Decoder(session.retentionBlocks, session.blockProfile, session.algorithm);
+  try {
+    decoder.configure_params(session.sourceSymbols, session.symbolSize);
+  } catch (error) {
+    decoder.free();
+    throw error;
+  }
+  return decoder;
+}
 function requirePositiveInteger(value, path) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
     throw new Error(`MmtpFecSession: ${path} must be a positive integer (got ${String(value)})`);
@@ -31638,6 +32526,168 @@ function requireNumber(value, path) {
   return value;
 }
 
+// src/repair-layer-subscriptions.ts
+var SERIAL32_HALF2 = 2147483648;
+var RepairLayerSubscriptions = class {
+  #opts;
+  #windowPackets;
+  #margin;
+  #dropAfterWindows;
+  #source;
+  #layerCount = 0;
+  #subs = /* @__PURE__ */ new Map();
+  #disposed = false;
+  #lastSeq;
+  #expected = 0;
+  #lost = 0;
+  #wantFewer = 0;
+  #lossRate = null;
+  #repairPackets = 0;
+  #repairBytes = 0;
+  #staleDropped = 0;
+  constructor(opts) {
+    this.#opts = opts;
+    this.#source = opts.source;
+    this.#windowPackets = opts.windowPackets ?? 500;
+    this.#margin = opts.margin ?? 2;
+    this.#dropAfterWindows = opts.dropAfterWindows ?? 3;
+  }
+  get layerCount() {
+    return this.#layerCount;
+  }
+  /**
+   * One source packet's MMTP `packet_sequence_number`, in arrival order.
+   * The sequence is per `packet_id`: pass the packets of ONE packet_id only,
+   * or interleaved sequences read as loss.
+   */
+  noteSourceSequence(seq) {
+    if (this.#disposed || this.#delivery() === "stream") return;
+    seq >>>= 0;
+    if (this.#lastSeq === void 0) {
+      this.#lastSeq = seq;
+      return;
+    }
+    const d = serial32Distance(this.#lastSeq, seq);
+    if (d === 0) return;
+    const back = d >= SERIAL32_HALF2 ? 2 ** 32 - d : 0;
+    if (d > this.#windowPackets && (back === 0 || back > this.#windowPackets)) {
+      this.#lastSeq = seq;
+      this.#expected = 0;
+      this.#lost = 0;
+      return;
+    }
+    if (back === 0) {
+      this.#expected += d;
+      this.#lost += d - 1;
+      this.#lastSeq = seq;
+    } else if (this.#lost > 0) {
+      this.#lost -= 1;
+    }
+    if (this.#expected >= this.#windowPackets) this.#closeWindow();
+  }
+  /** ABR switch R -> R': close R's tracks, carry the layer count to R'. */
+  switchSource(next) {
+    if (this.#disposed) return;
+    this.#closeAll();
+    this.#source = next;
+    this.#lastSeq = void 0;
+    this.#expected = 0;
+    this.#lost = 0;
+    this.#wantFewer = 0;
+    this.#layerCount = this.#delivery() === "stream" ? 0 : Math.min(this.#layerCount, this.#layers().length);
+    this.#reconcile();
+  }
+  snapshot() {
+    return {
+      delivery: this.#delivery(),
+      layerCount: this.#layerCount,
+      subscribedTracks: [...this.#subs.keys()],
+      repairPackets: this.#repairPackets,
+      repairBytes: this.#repairBytes,
+      staleDropped: this.#staleDropped,
+      lossRate: this.#lossRate
+    };
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#closeAll();
+    this.#disposed = true;
+  }
+  #delivery() {
+    return this.#source.deliveryMode === "stream" ? "stream" : "datagram";
+  }
+  #layers() {
+    return this.#source.repairLayers ?? [];
+  }
+  #closeWindow() {
+    const rate = this.#lost / this.#expected;
+    this.#lossRate = rate;
+    this.#expected = 0;
+    this.#lost = 0;
+    const target = this.#targetLayers(rate);
+    if (target > this.#layerCount) {
+      this.#wantFewer = 0;
+      this.#layerCount = target;
+    } else if (target < this.#layerCount) {
+      this.#wantFewer += 1;
+      if (this.#wantFewer >= this.#dropAfterWindows) {
+        this.#wantFewer = 0;
+        this.#layerCount -= 1;
+      }
+    } else {
+      this.#wantFewer = 0;
+    }
+    this.#reconcile();
+  }
+  /** Fewest base layers whose summed P covers margin x the measured loss of K. */
+  #targetLayers(rate) {
+    if (rate <= 0) return 0;
+    const needed = Math.ceil(rate * this.#source.fecK * this.#margin);
+    const layers = this.#layers();
+    let held = 0;
+    for (let n = 0; n < layers.length; n++) {
+      held += layers[n].repairSymbols;
+      if (held >= needed) return n + 1;
+    }
+    return layers.length;
+  }
+  /** Stream delivery never leaves layer count 0, so it never subscribes. */
+  #reconcile() {
+    const want = /* @__PURE__ */ new Map();
+    for (const layer of this.#layers().slice(0, this.#layerCount)) {
+      want.set(layer.repairTrackName, layer.priority);
+    }
+    const overlay = this.#source.repairOverlays?.[0];
+    if (this.#layerCount > 0 && overlay) want.set(overlay.repairTrackName, overlay.priority);
+    for (const [name, entry] of this.#subs) {
+      if (!want.has(name)) {
+        entry.sub.close();
+        this.#subs.delete(name);
+      }
+    }
+    for (const [name, priority] of want) {
+      if (this.#subs.has(name)) continue;
+      const entry = {};
+      entry.sub = this.#opts.subscribe(name, priority, (packet) => this.#onPacket(name, entry, packet));
+      this.#subs.set(name, entry);
+    }
+  }
+  /** Fenced on the entry itself, so a closed subscription is stale even if its track is re-added. */
+  #onPacket(name, entry, packet) {
+    if (this.#disposed || this.#subs.get(name) !== entry) {
+      this.#staleDropped += 1;
+      return;
+    }
+    this.#repairPackets += 1;
+    this.#repairBytes += packet.byteLength;
+    this.#opts.feed(packet, name);
+  }
+  #closeAll() {
+    for (const entry of this.#subs.values()) entry.sub.close();
+    this.#subs.clear();
+  }
+};
+
 // src/repair-fetch.ts
 var MOQT_PRIORITY_MAX = 255;
 var SOURCE_MEDIA_PRIORITY_MAX = REPAIR_PRIORITY_MIN - 1;
@@ -32283,6 +33333,7 @@ export {
   REPAIR_LIFECYCLE_LOG_PREFIX,
   REPAIR_PRIORITY_MAX,
   REPAIR_PRIORITY_MIN,
+  RepairLayerSubscriptions,
   SOURCE_MEDIA_PRIORITY_MAX,
   SampleCombineError,
   SampleCombiner,
@@ -32307,6 +33358,7 @@ export {
   catalogGroupDurationMs,
   catalogKeyframeCadenceMs,
   catalogRepairTarget,
+  catalogTrackDeliveryMode,
   catalogTrackFecUnavailable,
   classifyH264Keyframe,
   classifyHevcKeyframe,
@@ -32327,6 +33379,7 @@ export {
   detectH264Keyframe,
   detectHevcKeyframe,
   driftCheck,
+  encodeCmcdRecord,
   encodeDataSegment,
   encodeFecSourceInfo,
   encodeLocTimestamp,