@blockcast/fec-worker 0.1.0 → 0.3.0-main.10140e847083

package/dist/fec-worker.js

@@ -7,17 +7,42 @@ function toOwnedArrayBuffer(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;
@@ -26,24 +51,16 @@ var repairSymbols = 0;
 var blocksComplete = 0;
 var blocksRecovered = 0;
 var blocksFailed = 0;
-var greenFillFrames = 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 retiredSbnFrontier = -1;
+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 ?? []);
 }
@@ -61,23 +78,39 @@ function clearBlockTracking() {
   blocks.clear();
   acceptedSourceEsis.clear();
   acceptedRepairEsis.clear();
-  pendingVerify.clear();
+  unplacedSources.clear();
   recoveryTimes.length = 0;
   liveSbn = 0;
-  retiredSbnFrontier = -1;
+  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) || sbn > retiredSbnFrontier) continue;
+    if (!isTerminalBlock(block) || !isRetiredBlock(sbn, block)) continue;
     blocks.delete(sbn);
     retireAcceptedIds(sbn);
   }
 }
 function advanceMediaHorizon(sbn) {
-  if (!config || sbn <= liveSbn) return;
+  if (!config) return;
+  if (liveSbnKnown && !serialPrecedes(liveSbn, sbn)) return;
   liveSbn = sbn;
-  const firstRetainedSbn = Math.max(0, liveSbn - config.interleaveDepth);
-  retiredSbnFrontier = Math.max(retiredSbnFrontier, firstRetainedSbn - 1);
+  liveSbnKnown = true;
   trimBlockRetention();
 }
 function markBlockTerminal(block, state) {
@@ -87,8 +120,8 @@ function markBlockTerminal(block, state) {
   trimBlockRetention();
 }
 function synchronizeDecoderHorizon() {
-  if (!wasmDecoder) return;
-  const expired = wasmDecoder.cleanup_by_sbn(liveSbn);
+  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)) {
@@ -99,9 +132,18 @@ function synchronizeDecoderHorizon() {
     blocksFailed++;
     emitBlockUpdate(block);
   }
+  retireUnplacedSources();
   trimBlockRetention();
 }
-function getOrCreateBlock(sbn) {
+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");
@@ -111,14 +153,16 @@ function getOrCreateBlock(sbn) {
       state: "collecting",
       sourceReceived: 0,
       repairReceived: 0,
-      k: config.k,
+      k: isoSsbLength ?? config.k,
       repairCount: config.repairCount,
       firstSymbolTs: now,
       lastSymbolTs: now,
+      // A positive interleaveMs makes this the catalog completion deadline;
+      // zero makes deliveryWindowMs a receiver-local cleanup bound.
       deadlineTs: now + config.deliveryWindowMs,
-      altaVerified: 0,
       relayBlockSigValid: null
     };
+    if (isoSsbLength !== void 0) block.ssbLength = isoSsbLength;
     blocks.set(sbn, block);
     trimBlockRetention();
   }
@@ -139,7 +183,7 @@ function buildStatsSnapshot() {
   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);
+  const blockArray = Array.from(blocks.values()).sort((a, b) => serialDistance(a.sbn, liveSbn) - serialDistance(b.sbn, liveSbn)).slice(0, maxBlocks);
   return {
     config,
     sourceSymbols,
@@ -147,19 +191,9 @@ function buildStatsSnapshot() {
     blocksComplete,
     blocksRecovered,
     blocksFailed,
-    greenFillFrames,
     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,
@@ -168,6 +202,10 @@ function buildStatsSnapshot() {
     avgRecoveryMs: Math.round(avgRecoveryMs * 100) / 100,
     maxRecoveryMs: Math.round(maxRecoveryMs * 100) / 100,
     repairSymbolSizeMismatch,
+    sourceDroppedRetired,
+    sourceDroppedTerminal,
+    sourceDroppedDuplicate,
+    sourceUnplacedRetired,
     decoder
   };
 }
@@ -176,6 +214,7 @@ function emitSnapshot() {
   emit({ type: "snapshot", stats: buildStatsSnapshot() });
 }
 function emitBlockUpdate(block) {
+  if (!blockUpdatesSubscribed) return;
   emit({ type: "blockUpdate", block: { ...block } });
 }
 function emitRecoveredSymbols(sbn, recoveredBlock, block) {
@@ -189,28 +228,47 @@ function emitRecoveredSymbols(sbn, recoveredBlock, block) {
     });
     return;
   }
-  if (recoveredBlock.byteLength < symbolSize * config.k) {
+  const ssbLength = block.ssbLength ?? config.k;
+  if (recoveredBlock.byteLength !== symbolSize * ssbLength) {
     emit({
       type: "error",
       code: "recovered-block-too-short",
-      message: `[FecWorker] recovered block too short: got ${recoveredBlock.byteLength}B, expected at least ${symbolSize * config.k}B`
+      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 < config.k; i++) {
+  for (let i = 0; i < ssbLength; i++) {
     const symbol = recoveredBlock.subarray(i * symbolSize, (i + 1) * symbolSize);
-    const recoveredAltaVerified = null;
-    if (altaEnabled) altaPending++;
+    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 buf = toOwnedArrayBuffer(symbol);
     const meta = {
-      altaVerified: recoveredAltaVerified,
       recovered: true,
       sbn,
-      esi: i
+      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);
@@ -224,6 +282,173 @@ function resolveWasmBindings() {
   }
   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 (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++;
+  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");
@@ -231,14 +456,25 @@ async function handleConfigure(cmd) {
   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) {
+  if (!Number.isFinite(cmd.config.interleaveMs) || !Number.isSafeInteger(cmd.config.interleaveMs) || cmd.config.interleaveMs < 0) {
     throw new Error(
-      `[FecWorker] configure: interleaveMs must be finite and > 0 (got ${cmd.config.interleaveMs})`
+      `[FecWorker] configure: interleaveMs must be a finite non-negative integer (got ${cmd.config.interleaveMs})`
     );
   }
   if (!Number.isFinite(cmd.config.deliveryWindowMs) || cmd.config.deliveryWindowMs <= 0) {
@@ -261,34 +497,12 @@ async function handleConfigure(cmd) {
   wasmDecoder?.free();
   wasmDecoder = null;
   clearBlockTracking();
-  wasmDecoder = new wasm.MmtFecDecoder(
-    cmd.config.interleaveDepth,
-    cmd.config.trackType === "video"
-  );
+  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();
 }
@@ -302,44 +516,7 @@ function handleFeedSource(cmd) {
   if (!isUint32(cmd.ssId) || !(cmd.data instanceof ArrayBuffer)) {
     throw new Error("[FecWorker] feedSource: invalid source symbol");
   }
-  const view = new Uint8Array(cmd.data);
-  const sbn = config.k > 0 ? Math.floor(cmd.ssId / config.k) : cmd.ssId;
-  const esi = cmd.ssId % config.k;
-  if (sbn <= retiredSbnFrontier) return;
-  const existingBlock = blocks.get(sbn);
-  if (existingBlock && isTerminalBlock(existingBlock)) return;
-  if (acceptedSourceEsis.get(sbn)?.has(esi)) 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++;
-  if (block.sourceReceived >= block.k && block.state === "collecting") {
-    markBlockTerminal(block, "complete");
-    blocksComplete++;
-    emitBlockUpdate(block);
-  }
-  if (result && result.byteLength > 0 && block.sourceReceived < block.k) {
-    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(sbn, recovered, block);
-  }
-  synchronizeDecoderHorizon();
+  feedIsoSource(cmd, new Uint8Array(cmd.data), wasmDecoder, config);
 }
 function handleFeedRepair(cmd) {
   if (!wasmDecoder) {
@@ -348,7 +525,7 @@ function handleFeedRepair(cmd) {
   if (!config) {
     throw new Error("[FecWorker] feedRepair: config missing");
   }
-  if (!isUint32(cmd.ssStart) || !isUint32(cmd.ssbLength) || cmd.ssbLength <= 0 || cmd.ssbLength !== config.k || cmd.ssStart % cmd.ssbLength !== 0 || !isUint32(cmd.rsId) || cmd.ssbLength + cmd.rsId > UINT24_MAX || !(cmd.data instanceof ArrayBuffer)) {
+  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);
@@ -363,43 +540,7 @@ function handleFeedRepair(cmd) {
     }
     return;
   }
-  const sbn = Math.floor(cmd.ssStart / cmd.ssbLength);
-  const repairEsi = cmd.ssbLength + cmd.rsId;
-  if (sbn <= retiredSbnFrontier) return;
-  const existingBlock = blocks.get(sbn);
-  if (existingBlock && isTerminalBlock(existingBlock)) return;
-  if (acceptedRepairEsis.get(sbn)?.has(repairEsi)) 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.repairReceived++;
-  block.lastSymbolTs = performance.now();
-  repairSymbols++;
-  if (result && result.byteLength > 0) {
-    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(sbn, recovered, block);
-  }
-  synchronizeDecoderHorizon();
+  feedIsoRepair(cmd, view, wasmDecoder);
 }
 function handleRelayBlockSig(cmd) {
   const block = blocks.get(cmd.sbn);
@@ -413,20 +554,23 @@ function handleCleanup(cmd) {
     throw new Error("[FecWorker] cleanup: invalid SBNs");
   }
   const sbns = [...new Set(cmd.sbns)].sort((a, b) => a - b);
-  const pendingSbns = sbns.filter((sbn) => sbn > retiredSbnFrontier);
+  const pendingSbns = sbns.filter((sbn) => !isRetiredSbn(sbn));
   try {
     if (!wasmDecoder) {
       throw new Error("[FecWorker] cleanup: not configured");
     }
-    const cleanupRecords = pendingSbns.length > 0 ? wasmDecoder.cleanup_blocks_detailed(Uint32Array.from(pendingSbns)) : new Uint8Array();
+    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 ?? (currentBlock = getOrCreateBlock(sbn));
-      if (currentBlock.sourceReceived >= currentBlock.k) {
+      currentBlock ??= getOrCreateBlock(sbn);
+      const authoredLength = currentBlock.ssbLength;
+      if (authoredLength !== void 0 && currentBlock.sourceReceived >= authoredLength) {
         markBlockTerminal(currentBlock, "complete");
         blocksComplete++;
       } else {
@@ -435,54 +579,19 @@ function handleCleanup(cmd) {
       }
       emitBlockUpdate(currentBlock);
     }
-    const greenFills = decodeCleanupRecords(cleanupRecords);
-    for (const { sbn, data } of greenFills) {
-      greenFillFrames++;
-      emit({ type: "greenFill", sbn, data }, [data]);
-    }
   } finally {
     emit({ type: "cleanupComplete", sbns });
   }
 }
-function decodeCleanupRecords(framed) {
-  const records = [];
-  const view = new DataView(framed.buffer, framed.byteOffset, framed.byteLength);
-  let offset = 0;
-  while (offset < framed.byteLength) {
-    if (framed.byteLength - offset < 8) {
-      throw new Error("[FecWorker] cleanup_blocks_detailed: truncated record header");
-    }
-    const sbn = view.getUint32(offset, false);
-    const length = view.getUint32(offset + 4, false);
-    offset += 8;
-    if (length > framed.byteLength - offset) {
-      throw new Error("[FecWorker] cleanup_blocks_detailed: truncated record payload");
-    }
-    const data = toOwnedArrayBuffer(framed.subarray(offset, offset + length));
-    records.push({ sbn, data });
-    offset += length;
-  }
-  return records;
-}
 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();
 }
@@ -504,20 +613,38 @@ function handleReset() {
   blocksComplete = 0;
   blocksRecovered = 0;
   blocksFailed = 0;
-  greenFillFrames = 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) {
@@ -530,6 +657,9 @@ async function dispatchCommand(cmd) {
       case "feedRepair":
         handleFeedRepair(cmd);
         break;
+      case "feedSymbols":
+        handleFeedSymbols(cmd);
+        break;
       case "relayBlockSig":
         handleRelayBlockSig(cmd);
         break;
@@ -539,6 +669,9 @@ async function dispatchCommand(cmd) {
       case "reset":
         handleReset();
         break;
+      case "subscribeBlockUpdates":
+        blockUpdatesSubscribed = true;
+        break;
       case "dispose":
         handleDispose();
         break;