@blockcast/mmt-container 2.2.0-main.a88c3a0aa4f3 → 2.2.0-main.bdefba2a99c2

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;
@@ -7949,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,
@@ -7958,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;
@@ -8710,11 +8749,11 @@ var MOQT_PUBLISHER_PRIORITY = Object.freeze({
 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") {
@@ -8723,12 +8762,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
@@ -8738,6 +8787,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}`);
@@ -8773,6 +8823,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)}`);
     }
   }
@@ -8794,6 +8846,8 @@ var AMTGatewayManager = class {
     } finally {
       this.subscriptions.delete(handle);
       this.pendingPackets.delete(subscription.subscriptionId);
+      if (this.subscriptions.size === 0)
+        this.removeMessageListener();
     }
   }
   /**
@@ -8810,10 +8864,8 @@ 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;
@@ -8843,19 +8895,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) => {
@@ -18811,10 +18859,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) {
@@ -28678,6 +28726,7 @@ 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).
@@ -29626,7 +29675,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,
@@ -30168,24 +30217,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;
@@ -30196,9 +30245,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);
@@ -31167,63 +31216,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)) {
@@ -31234,9 +31285,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) {
@@ -31246,112 +31296,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"));
   }
 };
 
@@ -31447,18 +31524,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;
@@ -31490,6 +31580,7 @@ function fecParams(catalog, track, fps, sampleRate) {
     repairTrackName: base.repairTrack,
     repairLayers: repair.baseLayers,
     repairOverlays: repair.overlays,
+    deliveryMode: catalogTrackDeliveryMode(catalog, track),
     ...mediaRate
   };
 }
@@ -31540,7 +31631,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. */
@@ -31578,6 +31676,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");
@@ -31588,7 +31704,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");
@@ -31608,17 +31724,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() {
@@ -31713,7 +31842,7 @@ var MmtpFecSession = class {
     }
     if (admission.reject) {
       const verdict2 = this.#heldLayers.failsClosed(
-        repairTrackName,
+        this.#trackFor(repairTrackName),
         frame.ssStart,
         frame.rsbLength,
         this.#anchorHorizon,
@@ -31728,7 +31857,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,
@@ -31787,6 +31916,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 [];
@@ -31908,6 +32041,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)})`);
@@ -31921,6 +32070,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;
@@ -32566,6 +32877,7 @@ export {
   REPAIR_LIFECYCLE_LOG_PREFIX,
   REPAIR_PRIORITY_MAX,
   REPAIR_PRIORITY_MIN,
+  RepairLayerSubscriptions,
   SOURCE_MEDIA_PRIORITY_MAX,
   SampleCombineError,
   SampleCombiner,
@@ -32590,6 +32902,7 @@ export {
   catalogGroupDurationMs,
   catalogKeyframeCadenceMs,
   catalogRepairTarget,
+  catalogTrackDeliveryMode,
   catalogTrackFecUnavailable,
   classifyH264Keyframe,
   classifyHevcKeyframe,
@@ -32610,6 +32923,7 @@ export {
   detectH264Keyframe,
   detectHevcKeyframe,
   driftCheck,
+  encodeCmcdRecord,
   encodeDataSegment,
   encodeFecSourceInfo,
   encodeLocTimestamp,