@blockcast/mmt-container 0.1.0-main.149f78a4adae

package/dist/fec-manager.js

@@ -0,0 +1,1447 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/track-session.ts
+import { deriveFecInterleaveDepth } from "@blockcast/mmt-fec";
+function computeFecDeliveryWindowMs(config) {
+  const fecInterleaveMs = config.interleaveDepthMs;
+  const fecK = config.sourceSymbols;
+  if (fecInterleaveMs <= 0) {
+    throw new Error(
+      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+    );
+  }
+  if (fecK <= 0) {
+    throw new Error(
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+    );
+  }
+  const spansMs = [fecInterleaveMs];
+  if (config.mediaUnitsPerSecond && config.mediaUnitsPerSecond > 0) {
+    const mediaUnitMs = 1e3 / config.mediaUnitsPerSecond;
+    const interleaveUnits = deriveFecInterleaveDepth(fecInterleaveMs, mediaUnitMs);
+    const deliverySymbols = fecK + Math.max(0, config.repairSymbols ?? 0);
+    spansMs.push(deliverySymbols * interleaveUnits * mediaUnitMs);
+  }
+  if (config.symbolSize && config.symbolSize > 0 && config.bandwidthBps && config.bandwidthBps > 0) {
+    const repairSymbols = Math.max(0, config.repairSymbols ?? 0);
+    spansMs.push(
+      (fecK + repairSymbols) * config.symbolSize * 8 * 1e3 / config.bandwidthBps
+    );
+  }
+  const coreMs = Math.max(...spansMs);
+  const marginMs = config.jitterBufferMs !== void 0 && config.jitterBufferMs >= 0 ? config.jitterBufferMs : fecInterleaveMs;
+  return Math.ceil(coreMs) + Math.ceil(marginMs);
+}
+
+// src/fec-manager.ts
+import { deriveFecInterleaveDepth as deriveFecInterleaveDepth2 } from "@blockcast/mmt-fec";
+var MIN_INTERLEAVE_DEPTH_MS = 33;
+var WORKER_ERROR_LOG_CAP = 5;
+var WORKER_ERROR_KIND_CAP = 32;
+var WORKER_ERROR_OVERFLOW_KIND = "other";
+var STARTUP_REPAIR_WAIT_SOURCE_BOUNDARIES = 2;
+function newFecCounters() {
+  return {
+    sourcePackets: 0,
+    repairPackets: 0,
+    duplicateSymbols: 0,
+    blocksClean: 0,
+    blocksRecovered: 0,
+    blocksFailed: 0,
+    greenFillFrames: 0
+  };
+}
+var _fecDecoders, _workerClients, _syncDecoderBlockOwners, _decoderBlockOwners, _fecK, _fecSymbolSize, _fecTimeoutMs, _trackConfigs, _fecStats, _fecTrackStats, _fecWorkerStats, _fecStatsObservers, _activeBlocks, _activeBlockDeadlinesMs, _activeBlockTimeoutOwners, _lifecycleTrace, _pendingWorkerCleanups, _pendingWorkerCleanupClients, _blockSourceCounts, _blockSourceEsis, _blockRepairRsIds, _completedBlocks, _seenSymbols, _blockPathCounts, _blockCatalogTrackNames, _startupAlignedPackets, _startupPartialBlocks, _startupRequireRepairReady, _startupRepairReadyPackets, _startupRepairBoundaryCounts, _startupRepairFailOpenPackets, _cleanlyCompletedBlocks, _repairRequestedBlocks, _repairDeadlines, _workerRecoveredBlocks, _fpsDetected, _fecFps, _fecInterleaveDepthMs, _workerErrorCounts, _repairSymbolSizeMismatchCount, _FECManager_instances, streamKey_fn, belongsToPacket_fn, belongsToStream_fn, packetIdsForStreamKeys_fn, blockKey_fn, parseBlockKey_fn, decoderForPacket_fn, workerForPacket_fn, claimDecoderBlock_fn, decoderBlockCatalogTrackName_fn, resetDecoderBlockOwners_fn, discardFecDecoderClient_fn, assertExclusiveDecoderClient_fn, statsForPacket_fn, markPathBlockComplete_fn, clearRepairDeadline_fn, requestRepair_fn, traceLifecycle_fn, defaultTrackConfig_fn, resolveTrackConfig_fn, computeTimeout_fn, repairDeadlineMs_fn, repairGraceMs_fn, armBlockTimeout_fn, upsertTrackConfig_fn, normalizeSymbolData_fn, blockKeysFor_fn, observeBlockCatalogTrackName_fn, markStartupPartial_fn, routeSyncCleanup_fn, failBlock_fn;
+var FECManager = class {
+  constructor() {
+    __privateAdd(this, _FECManager_instances);
+    // Per-track WASM RaptorQ decoders, keyed by physical stream identity.
+    __privateAdd(this, _fecDecoders, /* @__PURE__ */ new Map());
+    /** @deprecated Use setFecDecoder(packetId, ...). Backwards-compat shim. */
+    // Per-track Worker-backed FEC decoders, keyed by physical stream identity.
+    // Worker-backed tracks use async decode — recovered frames arrive via onFrame callback,
+    // not synchronous return from feedSourceSymbol/feedRepairSymbol.
+    __privateAdd(this, _workerClients, /* @__PURE__ */ new Map());
+    // Worker setup can finish while an interleaved block is already collecting
+    // on the sync decoder. Keep that block on its original decoder so later
+    // source/repair symbols do not split across two RaptorQ states.
+    __privateAdd(this, _syncDecoderBlockOwners, /* @__PURE__ */ new Map());
+    __privateAdd(this, _decoderBlockOwners, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _fecK, 4);
+    __privateAdd(this, _fecSymbolSize, 0);
+    __privateAdd(this, _fecTimeoutMs, 500);
+    // default 500ms; refined by setFramerate() when fps known
+    __privateAdd(this, _trackConfigs, /* @__PURE__ */ new Map());
+    __privateAdd(this, _fecStats, newFecCounters());
+    __privateAdd(this, _fecTrackStats, /* @__PURE__ */ new Map());
+    __privateAdd(this, _fecWorkerStats, /* @__PURE__ */ new Map());
+    __privateAdd(this, _fecStatsObservers, /* @__PURE__ */ new Set());
+    // Block inactivity tracking: (packetId, SBN) -> timer. The deadline is
+    // derived from catalog geometry and refreshed on progress; only an idle
+    // block fails.
+    __privateAdd(this, _activeBlocks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _activeBlockDeadlinesMs, /* @__PURE__ */ new Map());
+    __privateAdd(this, _activeBlockTimeoutOwners, /* @__PURE__ */ new Map());
+    __privateAdd(this, _lifecycleTrace, []);
+    // Worker-backed timeouts enqueue cleanup behind all prior symbol messages.
+    // Failure remains pending until cleanupComplete acknowledges that queue drain.
+    __privateAdd(this, _pendingWorkerCleanups, /* @__PURE__ */ new Set());
+    __privateAdd(this, _pendingWorkerCleanupClients, /* @__PURE__ */ new Map());
+    // Source symbol count per track-scoped block — marks complete when K symbols arrive.
+    __privateAdd(this, _blockSourceCounts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _blockSourceEsis, /* @__PURE__ */ new Map());
+    __privateAdd(this, _blockRepairRsIds, /* @__PURE__ */ new Map());
+    // Blocks already recovered — prevents late source symbols from restarting timeouts.
+    // WASM removes blocks after recovery; late symbols create empty blocks returning null,
+    // which would falsely start new timeouts without this guard.
+    __privateAdd(this, _completedBlocks, /* @__PURE__ */ new Set());
+    __privateAdd(this, _seenSymbols, /* @__PURE__ */ new Set());
+    __privateAdd(this, _blockPathCounts, /* @__PURE__ */ new Map());
+    // Exact catalog identity observed on accepted symbols for each FEC block.
+    // Conflicting identities collapse to null so recovery fails closed.
+    __privateAdd(this, _blockCatalogTrackNames, /* @__PURE__ */ new Map());
+    // A receiver joins an already-running live stream in the middle of D
+    // interleaved source blocks. This applies to both multicast and reliable MoQ:
+    // a MoQ group boundary is not an FEC ESI=0 boundary. Those blocks are not
+    // packet loss because their earlier ESIs predate the subscription. Ignore
+    // each such block until ESI=0 establishes a complete boundary for the track.
+    // After that boundary, a first observed ESI>0 is real delivery loss and must
+    // continue through normal FEC recovery/failure accounting.
+    __privateAdd(this, _startupAlignedPackets, /* @__PURE__ */ new Set());
+    __privateAdd(this, _startupPartialBlocks, /* @__PURE__ */ new Set());
+    // A live multicast join can observe an ESI=0 source boundary before the
+    // repair lane catches up. Returning false here also drops that media packet
+    // at MmtpRouter, so the readiness probe is multicast-only and bounded: an
+    // actual multicast repair unlocks the next boundary, while a second source
+    // boundary fails open. Reliable MoQ media continues through normal startup
+    // alignment and retained MoQ repair cannot prove multicast readiness.
+    __privateAdd(this, _startupRequireRepairReady, false);
+    __privateAdd(this, _startupRepairReadyPackets, /* @__PURE__ */ new Set());
+    __privateAdd(this, _startupRepairBoundaryCounts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _startupRepairFailOpenPackets, /* @__PURE__ */ new Set());
+    // SBNs that reached K source-symbol arrivals via trackBlock. Used by the
+    // worker recovery suppression check (see onFrame handler below) so we only
+    // suppress `recovered=true` emits for blocks that ALSO completed cleanly
+    // via source symbols. Separating this from #completedBlocks (which is also
+    // populated by every worker frame emit, by failed timeouts, and by external
+    // callers) was the BLO-3323 L15 fix: the prior predicate caused blocksRecovered
+    // to stay at 0 because the SBN was always in #completedBlocks by the time the
+    // worker fired recovered=true.
+    __privateAdd(this, _cleanlyCompletedBlocks, /* @__PURE__ */ new Set());
+    // D-28: blocks whose repair deadline already fired onRepairNeeded. At most
+    // one repair request per block; entries are removed when the block
+    // completes, recovers, or fails.
+    __privateAdd(this, _repairRequestedBlocks, /* @__PURE__ */ new Set());
+    // D-28: repair-deadline timers refreshed by accepted source progress until
+    // the first repair request. A `null` value marks a deadline that already
+    // fired (never re-armed). At most K accepted source symbols can refresh the
+    // horizon, so browser scheduling delay cannot create an early loss signal
+    // and repair traffic cannot keep a block alive indefinitely.
+    __privateAdd(this, _repairDeadlines, /* @__PURE__ */ new Map());
+    // Worker recovery emits all K source symbols. Track recovery once per block
+    // while routing only ESI slots that were absent from the direct source path.
+    __privateAdd(this, _workerRecoveredBlocks, /* @__PURE__ */ new Set());
+    // Framerate detection state
+    __privateAdd(this, _fpsDetected, false);
+    __privateAdd(this, _fecFps);
+    __privateAdd(this, _fecInterleaveDepthMs, 0);
+    // Worker error log rate-limiter — bounds console.warn output and exported
+    // error cardinality when the FEC Worker emits the same failure repeatedly
+    // with volatile packet details (e.g. ssStart) in the message text.
+    // Stable Worker codes aggregate those messages; uncoded/legacy messages are
+    // capped into an `other` bucket. This also covers wasm-bindgen
+    // "recursive use of an object" bubbled from add_source/add_repair during
+    // overlapping message processing). Without this, Point 5 of the 7-point
+    // validation harness — which caps headless warnings at 500 — fails even
+    // though the errors are duplicates of a single underlying event.
+    __privateAdd(this, _workerErrorCounts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _repairSymbolSizeMismatchCount, 0);
+    // Event callbacks — block lifecycle notifications for MmtpRouter wiring.
+    // NOTE: For sync WASM path, recovery routing is handled by MmtpRouter from
+    // feedSourceSymbol/feedRepairSymbol return values. For Worker path, recovery
+    // arrives via onBlockRecovered callback.
+    this.onBlockStarted = null;
+    this.onBlockComplete = null;
+    this.onBlockFailed = null;
+    // D-28 on-demand repair callbacks. When onRepairNeeded is registered, each
+    // block arms a one-shot repair deadline after the derived K-symbol source
+    // horizon; a block still short of K when it fires requests a per-SBN MoQ
+    // repair fetch upstream. The inactivity fail bound is unchanged either way —
+    // repair and failure are orthogonal timers, so wiring D-28 never delays
+    // failure accounting. onRepairResolved fires when a repair-requested block
+    // leaves the active set, with the outcome ("completed" after clean completion
+    // or recovery, "failed" at the fail bound) so the upstream in-flight slot
+    // (MulticastManager.clearRepairForBlock) can be released and logged.
+    this.onRepairNeeded = null;
+    this.onRepairResolved = null;
+    // Worker-path callbacks — async recovery and stats from FecWorkerClient.
+    this.onBlockRecovered = null;
+    this.onFecStatsUpdate = null;
+    this.onGreenFill = null;
+  }
+  // -----------------------------------------------------------------------
+  // Accessors
+  // -----------------------------------------------------------------------
+  /** Internal state for diagnostics — not part of the public stats API. */
+  get diagnostics() {
+    return {
+      timeoutMs: __privateGet(this, _fecTimeoutMs),
+      activeBlocks: __privateGet(this, _activeBlocks).size,
+      completedBlocks: __privateGet(this, _completedBlocks).size,
+      pendingCounts: Object.fromEntries(__privateGet(this, _blockSourceCounts)),
+      fpsDetected: __privateGet(this, _fpsDetected),
+      interleaveDepthMs: __privateGet(this, _fecInterleaveDepthMs),
+      startupAlignedPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupAlignedPackets)),
+      startupPartialBlocks: __privateGet(this, _startupPartialBlocks).size,
+      startupRepairReadyPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupRepairReadyPackets)),
+      startupRepairFailOpenPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupRepairFailOpenPackets)),
+      pendingWorkerCleanups: __privateGet(this, _pendingWorkerCleanups).size,
+      repairTrackedBlocks: __privateGet(this, _blockRepairRsIds).size,
+      lifecycleTrace: __privateGet(this, _lifecycleTrace).map((entry) => ({ ...entry }))
+    };
+  }
+  get fecStats() {
+    const s = __privateGet(this, _fecStats);
+    const affected = s.blocksRecovered + s.blocksFailed;
+    const total = s.blocksClean + affected;
+    const tracks = [...__privateGet(this, _fecTrackStats).entries()].sort(([left], [right]) => left - right).map(([packetId, stats]) => {
+      const trackAffected = stats.blocksRecovered + stats.blocksFailed;
+      const trackTotal = stats.blocksClean + trackAffected;
+      return {
+        ...stats,
+        packetId,
+        blocksComplete: trackTotal,
+        k: __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).k,
+        recoveryRate: trackAffected > 0 ? stats.blocksRecovered / trackAffected * 100 : 100,
+        packetLossRate: trackTotal > 0 ? trackAffected / trackTotal * 100 : 0
+      };
+    });
+    return {
+      ...s,
+      blocksComplete: total,
+      mixedPathBlocks: Array.from(__privateGet(this, _blockPathCounts).values()).filter(
+        (block) => block.multicastSymbols > 0 && block.moqSymbols > 0
+      ).length,
+      recentBlockPathCounts: Array.from(__privateGet(this, _blockPathCounts).values()).slice(-24),
+      k: __privateGet(this, _fecK),
+      // True recovery rate: of blocks that HAD loss, how many were recovered?
+      recoveryRate: affected > 0 ? s.blocksRecovered / affected * 100 : 100,
+      packetLossRate: total > 0 ? affected / total * 100 : 0,
+      tracks,
+      workers: [...__privateGet(this, _fecWorkerStats).entries()].sort(([left], [right]) => left - right).map(([packetId, stats]) => ({
+        ...stats,
+        config: {
+          ...stats.config,
+          resolution: stats.config.resolution ? { ...stats.config.resolution } : void 0
+        },
+        blocks: stats.blocks.map((block) => ({ ...block })),
+        decoder: stats.decoder ? { ...stats.decoder } : void 0,
+        altaFailedDetails: stats.altaFailedDetails?.map((detail) => ({ ...detail })),
+        packetId
+      })),
+      repairSymbolSizeMismatches: __privateGet(this, _repairSymbolSizeMismatchCount),
+      workerErrors: Object.fromEntries(__privateGet(this, _workerErrorCounts))
+    };
+  }
+  /**
+   * Observe Worker-backed per-track snapshots without taking ownership of the
+   * legacy single-callback slot. Infrastructure diagnostics and a player may
+   * therefore consume the same source event without wrapping or replacing one
+   * another's callback.
+   */
+  addFecStatsObserver(observer) {
+    __privateGet(this, _fecStatsObservers).add(observer);
+    return () => __privateGet(this, _fecStatsObservers).delete(observer);
+  }
+  /** Start a new multicast transport join without discarding track/decoder state. */
+  beginMulticastJoin() {
+    __privateGet(this, _startupAlignedPackets).clear();
+    __privateGet(this, _startupPartialBlocks).clear();
+    __privateSet(this, _startupRequireRepairReady, true);
+    __privateGet(this, _startupRepairReadyPackets).clear();
+    __privateGet(this, _startupRepairBoundaryCounts).clear();
+    __privateGet(this, _startupRepairFailOpenPackets).clear();
+  }
+  /** Begin a fresh decode epoch for one physical stream. */
+  resetTrack(packetId, catalogTrackName) {
+    if (!Number.isInteger(packetId) || packetId < 0) {
+      throw new Error(`[FECManager] invalid packetId for reset: ${packetId}`);
+    }
+    if (!catalogTrackName) {
+      throw new Error("[FECManager] catalogTrackName is required for track reset");
+    }
+    const resetMap = (map) => {
+      for (const key of map.keys()) {
+        if (!__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) continue;
+        map.delete(key);
+      }
+    };
+    const resetTimerMap = (map) => {
+      for (const [key, timer] of map) {
+        if (!__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) continue;
+        if (timer != null) clearTimeout(timer);
+        map.delete(key);
+      }
+    };
+    const resetSet = (set) => {
+      for (const key of set) {
+        if (__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) set.delete(key);
+      }
+    };
+    resetTimerMap(__privateGet(this, _activeBlocks));
+    resetTimerMap(__privateGet(this, _repairDeadlines));
+    resetMap(__privateGet(this, _activeBlockDeadlinesMs));
+    resetMap(__privateGet(this, _activeBlockTimeoutOwners));
+    resetMap(__privateGet(this, _pendingWorkerCleanupClients));
+    resetMap(__privateGet(this, _blockSourceCounts));
+    resetMap(__privateGet(this, _blockSourceEsis));
+    resetMap(__privateGet(this, _blockRepairRsIds));
+    resetMap(__privateGet(this, _blockPathCounts));
+    resetMap(__privateGet(this, _blockCatalogTrackNames));
+    resetMap(__privateGet(this, _syncDecoderBlockOwners));
+    resetMap(__privateGet(this, _startupRepairBoundaryCounts));
+    resetSet(__privateGet(this, _pendingWorkerCleanups));
+    resetSet(__privateGet(this, _completedBlocks));
+    resetSet(__privateGet(this, _cleanlyCompletedBlocks));
+    resetSet(__privateGet(this, _repairRequestedBlocks));
+    resetSet(__privateGet(this, _workerRecoveredBlocks));
+    resetSet(__privateGet(this, _startupAlignedPackets));
+    resetSet(__privateGet(this, _startupPartialBlocks));
+    resetSet(__privateGet(this, _startupRepairReadyPackets));
+    resetSet(__privateGet(this, _startupRepairFailOpenPackets));
+    resetSet(__privateGet(this, _seenSymbols));
+    const decoderClients = /* @__PURE__ */ new Set();
+    for (const [key, entry] of __privateGet(this, _fecDecoders)) {
+      if (__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) {
+        decoderClients.add(entry.client);
+      }
+    }
+    const clients = /* @__PURE__ */ new Set();
+    for (const client of decoderClients) {
+      if (typeof client.flush === "function" && typeof client.reset_stats === "function") {
+        try {
+          client.flush();
+          client.reset_stats();
+          clients.add(client);
+        } catch {
+          __privateMethod(this, _FECManager_instances, discardFecDecoderClient_fn).call(this, client);
+        }
+      } else {
+        __privateMethod(this, _FECManager_instances, discardFecDecoderClient_fn).call(this, client);
+      }
+    }
+    for (const [key, client] of __privateGet(this, _workerClients)) {
+      if (!__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) continue;
+      client.reset();
+      clients.add(client);
+    }
+    for (const client of clients) __privateMethod(this, _FECManager_instances, resetDecoderBlockOwners_fn).call(this, client, catalogTrackName);
+  }
+  /** Record a transport symbol and reject later duplicates of the same packetId/SBN/ESI. */
+  feedSymbolFromSource(packetId, sbn, esi, _data, source, catalogTrackName) {
+    const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+    const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
+    const k = this.kForPacket(packetId);
+    const isSourceSymbol = esi >= 0 && esi < k;
+    const isStartupPartial = __privateGet(this, _startupPartialBlocks).has(blockKey);
+    const awaitingMulticastRepair = __privateGet(this, _startupRequireRepairReady) && source === "multicast" && !__privateGet(this, _startupRepairReadyPackets).has(streamKey) && !__privateGet(this, _startupRepairFailOpenPackets).has(streamKey);
+    if (awaitingMulticastRepair) {
+      if (!isSourceSymbol) {
+        __privateGet(this, _startupRepairReadyPackets).add(streamKey);
+        __privateGet(this, _startupRepairBoundaryCounts).delete(streamKey);
+        __privateMethod(this, _FECManager_instances, markStartupPartial_fn).call(this, blockKey);
+        return false;
+      }
+      if (esi === 0) {
+        const boundaries = (__privateGet(this, _startupRepairBoundaryCounts).get(streamKey) ?? 0) + 1;
+        __privateGet(this, _startupRepairBoundaryCounts).set(streamKey, boundaries);
+        if (boundaries >= STARTUP_REPAIR_WAIT_SOURCE_BOUNDARIES) {
+          __privateGet(this, _startupRepairBoundaryCounts).delete(streamKey);
+          __privateGet(this, _startupRepairFailOpenPackets).add(streamKey);
+        } else {
+          __privateMethod(this, _FECManager_instances, markStartupPartial_fn).call(this, blockKey);
+          return false;
+        }
+      } else {
+        __privateMethod(this, _FECManager_instances, markStartupPartial_fn).call(this, blockKey);
+        return false;
+      }
+    }
+    if (isSourceSymbol && esi === 0) {
+      __privateGet(this, _startupPartialBlocks).delete(blockKey);
+      __privateGet(this, _startupAlignedPackets).add(streamKey);
+    } else if (isStartupPartial || !__privateGet(this, _startupAlignedPackets).has(streamKey)) {
+      __privateMethod(this, _FECManager_instances, markStartupPartial_fn).call(this, blockKey);
+      return false;
+    }
+    if (__privateGet(this, _completedBlocks).has(blockKey)) {
+      __privateGet(this, _fecStats).duplicateSymbols++;
+      __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).duplicateSymbols++;
+      return false;
+    }
+    const symbolKey = `${blockKey}:${esi}`;
+    if (__privateGet(this, _seenSymbols).has(symbolKey)) {
+      __privateGet(this, _fecStats).duplicateSymbols++;
+      __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).duplicateSymbols++;
+      return false;
+    }
+    __privateGet(this, _seenSymbols).add(symbolKey);
+    const counts = __privateGet(this, _blockPathCounts).get(blockKey) ?? {
+      packetId,
+      sbn,
+      ...catalogTrackName === void 0 ? {} : { catalogTrackName },
+      multicastSymbols: 0,
+      moqSymbols: 0,
+      complete: false
+    };
+    if (source === "multicast") counts.multicastSymbols++;
+    else counts.moqSymbols++;
+    __privateGet(this, _blockPathCounts).set(blockKey, counts);
+    __privateMethod(this, _FECManager_instances, observeBlockCatalogTrackName_fn).call(this, blockKey, catalogTrackName);
+    if (__privateGet(this, _seenSymbols).size > 4096) {
+      __privateSet(this, _seenSymbols, new Set(Array.from(__privateGet(this, _seenSymbols)).slice(-2048)));
+    }
+    if (__privateGet(this, _blockPathCounts).size > 512) {
+      __privateSet(this, _blockPathCounts, new Map(Array.from(__privateGet(this, _blockPathCounts)).slice(-256)));
+    }
+    if (__privateGet(this, _blockCatalogTrackNames).size > 512) {
+      __privateSet(this, _blockCatalogTrackNames, new Map(
+        Array.from(__privateGet(this, _blockCatalogTrackNames)).slice(-256)
+      ));
+    }
+    return true;
+  }
+  /** Exact catalog identity retained for async recovery, if unambiguous. */
+  catalogTrackNameForBlock(sbn, packetId, catalogTrackName) {
+    if (catalogTrackName !== void 0) {
+      return __privateGet(this, _blockCatalogTrackNames).get(
+        __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName)
+      ) ?? void 0;
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const [key, name] of __privateGet(this, _blockCatalogTrackNames)) {
+      const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      if (block.packetId === packetId && block.sbn === sbn && name !== null) names.add(name);
+    }
+    return names.size === 1 ? [...names][0] : void 0;
+  }
+  /** Per-block state snapshot for FecBlockGrid visualization.
+   *  Returns the most recent blocks (active + recently completed). */
+  getBlockStates() {
+    const blocks = [];
+    for (const [key] of __privateGet(this, _activeBlocks)) {
+      const { packetId, sbn } = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      const count = __privateGet(this, _blockSourceCounts).get(key) ?? 0;
+      const k = this.kForPacket(packetId);
+      blocks.push({ sbn, packetId, state: "collecting", sourceCount: count, k, progress: k > 0 ? Math.min(count / k, 1) : 0 });
+    }
+    const completed = [...__privateGet(this, _completedBlocks)].slice(-16);
+    for (const key of completed) {
+      const { packetId, sbn } = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      if (!__privateGet(this, _activeBlocks).has(key)) {
+        const k = this.kForPacket(packetId);
+        blocks.push({ sbn, packetId, state: "complete", sourceCount: k, k, progress: 1 });
+      }
+    }
+    blocks.sort((a, b) => a.sbn - b.sbn || (a.packetId ?? 0) - (b.packetId ?? 0));
+    return blocks.slice(-24);
+  }
+  /** The raw WASM decoder for stats access (first registered decoder) */
+  get wasmDecoder() {
+    return __privateGet(this, _fecDecoders).values().next().value?.client ?? null;
+  }
+  get k() {
+    return __privateGet(this, _fecK);
+  }
+  kForPacket(packetId) {
+    return __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).k;
+  }
+  /** FEC symbol size in bytes. */
+  get symbolSize() {
+    return __privateGet(this, _fecSymbolSize);
+  }
+  symbolSizeForPacket(packetId) {
+    return __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).symbolSize;
+  }
+  /** FEC interleave window in milliseconds (0 = no interleaving). */
+  get interleaveDepthMs() {
+    return __privateGet(this, _fecInterleaveDepthMs);
+  }
+  interleaveDepthMsForPacket(packetId) {
+    return __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).interleaveDepthMs;
+  }
+  /** Resolved per-track block fail bound in milliseconds. */
+  timeoutMsForPacket(packetId) {
+    return __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).timeoutMs;
+  }
+  /** Resolved per-track D-28 repair request deadline in milliseconds. */
+  repairDeadlineMsForPacket(packetId) {
+    return __privateMethod(this, _FECManager_instances, repairDeadlineMs_fn).call(this, __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId));
+  }
+  /** Remaining fetch budget for a specific repair-requested block. */
+  repairFetchTimeoutMsForBlock(sbn, packetId, catalogTrackName) {
+    const deadlineMs = __privateGet(this, _activeBlockDeadlinesMs).get(
+      __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName)
+    );
+    if (deadlineMs !== void 0) {
+      return Math.max(1, Math.ceil(deadlineMs - performance.now()));
+    }
+    const trackConfig = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId);
+    return Math.max(1, trackConfig.timeoutMs - __privateMethod(this, _FECManager_instances, repairDeadlineMs_fn).call(this, trackConfig));
+  }
+  // -----------------------------------------------------------------------
+  // Configuration
+  // -----------------------------------------------------------------------
+  /** Configure FEC parameters. */
+  configure(config) {
+    if (config.k != null) __privateSet(this, _fecK, config.k);
+    if (config.symbolSize != null && config.symbolSize > 0) __privateSet(this, _fecSymbolSize, config.symbolSize);
+    if (config.interleaveDepthMs != null) __privateSet(this, _fecInterleaveDepthMs, config.interleaveDepthMs);
+    if (config.fps != null && Number.isFinite(config.fps) && config.fps > 0) {
+      __privateSet(this, _fecFps, config.fps);
+    }
+    if (config.interleaveDepthMs != null && config.interleaveDepthMs > 0 && config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) {
+      console.warn(`[FECManager] interleaveDepthMs=${config.interleaveDepthMs} looks like frame count, not milliseconds (\xA75.1 requires ms). Expected range: ${MIN_INTERLEAVE_DEPTH_MS}-10000ms.`);
+    }
+    if (config.timeoutMs != null && config.timeoutMs > 0) {
+      __privateSet(this, _fecTimeoutMs, config.timeoutMs);
+    } else if (config.interleaveDepthMs != null && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+      __privateSet(this, _fecTimeoutMs, computeFecDeliveryWindowMs({
+        interleaveDepthMs: config.interleaveDepthMs,
+        sourceSymbols: __privateGet(this, _fecK),
+        symbolSize: __privateGet(this, _fecSymbolSize),
+        mediaUnitsPerSecond: config.fps
+      }));
+    }
+    for (const [packetId, track] of __privateGet(this, _trackConfigs)) {
+      if (track.timeoutMs < __privateGet(this, _fecTimeoutMs)) {
+        __privateGet(this, _trackConfigs).set(packetId, { ...track, timeoutMs: __privateGet(this, _fecTimeoutMs) });
+      }
+    }
+  }
+  /** Configure FEC parameters for one packetId without changing legacy defaults. */
+  configureTrack(packetId, config) {
+    __privateMethod(this, _FECManager_instances, upsertTrackConfig_fn).call(this, packetId, config);
+  }
+  /** Register a FEC decoder for a specific packetId (track). */
+  setFecDecoder(packetId, client, k, config, catalogTrackName) {
+    const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
+    __privateMethod(this, _FECManager_instances, assertExclusiveDecoderClient_fn).call(this, streamKey, client, [...__privateGet(this, _fecDecoders)].map(([key, entry]) => [key, entry.client]), "decoder");
+    const trackConfig = __privateMethod(this, _FECManager_instances, upsertTrackConfig_fn).call(this, packetId, { ...config, k });
+    __privateGet(this, _fecDecoders).set(streamKey, { client, k: trackConfig.k });
+  }
+  /**
+   * Register a Worker-backed FEC decoder for a specific packetId (track).
+   *
+   * Worker-backed tracks decode asynchronously — feedSourceSymbol/feedRepairSymbol
+   * return null immediately, and recovered frames arrive via the onBlockRecovered callback.
+   *
+   * Takes precedence over sync WASM decoders for the same packetId.
+   */
+  setFecWorker(packetId, client, config, catalogTrackName) {
+    const k = config?.k;
+    if (k === void 0 || !Number.isFinite(k) || k <= 0) {
+      throw new Error(`[FECManager] packetId=${packetId} Worker requires an explicit positive k`);
+    }
+    const symbolSize = config.symbolSize;
+    if (symbolSize === void 0 || !Number.isFinite(symbolSize) || symbolSize <= 0) {
+      throw new Error(
+        `[FECManager] packetId=${packetId} Worker requires an explicit positive symbolSize`
+      );
+    }
+    const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
+    __privateMethod(this, _FECManager_instances, assertExclusiveDecoderClient_fn).call(this, streamKey, client, __privateGet(this, _workerClients), "worker");
+    if (config) __privateMethod(this, _FECManager_instances, upsertTrackConfig_fn).call(this, packetId, config);
+    const workerK = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).k;
+    __privateGet(this, _workerClients).set(streamKey, client);
+    client.onFrame((data, meta) => {
+      if (meta.recovered) {
+        if (!Number.isInteger(meta.esi) || meta.esi < 0 || meta.esi >= workerK) {
+          const kind = "recovered-symbol-missing-esi";
+          const seen = __privateGet(this, _workerErrorCounts).get(kind) ?? 0;
+          __privateGet(this, _workerErrorCounts).set(kind, seen + 1);
+          if (seen < WORKER_ERROR_LOG_CAP) {
+            console.warn(
+              `[FECManager] Dropping recovered symbol without valid ESI: pid=${packetId} sbn=${meta.sbn} esi=${String(meta.esi)}`
+            );
+          }
+          return;
+        }
+        const esi = meta.esi;
+        const recoveredCatalogTrackName = catalogTrackName ?? __privateMethod(this, _FECManager_instances, decoderBlockCatalogTrackName_fn).call(this, client, meta.sbn);
+        if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, client, meta.sbn, recoveredCatalogTrackName)) return;
+        const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, meta.sbn, packetId, recoveredCatalogTrackName);
+        const cleanlyCompleted = __privateGet(this, _cleanlyCompletedBlocks).has(blockKey);
+        if (!cleanlyCompleted) {
+          if (!__privateGet(this, _workerRecoveredBlocks).has(blockKey)) {
+            __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "recovered", meta.sbn, packetId, recoveredCatalogTrackName);
+            __privateGet(this, _workerRecoveredBlocks).add(blockKey);
+            __privateGet(this, _fecStats).blocksRecovered++;
+            __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).blocksRecovered++;
+            if (__privateGet(this, _workerRecoveredBlocks).size > 1e3) {
+              const stale = Array.from(__privateGet(this, _workerRecoveredBlocks)).slice(0, 500);
+              for (const key of stale) __privateGet(this, _workerRecoveredBlocks).delete(key);
+            }
+          }
+          const symbolKey = `${blockKey}:${esi}`;
+          if (!__privateGet(this, _seenSymbols).has(symbolKey)) {
+            __privateGet(this, _seenSymbols).add(symbolKey);
+            this.onBlockRecovered?.(
+              meta.sbn,
+              packetId,
+              data,
+              meta,
+              recoveredCatalogTrackName
+            );
+          }
+        }
+        if (esi >= workerK - 1 && !__privateGet(this, _completedBlocks).has(blockKey)) {
+          this.cancelBlockTimeout(meta.sbn, packetId, recoveredCatalogTrackName);
+          if (recoveredCatalogTrackName === void 0) {
+            this.onBlockComplete?.(meta.sbn, packetId);
+          } else {
+            this.onBlockComplete?.(
+              meta.sbn,
+              packetId,
+              recoveredCatalogTrackName
+            );
+          }
+        }
+      } else {
+        const completedCatalogTrackName = catalogTrackName ?? __privateMethod(this, _FECManager_instances, decoderBlockCatalogTrackName_fn).call(this, client, meta.sbn);
+        this.markBlockCompleted(meta.sbn, packetId, completedCatalogTrackName);
+      }
+    });
+    client.onSnapshot((stats) => {
+      __privateGet(this, _fecWorkerStats).set(packetId, stats);
+      try {
+        this.onFecStatsUpdate?.(packetId, stats);
+      } catch (error) {
+        console.warn("[FECManager] FEC stats callback failed:", error);
+      }
+      for (const observer of __privateGet(this, _fecStatsObservers)) {
+        try {
+          observer(packetId, stats);
+        } catch (error) {
+          console.warn("[FECManager] FEC stats observer failed:", error);
+        }
+      }
+    });
+    client.onGreenFill((sbn, data) => {
+      __privateGet(this, _fecStats).greenFillFrames++;
+      __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).greenFillFrames++;
+      this.onGreenFill?.(sbn, packetId, data);
+    });
+    client.onCleanupComplete((sbn) => {
+      const cleanupKeys = [...__privateGet(this, _pendingWorkerCleanups)].filter((key) => {
+        const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+        return block.packetId === packetId && block.sbn === sbn && __privateGet(this, _pendingWorkerCleanupClients).get(key) === client;
+      });
+      for (const key of cleanupKeys) {
+        __privateGet(this, _pendingWorkerCleanups).delete(key);
+        __privateGet(this, _pendingWorkerCleanupClients).delete(key);
+        if (__privateGet(this, _completedBlocks).has(key)) continue;
+        const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+        __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "cleanup-ack", sbn, packetId, block.catalogTrackName);
+        __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, block.catalogTrackName);
+      }
+    });
+    client.onError((msg, code) => {
+      const requestedKind = code ?? msg;
+      const kind = __privateGet(this, _workerErrorCounts).has(requestedKind) || __privateGet(this, _workerErrorCounts).size < WORKER_ERROR_KIND_CAP - 1 ? requestedKind : WORKER_ERROR_OVERFLOW_KIND;
+      const seen = __privateGet(this, _workerErrorCounts).get(kind) ?? 0;
+      __privateGet(this, _workerErrorCounts).set(kind, seen + 1);
+      if (seen < WORKER_ERROR_LOG_CAP) {
+        console.warn("[FECManager] Worker error:", msg);
+      } else if (seen === WORKER_ERROR_LOG_CAP) {
+        console.warn(
+          `[FECManager] Worker error (suppressing further copies of ${kind}): ${msg}`
+        );
+      }
+    });
+  }
+  /** Called by player when framerate is known (from decoder output). Refines FEC block timeout. */
+  setFramerate(fps) {
+    if (__privateGet(this, _fpsDetected) || fps <= 0) return;
+    __privateSet(this, _fpsDetected, true);
+    __privateSet(this, _fecFps, fps);
+    if (__privateGet(this, _fecInterleaveDepthMs) >= MIN_INTERLEAVE_DEPTH_MS) {
+      __privateSet(this, _fecTimeoutMs, computeFecDeliveryWindowMs({
+        interleaveDepthMs: __privateGet(this, _fecInterleaveDepthMs),
+        sourceSymbols: __privateGet(this, _fecK),
+        symbolSize: __privateGet(this, _fecSymbolSize),
+        mediaUnitsPerSecond: fps
+      }));
+    }
+    for (const [packetId, config] of __privateGet(this, _trackConfigs)) {
+      if (config.fps !== void 0 || config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) continue;
+      __privateGet(this, _trackConfigs).set(packetId, {
+        ...config,
+        fps,
+        timeoutMs: Math.max(
+          __privateGet(this, _fecTimeoutMs),
+          computeFecDeliveryWindowMs({
+            interleaveDepthMs: config.interleaveDepthMs,
+            sourceSymbols: config.k,
+            symbolSize: config.symbolSize,
+            mediaUnitsPerSecond: fps
+          })
+        )
+      });
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Symbol feeding (codec-agnostic)
+  // -----------------------------------------------------------------------
+  /**
+   * Feed a source symbol to the WASM FEC decoder.
+   *
+   * Does NOT track block source counts or fire lifecycle events — call
+   * `trackBlock()` separately BEFORE this method (MmtpRouter does this).
+   *
+   * @returns Recovered block data if WASM completed the block, else null.
+   *          Caller is responsible for routing recovered data and updating
+   *          block completion state via `markBlockCompleted()`.
+   */
+  feedSourceSymbol(packetId, ssId, symbolData, alta, catalogTrackName) {
+    __privateGet(this, _fecStats).sourcePackets++;
+    __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).sourcePackets++;
+    const fecData = __privateMethod(this, _FECManager_instances, normalizeSymbolData_fn).call(this, packetId, symbolData);
+    const sbn = Math.floor(ssId / this.kForPacket(packetId));
+    const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+    const syncBlockOwner = __privateGet(this, _syncDecoderBlockOwners).get(blockKey);
+    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    if (workerClient && !syncBlockOwner) {
+      if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, workerClient, sbn, catalogTrackName)) return null;
+      const buf = fecData.buffer.slice(
+        fecData.byteOffset,
+        fecData.byteOffset + fecData.byteLength
+      );
+      if (alta) {
+        const authBuf = alta.auth.buffer.slice(
+          alta.auth.byteOffset,
+          alta.auth.byteOffset + alta.auth.byteLength
+        );
+        workerClient.feedSource(ssId, buf, performance.now(), {
+          auth: authBuf,
+          payloadEnd: alta.payloadEnd
+        });
+      } else {
+        workerClient.feedSource(ssId, buf, performance.now());
+      }
+      return null;
+    }
+    const entry = __privateMethod(this, _FECManager_instances, decoderForPacket_fn).call(this, packetId, catalogTrackName);
+    const client = syncBlockOwner ?? entry?.client;
+    if (!client) return null;
+    if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, client, sbn, catalogTrackName)) return null;
+    __privateGet(this, _syncDecoderBlockOwners).set(blockKey, client);
+    let recovered = null;
+    try {
+      recovered = client.add_source(ssId, fecData, performance.now());
+    } catch {
+    }
+    if (recovered || __privateGet(this, _completedBlocks).has(blockKey)) {
+      __privateGet(this, _syncDecoderBlockOwners).delete(blockKey);
+    }
+    return recovered;
+  }
+  /**
+   * Feed a repair symbol to the WASM FEC decoder.
+   *
+   * @returns Recovered block data if repair completed the block, else null.
+   *          Caller is responsible for routing recovered data and updating
+   *          block completion state via `markBlockCompleted()`.
+   */
+  feedRepairSymbol(packetId, ssStart, ssbLength, rsId, repairData, catalogTrackName) {
+    __privateGet(this, _fecStats).repairPackets++;
+    __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).repairPackets++;
+    const symbolSize = this.symbolSizeForPacket(packetId);
+    if (symbolSize > 0 && repairData.byteLength !== symbolSize) {
+      __privateWrapper(this, _repairSymbolSizeMismatchCount)._++;
+      if (__privateGet(this, _repairSymbolSizeMismatchCount) <= 5 || __privateGet(this, _repairSymbolSizeMismatchCount) % 100 === 0) {
+        console.warn(
+          `[FECManager] Dropping repair symbol with invalid size: got ${repairData.byteLength}B, expected ${symbolSize}B (packetId=${packetId}, ssStart=${ssStart}, ssbLength=${ssbLength}, rsId=${rsId})`
+        );
+      }
+      return null;
+    }
+    const fecData = repairData;
+    if (ssbLength > 1) {
+      this.noteBlockActivity(
+        Math.floor(ssStart / ssbLength),
+        packetId,
+        catalogTrackName
+      );
+    }
+    const sbn = ssbLength > 0 ? Math.floor(ssStart / ssbLength) : 0;
+    const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+    if (__privateGet(this, _completedBlocks).has(blockKey)) return null;
+    const syncBlockOwner = __privateGet(this, _syncDecoderBlockOwners).get(blockKey);
+    let repairIds = __privateGet(this, _blockRepairRsIds).get(blockKey);
+    if (!repairIds) {
+      repairIds = /* @__PURE__ */ new Set();
+      __privateGet(this, _blockRepairRsIds).set(blockKey, repairIds);
+    }
+    repairIds.add(rsId);
+    if (__privateGet(this, _repairRequestedBlocks).has(blockKey)) {
+      __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "repair-arrived", sbn, packetId, catalogTrackName, rsId);
+    }
+    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    if (workerClient && !syncBlockOwner) {
+      if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, workerClient, sbn, catalogTrackName)) return null;
+      const buf = fecData.buffer.slice(
+        fecData.byteOffset,
+        fecData.byteOffset + fecData.byteLength
+      );
+      workerClient.feedRepair(ssStart, ssbLength, rsId, buf, performance.now());
+      return null;
+    }
+    const entry = __privateMethod(this, _FECManager_instances, decoderForPacket_fn).call(this, packetId, catalogTrackName);
+    const client = syncBlockOwner ?? entry?.client;
+    if (!client) return null;
+    if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, client, sbn, catalogTrackName)) return null;
+    __privateGet(this, _syncDecoderBlockOwners).set(blockKey, client);
+    let recovered = null;
+    try {
+      recovered = client.add_repair(ssStart, ssbLength, rsId, fecData, performance.now());
+    } catch {
+    }
+    if (recovered) __privateGet(this, _syncDecoderBlockOwners).delete(blockKey);
+    return recovered;
+  }
+  /**
+   * Unified symbol feeder. Dispatches to feedSourceSymbol or feedRepairSymbol.
+   */
+  feedSymbol(packetId, symbolId, data, isRepair) {
+    if (isRepair) {
+      return this.feedRepairSymbol(packetId, symbolId, 1, symbolId, data);
+    }
+    return this.feedSourceSymbol(packetId, symbolId, data);
+  }
+  // -----------------------------------------------------------------------
+  // Block lifecycle
+  // -----------------------------------------------------------------------
+  /**
+   * Track a source symbol for an FEC block. Refreshes the inactivity deadline
+   * on each symbol and marks the block clean when K source symbols arrive.
+   */
+  trackBlock(sbn, packetId, catalogTrackName, esi) {
+    const key = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+    const trackConfig = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId);
+    const k = trackConfig.k;
+    if (__privateGet(this, _completedBlocks).has(key)) return;
+    const count = (__privateGet(this, _blockSourceCounts).get(key) ?? 0) + 1;
+    __privateGet(this, _blockSourceCounts).set(key, count);
+    if (Number.isInteger(esi) && esi >= 0 && esi < k) {
+      let sourceEsis = __privateGet(this, _blockSourceEsis).get(key);
+      if (!sourceEsis) {
+        sourceEsis = /* @__PURE__ */ new Set();
+        __privateGet(this, _blockSourceEsis).set(key, sourceEsis);
+      }
+      sourceEsis.add(esi);
+    }
+    if (count === 1) {
+      if (catalogTrackName === void 0) {
+        this.onBlockStarted?.(sbn, packetId);
+      } else {
+        this.onBlockStarted?.(sbn, packetId, catalogTrackName);
+      }
+    }
+    if (k > 0 && count >= k) {
+      __privateGet(this, _fecStats).blocksClean++;
+      __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).blocksClean++;
+      this.cancelBlockTimeout(sbn, packetId, catalogTrackName);
+      __privateGet(this, _blockSourceCounts).delete(key);
+      __privateGet(this, _blockSourceEsis).delete(key);
+      __privateGet(this, _blockRepairRsIds).delete(key);
+      __privateGet(this, _completedBlocks).add(key);
+      __privateGet(this, _cleanlyCompletedBlocks).add(key);
+      __privateMethod(this, _FECManager_instances, markPathBlockComplete_fn).call(this, sbn, packetId, catalogTrackName);
+      if (catalogTrackName === void 0) {
+        this.onBlockComplete?.(sbn, packetId);
+      } else {
+        this.onBlockComplete?.(sbn, packetId, catalogTrackName);
+      }
+      queueMicrotask(() => __privateGet(this, _syncDecoderBlockOwners).delete(key));
+      return;
+    }
+    this.noteBlockActivity(sbn, packetId, catalogTrackName, true);
+  }
+  /** Refresh deadlines after accepted block activity. */
+  noteBlockActivity(sbn, packetId, catalogTrackName, sourceProgress = false) {
+    const key = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+    if (__privateGet(this, _completedBlocks).has(key)) return;
+    if (__privateGet(this, _pendingWorkerCleanups).has(key)) return;
+    if (__privateGet(this, _repairRequestedBlocks).has(key)) return;
+    const trackConfig = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId);
+    const timeoutMs = trackConfig.timeoutMs;
+    if (timeoutMs <= 0) return;
+    const repairDeadline = __privateGet(this, _repairDeadlines).get(key);
+    if (this.onRepairNeeded && (repairDeadline === void 0 || sourceProgress)) {
+      if (repairDeadline != null) clearTimeout(repairDeadline);
+      __privateGet(this, _repairDeadlines).set(
+        key,
+        setTimeout(() => {
+          __privateMethod(this, _FECManager_instances, requestRepair_fn).call(this, sbn, packetId, catalogTrackName);
+        }, __privateMethod(this, _FECManager_instances, repairDeadlineMs_fn).call(this, trackConfig))
+      );
+    }
+    __privateMethod(this, _FECManager_instances, armBlockTimeout_fn).call(this, sbn, packetId, catalogTrackName, timeoutMs);
+  }
+  /** Check whether a block has already been completed (clean or recovered). */
+  isBlockCompleted(sbn, packetId, catalogTrackName) {
+    return __privateMethod(this, _FECManager_instances, blockKeysFor_fn).call(this, sbn, packetId, catalogTrackName).some((key) => __privateGet(this, _completedBlocks).has(key));
+  }
+  /** Mark a block as completed externally (e.g., after routing recovered data). */
+  markBlockCompleted(sbn, packetId, catalogTrackName) {
+    for (const key of __privateMethod(this, _FECManager_instances, blockKeysFor_fn).call(this, sbn, packetId, catalogTrackName)) {
+      __privateGet(this, _completedBlocks).add(key);
+      __privateGet(this, _pendingWorkerCleanups).delete(key);
+      __privateGet(this, _pendingWorkerCleanupClients).delete(key);
+      const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      __privateMethod(this, _FECManager_instances, markPathBlockComplete_fn).call(this, block.sbn, block.packetId, block.catalogTrackName);
+      __privateMethod(this, _FECManager_instances, clearRepairDeadline_fn).call(this, key);
+      if (__privateGet(this, _repairRequestedBlocks).delete(key)) {
+        if (block.catalogTrackName === void 0) {
+          this.onRepairResolved?.(block.sbn, block.packetId, "completed");
+        } else {
+          this.onRepairResolved?.(
+            block.sbn,
+            block.packetId,
+            "completed",
+            block.catalogTrackName
+          );
+        }
+      }
+      __privateGet(this, _blockSourceCounts).delete(key);
+      __privateGet(this, _blockSourceEsis).delete(key);
+      __privateGet(this, _blockRepairRsIds).delete(key);
+      const timer = __privateGet(this, _activeBlocks).get(key);
+      if (timer) {
+        clearTimeout(timer);
+        __privateGet(this, _activeBlocks).delete(key);
+      }
+      __privateGet(this, _activeBlockDeadlinesMs).delete(key);
+      __privateGet(this, _activeBlockTimeoutOwners).delete(key);
+    }
+  }
+  /** Increment blocksRecovered stat (called by MmtpRouter after routing recovery). */
+  countRecovery(packetId) {
+    __privateGet(this, _fecStats).blocksRecovered++;
+    if (packetId != null) __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).blocksRecovered++;
+  }
+  /**
+   * Strict delivery provenance for one FEC block.
+   *
+   * A recovered symbol is a function of every symbol that entered its block,
+   * so it can only be attributed to multicast when NO symbol in that block
+   * arrived over MoQ. Repair symbols routinely arrive over reliable QUIC
+   * (`MmtpRouter.feedRepairPacket`), so a block that recovered with MoQ help
+   * produced bytes that never crossed a multicast socket.
+   *
+   * An untracked block returns 'unknown' rather than a guess: absence of
+   * evidence is not evidence of multicast.
+   */
+  blockDeliveryProvenance(sbn, packetId, catalogTrackName) {
+    const counts = this.blockPathCount(sbn, packetId, catalogTrackName);
+    if (!counts) return "unknown";
+    if (counts.moqSymbols > 0) return "mixed";
+    if (counts.multicastSymbols > 0) return "multicast";
+    return "unknown";
+  }
+  /** Per-path symbol counts for one block (D-28 gate logging), if tracked. */
+  blockPathCount(sbn, packetId, catalogTrackName) {
+    return __privateGet(this, _blockPathCounts).get(
+      __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName)
+    ) ?? null;
+  }
+  /** Cancel block timeout (block completed via clean reception or FEC recovery). */
+  cancelBlockTimeout(sbn, packetId, catalogTrackName) {
+    for (const key of __privateMethod(this, _FECManager_instances, blockKeysFor_fn).call(this, sbn, packetId, catalogTrackName)) {
+      __privateGet(this, _completedBlocks).add(key);
+      __privateGet(this, _pendingWorkerCleanups).delete(key);
+      __privateGet(this, _pendingWorkerCleanupClients).delete(key);
+      const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      __privateMethod(this, _FECManager_instances, markPathBlockComplete_fn).call(this, block.sbn, block.packetId, block.catalogTrackName);
+      __privateMethod(this, _FECManager_instances, clearRepairDeadline_fn).call(this, key);
+      if (__privateGet(this, _repairRequestedBlocks).delete(key)) {
+        if (block.catalogTrackName === void 0) {
+          this.onRepairResolved?.(block.sbn, block.packetId, "completed");
+        } else {
+          this.onRepairResolved?.(
+            block.sbn,
+            block.packetId,
+            "completed",
+            block.catalogTrackName
+          );
+        }
+      }
+      __privateGet(this, _blockSourceCounts).delete(key);
+      __privateGet(this, _blockSourceEsis).delete(key);
+      __privateGet(this, _blockRepairRsIds).delete(key);
+      const timer = __privateGet(this, _activeBlocks).get(key);
+      if (timer) {
+        clearTimeout(timer);
+        __privateGet(this, _activeBlocks).delete(key);
+      }
+      __privateGet(this, _activeBlockDeadlinesMs).delete(key);
+      __privateGet(this, _activeBlockTimeoutOwners).delete(key);
+    }
+    if (__privateGet(this, _completedBlocks).size > 1e3) {
+      const iter = __privateGet(this, _completedBlocks).values();
+      for (let i = 0; i < 500; i++) iter.next();
+      const keep = /* @__PURE__ */ new Set();
+      for (const v of iter) keep.add(v);
+      __privateSet(this, _completedBlocks, keep);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Cleanup
+  // -----------------------------------------------------------------------
+  dispose() {
+    for (const timer of __privateGet(this, _activeBlocks).values()) clearTimeout(timer);
+    __privateGet(this, _activeBlocks).clear();
+    __privateGet(this, _activeBlockDeadlinesMs).clear();
+    __privateGet(this, _activeBlockTimeoutOwners).clear();
+    __privateGet(this, _pendingWorkerCleanups).clear();
+    __privateGet(this, _pendingWorkerCleanupClients).clear();
+    for (const timer of __privateGet(this, _repairDeadlines).values()) {
+      if (timer != null) clearTimeout(timer);
+    }
+    __privateGet(this, _repairDeadlines).clear();
+    __privateGet(this, _blockSourceCounts).clear();
+    __privateGet(this, _blockSourceEsis).clear();
+    __privateGet(this, _blockRepairRsIds).clear();
+    __privateGet(this, _completedBlocks).clear();
+    __privateGet(this, _cleanlyCompletedBlocks).clear();
+    __privateGet(this, _repairRequestedBlocks).clear();
+    __privateGet(this, _workerRecoveredBlocks).clear();
+    __privateGet(this, _syncDecoderBlockOwners).clear();
+    __privateGet(this, _startupAlignedPackets).clear();
+    __privateGet(this, _startupPartialBlocks).clear();
+    __privateSet(this, _startupRequireRepairReady, false);
+    __privateGet(this, _startupRepairReadyPackets).clear();
+    __privateGet(this, _startupRepairBoundaryCounts).clear();
+    __privateGet(this, _startupRepairFailOpenPackets).clear();
+    __privateGet(this, _seenSymbols).clear();
+    __privateGet(this, _blockPathCounts).clear();
+    __privateGet(this, _blockCatalogTrackNames).clear();
+    __privateGet(this, _trackConfigs).clear();
+    __privateGet(this, _fecDecoders).clear();
+    for (const client of new Set(__privateGet(this, _workerClients).values())) client.dispose();
+    __privateGet(this, _workerClients).clear();
+  }
+};
+_fecDecoders = new WeakMap();
+_workerClients = new WeakMap();
+_syncDecoderBlockOwners = new WeakMap();
+_decoderBlockOwners = new WeakMap();
+_fecK = new WeakMap();
+_fecSymbolSize = new WeakMap();
+_fecTimeoutMs = new WeakMap();
+_trackConfigs = new WeakMap();
+_fecStats = new WeakMap();
+_fecTrackStats = new WeakMap();
+_fecWorkerStats = new WeakMap();
+_fecStatsObservers = new WeakMap();
+_activeBlocks = new WeakMap();
+_activeBlockDeadlinesMs = new WeakMap();
+_activeBlockTimeoutOwners = new WeakMap();
+_lifecycleTrace = new WeakMap();
+_pendingWorkerCleanups = new WeakMap();
+_pendingWorkerCleanupClients = new WeakMap();
+_blockSourceCounts = new WeakMap();
+_blockSourceEsis = new WeakMap();
+_blockRepairRsIds = new WeakMap();
+_completedBlocks = new WeakMap();
+_seenSymbols = new WeakMap();
+_blockPathCounts = new WeakMap();
+_blockCatalogTrackNames = new WeakMap();
+_startupAlignedPackets = new WeakMap();
+_startupPartialBlocks = new WeakMap();
+_startupRequireRepairReady = new WeakMap();
+_startupRepairReadyPackets = new WeakMap();
+_startupRepairBoundaryCounts = new WeakMap();
+_startupRepairFailOpenPackets = new WeakMap();
+_cleanlyCompletedBlocks = new WeakMap();
+_repairRequestedBlocks = new WeakMap();
+_repairDeadlines = new WeakMap();
+_workerRecoveredBlocks = new WeakMap();
+_fpsDetected = new WeakMap();
+_fecFps = new WeakMap();
+_fecInterleaveDepthMs = new WeakMap();
+_workerErrorCounts = new WeakMap();
+_repairSymbolSizeMismatchCount = new WeakMap();
+_FECManager_instances = new WeakSet();
+streamKey_fn = function(packetId, catalogTrackName) {
+  return catalogTrackName === void 0 ? `${packetId}` : `${packetId}:${encodeURIComponent(catalogTrackName)}`;
+};
+belongsToPacket_fn = function(key, packetId) {
+  return Number(key.split(":", 1)[0]) === packetId;
+};
+belongsToStream_fn = function(key, packetId, catalogTrackName) {
+  if (!__privateMethod(this, _FECManager_instances, belongsToPacket_fn).call(this, key, packetId)) return false;
+  const parts = key.split(":");
+  const encodedTrackName = encodeURIComponent(catalogTrackName);
+  if (parts.length === 2) return parts[1] === encodedTrackName;
+  if (parts.length >= 3) return parts[2] === encodedTrackName;
+  return false;
+};
+packetIdsForStreamKeys_fn = function(keys) {
+  return [...new Set([...keys].map((key) => Number(key.split(":", 1)[0])))];
+};
+blockKey_fn = function(sbn, packetId, catalogTrackName) {
+  const base = `${packetId}:${sbn}`;
+  return catalogTrackName === void 0 ? base : `${base}:${encodeURIComponent(catalogTrackName)}`;
+};
+parseBlockKey_fn = function(key) {
+  const [packetIdText, sbnText, ...catalogParts] = key.split(":");
+  const catalogTrackName = catalogParts.length > 0 ? decodeURIComponent(catalogParts.join(":")) : void 0;
+  return {
+    packetId: Number(packetIdText) || 0,
+    sbn: Number(sbnText) || 0,
+    ...catalogTrackName === void 0 ? {} : { catalogTrackName }
+  };
+};
+decoderForPacket_fn = function(packetId, catalogTrackName) {
+  return __privateGet(this, _fecDecoders).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName)) ?? __privateGet(this, _fecDecoders).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId));
+};
+workerForPacket_fn = function(packetId, catalogTrackName) {
+  return __privateGet(this, _workerClients).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName)) ?? __privateGet(this, _workerClients).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId));
+};
+claimDecoderBlock_fn = function(client, sbn, catalogTrackName) {
+  let blocks = __privateGet(this, _decoderBlockOwners).get(client);
+  if (!blocks) {
+    blocks = /* @__PURE__ */ new Map();
+    __privateGet(this, _decoderBlockOwners).set(client, blocks);
+  }
+  const owner = blocks.get(sbn);
+  if (!owner) {
+    blocks.set(sbn, { catalogTrackName, conflicted: false });
+    if (blocks.size > 512) {
+      const stale = [...blocks.keys()].slice(0, 256);
+      for (const key of stale) blocks.delete(key);
+    }
+    return true;
+  }
+  if (owner.conflicted) return false;
+  if (owner.catalogTrackName === catalogTrackName) return true;
+  owner.conflicted = true;
+  return false;
+};
+decoderBlockCatalogTrackName_fn = function(client, sbn) {
+  const owner = __privateGet(this, _decoderBlockOwners).get(client)?.get(sbn);
+  return owner?.conflicted ? void 0 : owner?.catalogTrackName;
+};
+resetDecoderBlockOwners_fn = function(client, catalogTrackName) {
+  const blocks = __privateGet(this, _decoderBlockOwners).get(client);
+  if (!blocks) return;
+  for (const [sbn, owner] of blocks) {
+    if (owner.catalogTrackName === catalogTrackName || owner.conflicted) {
+      blocks.delete(sbn);
+    }
+  }
+  if (blocks.size === 0) __privateGet(this, _decoderBlockOwners).delete(client);
+};
+discardFecDecoderClient_fn = function(client) {
+  for (const [key, entry] of __privateGet(this, _fecDecoders)) {
+    if (entry.client === client) __privateGet(this, _fecDecoders).delete(key);
+  }
+  __privateGet(this, _decoderBlockOwners).delete(client);
+};
+assertExclusiveDecoderClient_fn = function(streamKey, client, registrations, kind) {
+  for (const [registeredKey, registeredClient] of registrations) {
+    if (registeredClient !== client || registeredKey === streamKey) continue;
+    throw new Error(
+      `[FECManager] ${kind} client is already registered for stream ${registeredKey}; create one client per physical stream`
+    );
+  }
+};
+statsForPacket_fn = function(packetId) {
+  let stats = __privateGet(this, _fecTrackStats).get(packetId);
+  if (!stats) {
+    stats = newFecCounters();
+    __privateGet(this, _fecTrackStats).set(packetId, stats);
+  }
+  return stats;
+};
+markPathBlockComplete_fn = function(sbn, packetId, catalogTrackName) {
+  const block = __privateGet(this, _blockPathCounts).get(__privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName));
+  if (block) block.complete = true;
+};
+/** Cancel and forget a block's D-28 repair-deadline timer. */
+clearRepairDeadline_fn = function(key) {
+  const timer = __privateGet(this, _repairDeadlines).get(key);
+  if (timer != null) clearTimeout(timer);
+  __privateGet(this, _repairDeadlines).delete(key);
+};
+requestRepair_fn = function(sbn, packetId, catalogTrackName) {
+  const key = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+  if (__privateGet(this, _completedBlocks).has(key) || !this.onRepairNeeded || __privateGet(this, _repairRequestedBlocks).has(key)) return;
+  const deadline = __privateGet(this, _repairDeadlines).get(key);
+  if (deadline) clearTimeout(deadline);
+  __privateGet(this, _repairDeadlines).set(key, null);
+  __privateGet(this, _repairRequestedBlocks).add(key);
+  const config = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId);
+  const graceMs = __privateMethod(this, _FECManager_instances, repairGraceMs_fn).call(this, config);
+  const now = performance.now();
+  const currentDeadline = __privateGet(this, _activeBlockDeadlinesMs).get(key) ?? now;
+  __privateMethod(this, _FECManager_instances, armBlockTimeout_fn).call(this, sbn, packetId, catalogTrackName, Math.max(1, Math.ceil(Math.max(now, currentDeadline) + graceMs - now)));
+  __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "repair-requested", sbn, packetId, catalogTrackName);
+  if (catalogTrackName === void 0) {
+    this.onRepairNeeded(sbn, packetId);
+  } else {
+    this.onRepairNeeded(sbn, packetId, catalogTrackName);
+  }
+};
+traceLifecycle_fn = function(event, sbn, packetId, catalogTrackName, rsId) {
+  const key = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+  const deadline = __privateGet(this, _activeBlockDeadlinesMs).get(key);
+  const decoderPath = __privateGet(this, _syncDecoderBlockOwners).has(key) ? "sync" : __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName) ? "worker" : __privateMethod(this, _FECManager_instances, decoderForPacket_fn).call(this, packetId, catalogTrackName) ? "sync" : "none";
+  __privateGet(this, _lifecycleTrace).push({
+    atMs: Date.now(),
+    event,
+    packetId,
+    sbn,
+    ...catalogTrackName === void 0 ? {} : { catalogTrackName },
+    sourceCount: __privateGet(this, _blockSourceCounts).get(key) ?? 0,
+    sourceEsis: [...__privateGet(this, _blockSourceEsis).get(key) ?? []].sort((a, b) => a - b),
+    repairRsIds: [...__privateGet(this, _blockRepairRsIds).get(key) ?? []].sort((a, b) => a - b),
+    decoderPath,
+    ...deadline === void 0 ? {} : { deadlineRemainingMs: Math.max(0, deadline - performance.now()) },
+    pendingCleanup: __privateGet(this, _pendingWorkerCleanups).has(key),
+    ...rsId === void 0 ? {} : { rsId }
+  });
+  if (__privateGet(this, _lifecycleTrace).length > 64) __privateGet(this, _lifecycleTrace).splice(0, 32);
+};
+defaultTrackConfig_fn = function() {
+  return {
+    k: __privateGet(this, _fecK),
+    symbolSize: __privateGet(this, _fecSymbolSize),
+    interleaveDepthMs: __privateGet(this, _fecInterleaveDepthMs),
+    fps: __privateGet(this, _fecFps),
+    timeoutMs: __privateGet(this, _fecTimeoutMs)
+  };
+};
+resolveTrackConfig_fn = function(packetId) {
+  return __privateGet(this, _trackConfigs).get(packetId) ?? __privateMethod(this, _FECManager_instances, defaultTrackConfig_fn).call(this);
+};
+computeTimeout_fn = function(config) {
+  if (config.timeoutMs && config.timeoutMs > 0) return config.timeoutMs;
+  if (config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+    return Math.max(
+      __privateGet(this, _fecTimeoutMs),
+      computeFecDeliveryWindowMs({
+        interleaveDepthMs: config.interleaveDepthMs,
+        sourceSymbols: config.k,
+        mediaUnitsPerSecond: config.fps
+      })
+    );
+  }
+  return __privateGet(this, _fecTimeoutMs);
+};
+repairDeadlineMs_fn = function(config) {
+  const halfFailBoundMs = Math.ceil(config.timeoutMs / 2);
+  if (config.k > 0 && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS && config.fps !== void 0 && Number.isFinite(config.fps) && config.fps > 0) {
+    const mediaUnitMs = 1e3 / config.fps;
+    const interleaveUnits = deriveFecInterleaveDepth2(
+      config.interleaveDepthMs,
+      mediaUnitMs
+    );
+    const sourceHorizonMs = Math.ceil(config.k * interleaveUnits * mediaUnitMs);
+    if (sourceHorizonMs < config.timeoutMs) return sourceHorizonMs;
+  }
+  return halfFailBoundMs;
+};
+repairGraceMs_fn = function(config) {
+  return Math.max(1, config.timeoutMs - __privateMethod(this, _FECManager_instances, repairDeadlineMs_fn).call(this, config));
+};
+armBlockTimeout_fn = function(sbn, packetId, catalogTrackName, delayMs) {
+  const key = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+  const current = __privateGet(this, _activeBlocks).get(key);
+  if (current) clearTimeout(current);
+  const boundedDelayMs = Math.max(1, Math.ceil(delayMs));
+  __privateGet(this, _activeBlockDeadlinesMs).set(key, performance.now() + boundedDelayMs);
+  const owner = {};
+  __privateGet(this, _activeBlockTimeoutOwners).set(key, owner);
+  const timer = setTimeout(() => {
+    if (__privateGet(this, _activeBlockTimeoutOwners).get(key) !== owner) return;
+    __privateGet(this, _activeBlocks).delete(key);
+    __privateGet(this, _activeBlockDeadlinesMs).delete(key);
+    __privateGet(this, _activeBlockTimeoutOwners).delete(key);
+    __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "timeout-queued", sbn, packetId, catalogTrackName);
+    const syncOwner = __privateGet(this, _syncDecoderBlockOwners).get(key);
+    if (syncOwner) {
+      __privateMethod(this, _FECManager_instances, routeSyncCleanup_fn).call(this, syncOwner, sbn, packetId);
+      __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, catalogTrackName);
+      return;
+    }
+    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    if (workerClient) {
+      __privateGet(this, _pendingWorkerCleanups).add(key);
+      __privateGet(this, _pendingWorkerCleanupClients).set(key, workerClient);
+      workerClient.cleanup(sbn);
+    } else {
+      const decoder = __privateMethod(this, _FECManager_instances, decoderForPacket_fn).call(this, packetId, catalogTrackName)?.client;
+      if (decoder) {
+        __privateMethod(this, _FECManager_instances, routeSyncCleanup_fn).call(this, decoder, sbn, packetId);
+        __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, catalogTrackName);
+      } else {
+        __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, catalogTrackName);
+      }
+    }
+  }, boundedDelayMs);
+  __privateGet(this, _activeBlocks).set(key, timer);
+};
+upsertTrackConfig_fn = function(packetId, config) {
+  const previous = __privateGet(this, _trackConfigs).get(packetId) ?? __privateMethod(this, _FECManager_instances, defaultTrackConfig_fn).call(this);
+  const timingChanged = config.k !== void 0 || config.interleaveDepthMs !== void 0 || config.fps !== void 0;
+  const next = {
+    k: config.k ?? previous.k,
+    symbolSize: config.symbolSize != null && config.symbolSize > 0 ? config.symbolSize : previous.symbolSize,
+    interleaveDepthMs: config.interleaveDepthMs ?? previous.interleaveDepthMs,
+    fps: config.fps ?? previous.fps,
+    timeoutMs: config.timeoutMs ?? (timingChanged ? 0 : previous.timeoutMs)
+  };
+  next.timeoutMs = __privateMethod(this, _FECManager_instances, computeTimeout_fn).call(this, next);
+  __privateGet(this, _trackConfigs).set(packetId, next);
+  return next;
+};
+normalizeSymbolData_fn = function(packetId, data) {
+  const symbolSize = this.symbolSizeForPacket(packetId);
+  if (symbolSize <= 0 || data.byteLength === symbolSize) return data;
+  const normalized = new Uint8Array(symbolSize);
+  normalized.set(data.subarray(0, symbolSize));
+  return normalized;
+};
+blockKeysFor_fn = function(sbn, packetId, catalogTrackName) {
+  if (packetId != null && catalogTrackName !== void 0) {
+    return [__privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName)];
+  }
+  const keys = /* @__PURE__ */ new Set();
+  for (const source of [
+    __privateGet(this, _activeBlocks),
+    __privateGet(this, _blockSourceCounts),
+    __privateGet(this, _blockCatalogTrackNames)
+  ]) {
+    for (const key of source.keys()) {
+      const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      if (block.sbn === sbn && (packetId === void 0 || block.packetId === packetId)) keys.add(key);
+    }
+  }
+  for (const source of [__privateGet(this, _completedBlocks), __privateGet(this, _cleanlyCompletedBlocks)]) {
+    for (const key of source) {
+      const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+      if (block.sbn === sbn && (packetId === void 0 || block.packetId === packetId)) keys.add(key);
+    }
+  }
+  if (packetId !== void 0) {
+    if (keys.size === 0) return [__privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId)];
+    return keys.size === 1 ? [...keys] : [];
+  }
+  return keys.size > 0 ? [...keys] : [__privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, 0, catalogTrackName)];
+};
+observeBlockCatalogTrackName_fn = function(blockKey, catalogTrackName) {
+  if (catalogTrackName === void 0) return;
+  if (!__privateGet(this, _blockCatalogTrackNames).has(blockKey)) {
+    __privateGet(this, _blockCatalogTrackNames).set(blockKey, catalogTrackName);
+    return;
+  }
+  if (__privateGet(this, _blockCatalogTrackNames).get(blockKey) !== catalogTrackName) {
+    __privateGet(this, _blockCatalogTrackNames).set(blockKey, null);
+  }
+};
+markStartupPartial_fn = function(blockKey) {
+  __privateGet(this, _startupPartialBlocks).add(blockKey);
+  if (__privateGet(this, _startupPartialBlocks).size > 128) {
+    __privateSet(this, _startupPartialBlocks, new Set(
+      Array.from(__privateGet(this, _startupPartialBlocks)).slice(-64)
+    ));
+  }
+};
+routeSyncCleanup_fn = function(decoder, sbn, packetId) {
+  let framed;
+  try {
+    framed = decoder.cleanup_blocks_detailed(Uint32Array.of(sbn));
+  } catch (error) {
+    console.warn(`[FECManager] Scoped cleanup failed for SBN ${sbn}:`, error);
+    return;
+  }
+  const view = new DataView(framed.buffer, framed.byteOffset, framed.byteLength);
+  let offset = 0;
+  while (offset < framed.byteLength) {
+    if (framed.byteLength - offset < 8) {
+      console.warn(`[FECManager] Scoped cleanup returned a truncated record for SBN ${sbn}`);
+      return;
+    }
+    const fillSbn = view.getUint32(offset, false);
+    const length = view.getUint32(offset + 4, false);
+    offset += 8;
+    if (length > framed.byteLength - offset) {
+      console.warn(`[FECManager] Scoped cleanup returned a truncated payload for SBN ${sbn}`);
+      return;
+    }
+    const data = framed.slice(offset, offset + length).buffer;
+    offset += length;
+    __privateGet(this, _fecStats).greenFillFrames++;
+    __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).greenFillFrames++;
+    this.onGreenFill?.(fillSbn, packetId, data);
+  }
+};
+failBlock_fn = function(sbn, packetId, countGreenFill, catalogTrackName) {
+  const key = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
+  __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "failed", sbn, packetId, catalogTrackName);
+  __privateMethod(this, _FECManager_instances, clearRepairDeadline_fn).call(this, key);
+  const activeTimer = __privateGet(this, _activeBlocks).get(key);
+  if (activeTimer) {
+    clearTimeout(activeTimer);
+    __privateGet(this, _activeBlocks).delete(key);
+  }
+  __privateGet(this, _activeBlockDeadlinesMs).delete(key);
+  if (__privateGet(this, _repairRequestedBlocks).delete(key)) {
+    if (catalogTrackName === void 0) {
+      this.onRepairResolved?.(sbn, packetId, "failed");
+    } else {
+      this.onRepairResolved?.(sbn, packetId, "failed", catalogTrackName);
+    }
+  }
+  __privateGet(this, _blockSourceCounts).delete(key);
+  __privateGet(this, _blockSourceEsis).delete(key);
+  __privateGet(this, _blockRepairRsIds).delete(key);
+  __privateGet(this, _activeBlockTimeoutOwners).delete(key);
+  __privateGet(this, _syncDecoderBlockOwners).delete(key);
+  __privateGet(this, _completedBlocks).add(key);
+  __privateMethod(this, _FECManager_instances, markPathBlockComplete_fn).call(this, sbn, packetId, catalogTrackName);
+  __privateGet(this, _fecStats).blocksFailed++;
+  __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).blocksFailed++;
+  if (countGreenFill) {
+    __privateGet(this, _fecStats).greenFillFrames++;
+    __privateMethod(this, _FECManager_instances, statsForPacket_fn).call(this, packetId).greenFillFrames++;
+  }
+  if (catalogTrackName === void 0) {
+    this.onBlockFailed?.(sbn, packetId);
+  } else {
+    this.onBlockFailed?.(sbn, packetId, catalogTrackName);
+  }
+};
+export {
+  FECManager,
+  MIN_INTERLEAVE_DEPTH_MS
+};
+//# sourceMappingURL=fec-manager.js.map