@blockcast/fec-worker 0.3.0-main.d9354616fdf2 → 0.3.0-main.dd5b3a8dcbc8

package/src/block-order.ts

@@ -1,46 +1,12 @@
 /**
- * Order of K-stride FEC blocks on the 32-bit SS_ID (ISO/IEC 23008-1:2023
- * C.5.2; RFC 1982 serial arithmetic, SERIAL_BITS = 32; BLO-35597 iso:5).
- *
- * Block `sbn` starts at SS_ID `sbn * K mod 2^32`, and blocks are ordered by
- * serial comparison of their starts. That is identical to comparing SBNs
- * with < for any two blocks less than 2^31 SS_IDs apart, so only the order
- * across the SS_ID wrap changes.
- *
- * The canonical helpers are @blockcast/mmt-base `kStrideBlockPrecedes` /
- * `kStrideBlocksBehind`. This worker bundle does not depend on mmt-base, so
- * it carries these two, and block-order.test.ts pins them to the same wrap
- * vectors.
+ * Order of iso-ssbg1-v1 FEC blocks on the 32-bit SS_ID (ISO/IEC 23008-1:2023
+ * C.5.2/C.5.3; RFC 1982 serial arithmetic, SERIAL_BITS = 32; BLO-35597 iso:5).
+ * The K-stride (SBN * K) order of the retired k-padded-v1 profile is gone.
  */
 
 const SPAN = 0x1_0000_0000;
 const HALF = 0x8000_0000;
 
-function blockStart(sbn: number, k: number): number {
-	// sbn < 2^32 and k <= 56 403 keep the product below 2^48: exact.
-	return (sbn * k) % SPAN;
-}
-
-/** Forward SS_ID distance from block `a`'s start to block `b`'s, or null when `a` does not precede `b`. */
-function precedingDistance(a: number, b: number, k: number): number | null {
-	const distance = (blockStart(b, k) - blockStart(a, k) + SPAN) % SPAN;
-	return distance !== 0 && distance < HALF ? distance : null;
-}
-
-/** Whether block `a` precedes block `b`. */
-export function blockPrecedes(a: number, b: number, k: number): boolean {
-	return precedingDistance(a, b, k) !== null;
-}
-
-/**
- * How many blocks `a` lies behind `b`: 0 unless `a` precedes `b`. Across the
- * wrap the short pre-wrap block (2^32 mod K symbols) counts as one block.
- */
-export function blocksBehind(a: number, b: number, k: number): number {
-	const distance = precedingDistance(a, b, k);
-	return distance === null ? 0 : Math.ceil(distance / k);
-}
-
 // --- iso-ssbg1-v1 (ISO/IEC 23008-1 C.3.3 ssbg_mode1; C.5.2/C.5.3) ---------
 //
 // Under the ISO profile SS_ID increments by one per FEC source packet and

package/src/fec-worker-client.ts

@@ -137,8 +137,7 @@ 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 * configured K
-	 *              under `k-padded-v1`; any uint32, the block key, under `iso-ssbg1-v1`)
+	 * - ssStart:   SS_ID of first source symbol in the block (any uint32; the block key)
 	 * - ssbLength: authored source-symbol count (1..configured K)
 	 * - rsId:      repair symbol index within the block
 	 */
@@ -199,7 +198,7 @@ export class FecWorkerClient {
 
 	/**
 	 * Trigger cleanup after a block's inactivity deadline. `currentSbn` is the
-	 * block key: the SBN under `k-padded-v1`, the SS_Start under `iso-ssbg1-v1`.
+	 * block key, the block's SS_Start.
 	 *
 	 * While one queue-drain barrier is in flight, later SBNs are coalesced into
 	 * the next command without losing their individual acknowledgement identity.

package/src/fec-worker-types.ts

@@ -12,19 +12,16 @@
 
 /**
  * FEC block profile (BLO-35597, ISO/IEC 23008-1 Annex C): the catalog
- * `fec.blockProfile` token. Both profiles carry identical wire tuples whose
- * block math differs, so it is required and never inferred.
- *
- * - `k-padded-v1` (legacy): SBN = floor(SS_ID / K), ESI = SS_ID % K;
- *   SS_Start = SBN * K; repair ESI = K + RS_ID.
- * - `iso-ssbg1-v1` (C.3.3 ssbg_mode1): SS_ID increments by one per source
- *   packet mod 2^32; a block is `[SS_Start, SS_Start + SSB_length)` keyed by
- *   SS_Start; `k` is only the maximum SSB_length; repair ESI =
- *   SSB_length + RS_ID.
+ * `fec.blockProfile` token. Required and never inferred; the only profile is
+ * `iso-ssbg1-v1` (C.3.3 ssbg_mode1): SS_ID increments by one per source
+ * packet mod 2^32; a block is `[SS_Start, SS_Start + SSB_length)` keyed by
+ * SS_Start; `k` is only the maximum SSB_length; repair ESI =
+ * SSB_length + RS_ID. The retired `k-padded-v1` token is refused like any
+ * unknown one.
  *
  * Mirrors @blockcast/mmt-base `FecBlockProfile`.
  */
-export type FecBlockProfile = "k-padded-v1" | "iso-ssbg1-v1";
+export type FecBlockProfile = "iso-ssbg1-v1";
 
 /** Per-track FEC configuration. Matches design spec section 3.2 FecTrackConfig. */
 export interface FecTrackConfig {
@@ -51,12 +48,11 @@ export interface FecTrackConfig {
 	repairCount: number;
 	/** Bytes per symbol */
 	symbolSize: number;
-	/** Retained decoder horizon as a BLOCK COUNT (SBN distance), not D.
-	 *  `isRetiredSbn` retires blocks more than this many blocks behind
-	 *  `liveSbn` (serial order on SS_ID, BLO-35597 iso:5) and
-	 *  `MmtFecDecoder::new` documents it as "the number of interleaved blocks".
-	 *  Under `iso-ssbg1-v1` the distance is `isoBlocksBehind(SS_ID, live SS_ID, k)`
-	 *  (block-order.ts), the lower bound every ISO receiver layer shares.
+	/** Retained decoder horizon as a BLOCK COUNT, not D. `isRetiredSbn`
+	 *  retires blocks more than this many blocks behind the live SS_ID, by
+	 *  `isoBlocksBehind(SS_ID, live SS_ID, k)` (block-order.ts), the lower
+	 *  bound every ISO receiver layer shares, and `MmtFecDecoder::new`
+	 *  documents it as "the number of interleaved blocks".
 	 *  Never assign `deriveFecInterleaveDepth()` here — that returns media units
 	 *  per block, which is a different quantity (BLO-35597). */
 	interleaveDepth: number;
@@ -79,8 +75,7 @@ export interface FecTrackConfig {
 
 /** Per-block snapshot for live block visualization and stats. */
 export interface FecBlockSnapshot {
-	/** Block key: the source block number under `k-padded-v1`, the block's
-	 *  SS_Start under `iso-ssbg1-v1`. */
+	/** Block key: the block's SS_Start. */
 	sbn: number;
 	/** Current block state */
 	state: "collecting" | "complete" | "recovered" | "failed";
@@ -168,8 +163,7 @@ export interface FecTrackStats {
 	/** Blocks with invalid relay signature */
 	relayBlocksFailed: number;
 
-	/** Live media position: the newest source block number under
-	 *  `k-padded-v1`, the newest accepted SS_ID / SS_Start under `iso-ssbg1-v1`. */
+	/** Live media position: the newest accepted SS_ID / SS_Start. */
 	liveSbn: number;
 	/** Active block snapshots */
 	blocks: FecBlockSnapshot[];
@@ -220,13 +214,14 @@ export interface FecTrackStats {
 	 */
 	sourceDroppedDuplicate?: number;
 	/**
-	 * `iso-ssbg1-v1` only: accepted source symbols whose block never became
-	 * known (no repair symbol named a range containing them) before their
-	 * SS_ID fell behind the retained horizon. They were already fed to the
-	 * decoder and routed directly; this counts the bookkeeping retired with
-	 * them, i.e. evidence that a block's repair symbols never arrived.
+	 * Accepted source symbols whose block never became known (no repair
+	 * symbol named a range containing them) before their SS_ID fell behind
+	 * the retained horizon. They were already fed to the decoder and routed
+	 * directly; this counts the bookkeeping retired with them, i.e. evidence
+	 * that a block's repair symbols never arrived. The decoder retires its
+	 * own copies by the same horizon inside `cleanup_by_ss_start`.
 	 */
-	sourceUnplacedRetired?: number;
+	sourceUnplacedRetired: number;
 	/** Native decoder counters, converted to numbers so browser diagnostics remain JSON-safe. */
 	decoder?: {
 		sourcePackets: number;
@@ -266,7 +261,7 @@ export interface FrameMeta {
 	altaVerified: boolean | null;
 	/** Whether this frame was recovered via FEC (not received directly) */
 	recovered: boolean;
-	/** Block key this frame belongs to: SBN (`k-padded-v1`) or SS_Start (`iso-ssbg1-v1`) */
+	/** Block key this frame belongs to: the block's SS_Start */
 	sbn: number;
 	/** Encoding Symbol ID within the recovered source block (0..ssbLength-1).
 	 *  Under `iso-ssbg1-v1` a recovered frame is the full T-byte ssbg_mode1
@@ -301,13 +296,12 @@ export type FecWorkerCommand =
 	| {
 			type: "feedSource";
 			/** Flat 32-bit Source Symbol ID from the MMTP Source FEC Payload ID
-			 *  (ISO 23008-1 §C.5.2). Under `k-padded-v1` the WASM decoder derives
-			 *  SBN = floor(ssId/K) and ESI = ssId % K internally — do NOT
-			 *  pre-compute. Under `iso-ssbg1-v1` SS_IDs are consecutive per source
-			 *  packet mod 2^32 and the block comes from a repair's range. */
+			 *  (ISO 23008-1 §C.5.2). SS_IDs are consecutive per source packet mod
+			 *  2^32 and the block comes from a repair's range — do NOT
+			 *  pre-compute a block. */
 			ssId: number;
-			/** `k-padded-v1`: the source symbol. `iso-ssbg1-v1`: the protected
-			 *  packet exactly, unpadded and without its SS_ID (at most T-2 bytes). */
+			/** The protected packet exactly, unpadded and without its SS_ID (at
+			 *  most T-2 bytes). */
 			data: ArrayBuffer;
 			ts: number;
 			/** Optional ALTA authenticator bytes (detached mode — 08-07 MMTP
@@ -326,14 +320,13 @@ export type FecWorkerCommand =
 	| {
 			type: "feedRepair";
 			/** SS_Start: SS_ID of the first source symbol in the block, from the
-			 *  MMTP Repair FEC Payload ID (ISO 23008-1 §C.5.3). `k-padded-v1`:
-			 *  = SBN * configured K. `iso-ssbg1-v1`: any uint32; the block key. */
+			 *  MMTP Repair FEC Payload ID (ISO 23008-1 §C.5.3): any uint32; the
+			 *  block key. */
 			ssStart: number;
 			/** 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 = configured K + RS_ID (`k-padded-v1`) or SSB_length + RS_ID
-			 *  (`iso-ssbg1-v1`). */
+			 *  ESI = SSB_length + RS_ID. */
 			rsId: number;
 			data: ArrayBuffer;
 			ts: number;
@@ -358,7 +351,7 @@ export type FecWorkerCommand =
 	| {
 			type: "cleanup";
 			/** Every timed-out block covered by this coalesced queue-drain barrier,
-			 *  by block key: SBN (`k-padded-v1`) or SS_Start (`iso-ssbg1-v1`). */
+			 *  by block key (SS_Start). */
 			sbns: number[];
 	  }
 	| { type: "reset" }

package/src/fec-worker.ts

@@ -22,8 +22,6 @@ import type {
 } from "./fec-worker-types.js";
 import { toOwnedArrayBuffer } from "./transfer.js";
 import {
-	blockPrecedes,
-	blocksBehind,
 	isoBlockContains,
 	isoBlocksBehind,
 	isoBlocksOverlap,
@@ -36,10 +34,9 @@ import {
 // The decoder derives SBN/ESI internally — do not pre-compute.
 interface WasmFecDecoder {
 	/**
-	 * ISO 23008-1 §C.5.2: ss_id is the flat 32-bit Source Symbol ID.
-	 * `k-padded-v1`: data is the source symbol. `iso-ssbg1-v1`: data is the
-	 * protected packet, unpadded; the decoder builds the ssbg_mode1 symbol and
-	 * holds it until a repair names the block containing it.
+	 * ISO 23008-1 §C.5.2: ss_id is the flat 32-bit Source Symbol ID; data is
+	 * the protected packet, unpadded. The decoder builds the ssbg_mode1 symbol
+	 * and holds it until a repair names the block containing it.
 	 */
 	add_source(
 		ss_id: number,
@@ -47,11 +44,9 @@ interface WasmFecDecoder {
 		timestamp: number,
 	): Uint8Array | undefined;
 	/**
-	 * ISO 23008-1 §C.5.3. `k-padded-v1`: repair ESI = configured K + rs_id,
-	 * SBN = ss_start / configured K. `iso-ssbg1-v1`: the block is
-	 * `[ss_start, ss_start + ssb_length)` with K' = ssb_length and repair
-	 * ESI = ssb_length + rs_id; a recovered block is ssb_length x T bytes of
-	 * ssbg_mode1 symbols.
+	 * ISO 23008-1 §C.5.3: the block is `[ss_start, ss_start + ssb_length)`
+	 * with K' = ssb_length and repair ESI = ssb_length + rs_id; a recovered
+	 * block is ssb_length x T bytes of ssbg_mode1 symbols.
 	 */
 	add_repair(
 		ss_start: number,
@@ -68,14 +63,12 @@ interface WasmFecDecoder {
 	 */
 	cleanup_blocks_detailed(sbns: Uint32Array): void;
 	/**
-	 * `k-padded-v1` only (throws under `iso-ssbg1-v1`): remove decoder blocks
-	 * below its configured live-SBN interleave horizon; returns their SBNs.
-	 */
-	cleanup_by_sbn(current_sbn: number): Uint32Array;
-	/**
-	 * `iso-ssbg1-v1` only: remove decoder blocks, and held unplaced sources,
-	 * more than interleaveDepth `isoBlocksBehind` the live SS_ID; returns the
-	 * SS_Starts of the blocks it removed.
+	 * Remove decoder blocks, and held unplaced sources, more than
+	 * interleaveDepth `isoBlocksBehind` the live SS_ID; returns the SS_Starts
+	 * of the blocks it removed. It runs the decoder's `retire_unplaced` sweep
+	 * itself, so the Worker never calls that separately: synchronizeDecoderHorizon
+	 * calls this after every source and repair it accepts, which is what keeps
+	 * the decoder's unplaced pool bounded when a block's repairs never arrive.
 	 */
 	cleanup_by_ss_start(current: number): Uint32Array;
 	/** The block profile the decoder was constructed with. */
@@ -255,15 +248,9 @@ function clearBlockTracking(): void {
  */
 function isRetiredSbn(sbn: number): boolean {
 	if (config === null || !liveSbnKnown) return false;
-	// iso-ssbg1-v1: `sbn` is an SS_ID (a block's SS_Start or a source's own
-	// SS_ID) and liveSbn the live SS_ID; K is only the maximum block length.
-	return config.blockProfile === "iso-ssbg1-v1"
-		? isoBlocksBehind(sbn, liveSbn, config.k) > config.interleaveDepth
-		: blocksBehind(sbn, liveSbn, config.k) > config.interleaveDepth;
-}
-
-function isIsoProfile(): boolean {
-	return config?.blockProfile === "iso-ssbg1-v1";
+	// `sbn` is an SS_ID (a block's SS_Start or a source's own SS_ID) and
+	// liveSbn the live SS_ID; K is only the maximum block length.
+	return isoBlocksBehind(sbn, liveSbn, config.k) > config.interleaveDepth;
 }
 
 /**
@@ -291,9 +278,7 @@ function findIsoBlock(ssId: number): FecBlockSnapshot | undefined {
  * retired, after which the SS_ID retirement check refuses every member.
  */
 function isRetiredBlock(key: number, block: FecBlockSnapshot): boolean {
-	return isIsoProfile()
-		? isRetiredSbn((key + isoKnownLength(block) - 1) % SS_ID_SPAN)
-		: isRetiredSbn(key);
+	return isRetiredSbn((key + isoKnownLength(block) - 1) % SS_ID_SPAN);
 }
 
 /**
@@ -310,15 +295,10 @@ function trimBlockRetention(): void {
 	}
 }
 
-/** Advance the live position: an SBN (k-padded-v1) or an SS_ID / SS_Start (iso-ssbg1-v1). */
+/** Advance the live position: an SS_ID / SS_Start, in serial order. */
 function advanceMediaHorizon(sbn: number): void {
 	if (!config) return;
-	if (liveSbnKnown) {
-		const ahead = config.blockProfile === "iso-ssbg1-v1"
-			? serialPrecedes(liveSbn, sbn)
-			: blockPrecedes(liveSbn, sbn, config.k);
-		if (!ahead) return;
-	}
+	if (liveSbnKnown && !serialPrecedes(liveSbn, sbn)) return;
 	liveSbn = sbn;
 	liveSbnKnown = true;
 	trimBlockRetention();
@@ -336,10 +316,7 @@ function markBlockTerminal(
 
 function synchronizeDecoderHorizon(): void {
 	if (!wasmDecoder || !liveSbnKnown) return;
-	const iso = isIsoProfile();
-	const expired = iso
-		? wasmDecoder.cleanup_by_ss_start(liveSbn)
-		: wasmDecoder.cleanup_by_sbn(liveSbn);
+	const expired = wasmDecoder.cleanup_by_ss_start(liveSbn);
 	for (const sbn of expired) {
 		const block = blocks.get(sbn);
 		if (!block || isTerminalBlock(block)) {
@@ -350,7 +327,7 @@ function synchronizeDecoderHorizon(): void {
 		blocksFailed++;
 		emitBlockUpdate(block);
 	}
-	if (iso) retireUnplacedSources();
+	retireUnplacedSources();
 	trimBlockRetention();
 }
 
@@ -583,8 +560,10 @@ function buildStatsSnapshot(): FecTrackStats {
 
 	// Cap block array to interleave window
 	const maxBlocks = Math.max(config.interleaveDepth * 3, 24);
+	// Newest first in SS_ID serial order, so the cap keeps the newest blocks
+	// across the 2^32 wrap too: every block start precedes the live SS_ID.
 	const blockArray = Array.from(blocks.values())
-		.sort((a, b) => b.sbn - a.sbn)
+		.sort((a, b) => serialDistance(a.sbn, liveSbn) - serialDistance(b.sbn, liveSbn))
 		.slice(0, maxBlocks);
 
 	return {
@@ -620,7 +599,7 @@ function buildStatsSnapshot(): FecTrackStats {
 		sourceDroppedRetired,
 		sourceDroppedTerminal,
 		sourceDroppedDuplicate,
-		...(config.blockProfile === "iso-ssbg1-v1" ? { sourceUnplacedRetired } : {}),
+		sourceUnplacedRetired,
 		decoder,
 	};
 }
@@ -662,22 +641,19 @@ function emitRecoveredSymbols(
 		return;
 	}
 
-	const iso = config.blockProfile === "iso-ssbg1-v1";
 	for (let i = 0; i < ssbLength; i++) {
 		const symbol = recoveredBlock.subarray(i * symbolSize, (i + 1) * symbolSize);
 		// ssbg_mode1 symbols are emitted whole: the router trims them by their
 		// length field. A field past T-2 or non-zero padding means the
 		// recovered symbol is not what was sent, so it is refused, not trimmed.
-		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 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;
 		}
 
 		// Source authentication now runs once at router admission in
@@ -990,12 +966,12 @@ async function handleConfigure(
 	const blockProfile: unknown = cmd.config.blockProfile;
 	if (blockProfile === undefined) {
 		throw new Error(
-			'[FecWorker] configure: blockProfile is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")',
+			'[FecWorker] configure: blockProfile is required: name the FEC block profile ("iso-ssbg1-v1")',
 		);
 	}
-	if (blockProfile !== "k-padded-v1" && blockProfile !== "iso-ssbg1-v1") {
+	if (blockProfile !== "iso-ssbg1-v1") {
 		throw new Error(
-			`[FecWorker] configure: blockProfile must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(blockProfile)})`,
+			`[FecWorker] configure: blockProfile must be "iso-ssbg1-v1" (got ${JSON.stringify(blockProfile)})`,
 		);
 	}
 	if (
@@ -1134,51 +1110,7 @@ function handleFeedSource(
 		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;
-	}
-
-	// Derive SBN locally for block-level accounting. WASM derives the same
-	// value internally (ISO 23008-1 §C.5.2: SBN = floor(SS_ID / K)).
-	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 = new Set<number>();
-		acceptedSourceEsis.set(sbn, sourceEsis);
-	}
-	sourceEsis.add(esi);
-
-	// Update block state
-	const block = getOrCreateBlock(sbn);
-	block.sourceReceived++;
-	block.lastSymbolTs = performance.now();
-	sourceSymbols++;
-
-	// The FEC worker must remain decode-only on the per-symbol hot path. ALTA
-	// WASM is retained temporarily for low-rate signaling users, but media is
-	// authenticated by the canonical manifest verifier at router admission.
-	if (altaEnabled) altaPending++;
-
-	settleSourceArrival(sbn, block, result);
+	feedIsoSource(cmd, new Uint8Array(cmd.data), wasmDecoder, config);
 }
 
 function handleFeedRepair(
@@ -1190,17 +1122,14 @@ function handleFeedRepair(
 	if (!config) {
 		throw new Error("[FecWorker] feedRepair: config missing");
 	}
-	// k-padded-v1 blocks start at multiples of K and repair ESI = K + RS_ID;
 	// iso-ssbg1-v1 blocks start at any SS_ID and repair ESI = SSB_length + RS_ID.
-	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.ssbLength + cmd.rsId > UINT24_MAX ||
 		!(cmd.data instanceof ArrayBuffer)
 	) {
 		throw new Error("[FecWorker] feedRepair: invalid repair symbol");
@@ -1218,51 +1147,7 @@ function handleFeedRepair(
 		}
 		return;
 	}
-	if (iso) {
-		feedIsoRepair(cmd, view, wasmDecoder);
-		return;
-	}
-	const sbn = Math.floor(cmd.ssStart / config.k);
-	const repairEsi = config.k + cmd.rsId;
-	// The repair path's mirror drops stay silent and uncounted: BLO-35597
-	// defect 2 is a source-symbol shortfall, so only the source side needed
-	// evidence. The asymmetry is deliberate, not an oversight — extend these
-	// the same way if a repair-side shortfall ever needs attributing.
-	if (isRetiredSbn(sbn)) return;
-	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,
-		cmd.ssbLength,
-		cmd.rsId,
-		view,
-		cmd.ts,
-	);
-	advanceMediaHorizon(sbn);
-	let repairEsis = acceptedRepairEsis.get(sbn);
-	if (!repairEsis) {
-		repairEsis = new Set<number>();
-		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);
+	feedIsoRepair(cmd, view, wasmDecoder);
 }
 
 function handleRelayBlockSig(
@@ -1315,10 +1200,9 @@ function handleCleanup(
 				continue;
 			}
 			currentBlock ??= getOrCreateBlock(sbn);
-			// k-padded-v1 compares with K, unchanged. iso-ssbg1-v1 compares with
-			// the block's SSB_length; a key no repair declared has none, so a
-			// block the Worker never knew can only have failed.
-			const authoredLength = isIsoProfile() ? currentBlock.ssbLength : currentBlock.k;
+			// Compare with the block's SSB_length; a key no repair declared has
+			// none, so a block the Worker never knew can only have failed.
+			const authoredLength = currentBlock.ssbLength;
 			if (authoredLength !== undefined && currentBlock.sourceReceived >= authoredLength) {
 				markBlockTerminal(currentBlock, "complete");
 				blocksComplete++;