@blockcast/fec-worker 0.1.0-main.c71423b8a4e4 → 0.1.0-main.ce3c8aeb7f68

package/src/fec-worker.ts

@@ -75,6 +75,8 @@ let altaEnabled = false;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let altaVerifier: any = null;  // JsAltaVerifier instance (loaded from ALTA WASM)
 let snapshotTimer: ReturnType<typeof setInterval> | null = null;
+// blockUpdate events are posted only after a client subscribes (BLO-36599).
+let blockUpdatesSubscribed = false;
 
 // Block tracking
 const blocks = new Map<number, FecBlockSnapshot>();
@@ -478,6 +480,7 @@ function emitSnapshot(): void {
 }
 
 function emitBlockUpdate(block: FecBlockSnapshot): void {
+	if (!blockUpdatesSubscribed) return;
 	emit({ type: "blockUpdate", block: { ...block } });
 }
 
@@ -496,16 +499,19 @@ function emitRecoveredSymbols(
 		});
 		return;
 	}
-	if (recoveredBlock.byteLength < symbolSize * config.k) {
+	// The decoder returns only the block's authored source symbols
+	// (SSB_length x T); the encoder's zero padding is not media.
+	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);
 
 		// Source authentication now runs once at router admission in
@@ -520,6 +526,7 @@ function emitRecoveredSymbols(
 			recovered: true,
 			sbn,
 			esi: i,
+			ssbLength,
 		};
 		emit({ type: "frame", data: buf, meta }, [buf]);
 	}
@@ -662,6 +669,10 @@ async function handleConfigure(
 
 	wasmDecoder.configure_params(config.k, config.symbolSize);
 
+	// Tell the client which optional commands this Worker accepts, so it can
+	// batch symbols without risking a Worker that predates the batch command.
+	emit({ type: "capabilities", commands: ["feedSymbols", "subscribeBlockUpdates"] });
+
 	// Start periodic snapshot emission (200ms floor)
 	startSnapshotTimer();
 
@@ -716,9 +727,11 @@ function handleFeedSource(
 	// authenticated by the canonical manifest verifier at router admission.
 	if (altaEnabled) altaPending++;
 
-	// Check if block is complete (all K source symbols received)
+	// Check if block is complete (all authored source symbols received:
+	// SSB_length once a repair symbol declared it, otherwise K)
+	const authoredLength = block.ssbLength ?? block.k;
 	if (
-		block.sourceReceived >= block.k &&
+		block.sourceReceived >= authoredLength &&
 		block.state === "collecting"
 	) {
 		markBlockTerminal(block, "complete");
@@ -730,7 +743,7 @@ function handleFeedSource(
 		// of earlier missing symbols after repair arrived. Clean completion is
 		// already routed by the source path, so only emit when the block did not
 		// reach K source arrivals.
-		if (result && result.byteLength > 0 && block.sourceReceived < block.k) {
+		if (result && result.byteLength > 0 && block.sourceReceived < authoredLength) {
 			const recovered = new Uint8Array(toOwnedArrayBuffer(result));
 			const recoveryMs = performance.now() - block.firstSymbolTs;
 			recoveryTimes.push(recoveryMs);
@@ -786,6 +799,16 @@ function handleFeedRepair(
 	const existingBlock = blocks.get(sbn);
 	if (existingBlock && isTerminalBlock(existingBlock)) return;
 	if (acceptedRepairEsis.get(sbn)?.has(repairEsi)) return;
+	// One block has one authored SSB_length; a repair symbol naming another
+	// is dropped before it reaches the decoder (which rejects it too).
+	if (existingBlock?.ssbLength !== undefined && 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,
@@ -802,13 +825,20 @@ function handleFeedRepair(
 	}
 	repairEsis.add(repairEsi);
 	const block = getOrCreateBlock(sbn);
+	block.ssbLength = cmd.ssbLength;
 	block.repairReceived++;
 	block.lastSymbolTs = performance.now();
 	repairSymbols++;
-		// If WASM returned data, it is the recovered source block: K fixed-width
-		// source symbols concatenated. Split it before emitting so MmtpRouter gets
-		// the same one-symbol shape as a direct source packet.
-		if (result && result.byteLength > 0) {
+		// Every authored source symbol already arrived: knowing SSB_length makes
+		// the block clean. The decoder's return is the source already routed.
+		// Otherwise, returned data is the recovered source block: its SSB_length
+		// fixed-width authored symbols concatenated. Split it before emitting so
+		// MmtpRouter gets the same one-symbol shape as a direct source packet.
+		if (block.sourceReceived >= cmd.ssbLength && block.state === "collecting") {
+			markBlockTerminal(block, "complete");
+			blocksComplete++;
+			emitBlockUpdate(block);
+		} else if (result && result.byteLength > 0) {
 			const recovered = new Uint8Array(toOwnedArrayBuffer(result));
 			const recoveryMs = performance.now() - block.firstSymbolTs;
 			recoveryTimes.push(recoveryMs);
@@ -994,6 +1024,38 @@ function handleReset(): void {
 	if (config) emitSnapshot();
 }
 
+/**
+ * A batch of symbols fed in one page task (BLO-36599). Each record is
+ * handled exactly as its single-symbol command would be, in order, and a
+ * failing record reports the same `command-failed` error that command would
+ * without stopping the records after it.
+ */
+function handleFeedSymbols(
+	cmd: Extract<FecWorkerCommand, { type: "feedSymbols" }>,
+): void {
+	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 as { type?: unknown } | null)?.type)}`,
+				);
+			}
+		} catch (err) {
+			emit({
+				type: "error",
+				code: "command-failed",
+				message:
+					err instanceof Error ? err.message : `[FecWorker] ${String(err)}`,
+			});
+		}
+	}
+}
+
 // --- Main message handler ---
 
 async function dispatchCommand(cmd: FecWorkerCommand): Promise<void> {
@@ -1011,6 +1073,9 @@ async function dispatchCommand(cmd: FecWorkerCommand): Promise<void> {
 			case "feedRepair":
 				handleFeedRepair(cmd);
 				break;
+			case "feedSymbols":
+				handleFeedSymbols(cmd);
+				break;
 			case "relayBlockSig":
 				handleRelayBlockSig(cmd);
 				break;
@@ -1020,6 +1085,9 @@ async function dispatchCommand(cmd: FecWorkerCommand): Promise<void> {
 			case "reset":
 				handleReset();
 				break;
+			case "subscribeBlockUpdates":
+				blockUpdatesSubscribed = true;
+				break;
 			case "dispose":
 				handleDispose();
 				break;

package/src/index.ts

@@ -6,6 +6,8 @@
 
 export type {
 	FecWorkerCommand,
+	FecSymbolCommand,
+	FecWorkerOptionalCommand,
 	FecWorkerEvent,
 	FecWorkerErrorCode,
 	FecTrackConfig,