@blockcast/mmt-container 0.1.0 → 0.3.0-main.288475b64b3e

package/node_modules/@blockcast/fec-worker/dist/fec-worker.js

@@ -0,0 +1,764 @@
+// Self-contained worker bundle (no bare imports). See build.mjs.
+
+// src/transfer.ts
+function toOwnedArrayBuffer(view) {
+  const copy = new Uint8Array(view.byteLength);
+  copy.set(view);
+  return copy.buffer;
+}
+
+// src/block-order.ts
+var SPAN = 4294967296;
+var HALF = 2147483648;
+function serialDistance(from, to) {
+  return (to - from + SPAN) % SPAN;
+}
+function serialPrecedes(a, b) {
+  const distance = serialDistance(a, b);
+  return distance !== 0 && distance < HALF;
+}
+function isoBlockContains(ssStart, ssbLength, ssId) {
+  return serialDistance(ssStart, ssId) < ssbLength;
+}
+function isoBlocksOverlap(aStart, aLength, bStart, bLength) {
+  return isoBlockContains(aStart, aLength, bStart) || isoBlockContains(bStart, bLength, aStart);
+}
+function isoBlocksBehind(a, b, kMax) {
+  if (!Number.isSafeInteger(kMax) || kMax <= 0) {
+    throw new Error(`iso-ssbg1-v1 block horizon needs a positive maximum K (got ${kMax})`);
+  }
+  return serialPrecedes(a, b) ? Math.floor(serialDistance(a, b) / kMax) : 0;
+}
+
+// src/fec-worker.ts
+var wasmDecoder = null;
+var config = null;
+var altaEnabled = false;
+var altaVerifier = null;
+var snapshotTimer = null;
+var blockUpdatesSubscribed = false;
+var blocks = /* @__PURE__ */ new Map();
+var acceptedSourceEsis = /* @__PURE__ */ new Map();
+var acceptedRepairEsis = /* @__PURE__ */ new Map();
+var unplacedSources = /* @__PURE__ */ new Map();
+var UINT32_MAX = 4294967295;
+var UINT24_MAX = 16777215;
+var SS_ID_SPAN = 4294967296;
+var SSBG1_LENGTH_FIELD_BYTES = 2;
+var MAX_INTERLEAVE_DEPTH = 255;
+var MAX_SYMBOL_SIZE = 65528;
+var MAX_RAPTORQ_SOURCE_SYMBOLS_PER_BLOCK = 56403;
+var sourceSymbols = 0;
+var repairSymbols = 0;
+var blocksComplete = 0;
+var blocksRecovered = 0;
+var blocksFailed = 0;
+var altaVerified = 0;
+var altaFailed = 0;
+var altaFailedDetails = [];
+var altaPending = 0;
+var altaPendingEvictedCap = 0;
+var altaPendingEvictedTtl = 0;
+var altaError = 0;
+var altaInitFailed = false;
+var relayBlocksVerified = 0;
+var relayBlocksFailed = 0;
+var liveSbn = 0;
+var liveSbnKnown = false;
+var repairSymbolSizeMismatch = 0;
+var sourceDroppedRetired = 0;
+var sourceDroppedTerminal = 0;
+var sourceDroppedDuplicate = 0;
+var sourceUnplacedRetired = 0;
+var recoveryTimes = [];
+var pendingVerify = /* @__PURE__ */ new Map();
+var pendingVerifyCap = 0;
+var pendingVerifyTtlMs = 0;
+function emit(event, transfer) {
+  self.postMessage(event, transfer ?? []);
+}
+function isUint32(value) {
+  return Number.isInteger(value) && value >= 0 && value <= UINT32_MAX;
+}
+function isTerminalBlock(block) {
+  return block.state !== "collecting";
+}
+function retireAcceptedIds(sbn) {
+  acceptedSourceEsis.delete(sbn);
+  acceptedRepairEsis.delete(sbn);
+}
+function clearBlockTracking() {
+  blocks.clear();
+  acceptedSourceEsis.clear();
+  acceptedRepairEsis.clear();
+  unplacedSources.clear();
+  pendingVerify.clear();
+  recoveryTimes.length = 0;
+  liveSbn = 0;
+  liveSbnKnown = false;
+}
+function isRetiredSbn(sbn) {
+  if (config === null || !liveSbnKnown) return false;
+  return isoBlocksBehind(sbn, liveSbn, config.k) > config.interleaveDepth;
+}
+function isoKnownLength(block) {
+  return block.ssbLength ?? 1;
+}
+function findIsoBlock(ssId) {
+  for (const block of blocks.values()) {
+    if (isoBlockContains(block.sbn, isoKnownLength(block), ssId)) return block;
+  }
+  return void 0;
+}
+function isRetiredBlock(key, block) {
+  return isRetiredSbn((key + isoKnownLength(block) - 1) % SS_ID_SPAN);
+}
+function trimBlockRetention() {
+  for (const [sbn, block] of blocks) {
+    if (!isTerminalBlock(block) || !isRetiredBlock(sbn, block)) continue;
+    blocks.delete(sbn);
+    retireAcceptedIds(sbn);
+  }
+}
+function advanceMediaHorizon(sbn) {
+  if (!config) return;
+  if (liveSbnKnown && !serialPrecedes(liveSbn, sbn)) return;
+  liveSbn = sbn;
+  liveSbnKnown = true;
+  trimBlockRetention();
+}
+function markBlockTerminal(block, state) {
+  block.state = state;
+  block.completedTs = performance.now();
+  retireAcceptedIds(block.sbn);
+  trimBlockRetention();
+}
+function synchronizeDecoderHorizon() {
+  if (!wasmDecoder || !liveSbnKnown) return;
+  const expired = wasmDecoder.cleanup_by_ss_start(liveSbn);
+  for (const sbn of expired) {
+    const block = blocks.get(sbn);
+    if (!block || isTerminalBlock(block)) {
+      retireAcceptedIds(sbn);
+      continue;
+    }
+    markBlockTerminal(block, "failed");
+    blocksFailed++;
+    emitBlockUpdate(block);
+  }
+  retireUnplacedSources();
+  trimBlockRetention();
+}
+function retireUnplacedSources() {
+  for (const ssId of unplacedSources.keys()) {
+    const unreachable = ssId !== liveSbn && !serialPrecedes(ssId, liveSbn);
+    if (!unreachable && !isRetiredSbn(ssId)) break;
+    unplacedSources.delete(ssId);
+    sourceUnplacedRetired++;
+  }
+}
+function getOrCreateBlock(sbn, isoSsbLength) {
+  let block = blocks.get(sbn);
+  if (!block) {
+    if (!config) throw new Error("[FecWorker] not configured");
+    const now = performance.now();
+    block = {
+      sbn,
+      state: "collecting",
+      sourceReceived: 0,
+      repairReceived: 0,
+      k: isoSsbLength ?? config.k,
+      repairCount: config.repairCount,
+      firstSymbolTs: now,
+      lastSymbolTs: now,
+      deadlineTs: now + config.deliveryWindowMs,
+      altaVerified: 0,
+      relayBlockSigValid: null
+    };
+    if (isoSsbLength !== void 0) block.ssbLength = isoSsbLength;
+    blocks.set(sbn, block);
+    trimBlockRetention();
+  }
+  return block;
+}
+function buildStatsSnapshot() {
+  if (!config) throw new Error("[FecWorker] not configured");
+  const decoderStats = wasmDecoder?.get_stats();
+  const decoder = decoderStats ? {
+    sourcePackets: Number(decoderStats.source_packets),
+    repairPackets: Number(decoderStats.repair_packets),
+    blocksComplete: Number(decoderStats.blocks_complete),
+    blocksRecovered: Number(decoderStats.blocks_recovered),
+    blocksFailed: Number(decoderStats.blocks_failed),
+    bytesRecovered: Number(decoderStats.bytes_recovered),
+    pendingBlocks: wasmDecoder?.pending_blocks() ?? 0
+  } : void 0;
+  const avgRecoveryMs = recoveryTimes.length > 0 ? recoveryTimes.reduce((a, b) => a + b, 0) / recoveryTimes.length : 0;
+  const maxRecoveryMs = recoveryTimes.length > 0 ? Math.max(...recoveryTimes) : 0;
+  const maxBlocks = Math.max(config.interleaveDepth * 3, 24);
+  const blockArray = Array.from(blocks.values()).sort((a, b) => serialDistance(a.sbn, liveSbn) - serialDistance(b.sbn, liveSbn)).slice(0, maxBlocks);
+  return {
+    config,
+    sourceSymbols,
+    repairSymbols,
+    blocksComplete,
+    blocksRecovered,
+    blocksFailed,
+    recoveryRate: blocksComplete + blocksRecovered > 0 ? Math.round(
+      blocksRecovered / (blocksRecovered + blocksFailed) * 100
+    ) || 0 : 0,
+    altaVerified,
+    altaFailed,
+    altaPending,
+    altaPendingEvictedCap,
+    altaPendingEvictedTtl,
+    altaError,
+    altaInitFailed,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    altaFailedDetails: altaFailedDetails.slice(),
+    relayBlocksVerified,
+    relayBlocksFailed,
+    liveSbn,
+    blocks: blockArray,
+    interleaveWindowBlocks: config.interleaveDepth,
+    avgRecoveryMs: Math.round(avgRecoveryMs * 100) / 100,
+    maxRecoveryMs: Math.round(maxRecoveryMs * 100) / 100,
+    repairSymbolSizeMismatch,
+    sourceDroppedRetired,
+    sourceDroppedTerminal,
+    sourceDroppedDuplicate,
+    sourceUnplacedRetired,
+    decoder
+  };
+}
+function emitSnapshot() {
+  if (!config) return;
+  emit({ type: "snapshot", stats: buildStatsSnapshot() });
+}
+function emitBlockUpdate(block) {
+  if (!blockUpdatesSubscribed) return;
+  emit({ type: "blockUpdate", block: { ...block } });
+}
+function emitRecoveredSymbols(sbn, recoveredBlock, block) {
+  if (!config) return;
+  const symbolSize = config.symbolSize;
+  if (symbolSize <= 0) {
+    emit({
+      type: "error",
+      code: "recovered-symbol-size-unconfigured",
+      message: "[FecWorker] recovered block has no configured symbolSize"
+    });
+    return;
+  }
+  const ssbLength = block.ssbLength ?? config.k;
+  if (recoveredBlock.byteLength !== symbolSize * ssbLength) {
+    emit({
+      type: "error",
+      code: "recovered-block-too-short",
+      message: `[FecWorker] recovered block has the wrong length: got ${recoveredBlock.byteLength}B, expected ${symbolSize * ssbLength}B (SSB_length=${ssbLength})`
+    });
+    return;
+  }
+  for (let i = 0; i < ssbLength; i++) {
+    const symbol = recoveredBlock.subarray(i * symbolSize, (i + 1) * symbolSize);
+    const invalid = invalidSsbg1Symbol(symbol, symbolSize);
+    if (invalid !== null) {
+      emit({
+        type: "error",
+        code: "recovered-ssbg1-symbol-invalid",
+        message: `[FecWorker] Dropping recovered ssbg_mode1 symbol (ssStart=${sbn}, esi=${i}, SSB_length=${ssbLength}): ${invalid}`
+      });
+      continue;
+    }
+    const recoveredAltaVerified = null;
+    if (altaEnabled) altaPending++;
+    const buf = toOwnedArrayBuffer(symbol);
+    const meta = {
+      altaVerified: recoveredAltaVerified,
+      recovered: true,
+      sbn,
+      esi: i,
+      ssbLength
+    };
+    emit({ type: "frame", data: buf, meta }, [buf]);
+  }
+}
+function invalidSsbg1Symbol(symbol, symbolSize) {
+  const length = symbol[0] << 8 | symbol[1];
+  const maxLength = symbolSize - SSBG1_LENGTH_FIELD_BYTES;
+  if (length > maxLength) {
+    return `length field ${length} exceeds T-2 = ${maxLength}`;
+  }
+  for (let j = SSBG1_LENGTH_FIELD_BYTES + length; j < symbolSize; j++) {
+    if (symbol[j] !== 0) return `non-zero padding at byte ${j} after a ${length}-byte packet`;
+  }
+  return null;
+}
+function startSnapshotTimer() {
+  if (snapshotTimer !== null) clearInterval(snapshotTimer);
+  snapshotTimer = setInterval(() => emitSnapshot(), 200);
+}
+function resolveWasmBindings() {
+  const bindings = self.__MMT_WASM_BINDINGS__;
+  if (!bindings) {
+    throw new Error(
+      "[FecWorker] WASM bindings not available. Set self.__MMT_WASM_BINDINGS__ = { initSync, MmtFecDecoder } before configure."
+    );
+  }
+  return bindings;
+}
+function verifyDecoderProfile(decoder, expected) {
+  let actual;
+  try {
+    actual = decoder.get_block_profile();
+  } catch (err) {
+    decoder.free();
+    throw new Error(
+      `[FecWorker] configure: decoder cannot report its block profile (${err instanceof Error ? err.message : String(err)})`
+    );
+  }
+  if (actual !== expected) {
+    decoder.free();
+    throw new Error(
+      `[FecWorker] configure: decoder runs block profile ${JSON.stringify(actual)}, not the configured "${expected}"`
+    );
+  }
+}
+function acceptId(ids, key, id) {
+  let set = ids.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    ids.set(key, set);
+  }
+  set.add(id);
+}
+function recordRecovered(key, block, result) {
+  const recovered = new Uint8Array(toOwnedArrayBuffer(result));
+  const recoveryMs = performance.now() - block.firstSymbolTs;
+  recoveryTimes.push(recoveryMs);
+  if (recoveryTimes.length > 1e3) recoveryTimes.shift();
+  if (block.state === "collecting") {
+    markBlockTerminal(block, "recovered");
+    blocksRecovered++;
+    emitBlockUpdate(block);
+  }
+  emitRecoveredSymbols(key, recovered, block);
+}
+function settleSourceArrival(key, block, result) {
+  const authoredLength = block.ssbLength ?? block.k;
+  if (block.sourceReceived >= authoredLength && block.state === "collecting") {
+    markBlockTerminal(block, "complete");
+    blocksComplete++;
+    emitBlockUpdate(block);
+  }
+  if (result && result.byteLength > 0 && block.sourceReceived < authoredLength) {
+    recordRecovered(key, block, result);
+  }
+  synchronizeDecoderHorizon();
+}
+function settleRepairArrival(key, block, ssbLength, result) {
+  if (block.sourceReceived >= ssbLength && block.state === "collecting") {
+    markBlockTerminal(block, "complete");
+    blocksComplete++;
+    emitBlockUpdate(block);
+  } else if (result && result.byteLength > 0) {
+    recordRecovered(key, block, result);
+  }
+  synchronizeDecoderHorizon();
+}
+function feedIsoSource(cmd, view, decoder, cfg) {
+  const maxPacketLength = cfg.symbolSize - SSBG1_LENGTH_FIELD_BYTES;
+  if (view.byteLength > maxPacketLength) {
+    throw new Error(
+      `[FecWorker] feedSource: iso-ssbg1-v1 protected packet of ${view.byteLength}B exceeds T-2 = ${maxPacketLength}B`
+    );
+  }
+  const block = findIsoBlock(cmd.ssId);
+  if (!block) {
+    if (isRetiredSbn(cmd.ssId)) {
+      sourceDroppedRetired++;
+      return;
+    }
+    if (unplacedSources.has(cmd.ssId)) {
+      sourceDroppedDuplicate++;
+      return;
+    }
+    const result2 = decoder.add_source(cmd.ssId, view, cmd.ts);
+    advanceMediaHorizon(cmd.ssId);
+    unplacedSources.set(cmd.ssId, performance.now());
+    sourceSymbols++;
+    if (altaEnabled) altaPending++;
+    if (result2 && result2.byteLength > 0) {
+      emit({
+        type: "error",
+        code: "recovered-block-unplaced",
+        message: `[FecWorker] Dropping a ${result2.byteLength}B recovered block returned for SS_ID ${cmd.ssId}, which no known block contains`
+      });
+    }
+    synchronizeDecoderHorizon();
+    return;
+  }
+  const key = block.sbn;
+  if (isRetiredSbn(key)) {
+    sourceDroppedRetired++;
+    return;
+  }
+  if (isTerminalBlock(block)) {
+    sourceDroppedTerminal++;
+    return;
+  }
+  const esi = serialDistance(key, cmd.ssId);
+  if (acceptedSourceEsis.get(key)?.has(esi)) {
+    sourceDroppedDuplicate++;
+    return;
+  }
+  const result = decoder.add_source(cmd.ssId, view, cmd.ts);
+  advanceMediaHorizon(cmd.ssId);
+  acceptId(acceptedSourceEsis, key, esi);
+  block.sourceReceived++;
+  block.lastSymbolTs = performance.now();
+  sourceSymbols++;
+  if (altaEnabled) altaPending++;
+  settleSourceArrival(key, block, result);
+}
+function findOverlappingIsoBlock(ssStart, ssbLength) {
+  for (const block of blocks.values()) {
+    if (isoBlocksOverlap(block.sbn, isoKnownLength(block), ssStart, ssbLength)) return block;
+  }
+  return void 0;
+}
+function placeIsoBlock(ssStart, ssbLength) {
+  const block = getOrCreateBlock(ssStart, ssbLength);
+  for (let esi = 0; esi < ssbLength; esi++) {
+    const ssId = (ssStart + esi) % SS_ID_SPAN;
+    const arrivalTs = unplacedSources.get(ssId);
+    if (arrivalTs === void 0) continue;
+    unplacedSources.delete(ssId);
+    acceptId(acceptedSourceEsis, ssStart, esi);
+    block.sourceReceived++;
+    if (arrivalTs < block.firstSymbolTs) block.firstSymbolTs = arrivalTs;
+  }
+  return block;
+}
+function feedIsoRepair(cmd, view, decoder) {
+  const key = cmd.ssStart;
+  if (isRetiredSbn(key)) return;
+  const existingBlock = blocks.get(key);
+  if (existingBlock && isTerminalBlock(existingBlock)) return;
+  if (existingBlock) {
+    if (existingBlock.ssbLength !== cmd.ssbLength) {
+      emit({
+        type: "error",
+        code: "repair-ssb-length-conflict",
+        message: `[FecWorker] Dropping repair symbol whose SSB_length ${cmd.ssbLength} conflicts with ${existingBlock.ssbLength} (ssStart=${key})`
+      });
+      return;
+    }
+  } else {
+    const overlapped = findOverlappingIsoBlock(key, cmd.ssbLength);
+    if (overlapped) {
+      emit({
+        type: "error",
+        code: "repair-block-overlap",
+        message: `[FecWorker] Dropping repair symbol whose block (ssStart=${key}, SSB_length=${cmd.ssbLength}) overlaps known block (ssStart=${overlapped.sbn}, SSB_length=${isoKnownLength(overlapped)})`
+      });
+      return;
+    }
+  }
+  const repairEsi = cmd.ssbLength + cmd.rsId;
+  if (acceptedRepairEsis.get(key)?.has(repairEsi)) return;
+  const result = decoder.add_repair(key, cmd.ssbLength, cmd.rsId, view, cmd.ts);
+  advanceMediaHorizon(key);
+  const block = existingBlock ?? placeIsoBlock(key, cmd.ssbLength);
+  acceptId(acceptedRepairEsis, key, repairEsi);
+  block.repairReceived++;
+  block.lastSymbolTs = performance.now();
+  repairSymbols++;
+  settleRepairArrival(key, block, cmd.ssbLength, result);
+}
+async function handleConfigure(cmd) {
+  if (!cmd.wasmModule) {
+    throw new Error("[FecWorker] configure: wasmModule required");
+  }
+  if (!cmd.config) {
+    throw new Error("[FecWorker] configure: config required");
+  }
+  const blockProfile = cmd.config.blockProfile;
+  if (blockProfile === void 0) {
+    throw new Error(
+      '[FecWorker] configure: blockProfile is required: name the FEC block profile ("iso-ssbg1-v1")'
+    );
+  }
+  if (blockProfile !== "iso-ssbg1-v1") {
+    throw new Error(
+      `[FecWorker] configure: blockProfile must be "iso-ssbg1-v1" (got ${JSON.stringify(blockProfile)})`
+    );
+  }
+  if (!Number.isFinite(cmd.config.interleaveDepth) || !Number.isInteger(cmd.config.interleaveDepth) || cmd.config.interleaveDepth <= 0 || cmd.config.interleaveDepth > MAX_INTERLEAVE_DEPTH) {
+    throw new Error(
+      `[FecWorker] configure: interleaveDepth must be an integer in 1..${MAX_INTERLEAVE_DEPTH} (got ${cmd.config.interleaveDepth})`
+    );
+  }
+  if (!Number.isFinite(cmd.config.interleaveMs) || cmd.config.interleaveMs <= 0) {
+    throw new Error(
+      `[FecWorker] configure: interleaveMs must be finite and > 0 (got ${cmd.config.interleaveMs})`
+    );
+  }
+  if (!Number.isFinite(cmd.config.deliveryWindowMs) || cmd.config.deliveryWindowMs <= 0) {
+    throw new Error(
+      `[FecWorker] configure: deliveryWindowMs must be > 0 (got ${cmd.config.deliveryWindowMs})`
+    );
+  }
+  if (!Number.isInteger(cmd.config.k) || cmd.config.k <= 0 || cmd.config.k > MAX_RAPTORQ_SOURCE_SYMBOLS_PER_BLOCK) {
+    throw new Error(
+      `[FecWorker] configure: k must be an integer in 1..${MAX_RAPTORQ_SOURCE_SYMBOLS_PER_BLOCK} (got ${cmd.config.k})`
+    );
+  }
+  if (!Number.isInteger(cmd.config.symbolSize) || cmd.config.symbolSize <= 0 || cmd.config.symbolSize > MAX_SYMBOL_SIZE || cmd.config.symbolSize % 8 !== 0) {
+    throw new Error(
+      `[FecWorker] configure: symbolSize must be an 8-byte-aligned integer in 8..${MAX_SYMBOL_SIZE} (got ${cmd.config.symbolSize})`
+    );
+  }
+  const wasm = resolveWasmBindings();
+  wasm.initSync({ module: cmd.wasmModule });
+  wasmDecoder?.free();
+  wasmDecoder = null;
+  clearBlockTracking();
+  const decoder = new wasm.MmtFecDecoder(cmd.config.interleaveDepth, blockProfile);
+  verifyDecoderProfile(decoder, blockProfile);
+  wasmDecoder = decoder;
+  config = cmd.config;
+  altaEnabled = !!cmd.altaPublicKey;
+  pendingVerifyCap = Math.ceil(config.interleaveDepth * 1.5);
+  pendingVerifyTtlMs = Math.ceil(config.interleaveMs * config.k * 1.5);
+  altaVerifier = null;
+  altaInitFailed = false;
+  if (cmd.altaPublicKey && cmd.altaWasmModule) {
+    try {
+      const altaGlueUrl = "/wasm/alta/alta_rs.js";
+      const altaGlue = await import(
+        /* webpackIgnore: true */
+        altaGlueUrl
+      );
+      altaGlue.initSync({ module: cmd.altaWasmModule });
+      const keyBytes = new Uint8Array(cmd.altaPublicKey);
+      altaVerifier = new altaGlue.JsAltaVerifier(keyBytes);
+    } catch (e) {
+      console.warn("[FecWorker] ALTA WASM init failed, verification disabled:", e);
+      altaVerifier = null;
+      altaEnabled = false;
+      altaInitFailed = true;
+    }
+  }
+  wasmDecoder.configure_params(config.k, config.symbolSize);
+  emit({ type: "capabilities", commands: ["feedSymbols", "subscribeBlockUpdates"] });
+  startSnapshotTimer();
+  emitSnapshot();
+}
+function handleFeedSource(cmd) {
+  if (!wasmDecoder) {
+    throw new Error("[FecWorker] feedSource: not configured");
+  }
+  if (!config) {
+    throw new Error("[FecWorker] feedSource: config missing");
+  }
+  if (!isUint32(cmd.ssId) || !(cmd.data instanceof ArrayBuffer)) {
+    throw new Error("[FecWorker] feedSource: invalid source symbol");
+  }
+  feedIsoSource(cmd, new Uint8Array(cmd.data), wasmDecoder, config);
+}
+function handleFeedRepair(cmd) {
+  if (!wasmDecoder) {
+    throw new Error("[FecWorker] feedRepair: not configured");
+  }
+  if (!config) {
+    throw new Error("[FecWorker] feedRepair: config missing");
+  }
+  if (!isUint32(cmd.ssStart) || !isUint32(cmd.ssbLength) || cmd.ssbLength <= 0 || cmd.ssbLength > config.k || !isUint32(cmd.rsId) || cmd.ssbLength + cmd.rsId > UINT24_MAX || !(cmd.data instanceof ArrayBuffer)) {
+    throw new Error("[FecWorker] feedRepair: invalid repair symbol");
+  }
+  const view = new Uint8Array(cmd.data);
+  if (config.symbolSize > 0 && view.byteLength !== config.symbolSize) {
+    repairSymbolSizeMismatch++;
+    if (repairSymbolSizeMismatch <= 5 || repairSymbolSizeMismatch % 100 === 0) {
+      emit({
+        type: "error",
+        code: "repair-symbol-size-mismatch",
+        message: `[FecWorker] Dropping repair symbol with invalid size: got ${view.byteLength}B, expected ${config.symbolSize}B (ssStart=${cmd.ssStart}, ssbLength=${cmd.ssbLength}, rsId=${cmd.rsId})`
+      });
+    }
+    return;
+  }
+  feedIsoRepair(cmd, view, wasmDecoder);
+}
+function handleRelayBlockSig(cmd) {
+  const block = blocks.get(cmd.sbn);
+  if (block) {
+    block.relayBlockSigValid = null;
+    emitBlockUpdate(block);
+  }
+}
+function handleCleanup(cmd) {
+  if (!Array.isArray(cmd.sbns) || cmd.sbns.length === 0 || !cmd.sbns.every(isUint32)) {
+    throw new Error("[FecWorker] cleanup: invalid SBNs");
+  }
+  const sbns = [...new Set(cmd.sbns)].sort((a, b) => a - b);
+  const pendingSbns = sbns.filter((sbn) => !isRetiredSbn(sbn));
+  try {
+    if (!wasmDecoder) {
+      throw new Error("[FecWorker] cleanup: not configured");
+    }
+    if (pendingSbns.length > 0) {
+      wasmDecoder.cleanup_blocks_detailed(Uint32Array.from(pendingSbns));
+    }
+    for (const sbn of pendingSbns) {
+      let currentBlock = blocks.get(sbn);
+      if (currentBlock && isTerminalBlock(currentBlock)) {
+        retireAcceptedIds(sbn);
+        continue;
+      }
+      currentBlock ??= getOrCreateBlock(sbn);
+      const authoredLength = currentBlock.ssbLength;
+      if (authoredLength !== void 0 && currentBlock.sourceReceived >= authoredLength) {
+        markBlockTerminal(currentBlock, "complete");
+        blocksComplete++;
+      } else {
+        markBlockTerminal(currentBlock, "failed");
+        blocksFailed++;
+      }
+      emitBlockUpdate(currentBlock);
+    }
+  } finally {
+    emit({ type: "cleanupComplete", sbns });
+  }
+}
+function handleDispose() {
+  if (snapshotTimer !== null) {
+    clearInterval(snapshotTimer);
+    snapshotTimer = null;
+  }
+  if (altaVerifier) {
+    try {
+      altaVerifier.free();
+    } catch (_e) {
+    }
+    altaVerifier = null;
+  }
+  if (wasmDecoder) {
+    wasmDecoder.free();
+    wasmDecoder = null;
+  }
+  pendingVerify.clear();
+  pendingVerifyCap = 0;
+  pendingVerifyTtlMs = 0;
+  config = null;
+  clearBlockTracking();
+}
+function handleReset() {
+  try {
+    wasmDecoder?.flush();
+    wasmDecoder?.reset_stats();
+  } catch (err) {
+    emit({
+      type: "error",
+      code: "reset-failed",
+      message: err instanceof Error ? `[FecWorker] reset failed: ${err.message}` : `[FecWorker] reset failed: ${String(err)}`
+    });
+    return;
+  }
+  clearBlockTracking();
+  sourceSymbols = 0;
+  repairSymbols = 0;
+  blocksComplete = 0;
+  blocksRecovered = 0;
+  blocksFailed = 0;
+  altaVerified = 0;
+  altaFailed = 0;
+  altaFailedDetails.length = 0;
+  altaPending = 0;
+  altaPendingEvictedCap = 0;
+  altaPendingEvictedTtl = 0;
+  altaError = 0;
+  relayBlocksVerified = 0;
+  relayBlocksFailed = 0;
+  repairSymbolSizeMismatch = 0;
+  sourceDroppedRetired = 0;
+  sourceDroppedTerminal = 0;
+  sourceDroppedDuplicate = 0;
+  sourceUnplacedRetired = 0;
+  emit({ type: "resetComplete" });
+  if (config) emitSnapshot();
+}
+function handleFeedSymbols(cmd) {
+  if (!Array.isArray(cmd.symbols)) {
+    throw new Error("[FecWorker] feedSymbols: symbols must be an array");
+  }
+  for (const symbol of cmd.symbols) {
+    try {
+      if (symbol?.type === "feedSource") handleFeedSource(symbol);
+      else if (symbol?.type === "feedRepair") handleFeedRepair(symbol);
+      else {
+        throw new Error(
+          `[FecWorker] feedSymbols: unknown symbol type ${String(symbol?.type)}`
+        );
+      }
+    } catch (err) {
+      emit({
+        type: "error",
+        code: "command-failed",
+        message: err instanceof Error ? err.message : `[FecWorker] ${String(err)}`
+      });
+    }
+  }
+}
+async function dispatchCommand(cmd) {
+  try {
+    switch (cmd.type) {
+      case "configure":
+        await handleConfigure(cmd);
+        break;
+      case "feedSource":
+        handleFeedSource(cmd);
+        break;
+      case "feedRepair":
+        handleFeedRepair(cmd);
+        break;
+      case "feedSymbols":
+        handleFeedSymbols(cmd);
+        break;
+      case "relayBlockSig":
+        handleRelayBlockSig(cmd);
+        break;
+      case "cleanup":
+        handleCleanup(cmd);
+        break;
+      case "reset":
+        handleReset();
+        break;
+      case "subscribeBlockUpdates":
+        blockUpdatesSubscribed = true;
+        break;
+      case "dispose":
+        handleDispose();
+        break;
+      default:
+        emit({
+          type: "error",
+          code: "unknown-command",
+          message: `Unknown command type: ${cmd.type}`
+        });
+    }
+  } catch (err) {
+    emit({
+      type: "error",
+      code: "command-failed",
+      message: err instanceof Error ? err.message : `[FecWorker] ${String(err)}`
+    });
+  }
+}
+var commandQueue = Promise.resolve();
+self.onmessage = (e) => {
+  const cmd = e.data;
+  commandQueue = commandQueue.then(() => dispatchCommand(cmd));
+};
+//# sourceMappingURL=fec-worker.js.map