@blockcast/mmt-container 0.3.0 → 0.4.0-main.d6f2737828fc

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

@@ -1,859 +0,0 @@
-// 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 blockStart(sbn, k) {
-  return sbn * k % SPAN;
-}
-function precedingDistance(a, b, k) {
-  const distance = (blockStart(b, k) - blockStart(a, k) + SPAN) % SPAN;
-  return distance !== 0 && distance < HALF ? distance : null;
-}
-function blockPrecedes(a, b, k) {
-  return precedingDistance(a, b, k) !== null;
-}
-function blocksBehind(a, b, k) {
-  const distance = precedingDistance(a, b, k);
-  return distance === null ? 0 : Math.ceil(distance / k);
-}
-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 config.blockProfile === "iso-ssbg1-v1" ? isoBlocksBehind(sbn, liveSbn, config.k) > config.interleaveDepth : blocksBehind(sbn, liveSbn, config.k) > config.interleaveDepth;
-}
-function isIsoProfile() {
-  return config?.blockProfile === "iso-ssbg1-v1";
-}
-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 isIsoProfile() ? isRetiredSbn((key + isoKnownLength(block) - 1) % SS_ID_SPAN) : isRetiredSbn(key);
-}
-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) {
-    const ahead = config.blockProfile === "iso-ssbg1-v1" ? serialPrecedes(liveSbn, sbn) : blockPrecedes(liveSbn, sbn, config.k);
-    if (!ahead) 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 iso = isIsoProfile();
-  const expired = iso ? wasmDecoder.cleanup_by_ss_start(liveSbn) : wasmDecoder.cleanup_by_sbn(liveSbn);
-  for (const sbn of expired) {
-    const block = blocks.get(sbn);
-    if (!block || isTerminalBlock(block)) {
-      retireAcceptedIds(sbn);
-      continue;
-    }
-    markBlockTerminal(block, "failed");
-    blocksFailed++;
-    emitBlockUpdate(block);
-  }
-  if (iso) 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) => b.sbn - a.sbn).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,
-    ...config.blockProfile === "iso-ssbg1-v1" ? { 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;
-  }
-  const iso = config.blockProfile === "iso-ssbg1-v1";
-  for (let i = 0; i < ssbLength; i++) {
-    const symbol = recoveredBlock.subarray(i * symbolSize, (i + 1) * symbolSize);
-    if (iso) {
-      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 ("k-padded-v1" or "iso-ssbg1-v1")'
-    );
-  }
-  if (blockProfile !== "k-padded-v1" && blockProfile !== "iso-ssbg1-v1") {
-    throw new Error(
-      `[FecWorker] configure: blockProfile must be "k-padded-v1" or "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");
-  }
-  const view = new Uint8Array(cmd.data);
-  if (config.blockProfile === "iso-ssbg1-v1") {
-    feedIsoSource(cmd, view, wasmDecoder, config);
-    return;
-  }
-  const sbn = config.k > 0 ? Math.floor(cmd.ssId / config.k) : cmd.ssId;
-  const esi = cmd.ssId % config.k;
-  if (isRetiredSbn(sbn)) {
-    sourceDroppedRetired++;
-    return;
-  }
-  const existingBlock = blocks.get(sbn);
-  if (existingBlock && isTerminalBlock(existingBlock)) {
-    sourceDroppedTerminal++;
-    return;
-  }
-  if (acceptedSourceEsis.get(sbn)?.has(esi)) {
-    sourceDroppedDuplicate++;
-    return;
-  }
-  const result = wasmDecoder.add_source(cmd.ssId, view, cmd.ts);
-  advanceMediaHorizon(sbn);
-  let sourceEsis = acceptedSourceEsis.get(sbn);
-  if (!sourceEsis) {
-    sourceEsis = /* @__PURE__ */ new Set();
-    acceptedSourceEsis.set(sbn, sourceEsis);
-  }
-  sourceEsis.add(esi);
-  const block = getOrCreateBlock(sbn);
-  block.sourceReceived++;
-  block.lastSymbolTs = performance.now();
-  sourceSymbols++;
-  if (altaEnabled) altaPending++;
-  settleSourceArrival(sbn, block, result);
-}
-function handleFeedRepair(cmd) {
-  if (!wasmDecoder) {
-    throw new Error("[FecWorker] feedRepair: not configured");
-  }
-  if (!config) {
-    throw new Error("[FecWorker] feedRepair: config missing");
-  }
-  const iso = config.blockProfile === "iso-ssbg1-v1";
-  if (!isUint32(cmd.ssStart) || !isUint32(cmd.ssbLength) || cmd.ssbLength <= 0 || cmd.ssbLength > config.k || !iso && cmd.ssStart % config.k !== 0 || !isUint32(cmd.rsId) || (iso ? cmd.ssbLength : config.k) + 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;
-  }
-  if (iso) {
-    feedIsoRepair(cmd, view, wasmDecoder);
-    return;
-  }
-  const sbn = Math.floor(cmd.ssStart / config.k);
-  const repairEsi = config.k + cmd.rsId;
-  if (isRetiredSbn(sbn)) return;
-  const existingBlock = blocks.get(sbn);
-  if (existingBlock && isTerminalBlock(existingBlock)) return;
-  if (acceptedRepairEsis.get(sbn)?.has(repairEsi)) return;
-  if (existingBlock?.ssbLength !== void 0 && 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} (sbn=${sbn})`
-    });
-    return;
-  }
-  const result = wasmDecoder.add_repair(
-    cmd.ssStart,
-    cmd.ssbLength,
-    cmd.rsId,
-    view,
-    cmd.ts
-  );
-  advanceMediaHorizon(sbn);
-  let repairEsis = acceptedRepairEsis.get(sbn);
-  if (!repairEsis) {
-    repairEsis = /* @__PURE__ */ new Set();
-    acceptedRepairEsis.set(sbn, repairEsis);
-  }
-  repairEsis.add(repairEsi);
-  const block = getOrCreateBlock(sbn);
-  block.ssbLength = cmd.ssbLength;
-  block.repairReceived++;
-  block.lastSymbolTs = performance.now();
-  repairSymbols++;
-  settleRepairArrival(sbn, block, cmd.ssbLength, result);
-}
-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 = isIsoProfile() ? currentBlock.ssbLength : currentBlock.k;
-      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