@blockcast/fec-worker 0.1.0 → 0.3.0-main.0bde85f7082f

package/dist/fec-worker.js

@@ -7,17 +7,58 @@ function toOwnedArrayBuffer(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;
@@ -26,7 +67,6 @@ var repairSymbols = 0;
 var blocksComplete = 0;
 var blocksRecovered = 0;
 var blocksFailed = 0;
-var greenFillFrames = 0;
 var altaVerified = 0;
 var altaFailed = 0;
 var altaFailedDetails = [];
@@ -38,8 +78,12 @@ 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;
@@ -61,23 +105,46 @@ function clearBlockTracking() {
   blocks.clear();
   acceptedSourceEsis.clear();
   acceptedRepairEsis.clear();
+  unplacedSources.clear();
   pendingVerify.clear();
   recoveryTimes.length = 0;
   liveSbn = 0;
-  retiredSbnFrontier = -1;
+  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) || 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) {
+    const ahead = config.blockProfile === "iso-ssbg1-v1" ? serialPrecedes(liveSbn, sbn) : blockPrecedes(liveSbn, sbn, config.k);
+    if (!ahead) 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 +154,9 @@ function markBlockTerminal(block, state) {
   trimBlockRetention();
 }
 function synchronizeDecoderHorizon() {
-  if (!wasmDecoder) return;
-  const expired = wasmDecoder.cleanup_by_sbn(liveSbn);
+  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)) {
@@ -99,9 +167,18 @@ function synchronizeDecoderHorizon() {
     blocksFailed++;
     emitBlockUpdate(block);
   }
+  if (iso) 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,7 +188,7 @@ function getOrCreateBlock(sbn) {
       state: "collecting",
       sourceReceived: 0,
       repairReceived: 0,
-      k: config.k,
+      k: isoSsbLength ?? config.k,
       repairCount: config.repairCount,
       firstSymbolTs: now,
       lastSymbolTs: now,
@@ -119,6 +196,7 @@ function getOrCreateBlock(sbn) {
       altaVerified: 0,
       relayBlockSigValid: null
     };
+    if (isoSsbLength !== void 0) block.ssbLength = isoSsbLength;
     blocks.set(sbn, block);
     trimBlockRetention();
   }
@@ -147,7 +225,6 @@ function buildStatsSnapshot() {
     blocksComplete,
     blocksRecovered,
     blocksFailed,
-    greenFillFrames,
     recoveryRate: blocksComplete + blocksRecovered > 0 ? Math.round(
       blocksRecovered / (blocksRecovered + blocksFailed) * 100
     ) || 0 : 0,
@@ -168,6 +245,10 @@ function buildStatsSnapshot() {
     avgRecoveryMs: Math.round(avgRecoveryMs * 100) / 100,
     maxRecoveryMs: Math.round(maxRecoveryMs * 100) / 100,
     repairSymbolSizeMismatch,
+    sourceDroppedRetired,
+    sourceDroppedTerminal,
+    sourceDroppedDuplicate,
+    ...config.blockProfile === "iso-ssbg1-v1" ? { sourceUnplacedRetired } : {},
     decoder
   };
 }
@@ -176,6 +257,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,16 +271,29 @@ 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++) {
+  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);
@@ -206,11 +301,23 @@ function emitRecoveredSymbols(sbn, recoveredBlock, block) {
       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 +331,175 @@ 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 (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");
@@ -231,6 +507,17 @@ 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 ("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})`
@@ -261,10 +548,9 @@ 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);
@@ -289,6 +575,7 @@ async function handleConfigure(cmd) {
     }
   }
   wasmDecoder.configure_params(config.k, config.symbolSize);
+  emit({ type: "capabilities", commands: ["feedSymbols", "subscribeBlockUpdates"] });
   startSnapshotTimer();
   emitSnapshot();
 }
@@ -303,12 +590,25 @@ function handleFeedSource(cmd) {
     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 (sbn <= retiredSbnFrontier) return;
+  if (isRetiredSbn(sbn)) {
+    sourceDroppedRetired++;
+    return;
+  }
   const existingBlock = blocks.get(sbn);
-  if (existingBlock && isTerminalBlock(existingBlock)) return;
-  if (acceptedSourceEsis.get(sbn)?.has(esi)) return;
+  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);
@@ -322,24 +622,7 @@ function handleFeedSource(cmd) {
   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();
+  settleSourceArrival(sbn, block, result);
 }
 function handleFeedRepair(cmd) {
   if (!wasmDecoder) {
@@ -348,7 +631,8 @@ 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)) {
+  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);
@@ -363,12 +647,24 @@ function handleFeedRepair(cmd) {
     }
     return;
   }
-  const sbn = Math.floor(cmd.ssStart / cmd.ssbLength);
-  const repairEsi = cmd.ssbLength + cmd.rsId;
-  if (sbn <= retiredSbnFrontier) 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,
@@ -384,22 +680,11 @@ function handleFeedRepair(cmd) {
   }
   repairEsis.add(repairEsi);
   const block = getOrCreateBlock(sbn);
+  block.ssbLength = cmd.ssbLength;
   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();
+  settleRepairArrival(sbn, block, cmd.ssbLength, result);
 }
 function handleRelayBlockSig(cmd) {
   const block = blocks.get(cmd.sbn);
@@ -413,20 +698,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 = isIsoProfile() ? currentBlock.ssbLength : currentBlock.k;
+      if (authoredLength !== void 0 && currentBlock.sourceReceived >= authoredLength) {
         markBlockTerminal(currentBlock, "complete");
         blocksComplete++;
       } else {
@@ -435,35 +723,10 @@ 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);
@@ -504,7 +767,6 @@ function handleReset() {
   blocksComplete = 0;
   blocksRecovered = 0;
   blocksFailed = 0;
-  greenFillFrames = 0;
   altaVerified = 0;
   altaFailed = 0;
   altaFailedDetails.length = 0;
@@ -515,9 +777,35 @@ function handleReset() {
   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 +818,9 @@ async function dispatchCommand(cmd) {
       case "feedRepair":
         handleFeedRepair(cmd);
         break;
+      case "feedSymbols":
+        handleFeedSymbols(cmd);
+        break;
       case "relayBlockSig":
         handleRelayBlockSig(cmd);
         break;
@@ -539,6 +830,9 @@ async function dispatchCommand(cmd) {
       case "reset":
         handleReset();
         break;
+      case "subscribeBlockUpdates":
+        blockUpdatesSubscribed = true;
+        break;
       case "dispose":
         handleDispose();
         break;