@blockcast/mmt-container 0.5.0 → 1.0.0-main.3cb7359ea316

package/src/catalog-fec-params.ts

@@ -5,83 +5,55 @@
 // one shared implementation — players keep only wiring, not MMT/catalog
 // interpretation. Structural track shape ({ name, type }) keeps this module
 // player-agnostic.
+//
+// FEC comes only from `resolveFecBindings` (mmt-base), which reads
+// `validateFecCatalog`'s per-instance result over the
+// draft-ramadan-moq-fec-catalog-00 array (BLO-50171). Nothing here reads a
+// `fec` block or a repair track itself, and nothing throws on catalog input:
+// a source whose base instance is not `ok` has no FEC and a typed reason, and
+// no other track is affected.
 
 import {
-	catalogFecAvailable,
-	catalogFecDeclaresUnconfigurableInstance,
-	fecAlgorithmUnimplemented,
-	ISO_SSBG1_MIN_SYMBOL_SIZE,
 	FEC_BLOCK_PROFILES,
 	isFecBlockProfile,
-	locateCatalogFecSource,
 	parseFecBlockProfile,
-	type CatalogFecRole,
-	type CatalogFecSource,
+	resolveFecBindings,
+	type FecBindingUnavailable,
 	type FecBlockProfile,
+	type FecSourceBinding,
 } from "@blockcast/mmt-base";
 import { catalogFecInterleaveMs, type FecInterleaveCatalog } from "@blockcast/mmt-fec";
 import { resolveGroupDurationMs } from "./carp-catalog.js";
-import { catalogDeclaresFec, isoBlockSpanUsable } from "./fec-state.js";
-import {
-	assembleRepairLayers,
-	assertRepairTrackReachable,
-	describeRepairTrack,
-	rejectRepairFieldsOnMediaTrack,
-	rejectRepairTrackGeometry,
-	repairReachability,
-	dependsTarget,
-	readFecBlockProfile,
-	RepairContractError,
-	type RepairLayerParams,
-	type RepairLayersResolution,
-	type RepairOverlayParams,
-	type RepairSourceGeometry,
-	type RepairTrackDescriptor,
-	throwRepairContractError,
-	validateRepairTrackFields,
+import type {
+	RepairLayerParams,
+	RepairLayersResolution,
+	RepairOverlayParams,
 } from "./repair-layers.js";
 import type { RepairTarget } from "./repair-fetch.js";
 
 export { catalogFecInterleaveMs, type FecInterleaveCatalog };
 export { FEC_BLOCK_PROFILES, isFecBlockProfile, parseFecBlockProfile, type FecBlockProfile };
-// The shared catalog FEC source rules (BLO-40851): one copy, in the leaf
-// package transport and every player also read.
+// Re-exported here, not from index.ts: index's bundle keeps `./*.js` external,
+// so a direct mmt-base re-export there leaves a dangling `./mmtp.js` import.
 export {
-	catalogFecAvailable,
-	catalogFecDeclaresUnconfigurableInstance,
-	fecAlgorithmUnimplemented,
-	locateCatalogFecSource,
-	type CatalogFecRole,
-	type CatalogFecSource,
-};
+	validateFecCatalog,
+	type FecCatalogCode,
+	type FecCatalogInstance,
+	type FecCatalogIssue,
+	type FecCatalogOutcome,
+	type FecCatalogReceiver,
+	type FecCatalogReport,
+} from "@blockcast/mmt-base";
 export {
-	assembleRepairLayers,
-	assertRepairTrackReachable,
-	repairReachability,
-	type AssembleRepairLayersOptions,
-	type RepairReachability,
-	dependsTarget,
-	describeRepairTrack,
-	readFecBlockProfile,
-	rejectRepairFieldsOnMediaTrack,
-	rejectRepairTrackGeometry,
-	REPAIR_TRACK_GEOMETRY_KEYS,
-	REPAIR_TRACK_ONLY_KEYS,
-	validateRepairTrackFields,
 	DEFAULT_REPAIR_PRIORITY,
 	MAX_ENCODING_SYMBOL_ID,
 	MAX_RAPTORQ_SOURCE_SYMBOLS,
 	MAX_REPAIR_SYMBOLS,
 	REPAIR_PRIORITY_MAX,
 	REPAIR_PRIORITY_MIN,
-	RepairContractError,
-	type RepairContractCode,
-	type RepairContractFail,
 	type RepairLayerParams,
 	type RepairLayersResolution,
 	type RepairOverlayParams,
-	type RepairSourceGeometry,
-	type RepairTrackDescriptor,
 } from "./repair-layers.js";
 
 /**
@@ -94,40 +66,13 @@ export type CatalogTrackRef = {
 	type: "video" | "audio" | (string & {});
 };
 
-type FecCatalog = FecInterleaveCatalog & {
-	algorithm?: unknown;
-	/** FEC block profile token (BLO-35597): required on a declared FEC
-	 *  instance, read through `readFecBlockProfile`. */
-	blockProfile?: unknown;
-	sourceSymbols?: number;
-	repairSymbols?: number;
-	symbolSize?: number;
-	/** Signaled jitter/reorder allowance in ms (added to the block span). */
-	reorderToleranceMs?: number;
-	/** Layer 0 repair track. Further layers and overlays describe themselves
-	 *  (draft-ramadan-moq-fec §6.3): MSF `tracks[]` entries with
-	 *  `packaging: "fec-repair"`, or hang `repair.renditions` entries, that
-	 *  `depend` on this rendition. */
-	repairTrack?: string;
-};
 
-/** One self-describing repair rendition of the hang catalog's `repair` block
- *  (draft-ramadan-moq-fec §6.3). Mirrors the MSF fec-repair track fields. */
-export type RepairRenditionCatalog = {
-	depends?: unknown;
-	repairLayer?: unknown;
-	repairSymbols?: unknown;
-	priority?: unknown;
-	scope?: unknown;
-	sourceSymbols?: unknown;
-};
-
-/** The container fields the FEC and group-duration readers consult. */
+/** The container fields the group-duration reader consults. */
 type ContainerCatalog = { kind?: unknown; timescale?: unknown };
 
 type RenditionCatalog = KeyframeCadenceCatalog & {
 	container?: ContainerCatalog;
-	fec?: FecCatalog;
+	fec?: unknown;
 	framerate?: unknown;
 	sampleRate?: unknown;
 	samplerate?: unknown;
@@ -136,8 +81,8 @@ type RenditionCatalog = KeyframeCadenceCatalog & {
 type CatalogWithRenditions = {
 	video?: { renditions?: Record<string, RenditionCatalog> };
 	audio?: { renditions?: Record<string, RenditionCatalog> };
-	/** hang-native repair renditions: every repair track beyond layer 0. */
-	repair?: { renditions?: Record<string, RepairRenditionCatalog> };
+	/** hang-native repair renditions, bound by `source` + `instanceId`. */
+	repair?: { renditions?: Record<string, unknown> };
 };
 
 /** An MSF/CMSF catalog: `tracks[]` entries, each self-describing. */
@@ -280,65 +225,32 @@ export function catalogFecMediaUnitsPerSecond(
 	const sampleRate = positiveNumber(endpointSampleRate ?? rendition?.sampleRate ?? rendition?.timescale);
 	return sampleRate === undefined ? undefined : sampleRate / 1024;
 }
-
 /**
- * Why a track's catalog `fec` block resolved to no FEC although it is not a
- * plain no-FEC declaration (BLO-35597, draft-ramadan-moq-fec §5.1):
- *
- * - `track_fec_block_profile_unimplemented`: its `blockProfile` is a token
- *   this library does not implement. Only `iso-ssbg1-v1` is implemented; the
- *   retired `k-padded-v1` lands here.
- * - `track_fec_block_profile`: it declares an FEC instance but names no
- *   `blockProfile`, or the value is not a non-empty string.
- * - `track_fec_block_span`: retained for compatibility with older consumers;
- *   absence no longer disables in-band FEC.
- * - `track_fec` (on `interleaveDepthMs`): it names `iso-ssbg1-v1` with a
- *   declared span that is not a non-negative safe integer in milliseconds.
- *
- * The profile selects the block math and is never defaulted or inferred, and
- * the span is never borrowed from another track. Per §5.1 a receiver consumes
- * such a track's source without FEC and does not join its repair tracks, so it
- * carries no FEC geometry and no repair track; it is the only track affected,
- * and neither the session nor any other track's FEC fails on its account.
+ * Why a track that declares FEC resolved to no FEC: its base instance is not
+ * `ok` for this receiver (`resolveFecBindings`). `code` and `path` are the
+ * validator's (`validateFecCatalog`, draft-ramadan-moq-fec-catalog-00 5,
+ * fec-core-00 10.3); `outcome` tells an instance this receiver forgoes
+ * (`unavailable`, e.g. a block profile it does not decode) from an invalid
+ * one (`violation`). A draft-01 object `fec` is `fec_member` at that `fec`.
+ * Per fec-core-00 10.3 the track's source is consumed without FEC and none of
+ * its repair tracks is joined; it is the only track affected.
  */
-export type TrackFecUnavailable = {
-	/** The repair-contract code a catalog validator reports for the same field
-	 *  (`track_fec_block_span` excepted: an omitted span is valid shape). */
-	readonly code:
-		| "track_fec_block_profile"
-		| "track_fec_block_profile_unimplemented"
-		| "track_fec_block_span"
-		| "track_fec"
-		/** draft-ramadan-moq-fec-01 4: an `algorithm` this receiver does not
-		 *  implement. No validator reports it: such a catalog is valid. */
-		| "track_fec_algorithm_unimplemented";
-	/** JSON path of the offending field: `blockProfile`, or `interleaveDepthMs`. */
-	readonly path: string;
-	/** What is wrong, worded as the `RepairContractError` a validator throws. */
-	readonly message: string;
-};
+export type TrackFecUnavailable = FecBindingUnavailable;
 
 export type TrackFecParams = {
 	fecK: number;
-	/** The FEC scheme the track's decoder runs (draft-ramadan-moq-fec-01 4):
-	 *  present exactly when the track has FEC. An absent catalog `algorithm`
-	 *  (the hang dialect) is RaptorQ; a token this receiver does not implement
-	 *  leaves the track without FEC (`track_fec_algorithm_unimplemented`). */
+	/** The base instance's `scheme`: present exactly when the track has FEC. */
 	fecAlgorithm?: "raptorq" | "reed-solomon";
-	/** The catalog `fec.blockProfile` (BLO-35597, ISO/IEC 23008-1 Annex C).
-	 *  Present exactly when the track has FEC (`fecK > 0`) and absent on no
-	 *  FEC. The only profile is `iso-ssbg1-v1` (ssbg_mode1, K' = SSB_length,
-	 *  consecutive SS_IDs); it is never defaulted. A declared instance that
-	 *  names no implemented profile has no FEC; `fecUnavailable` says why. */
+	/** The base instance's `blockProfile`, present exactly when the track has
+	 *  FEC. This runtime decodes `iso-ssbg1-v1` only (ssbg_mode1, K' =
+	 *  SSB_length, consecutive SS_IDs); it is never defaulted. */
 	fecBlockProfile?: FecBlockProfile;
-	/** Present exactly when the track's `fec` block names no implemented
-	 *  `blockProfile`, or names `iso-ssbg1-v1` without a usable block span
-	 *  (see `TrackFecUnavailable`). The track then resolves to
-	 *  no FEC (`fecK` 0, no `fecBlockProfile`, no repair track) and this is
-	 *  the reason a caller surfaces. Absent on every other track, with FEC or
-	 *  without. */
+	/** Present exactly when the track declares FEC and its base instance is
+	 *  not `ok` (see `TrackFecUnavailable`). The track then resolves to no FEC
+	 *  (`fecK` 0, no `fecBlockProfile`, no repair track) and this is the
+	 *  reason a caller surfaces. */
 	fecUnavailable?: TrackFecUnavailable;
-	/** P_0: repair symbols per block on layer 0 (the track-level repairSymbols). */
+	/** P_0: the base instance's `repairSymbols` (layer 0). */
 	fecRepairCount: number;
 	/** Total repair symbols per block across the BASE layers: the wire
 	 *  RSB_length on every base layer packet. Equals fecRepairCount on a
@@ -401,156 +313,59 @@ export function joinedRepairSymbolCount(
 	return total;
 }
 
-function recordOf(value: unknown): Record<string, unknown> | undefined {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+/** The binding of one source, scoped to a typed ref's role. */
+function bindingOf(catalog: unknown, source: string | CatalogTrackRef): FecSourceBinding | undefined {
+	if (!catalog) return undefined;
+	const name = typeof source === "string" ? source : source.name;
+	const binding = resolveFecBindings(catalog).get(name);
+	if (binding === undefined || typeof source === "string") return binding;
+	const role = binding.pointer.split("/")[1];
+	// A typed ref resolves only within its own role; a `tracks[]` entry has none.
+	return role === "tracks" || role === source.type ? binding : undefined;
 }
 
-/** The MSF `tracks[]` view of a catalog, or undefined for the hang dialect. */
-function msfTracks(catalog: RepairLayerCatalog): { tracks: Record<string, unknown>[] } | undefined {
-	const raw = (catalog as CatalogWithTracks).tracks;
-	if (!Array.isArray(raw)) return undefined;
-	return { tracks: raw.map((t) => recordOf(t) ?? {}) };
+/**
+ * Why `source` has no FEC although it declares some, or undefined (it has FEC,
+ * or declares none).
+ */
+export function catalogTrackFecUnavailable(
+	catalog: RepairLayerCatalog | undefined,
+	source: string | CatalogTrackRef,
+): TrackFecUnavailable | undefined {
+	const binding = bindingOf(catalog, source);
+	return binding?.status === "unavailable" ? binding.reason : undefined;
 }
 
 /**
- * Resolve every repair track of one source track: base layers with derived
- * RS_ID offsets and keyframe overlays (draft-ramadan-moq-fec §6.3), from either
- * catalog dialect.
- *
- * - MSF `tracks[]`: the source is the entry named `source`; repair tracks are
- *   `packaging: "fec-repair"` entries. Layer 0 is the source's
- *   `fec.repairTrack`; layers 1..n and overlays `depend` on the source.
- * - hang: the source is a `video`/`audio` rendition; repair tracks beyond
- *   layer 0 are `repair.renditions` entries that `depend` on it.
- *
- * Returns undefined when the source carries no FEC repair track and nothing
- * depends on it, and when the source's FEC is unavailable
- * (`catalogFecUnavailable`: no implemented `blockProfile`, the retired
- * `k-padded-v1` included, or an `iso-ssbg1-v1` span it cannot use). Per
- * draft-ramadan-moq-fec §5.1 a receiver joins none of that source's repair
- * tracks, so it gets no layers; the catalog's repair contract is still
- * enforced for it as for every source. Throws `RepairContractError` (code +
- * JSON path) on any violation, including a repair rendition whose `depends`
- * names a rendition without FEC, so a player fails closed before joining any
- * repair track.
+ * Every repair track of one source track: base layers with derived RS_ID
+ * offsets and its keyframe overlay, from either catalog dialect, as
+ * `resolveFecBindings` binds them. Undefined when the source declares no FEC
+ * or its base instance is not `ok` (`catalogTrackFecUnavailable` says why): a
+ * receiver then joins none of its repair tracks. Never throws.
  */
 export function resolveRepairLayers(
 	catalog: RepairLayerCatalog | undefined,
 	source: string | CatalogTrackRef,
 ): RepairLayersResolution | undefined {
-	if (!catalog) return undefined;
-	const sourceName = typeof source === "string" ? source : source.name;
-
-	// hang dialect first. When a catalog carries hang-native rendition blocks
-	// beside a tracks[] switching-set index (the unified ABR ladder catalog),
-	// the rendition blocks are authoritative, exactly as they are for hang's own
-	// catalog decode. A typed ref resolves only within its own role.
-	// `locateCatalogFecSource` is that precedence rule, shared with transport's
-	// endpoint selection and the players' repair inventories.
-	const hang = catalog as CatalogWithRenditions;
-	const roles: CatalogFecRole[] =
-		typeof source === "string"
-			? ["video", "audio"]
-			: source.type === "audio"
-				? ["audio"]
-				: source.type === "video"
-					? ["video"]
-					: ["video", "audio"];
-	const located = locateCatalogFecSource(catalog, sourceName, roles);
-	if (located?.dialect === "hang") {
-		const renditionPath = `$.${located.role}.renditions[${JSON.stringify(sourceName)}]`;
-		const rendition = located.entry;
-		rejectRepairFieldsOnMediaTrack(renditionPath, rendition, throwRepairContractError);
-		const repairRenditions = recordOf(hang.repair?.renditions) ?? {};
-		const descriptors: RepairTrackDescriptor[] = Object.entries(repairRenditions).map(([name, entry]) => {
-			const path = `$.repair.renditions[${JSON.stringify(name)}]`;
-			const fields = recordOf(entry);
-			if (fields === undefined) {
-				throwRepairContractError("track_repair_layer", path, "a repair rendition must be an object");
-			}
-			rejectRepairTrackGeometry(path, fields, throwRepairContractError);
-			return describeRepairTrack(name, path, fields);
-		});
-		const fecOfRendition = (entry: unknown): Record<string, unknown> | undefined => {
-			const fec = recordOf(recordOf(entry)?.["fec"]);
-			return fec !== undefined && fec["algorithm"] !== "none" ? fec : undefined;
-		};
-		const mediaRenditions = [
-			...Object.values(recordOf(hang.video?.renditions) ?? {}),
-			...Object.values(recordOf(hang.audio?.renditions) ?? {}),
-		];
-		const reachability = repairReachability(mediaRenditions.map((entry) => recordOf(entry)?.["fec"]));
-		for (const d of descriptors) {
-			validateRepairTrackFields(d, throwRepairContractError);
-			assertRepairTrackReachable(d, reachability, throwRepairContractError);
-			const target = dependsTarget(d);
-			if (target === undefined) continue;
-			const targetFec =
-				fecOfRendition(hang.video?.renditions?.[target]) ?? fecOfRendition(hang.audio?.renditions?.[target]);
-			if (targetFec === undefined) {
-				throwRepairContractError(
-					"track_repair_depends",
-					`${d.path}.depends`,
-					`${JSON.stringify(target)} is not a video or audio rendition with FEC`,
-				);
-			}
-		}
-		const layers = assembleRepairLayers(
-			geometryOf(sourceName, `${renditionPath}.fec`, recordOf(rendition["fec"])),
-			descriptors,
-			throwRepairContractError,
-		);
-		return catalogFecUnavailable(rendition["fec"], `${renditionPath}.fec`) === undefined ? layers : undefined;
-	}
-
-	const msf = msfTracks(catalog);
-	if (!msf || located?.dialect !== "msf") return undefined;
-	const msfIndex = located.index;
-	const track = msf.tracks[msfIndex]!;
-	const fec = recordOf(track["fec"]);
-	const packagingOf = (t: Record<string, unknown>): unknown => t["packaging"];
-	const fecOfTrack = (t: Record<string, unknown> | undefined): Record<string, unknown> | undefined => {
-		const trackFec = recordOf(t?.["fec"]);
-		return trackFec !== undefined && trackFec["algorithm"] !== "none" ? trackFec : undefined;
+	const binding = bindingOf(catalog, source);
+	if (binding?.status !== "ok") return undefined;
+	const overlays: RepairOverlayParams[] = binding.overlay
+		? [
+				{
+					repairTrackName: binding.overlay.repairTrackName,
+					scope: "keyframe",
+					sourceSymbols: binding.overlay.sourceSymbols,
+					repairSymbols: binding.overlay.repairSymbols,
+					priority: binding.overlay.priority,
+				},
+			]
+		: [];
+	return {
+		sourceTrackName: binding.track,
+		baseLayers: binding.layers as readonly RepairLayerParams[],
+		overlays,
+		totalBaseRepairSymbols: binding.totalBaseRepairSymbols,
 	};
-	// Rule 8 on the resolver path too: a repair track carries no block geometry
-	// and a media track carries no repair-track fields. Without this a repair
-	// track with its own `fec` would count as a FEC source below and name
-	// itself as layer 0, so rule 9 would never see it.
-	const descriptors: RepairTrackDescriptor[] = [];
-	const mediaTracks: Record<string, unknown>[] = [];
-	msf.tracks.forEach((t, i) => {
-		const path = `$.tracks[${i}]`;
-		if (packagingOf(t) === "fec-repair") {
-			rejectRepairTrackGeometry(path, t, throwRepairContractError);
-			if (typeof t["name"] === "string") descriptors.push(describeRepairTrack(t["name"], path, t));
-			return;
-		}
-		rejectRepairFieldsOnMediaTrack(path, t, throwRepairContractError);
-		mediaTracks.push(t);
-	});
-	const reachability = repairReachability(mediaTracks.map((t) => t["fec"]));
-	for (const d of descriptors) {
-		validateRepairTrackFields(d, throwRepairContractError);
-		assertRepairTrackReachable(d, reachability, throwRepairContractError);
-		const target = dependsTarget(d);
-		if (target === undefined) continue;
-		const targetTrack = msf.tracks.find((t) => t["name"] === target);
-		if (targetTrack === undefined || packagingOf(targetTrack) !== "mmtp" || fecOfTrack(targetTrack) === undefined) {
-			throwRepairContractError(
-				"track_repair_depends",
-				`${d.path}.depends`,
-				`${JSON.stringify(target)} is not an mmtp track with FEC`,
-			);
-		}
-	}
-	const layers = assembleRepairLayers(
-		geometryOf(sourceName, `$.tracks[${msfIndex}].fec`, fec),
-		descriptors,
-		throwRepairContractError,
-		{ layerZeroMustBeDeclared: true },
-	);
-	return catalogFecUnavailable(fec, `$.tracks[${msfIndex}].fec`) === undefined ? layers : undefined;
 }
 
 /** A MoQ Transport priority (0..255, lower first), or null. */
@@ -559,59 +374,32 @@ function moqtPriority(value: unknown): number | null {
 }
 
 /**
- * The on-demand repair target of one source track, read from the catalog:
- * its base layer 0 repair track and the two catalog priorities
- * draft-ramadan-moq-fec §11.4.5 derives the FETCH's SUBSCRIBER_PRIORITY from
- * (see `repairFetchSubscriberPriority`). This is what a player's
- * `ResolveRepairTarget` returns once it knows which track owns the block.
+ * The on-demand repair target of one source track: its base layer 0 repair
+ * track and the two catalog priorities draft-ramadan-moq-fec §11.4.5 derives
+ * the FETCH's SUBSCRIBER_PRIORITY from (see `repairFetchSubscriberPriority`).
  *
- * - `repairPriority`: layer 0's catalog `priority`, or 240 when it declares
- *   none; that value is defined by draft-ramadan-moq-fec §10, not chosen
- *   here (`resolveRepairLayers` applies it).
- * - `sourcePriority`: the source track's MSF `tracks[]` entry `priority`
- *   (MoQ Transport scale). A catalog with no MSF entry for the track (a hang-only catalog,
- *   whose renditions carry no MoQ Transport priority) yields null, and the
- *   keyframe repair FETCH is then sent without the parameter.
+ * - `repairPriority`: layer 0's catalog `priority`, or 240 when it declares none.
+ * - `sourcePriority`: the source's MSF `tracks[]` entry `priority` (MoQ
+ *   Transport scale), or null for a hang rendition, which carries none.
  *
- * Returns null without a positive elapsed span, or when the track has no repair track, including when its FEC is
- * unavailable (`catalogFecUnavailable`): draft-ramadan-moq-fec §5.1 forbids
- * joining that track's repair tracks, so there is nothing to FETCH.
- *
- * @throws RepairContractError exactly as `resolveRepairLayers` does.
+ * Null when the source has no `ok` base instance, or no positive
+ * `interleaveDepthMs`: unicast repair requires a known elapsed FEC deadline
+ * (§11.4).
  */
 export function catalogRepairTarget(
 	catalog: RepairLayerCatalog | undefined,
 	source: string | CatalogTrackRef,
 ): RepairTarget | null {
-	const repair = resolveRepairLayers(catalog, source);
-	const layerZero = repair?.baseLayers[0];
-	if (!catalog || !layerZero) return null;
-	const sourceName = typeof source === "string" ? source : source.name;
-	const msf = msfTracks(catalog);
-	const entry = msf?.tracks.find((t) => t["name"] === sourceName);
-	const hang = catalog as CatalogWithRenditions;
-	const roles: Array<"video" | "audio"> = typeof source === "string" ? ["video", "audio"]
-		: source.type === "video" ? ["video"] : source.type === "audio" ? ["audio"] : ["video", "audio"];
-	const rendition = roles.map((role) => hang[role]?.renditions?.[sourceName]).find((r) => recordOf(r) !== undefined);
-	const fec = rendition === undefined ? recordOf(entry?.["fec"]) : recordOf(rendition.fec);
-	// Unicast repair requires a known elapsed FEC deadline (§11.4).
-	if (!fec || !(catalogFecInterleaveMs(fec) ?? 0)) return null;
-	const sourcePriority =
-		entry === undefined ? null : moqtPriority(entry["priority"]);
+	const binding = bindingOf(catalog, source);
+	if (binding?.status !== "ok" || !(binding.base.interleaveDepthMs ?? 0)) return null;
+	const layerZero = binding.layers[0]!;
+	const m = /^\/tracks\/(\d+)$/.exec(binding.pointer);
+	const tracks = (catalog as CatalogWithTracks).tracks;
+	const entry = m && Array.isArray(tracks) ? tracks[Number(m[1])] : undefined;
+	const sourcePriority = entry ? moqtPriority((entry as Record<string, unknown>)["priority"]) : null;
 	return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
 }
 
-function geometryOf(name: string, path: string, fec: Record<string, unknown> | undefined): RepairSourceGeometry {
-	return {
-		name,
-		path,
-		algorithm: fec?.["algorithm"],
-		sourceSymbols: fec?.["sourceSymbols"],
-		repairSymbols: fec?.["repairSymbols"],
-		repairTrack: fec?.["repairTrack"],
-	};
-}
-
 function numericField(value: unknown): number | undefined {
 	const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
 	return Number.isFinite(n) && n > 0 ? n : undefined;
@@ -626,167 +414,36 @@ function nonNegativeField(value: unknown): number | undefined {
 }
 
 /**
- * The track-scoped reading of `readFecBlockProfile` (BLO-35597): the same one
- * rule every catalog reader applies (a declared FEC instance names the
- * implemented profile; a block declaring none may omit it, but a token it
- * carries must be implemented), with its two failures,
- * `track_fec_block_profile_unimplemented` and `track_fec_block_profile`,
- * returned as the track's reason instead of thrown. A profile problem costs
- * only its own track: it never aborts resolving the catalog's other tracks, and
- * the token is still never defaulted or inferred.
- */
-function blockProfileUnavailable(
-	value: unknown,
-	path: string,
-	declaresFecInstance: boolean,
-): TrackFecUnavailable | undefined {
-	try {
-		readFecBlockProfile(value, path, declaresFecInstance, throwRepairContractError);
-		return undefined;
-	} catch (error) {
-		if (
-			!(error instanceof RepairContractError) ||
-			(error.code !== "track_fec_block_profile" && error.code !== "track_fec_block_profile_unimplemented")
-		) {
-			throw error;
-		}
-		return Object.freeze({ code: error.code, path: error.path, message: error.message });
-	}
-}
-
-/** Invalid declared spans disable the track; absence/zero still permits in-band FEC. */
-function isoSpanUnavailable(
-	fec: Record<string, unknown>,
-	path: string,
-	declaresFecInstance: boolean,
-): TrackFecUnavailable | undefined {
-	if (!declaresFecInstance || isoBlockSpanUsable(fec)) return undefined;
-
-	return Object.freeze({
-		code: "track_fec",
-		path,
-		message:
-			`[repair-layers:track_fec] ${path}: must be a non-negative safe integer in milliseconds`,
-	});
-}
-
-/**
- * Whether one catalog `fec` block leaves its track without FEC although it is
- * not a plain no-FEC declaration (draft-ramadan-moq-fec §5.1), and why: the
- * one track-scoped availability rule both catalog dialects apply. The hang
- * resolver (`resolveCatalogTrackFec`, `resolveRepairLayers`) and the MSF
- * `tracks[]` ingest (`MulticastManager.configureMultiTrack`) read it, so they
- * cannot disagree about which tracks keep FEC.
- *
- * Returns the reason (`TrackFecUnavailable`) when the block names no
- * implemented `blockProfile` (the retired `k-padded-v1` included; on
- * `algorithm: "none"` only a present token is read) or, for a declared
- * `iso-ssbg1-v1` instance, carries no usable block span. Returns undefined for
- * a non-object and for every block whose FEC is available. It reads only the
- * profile and the span: malformed geometry (`sourceSymbols`, `symbolSize`, ...)
- * is the caller's to reject, and takes precedence. Never throws on catalog
- * input: whether FEC is available is `catalogFecAvailable` (mmt-base), and a
- * test pins that every unavailable block gets a reason here.
- *
- * @param fec the track's catalog `fec` value.
- * @param fecPath JSON path of that `fec` block; the reason's `path` extends it.
- */
-export function catalogFecUnavailable(fec: unknown, fecPath: string): TrackFecUnavailable | undefined {
-	// The decision is mmt-base's `catalogFecAvailable`, which transport reads
-	// too; this function only explains a negative one.
-	if (catalogFecAvailable(fec)) return undefined;
-	const block = recordOf(fec)!;
-	if (fecAlgorithmUnimplemented(block["algorithm"])) {
-		return Object.freeze({
-			code: "track_fec_algorithm_unimplemented",
-			path: `${fecPath}.algorithm`,
-			message: `algorithm ${JSON.stringify(block["algorithm"])} is not implemented: the track plays without FEC`,
-		});
-	}
-	const declaresFecInstance = block["algorithm"] !== "none";
-	const reason =
-		blockProfileUnavailable(block["blockProfile"], `${fecPath}.blockProfile`, declaresFecInstance) ??
-		isoSpanUnavailable(block, `${fecPath}.interleaveDepthMs`, declaresFecInstance);
-	if (reason === undefined) {
-		throw new Error(`catalogFecUnavailable: ${fecPath} is unavailable but no reason applies (rule drift)`);
-	}
-	return reason;
-}
-
-/**
- * Per-track FEC geometry, or `NO_FEC` when the rendition declares none (no
- * `fec`, or `algorithm: "none"`) or its FEC is unavailable
- * (`catalogFecUnavailable`: no implemented `blockProfile`, or an
- * `iso-ssbg1-v1` span it cannot use), which carries `fecUnavailable`.
- *
- * @throws RepairContractError from `resolveRepairLayers` when the rendition
- * declares a `fec` block (any algorithm, `none` included) and the catalog's
- * repair contract is malformed, and `track_fec` when its `fec` declares an FEC
- * instance whose `sourceSymbols` or `symbolSize` is not a positive integer;
- * see `resolveCatalogTrackFec`. An absent or unimplemented `blockProfile`, or
- * an invalid `iso-ssbg1-v1` span,
- * never throws: it is this track's `fecUnavailable`.
+ * Per-track FEC geometry from the source's binding: `NO_FEC` when it declares
+ * none, `NO_FEC` plus `fecUnavailable` when its base instance is not `ok`.
  */
 function fecParams(
 	catalog: CatalogWithRenditions | undefined,
 	track: CatalogTrackRef | undefined,
-	rendition: RenditionCatalog | undefined,
 	fps?: number,
 	sampleRate?: number,
 ): TrackFecParams {
 	const mediaRate = sampleRate === undefined ? { fps } : { fps, sampleRate };
-	const fec = rendition?.fec;
-	// Every caller passes a track with its rendition.
-	if (!fec || !track) return { ...NO_FEC, ...mediaRate };
-	// The repair contract is enforced for every declared `fec` block, including
-	// one that declares no FEC instance (a repair layer may not depend on it).
-	const repair = resolveRepairLayers(catalog, track);
-	const fecPath = `$.${track.type}.renditions[${JSON.stringify(track.name)}].fec`;
-	// One predicate for "this track has FEC", shared with resolveFecState: K
-	// and T are positive integers, the algorithm is not `none`, and the block
-	// profile is known.
-	if (!catalogDeclaresFec(fec)) {
-		if (catalogFecDeclaresUnconfigurableInstance(fec)) {
-			const kValid = Number.isSafeInteger(fec.sourceSymbols) && (fec.sourceSymbols ?? 0) > 0;
-			// Any algorithm but `none` declares an FEC instance, so geometry a
-			// decoder cannot configure is a malformed catalog, not "no FEC".
-			// Returning NO_FEC would silently drop the track's repair
-			// subscription (repairTrackName, repairLayers, repairOverlays).
-			throwRepairContractError(
-				"track_fec",
-				`${fecPath}.${kValid ? "symbolSize" : "sourceSymbols"}`,
-				kValid && Number.isSafeInteger(fec.symbolSize) && (fec.symbolSize ?? 0) > 0
-					? `iso-ssbg1-v1 symbolSize must be at least ${ISO_SSBG1_MIN_SYMBOL_SIZE}`
-					: "must be a positive integer",
-			);
-		}
-		// What remains is `algorithm: "none"` (which carries no profile; a token
-		// it does carry must still be implemented) or a declared instance whose
-		// FEC is unavailable (§5.1). Neither has FEC; the reason says why, for
-		// this track alone.
-		const fecUnavailable = catalogFecUnavailable(fec, fecPath);
-		return fecUnavailable === undefined ? { ...NO_FEC, ...mediaRate } : { ...NO_FEC, ...mediaRate, fecUnavailable };
-	}
-	// The predicate held, so the profile is implemented: this read cannot fail.
-	const fecBlockProfile = readFecBlockProfile(fec.blockProfile, `${fecPath}.blockProfile`, true, throwRepairContractError);
+	const binding = track ? bindingOf(catalog, track) : undefined;
+	if (binding === undefined) return { ...NO_FEC, ...mediaRate };
+	if (binding.status === "unavailable") return { ...NO_FEC, ...mediaRate, fecUnavailable: binding.reason };
+	const { base } = binding;
+	const repair = resolveRepairLayers(catalog, track!)!;
 	return {
-		fecK: fec.sourceSymbols ?? 0,
-		fecAlgorithm: fec.algorithm === "reed-solomon" ? "reed-solomon" : "raptorq",
-		fecBlockProfile,
-		fecRepairCount: fec.repairSymbols ?? 0,
-		// The wire RSB_length: every base layer's packets carry the base total (§7.1).
-		fecTotalRepairCount: repair?.totalBaseRepairSymbols ?? fec.repairSymbols ?? 0,
-		fecSymbolSize: fec.symbolSize ?? 0,
+		fecK: base.sourceSymbols,
+		fecAlgorithm: base.scheme,
+		fecBlockProfile: parseFecBlockProfile(base.blockProfile, `${binding.pointer}/fec/blockProfile`),
+		fecRepairCount: base.repairSymbols,
+		// The wire RSB_length: every base layer's packets carry the base total.
+		fecTotalRepairCount: binding.totalBaseRepairSymbols,
+		fecSymbolSize: base.symbolSize,
 		// Zero/absence leaves the elapsed deadline unknown; geometry stays in-band.
-		fecInterleaveMs: catalogFecInterleaveMs(fec) ?? 0,
-		// Additive, never a multiplier on the span: jitter belongs to the network
-		// path and the span belongs to the encoder, so scaling one by the other
-		// hands one network different slack per track. `numericField` rejects 0,
-		// so it cannot be reused here — a declared 0 is a legitimate value.
-		fecReorderToleranceMs: nonNegativeField(fec.reorderToleranceMs),
-		repairTrackName: fec.repairTrack,
-		repairLayers: repair?.baseLayers,
-		repairOverlays: repair?.overlays,
+		fecInterleaveMs: catalogFecInterleaveMs(base) ?? 0,
+		// Additive to the span, never a multiplier; a declared 0 stays 0.
+		fecReorderToleranceMs: nonNegativeField(base.reorderToleranceMs),
+		repairTrackName: base.repairTrack,
+		repairLayers: repair.baseLayers,
+		repairOverlays: repair.overlays,
 		...mediaRate,
 	};
 }
@@ -801,28 +458,9 @@ function fecParams(
  * interleave and repair layers, never the first rendition's. A track with no
  * rendition of its type resolves to no FEC (`fecK` 0) and no media rate.
  *
- * The block profile is track-scoped (BLO-35597, draft-ramadan-moq-fec §5.1).
- * `iso-ssbg1-v1` is the only implemented profile. A rendition whose `fec`
- * declares an FEC instance but names no `blockProfile`
- * (`track_fec_block_profile`), or whose `fec` (a `none` block included) names
- * any other token (`track_fec_block_profile_unimplemented`; the retired
- * `k-padded-v1` is one), resolves to no FEC: `fecK` 0, no `fecBlockProfile`,
- * no repair track, layers or overlays, and `fecUnavailable` carrying the
- * reason at the field's JSON path for the caller to surface. Every other track
- * resolves as usual. The profile is never defaulted or inferred;
- * `algorithm: "none"` may omit it.
- *
- * @throws RepairContractError `track_fec` when a rendition's `fec` declares an
- * FEC instance (any `algorithm` but `none`) whose `sourceSymbols` or
- * `symbolSize` is not a positive integer, and when a rendition that declares a
- * `fec` block (any algorithm, `none` included) carries a repair contract that
- * violates draft-ramadan-moq-fec 6.3 (a gap or
- * duplicate in the layer chain, a bad `depends` target, an unreachable repair
- * track, a bound violation). Because the hang dialect validates every `repair.renditions`
- * entry of the catalog, resolving the video track fails on a malformed audio
- * repair rendition too. This is deliberate: a player must fail closed before it
- * joins any repair track. Callers that used to treat this function as total
- * must catch it and surface the catalog error.
+ * FEC is per track and per instance (fec-core-00 10.3): a track whose base
+ * instance is not `ok` resolves to no FEC with `fecUnavailable` saying why,
+ * and every other track resolves as usual. Never throws on catalog input.
  */
 export function resolveCatalogTrackFec(
 	catalog: CatalogWithRenditions | undefined,
@@ -847,11 +485,10 @@ export function resolveCatalogTrackFec(
 	const catalogFps = numericField(video?.framerate);
 	const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
 	const audioFps = sampleRate ? sampleRate / 1024 : undefined;
-	const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : undefined, video, catalogFps);
+	const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : undefined, catalogFps);
 	const audioParams = fecParams(
 		catalog,
 		audioTrackName ? { name: audioTrackName, type: "audio" } : undefined,
-		audio,
 		audioFps,
 		sampleRate,
 	);
@@ -862,12 +499,12 @@ export function resolveCatalogTrackFec(
 			const rendition = audioRenditions?.[track.name];
 			if (!rendition) return { ...NO_FEC };
 			const rate = numericField(rendition.sampleRate ?? rendition.samplerate);
-			return fecParams(catalog, { name: track.name, type: "audio" }, rendition, rate ? rate / 1024 : undefined, rate);
+			return fecParams(catalog, { name: track.name, type: "audio" }, rate ? rate / 1024 : undefined, rate);
 		}
 		if (track.name === videoTrackName) return videoParams;
 		const rendition = videoRenditions?.[track.name];
 		if (!rendition) return { ...NO_FEC };
-		return fecParams(catalog, { name: track.name, type: "video" }, rendition, numericField(rendition.framerate));
+		return fecParams(catalog, { name: track.name, type: "video" }, numericField(rendition.framerate));
 	};
 
 	return {