@blockcast/fec-worker 0.1.0-main.64a6b356bf43 → 0.1.0-main.6598eedfb039

package/src/fec-worker-client.ts

@@ -10,6 +10,7 @@
 
 import type {
 	FecWorkerCommand,
+	FecSymbolCommand,
 	FecWorkerEvent,
 	FecTrackConfig,
 	FecTrackStats,
@@ -23,7 +24,6 @@ export class FecWorkerClient {
 	#onFrame: ((data: ArrayBuffer, meta: FrameMeta) => void) | null = null;
 	#onSnapshot: ((stats: FecTrackStats) => void) | null = null;
 	#onBlockUpdate: ((block: FecBlockSnapshot) => void) | null = null;
-	#onGreenFill: ((sbn: number, data: ArrayBuffer) => void) | null = null;
 	#onCleanupComplete: ((sbn: number) => void) | null = null;
 	#onError: ((message: string, code?: FecWorkerErrorCode) => void) | null = null;
 	#cleanupInFlight: Set<number> | null = null;
@@ -31,6 +31,20 @@ export class FecWorkerClient {
 	#pendingResets = 0;
 	#resetFailed = false;
 	#disposed = false;
+	// Symbols fed during the current task, sent as one feedSymbols message
+	// when the task's microtasks run (BLO-36599). A packet stream delivers many
+	// symbols per task, and each postMessage is a structured-clone round trip
+	// on the page thread; the batch boundary is the task, not a size or timer.
+	#pendingSymbols: FecSymbolCommand[] = [];
+	#pendingTransfer: Transferable[] = [];
+	#flushQueued = false;
+	// Batching starts only once the Worker announced it accepts feedSymbols.
+	#batchSymbols = false;
+	// The Worker posts blockUpdate events only to a client that subscribed,
+	// which this client does once a callback is registered and the Worker
+	// announced the command (BLO-36599).
+	#blockUpdatesAnnounced = false;
+	#blockUpdatesSubscribed = false;
 
 	/**
 	 * Create a FecWorkerClient.
@@ -66,6 +80,7 @@ export class FecWorkerClient {
 		altaWasmModule?: WebAssembly.Module,
 	): void {
 		if (this.#disposed) throw new Error("[FecWorkerClient] disposed");
+		this.#flushSymbols();
 		const cmd: FecWorkerCommand = {
 			type: "configure",
 			config,
@@ -84,7 +99,8 @@ export class FecWorkerClient {
 
 	/**
 	 * Feed a source symbol to the Worker. data ArrayBuffer is transferred (zero-copy).
-	 * Caller must not access data after this call — it is detached.
+	 * Caller must not access data after this call — it is transferred with the
+	 * task's symbol batch, before any later command of this client.
 	 *
 	 * Optional `alta` carries the detached ALTA authenticator bytes and the
 	 * byte offset in `data` where the signed payload ends. The auth buffer is
@@ -98,18 +114,22 @@ export class FecWorkerClient {
 		alta?: { auth: ArrayBuffer; payloadEnd: number },
 	): void {
 		if (this.#disposed) throw new Error("[FecWorkerClient] feedSource on a disposed client");
-		const cmd: FecWorkerCommand = alta
-			? {
+		if (alta) {
+			this.#queueSymbol(
+				{
 					type: "feedSource",
 					ssId,
 					data,
 					ts,
 					altaAuth: alta.auth,
 					altaPayloadEnd: alta.payloadEnd,
-				}
-			: { type: "feedSource", ssId, data, ts };
-		const transfer: Transferable[] = alta ? [data, alta.auth] : [data];
-		this.#worker.postMessage(cmd, transfer);
+				},
+				data,
+				alta.auth,
+			);
+		} else {
+			this.#queueSymbol({ type: "feedSource", ssId, data, ts }, data);
+		}
 	}
 
 	/**
@@ -117,8 +137,8 @@ export class FecWorkerClient {
 	 * Caller must not access data after this call — it is detached.
 	 *
 	 * Carries the wire-level Repair FEC Payload ID fields (ISO 23008-1 §C.5.3):
-	 * - ssStart:   SS_ID of first source symbol in the block (= SBN * SSB_length)
-	 * - ssbLength: K for this block
+	 * - ssStart:   SS_ID of first source symbol in the block (= SBN * configured K)
+	 * - ssbLength: authored source-symbol count (1..configured K)
 	 * - rsId:      repair symbol index within the block
 	 */
 	feedRepair(
@@ -129,16 +149,38 @@ export class FecWorkerClient {
 		ts: number,
 	): void {
 		if (this.#disposed) throw new Error("[FecWorkerClient] feedRepair on a disposed client");
+		this.#queueSymbol({ type: "feedRepair", ssStart, ssbLength, rsId, data, ts }, data);
+	}
+
+	#queueSymbol(symbol: FecSymbolCommand, data: ArrayBuffer, auth?: ArrayBuffer): void {
+		if (!this.#batchSymbols) {
+			this.#worker.postMessage(symbol, auth ? [data, auth] : [data]);
+			return;
+		}
+		this.#pendingSymbols.push(symbol);
+		this.#pendingTransfer.push(data);
+		if (auth) this.#pendingTransfer.push(auth);
+		if (this.#flushQueued) return;
+		this.#flushQueued = true;
+		queueMicrotask(() => {
+			this.#flushQueued = false;
+			this.#flushSymbols();
+		});
+	}
+
+	/**
+	 * Send the symbols fed so far. Every other command calls this first, so a
+	 * cleanup barrier, reset or signature still follows all earlier symbols.
+	 */
+	#flushSymbols(): void {
+		if (this.#pendingSymbols.length === 0 || this.#disposed) return;
+		const symbols = this.#pendingSymbols;
+		const transfer = this.#pendingTransfer;
+		this.#pendingSymbols = [];
+		this.#pendingTransfer = [];
 		this.#worker.postMessage(
-			{
-				type: "feedRepair",
-				ssStart,
-				ssbLength,
-				rsId,
-				data,
-				ts,
-			} satisfies FecWorkerCommand,
-			[data],
+			{ type: "feedSymbols", symbols } satisfies FecWorkerCommand,
+			transfer,
 		);
 	}
 
@@ -147,6 +189,7 @@ export class FecWorkerClient {
 	 */
 	relayBlockSig(sbn: number, sig: ArrayBuffer, hash: ArrayBuffer): void {
 		if (this.#disposed) throw new Error("[FecWorkerClient] relayBlockSig on a disposed client");
+		this.#flushSymbols();
 		this.#worker.postMessage(
 			{ type: "relayBlockSig", sbn, sig, hash } satisfies FecWorkerCommand,
 			[sig, hash],
@@ -178,6 +221,7 @@ export class FecWorkerClient {
 	/** Reset this track's decoder epoch while preserving Worker configuration. */
 	reset(): void {
 		if (this.#disposed) throw new Error("[FecWorkerClient] reset on a disposed client");
+		this.#flushSymbols();
 		this.#pendingResets++;
 		this.#cleanupInFlight = null;
 		this.#queuedCleanupSbns.clear();
@@ -185,6 +229,9 @@ export class FecWorkerClient {
 	}
 
 	#postCleanup(sbns: Set<number>): void {
+		// The cleanup is a queue-drain barrier: every symbol fed before it is
+		// posted must reach the Worker first.
+		this.#flushSymbols();
 		this.#cleanupInFlight = sbns;
 		const orderedSbns = [...sbns].sort((a, b) => a - b);
 		this.#worker.postMessage(
@@ -202,14 +249,28 @@ export class FecWorkerClient {
 		this.#onSnapshot = cb;
 	}
 
-	/** Register callback for individual block state changes. */
+	/**
+	 * Register callback for individual block state changes. The Worker posts
+	 * them only once asked, so registering subscribes (after the Worker
+	 * announces `subscribeBlockUpdates`). An older Worker that does not
+	 * announce it posts them unasked.
+	 */
 	onBlockUpdate(cb: (block: FecBlockSnapshot) => void): void {
 		this.#onBlockUpdate = cb;
+		this.#subscribeBlockUpdates();
 	}
 
-	/** Register callback for green-fill frames. */
-	onGreenFill(cb: (sbn: number, data: ArrayBuffer) => void): void {
-		this.#onGreenFill = cb;
+	#subscribeBlockUpdates(): void {
+		if (
+			this.#disposed ||
+			this.#blockUpdatesSubscribed ||
+			!this.#blockUpdatesAnnounced ||
+			!this.#onBlockUpdate
+		) return;
+		this.#blockUpdatesSubscribed = true;
+		this.#worker.postMessage(
+			{ type: "subscribeBlockUpdates" } satisfies FecWorkerCommand,
+		);
 	}
 
 	/** Register callback fired after the Worker drains all commands queued before cleanup. */
@@ -239,6 +300,9 @@ export class FecWorkerClient {
 	dispose(): void {
 		if (this.#disposed) return;
 		this.#disposed = true;
+		// A terminated Worker decodes nothing; symbols still batched are dropped.
+		this.#pendingSymbols = [];
+		this.#pendingTransfer = [];
 		this.#cleanupInFlight = null;
 		this.#queuedCleanupSbns.clear();
 		this.#worker.postMessage({ type: "dispose" } satisfies FecWorkerCommand);
@@ -246,6 +310,16 @@ export class FecWorkerClient {
 	}
 
 	#handleEvent(event: FecWorkerEvent): void {
+		if (event.type === "capabilities") {
+			if (Array.isArray(event.commands) && event.commands.includes("feedSymbols")) {
+				this.#batchSymbols = true;
+			}
+			if (Array.isArray(event.commands) && event.commands.includes("subscribeBlockUpdates")) {
+				this.#blockUpdatesAnnounced = true;
+				this.#subscribeBlockUpdates();
+			}
+			return;
+		}
 		if (event.type === "resetComplete") {
 			this.#pendingResets = Math.max(0, this.#pendingResets - 1);
 			this.#resetFailed = false;
@@ -271,9 +345,6 @@ export class FecWorkerClient {
 			case "blockUpdate":
 				this.#onBlockUpdate?.(event.block);
 				break;
-			case "greenFill":
-				this.#onGreenFill?.(event.sbn, event.data);
-				break;
 			case "cleanupComplete":
 				for (const sbn of event.sbns) {
 					this.#onCleanupComplete?.(sbn);

package/src/fec-worker-types.ts

@@ -57,13 +57,15 @@ export interface FecBlockSnapshot {
 	/** Source block number */
 	sbn: number;
 	/** Current block state */
-	state: "collecting" | "complete" | "recovered" | "failed" | "green-fill";
+	state: "collecting" | "complete" | "recovered" | "failed";
 	/** Number of source symbols received */
 	sourceReceived: number;
 	/** Number of repair symbols received */
 	repairReceived: number;
-	/** Expected source symbols (K) */
+	/** Configured source-block geometry (K) */
 	k: number;
+	/** Authored source symbols (SSB_length) once a repair symbol declared it */
+	ssbLength?: number;
 	/** Expected repair symbols (P) */
 	repairCount: number;
 	/** Timestamp of first symbol arrival (ms) */
@@ -97,8 +99,6 @@ export interface FecTrackStats {
 	blocksRecovered: number;
 	/** Blocks that failed (unrecoverable) */
 	blocksFailed: number;
-	/** Frames replaced with green-fill */
-	greenFillFrames: number;
 	/** Recovery success rate 0-100 */
 	recoveryRate: number;
 
@@ -143,7 +143,7 @@ export interface FecTrackStats {
 	liveSbn: number;
 	/** Active block snapshots */
 	blocks: FecBlockSnapshot[];
-	/** Number of blocks in the interleave window */
+	/** Number of blocks in the FEC block span */
 	interleaveWindowBlocks: number;
 
 	/** Average recovery latency (ms) */
@@ -168,7 +168,9 @@ export interface FecTrackStats {
 export type FecWorkerErrorCode =
 	| "recovered-symbol-size-unconfigured"
 	| "recovered-block-too-short"
+	| "recovered-symbol-ssb-length-invalid"
 	| "repair-symbol-size-mismatch"
+	| "repair-ssb-length-conflict"
 	| "reset-failed"
 	| "unknown-command"
 	| "command-failed"
@@ -185,8 +187,14 @@ export interface FrameMeta {
 	recovered: boolean;
 	/** Source block number this frame belongs to */
 	sbn: number;
-	/** Encoding Symbol ID within the recovered source block (0..K-1). */
+	/** Encoding Symbol ID within the recovered source block (0..ssbLength-1). */
 	esi?: number;
+	/**
+	 * Authored source-symbol count of the recovered block (the repair
+	 * symbols' SSB_length, 1..K). Recovered frames are ESI 0..ssbLength-1;
+	 * ESIs ssbLength..K-1 are encoder zero padding and are never emitted.
+	 */
+	ssbLength?: number;
 }
 
 // --- Worker commands (main -> worker) ---
@@ -230,17 +238,28 @@ export type FecWorkerCommand =
 	| {
 			type: "feedRepair";
 			/** SS_Start: SS_ID of the first source symbol in the block
-			 *  (= SBN * SSB_length), from the MMTP Repair FEC Payload ID
+			 *  (= SBN * configured K), from the MMTP Repair FEC Payload ID
 			 *  (ISO 23008-1 §C.5.3). */
 			ssStart: number;
-			/** SSB_length: K for this block (variable-K allowed per spec). */
+			/** Authored source-symbol count for this block; 1..configured K. */
 			ssbLength: number;
 			/** RS_ID: repair symbol index within the block; WASM maps to
-			 *  repair ESI = SSB_length + RS_ID. */
+			 *  repair ESI = configured K + RS_ID. */
 			rsId: number;
 			data: ArrayBuffer;
 			ts: number;
 	  }
+	| {
+			/**
+			 * Every source and repair symbol the page fed in one task, in feed
+			 * order, sharing one transfer list. The client sends symbols this
+			 * way instead of one message per symbol (BLO-36599); the Worker
+			 * handles each record exactly like the single-symbol command of the
+			 * same `type`, and a record that fails does not stop the others.
+			 */
+			type: "feedSymbols";
+			symbols: FecSymbolCommand[];
+	  }
 	| {
 			type: "relayBlockSig";
 			sbn: number;
@@ -253,8 +272,21 @@ export type FecWorkerCommand =
 			sbns: number[];
 	  }
 	| { type: "reset" }
+	/**
+	 * Ask the Worker to post a blockUpdate on every block transition. Without
+	 * it the Worker posts none: each one is a structured clone and a task on
+	 * the page thread, and the player does not consume them (BLO-36599).
+	 * Sent only to a Worker that announced it in `capabilities`.
+	 */
+	| { type: "subscribeBlockUpdates" }
 	| { type: "dispose" };
 
+/** One symbol record of a `feedSymbols` batch. */
+export type FecSymbolCommand = Extract<
+	FecWorkerCommand,
+	{ type: "feedSource" } | { type: "feedRepair" }
+>;
+
 // --- Worker events (worker -> main) ---
 
 /** Discriminated union of all events emitted from Worker to main thread. */
@@ -262,7 +294,16 @@ export type FecWorkerEvent =
 	| { type: "frame"; data: ArrayBuffer; meta: FrameMeta }
 	| { type: "snapshot"; stats: FecTrackStats }
 	| { type: "blockUpdate"; block: FecBlockSnapshot }
-	| { type: "greenFill"; sbn: number; data: ArrayBuffer }
 	| { type: "cleanupComplete"; sbns: number[] }
 	| { type: "resetComplete" }
+	/**
+	 * Optional commands this Worker accepts, posted once it is configured.
+	 * The client uses `feedSymbols` only after the Worker names it, so a page
+	 * that meets an older cached Worker bundle keeps sending one command per
+	 * symbol instead of a batch that Worker would reject (BLO-36599).
+	 */
+	| { type: "capabilities"; commands: FecWorkerOptionalCommand[] }
 	| { type: "error"; message: string; code?: FecWorkerErrorCode };
+
+/** Commands a client may send only after the Worker announced them. */
+export type FecWorkerOptionalCommand = "feedSymbols" | "subscribeBlockUpdates";