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

package/src/fec-catalog.ts

@@ -0,0 +1,446 @@
+// FEC catalog binding validator (draft-ramadan-moq-fec-catalog-00, as posted
+// 2026-11-02, moqcast-draft 5f49172).
+//
+// The catalog-00 shape only: a track's `fec` is an array of instance objects,
+// and a repair or symbol track binds to its instance by `source` + `instanceId`
+// (or by being named in `repairTrack` / `symbolTrack`). The draft-01 object
+// shape (`fec: {...}`, `depends`) is not accepted: an object `fec` is a type
+// violation, and a repair track that only `depends` on its source is an orphan.
+//
+// Validation fails closed per instance (fec-core-00 10.3): a violation stops
+// FEC for that instance and no other. Three outcomes, each reported with the
+// catalog path that caused it:
+//   ok          - FEC may start for the instance.
+//   unavailable - the receiver forgoes FEC for it (fec-core-00 10.3 rule 1,
+//                 4.5); not a validation failure.
+//   violation   - the configuration is invalid for this receiver.
+// An orphan repair or symbol track (fec-catalog-00 5 rule 6) is reported and
+// stops nothing. `enhancementRepair` anywhere rejects the catalog (rule 4).
+//
+// The Rust twin is `mmt_fec::fec_catalog`; both run vectors/fec-catalog-00/.
+
+export type FecCatalogOutcome = "ok" | "unavailable" | "violation";
+
+export type FecCatalogCode =
+	// Unavailable (fec-core-00 10.3 rule 1; fec-catalog-00 3.1).
+	| "fec_scheme_absent"
+	| "fec_scheme_unimplemented"
+	| "fec_block_profile_absent"
+	| "fec_block_profile_unimplemented"
+	| "fec_block_profile_packaging"
+	// Violations.
+	| "fec_member" // fec-catalog-00 5 rule 1; fec-core-00 10.3 rule 11
+	| "fec_naming" // fec-catalog-00 5 rule 2
+	| "fec_resolution" // fec-catalog-00 5 rule 3
+	| "fec_enhancement_repair" // fec-catalog-00 5 rule 4, 3.4
+	| "fec_orphan" // fec-catalog-00 5 rule 6 (report only)
+	| "fec_layers" // fec-core-00 10.3 rule 3
+	| "fec_layer0" // fec-core-00 10.3 rule 4
+	| "fec_bounds" // fec-core-00 10.3 rule 5; block-codes-00 7; mmt-02 7.1
+	| "fec_instance_id" // fec-core-00 10.3 rule 7
+	| "fec_symbol_tracks" // fec-core-00 10.3 rule 7
+	| "fec_track_geometry" // fec-core-00 10.3 rule 8
+	| "fec_priority" // fec-core-00 10.3 rule 10
+	| "fec_overlay" // mmt-02 7.4.1
+	| "fec_overlay_unsupported"; // mmt-02 7.4.4
+
+export interface FecCatalogIssue {
+	readonly code: FecCatalogCode;
+	/** JSON Pointer into the catalog. */
+	readonly path: string;
+}
+
+export interface FecCatalogInstance {
+	/** JSON Pointer of the instance object, `/tracks/<i>/fec/<j>`. */
+	readonly path: string;
+	readonly track: string | null;
+	/** Resolved Instance ID; null when `instanceId` is malformed. */
+	readonly instanceId: number | null;
+	readonly outcome: FecCatalogOutcome;
+	readonly issues: readonly FecCatalogIssue[];
+	/** Index into `tracks` of the source track declaring the instance. */
+	readonly trackIndex: number;
+	/** Track index of the repair track `repairTrack` names, or null. */
+	readonly repairTrack: number | null;
+	/** Track indices of the other repair tracks bound by `source` + `instanceId`. */
+	readonly boundRepairTracks: readonly number[];
+	/** Track index of the instance's symbol track (named or bound), or null. */
+	readonly symbolTrack: number | null;
+}
+
+export interface FecCatalogReport {
+	readonly instances: readonly FecCatalogInstance[];
+	/** Every report, instance-attributed or not, in discovery order. */
+	readonly issues: readonly FecCatalogIssue[];
+}
+
+export interface FecCatalogReceiver {
+	/** Schemes the receiver implements. Default: reed-solomon, raptorq. */
+	readonly schemes?: readonly string[];
+	/** Block profiles the receiver implements. Default: moq-object-v1, iso-ssbg1-v1. */
+	readonly blockProfiles?: readonly string[];
+	/** Whether the receiver implements the mmt-02 7.4 keyframe overlay. Default true. */
+	readonly overlays?: boolean;
+}
+
+const DEFAULT_SCHEMES = ["reed-solomon", "raptorq"];
+const DEFAULT_PROFILES = ["moq-object-v1", "iso-ssbg1-v1"];
+const RS_MAX_BLOCK = 255; // block-codes-00 7
+const RAPTORQ_MAX_K = 56403; // block-codes-00 7
+const MAX_24 = 0xffffff; // fec-core-00 10.3 rule 5
+const ISO_MIN_T = 14; // mmt-02 7.1
+const GEOMETRY_KEYS = [
+	"scheme",
+	"blockProfile",
+	"mmtpMode",
+	"timescale",
+	"symbolSize",
+	"interleaveDepthMs",
+	"reorderToleranceMs",
+	"sourceSymbols",
+	"fec",
+];
+
+type Json = unknown;
+type Known =
+	| "tracks" | "fec" | "name" | "namespace" | "packaging" | "source" | "instanceId"
+	| "repairLayer" | "repairSymbols" | "priority" | "scheme" | "blockProfile"
+	| "sourceSymbols" | "symbolSize" | "repairTrack" | "symbolTrack"
+	| "interleaveDepthMs" | "reorderToleranceMs" | "label" | "scope";
+type Obj = Record<string, Json> & Partial<Record<Known, Json>>;
+
+const isObj = (v: Json): v is Obj => typeof v === "object" && v !== null && !Array.isArray(v);
+const has = (o: Obj, k: string) => Object.prototype.hasOwnProperty.call(o, k);
+const isInt = (v: Json): v is number => typeof v === "number" && Number.isInteger(v);
+const intIn = (v: Json, lo: number, hi = Number.MAX_SAFE_INTEGER): v is number =>
+	isInt(v) && v >= lo && v <= hi;
+
+// moq-object-v1 admits any packaging whose objects carry media as whole
+// objects (fec-core-00 15.3); iso-ssbg1-v1 admits mmtp (mmt-02 7.1).
+const profileAdmits = (profile: string, packaging: Json) => profile !== "iso-ssbg1-v1" || packaging === "mmtp";
+
+interface Inst {
+	path: string;
+	ti: number;
+	track: Obj;
+	obj: Obj | null;
+	id: number | null;
+	unavailable: boolean;
+	overlay: boolean;
+	issues: FecCatalogIssue[];
+	layer0: number | null; // track index of the resolved repairTrack
+	symbolNamed: number | null;
+	attached: number[]; // unnamed fec-repair/fec-source tracks bound by source
+}
+
+export function validateFecCatalog(catalog: Json, receiver: FecCatalogReceiver = {}): FecCatalogReport {
+	const schemes = receiver.schemes ?? DEFAULT_SCHEMES;
+	const profiles = receiver.blockProfiles ?? DEFAULT_PROFILES;
+	const overlays = receiver.overlays ?? true;
+	const all: FecCatalogIssue[] = [];
+	const report = (code: FecCatalogCode, path: string, inst?: Inst) => {
+		const issue = { code, path };
+		all.push(issue);
+		inst?.issues.push(issue);
+	};
+
+	const tracks: Json[] = isObj(catalog) && Array.isArray(catalog.tracks) ? catalog.tracks : [];
+	if (!isObj(catalog) || !Array.isArray(catalog.tracks)) report("fec_member", "/tracks");
+
+	// Rule 4: enhancementRepair at track level or inside an instance object.
+	let rejectAll = false;
+	tracks.forEach((t, ti) => {
+		if (!isObj(t)) return;
+		if (has(t, "enhancementRepair")) {
+			rejectAll = true;
+			report("fec_enhancement_repair", `/tracks/${ti}/enhancementRepair`);
+		}
+		if (Array.isArray(t.fec))
+			t.fec.forEach((o, ii) => {
+				if (isObj(o) && has(o, "enhancementRepair")) {
+					rejectAll = true;
+					report("fec_enhancement_repair", `/tracks/${ti}/fec/${ii}/enhancementRepair`);
+				}
+			});
+	});
+
+	// Track lookup by (namespace, name): a name resolves in the source track's namespace.
+	const key = (ns: Json, name: string) => JSON.stringify([ns ?? null, name]);
+	const byName = new Map<string, number>();
+	tracks.forEach((t, ti) => {
+		if (isObj(t) && typeof t.name === "string") {
+			const k = key(t.namespace, t.name);
+			if (!byName.has(k)) byName.set(k, ti);
+		}
+	});
+	const trackAt = (ti: number) => tracks[ti] as Obj;
+
+	// Collect instances.
+	const insts: Inst[] = [];
+	tracks.forEach((t, ti) => {
+		// A repair or symbol track's own `fec` is geometry (core rule 8), not instances.
+		if (!isObj(t) || !has(t, "fec") || t.packaging === "fec-repair" || t.packaging === "fec-source") return;
+		if (!Array.isArray(t.fec)) {
+			report("fec_member", `/tracks/${ti}/fec`);
+			return;
+		}
+		t.fec.forEach((o, ii) => {
+			const path = `/tracks/${ti}/fec/${ii}`;
+			const inst: Inst = {
+				path,
+				ti,
+				track: t,
+				obj: isObj(o) ? o : null,
+				id: null,
+				unavailable: false,
+				overlay: false,
+				issues: [],
+				layer0: null,
+				symbolNamed: null,
+				attached: [],
+			};
+			insts.push(inst);
+			if (!inst.obj) return report("fec_member", path, inst);
+			const o2 = inst.obj;
+			if (!has(o2, "instanceId")) inst.id = 0;
+			else if (intIn(o2.instanceId, 0, 255)) inst.id = o2.instanceId;
+			else report("fec_member", `${path}/instanceId`, inst);
+			inst.overlay = has(o2, "scope");
+		});
+	});
+	const declaresFec = insts.length > 0;
+
+	// Availability (fec-core-00 10.3 rule 1). Scheme first, then profile.
+	for (const inst of insts) {
+		const o = inst.obj;
+		if (!o) continue;
+		const avail = (field: "scheme" | "blockProfile", impl: readonly string[]) => {
+			const p = `${inst.path}/${field}`;
+			const absent = field === "scheme" ? "fec_scheme_absent" : "fec_block_profile_absent";
+			const unimpl = field === "scheme" ? "fec_scheme_unimplemented" : "fec_block_profile_unimplemented";
+			if (!has(o, field)) return report(absent, p, inst), false;
+			if (typeof o[field] !== "string") return report("fec_member", p, inst), true;
+			if (!impl.includes(o[field] as string)) return report(unimpl, p, inst), false;
+			return true;
+		};
+		if (!avail("scheme", schemes) || !avail("blockProfile", profiles)) inst.unavailable = true;
+		else if (typeof o.blockProfile === "string" && !profileAdmits(o.blockProfile, inst.track.packaging)) {
+			report("fec_block_profile_packaging", `${inst.path}/blockProfile`, inst);
+			inst.unavailable = true;
+		}
+	}
+	const live = (i: Inst) => !i.unavailable;
+
+	// Rule 1 on instance members, and core rule 11.
+	for (const inst of insts.filter(live)) {
+		const o = inst.obj;
+		if (!o) continue;
+		const p = inst.path;
+		for (const m of ["sourceSymbols", "repairSymbols", "symbolSize"])
+			if (!intIn(o[m], 1)) report("fec_member", `${p}/${m}`, inst);
+		if (typeof o.repairTrack !== "string") report("fec_member", `${p}/repairTrack`, inst);
+		if (has(o, "symbolTrack") && typeof o.symbolTrack !== "string") report("fec_member", `${p}/symbolTrack`, inst);
+		if (has(o, "interleaveDepthMs")) {
+			const d = o.interleaveDepthMs;
+			if (!intIn(d, 0) || (d === 0 && o.blockProfile !== "iso-ssbg1-v1"))
+				report("fec_member", `${p}/interleaveDepthMs`, inst);
+		}
+		if (has(o, "reorderToleranceMs")) {
+			const r = o.reorderToleranceMs;
+			if (typeof r !== "number" || !Number.isFinite(r) || r < 0) report("fec_member", `${p}/reorderToleranceMs`, inst);
+		}
+		if (has(o, "label") && typeof o.label !== "string") report("fec_member", `${p}/label`, inst);
+		if (inst.overlay && o.scope !== "keyframe") report("fec_member", `${p}/scope`, inst);
+	}
+
+	// Core rule 7: unique Instance IDs within a track.
+	const idGroups = new Map<string, Inst[]>();
+	for (const inst of insts)
+		if (inst.id !== null) {
+			const k = `${inst.ti}:${inst.id}`;
+			idGroups.set(k, [...(idGroups.get(k) ?? []), inst]);
+		}
+	for (const group of idGroups.values())
+		if (group.length > 1)
+			for (const inst of group.filter(live))
+				report("fec_instance_id", inst.obj && has(inst.obj, "instanceId") ? `${inst.path}/instanceId` : inst.path, inst);
+
+	// Rule 2: repairTrack / symbolTrack name a track of the right packaging, once
+	// per catalog. A name used twice binds no layer 0 or symbol track for either
+	// namer; the track is still claimed by the first, so it is not re-attached.
+	const nameUses = new Map<string, { inst: Inst; field: "repairTrack" | "symbolTrack" }[]>();
+	for (const inst of insts)
+		for (const field of ["repairTrack", "symbolTrack"] as const)
+			if (inst.obj && typeof inst.obj[field] === "string") {
+				const k = key(inst.track.namespace, inst.obj[field] as string);
+				nameUses.set(k, [...(nameUses.get(k) ?? []), { inst, field }]);
+			}
+	const namedBy = new Map<number, Inst>();
+	for (const [k, uses] of nameUses) {
+		const tj = byName.get(k);
+		for (const { inst, field } of uses) {
+			const path = `${inst.path}/${field}`;
+			if (tj === undefined || trackAt(tj).packaging !== (field === "repairTrack" ? "fec-repair" : "fec-source")) {
+				if (live(inst)) report("fec_naming", path, inst);
+			} else if (uses.length > 1) {
+				if (live(inst)) report("fec_naming", path, inst);
+				if (!namedBy.has(tj)) namedBy.set(tj, inst);
+			} else {
+				namedBy.set(tj, inst);
+				if (field === "repairTrack") inst.layer0 = tj;
+				else inst.symbolNamed = tj;
+			}
+		}
+	}
+
+	// Repair and symbol tracks: resolve each to its instance.
+	const owner = new Map<number, Inst>();
+	if (declaresFec)
+		tracks.forEach((t, tj) => {
+			if (!isObj(t) || (t.packaging !== "fec-repair" && t.packaging !== "fec-source")) return;
+			const tp = `/tracks/${tj}`;
+			const named = namedBy.get(tj);
+			if (named) {
+				owner.set(tj, named);
+				if (!live(named)) return;
+				// Rule 3: a named track's source / instanceId agree with its namer.
+				if (has(t, "source") && t.source !== named.track.name) report("fec_resolution", `${tp}/source`, named);
+				if (has(t, "instanceId") && t.instanceId !== named.id) report("fec_resolution", `${tp}/instanceId`, named);
+				return;
+			}
+			if (!has(t, "source")) return report("fec_orphan", tp); // rule 6, stops nothing
+			const id = has(t, "instanceId") ? t.instanceId : 0;
+			const src = typeof t.source === "string" ? byName.get(key(t.namespace, t.source)) : undefined;
+			const target = src === undefined ? undefined : insts.find((i) => i.ti === src && i.id === id);
+			if (!target) return report("fec_naming", has(t, "instanceId") && src !== undefined ? `${tp}/instanceId` : `${tp}/source`);
+			owner.set(tj, target);
+			target.attached.push(tj);
+		});
+
+	// Track fields (rule 1) and no geometry (core rule 8), charged to the owner.
+	for (const [tj, inst] of owner) {
+		if (!live(inst)) continue;
+		const t = trackAt(tj);
+		const tp = `/tracks/${tj}`;
+		const symbol = t.packaging === "fec-source";
+		if (has(t, "source") && typeof t.source !== "string") report("fec_member", `${tp}/source`, inst);
+		if (has(t, "instanceId") && !intIn(t.instanceId, 0, 255)) report("fec_member", `${tp}/instanceId`, inst);
+		for (const m of ["repairLayer", "repairSymbols"]) {
+			if (!has(t, m)) continue;
+			if (symbol || !intIn(t[m], m === "repairLayer" ? 0 : 1)) report("fec_member", `${tp}/${m}`, inst);
+		}
+		if (has(t, "priority") && !intIn(t.priority, symbol ? 0 : 192, 255)) report("fec_member", `${tp}/priority`, inst);
+		for (const k of Object.keys(t))
+			if (GEOMETRY_KEYS.includes(k) || k.startsWith("groupDuration"))
+				report("fec_track_geometry", `${tp}/${k.replace(/~/g, "~0").replace(/\//g, "~1")}`, inst); // RFC 6901
+	}
+
+	// Per instance: layers, symbol tracks, priorities, scheme bounds.
+	for (const inst of insts.filter(live)) {
+		const o = inst.obj;
+		if (!o) continue;
+		const repairs = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-repair");
+		const symbols = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-source");
+		if (symbols.length + (inst.symbolNamed !== null ? 1 : 0) > 1)
+			for (const tj of symbols) report("fec_symbol_tracks", `/tracks/${tj}`, inst);
+
+		const l0 = inst.layer0 === null ? null : trackAt(inst.layer0);
+		const l0p = `/tracks/${inst.layer0}`;
+		if (inst.overlay) {
+			// mmt-02 7.4.1: an overlay has one repair track and no repairLayer.
+			if (l0 && has(l0, "repairLayer")) report("fec_overlay", `${l0p}/repairLayer`, inst);
+			for (const tj of repairs)
+				report("fec_overlay", has(trackAt(tj), "repairLayer") ? `/tracks/${tj}/repairLayer` : `/tracks/${tj}`, inst);
+		} else {
+			if (l0 && has(l0, "repairLayer") && l0.repairLayer !== 0) report("fec_layers", `${l0p}/repairLayer`, inst);
+			if (l0 && has(l0, "repairSymbols") && intIn(o.repairSymbols, 1) && l0.repairSymbols !== o.repairSymbols)
+				report("fec_layer0", `${l0p}/repairSymbols`, inst);
+			const layers: { tj: number; layer: number }[] = [];
+			for (const tj of repairs) {
+				const t = trackAt(tj);
+				if (!has(t, "repairLayer")) report("fec_member", `/tracks/${tj}/repairLayer`, inst);
+				else if (t.repairLayer === 0) report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+				else if (intIn(t.repairLayer, 1)) layers.push({ tj, layer: t.repairLayer });
+				if (!has(t, "repairSymbols")) report("fec_member", `/tracks/${tj}/repairSymbols`, inst);
+			}
+			// Core rule 3: layers 1..n contiguous, no duplicates.
+			const counts = new Map<number, number>();
+			for (const { layer } of layers) counts.set(layer, (counts.get(layer) ?? 0) + 1);
+			let missing = 1;
+			while (counts.has(missing)) missing++;
+			for (const { tj, layer } of layers)
+				if (counts.get(layer)! > 1 || layer > missing) report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+			// Core rule 10: priority non-decreasing with layer; layer 0 defaults to 240.
+			const chain = [
+				{ layer: 0, tj: inst.layer0, pri: l0 && intIn(l0.priority, 192, 255) ? l0.priority : l0 && has(l0, "priority") ? null : 240 },
+				...layers.map(({ tj, layer }) => {
+					const pr = trackAt(tj).priority;
+					return { layer, tj, pri: intIn(pr, 192, 255) ? pr : null };
+				}),
+			].sort((a, b) => a.layer - b.layer);
+			let prev: number | null = null;
+			for (const c of chain) {
+				if (c.pri === null) continue;
+				if (prev !== null && c.pri < prev) report("fec_priority", `/tracks/${c.tj}/priority`, inst);
+				prev = Math.max(prev ?? c.pri, c.pri);
+			}
+		}
+
+		// Core rule 5 and the scheme / profile bounds.
+		const K = o.sourceSymbols;
+		const T = o.symbolSize;
+		const P0 = o.repairSymbols;
+		if (intIn(K, 1) && intIn(P0, 1)) {
+			let P = P0;
+			if (!inst.overlay)
+				for (const tj of repairs) {
+					const t = trackAt(tj);
+					if (intIn(t.repairLayer, 1) && intIn(t.repairSymbols, 1)) P += t.repairSymbols;
+				}
+			if (P > MAX_24 || K + P - 1 > MAX_24) report("fec_bounds", inst.path, inst);
+			else if (o.scheme === "reed-solomon" && K + P > RS_MAX_BLOCK) report("fec_bounds", inst.path, inst);
+		}
+		if (o.scheme === "raptorq" && intIn(K, 1) && K > RAPTORQ_MAX_K) report("fec_bounds", `${inst.path}/sourceSymbols`, inst);
+		if (intIn(T, 1)) {
+			if (o.scheme === "raptorq" && T % 8 !== 0) report("fec_bounds", `${inst.path}/symbolSize`, inst);
+			else if (o.blockProfile === "iso-ssbg1-v1" && T < ISO_MIN_T) report("fec_bounds", `${inst.path}/symbolSize`, inst);
+		}
+	}
+
+	// mmt-02 7.4.1 / 7.4.4: overlays, per source track.
+	const overlayTracks = new Set(insts.filter((i) => live(i) && i.overlay).map((i) => i.ti));
+	for (const ti of overlayTracks) {
+		const ofTrack = insts.filter((i) => i.ti === ti && live(i));
+		const ovs = ofTrack.filter((i) => i.overlay);
+		if (!overlays) {
+			for (const ov of ovs) report("fec_overlay_unsupported", `${ov.path}/scope`, ov);
+			for (const i of ofTrack) i.issues.length === 0 && i.issues.push({ code: "fec_overlay_unsupported", path: `${ovs[0].path}/scope` });
+			continue;
+		}
+		if (ovs.length > 1) for (const ov of ovs) report("fec_overlay", `${ov.path}/scope`, ov);
+		for (const ov of ovs)
+			if (ov.obj?.blockProfile !== "iso-ssbg1-v1") report("fec_overlay", `${ov.path}/blockProfile`, ov);
+		const cause = ovs.flatMap((ov) => ov.issues).find((x) => x.code === "fec_overlay");
+		if (cause) for (const ov of ovs) if (ov.issues.length === 0) ov.issues.push(cause);
+	}
+
+	// Rule 4 rejects every instance; each carries the cause so a consumer reading
+	// `instances[].issues` sees why.
+	const rule4 = all.find((x) => x.code === "fec_enhancement_repair");
+	if (rejectAll && rule4) for (const i of insts) if (i.issues.length === 0) i.issues.push(rule4);
+
+	return {
+		instances: insts.map((i) => ({
+			path: i.path,
+			track: typeof i.track.name === "string" ? i.track.name : null,
+			instanceId: i.id,
+			outcome: rejectAll || (!i.unavailable && i.issues.length > 0) ? "violation" : i.unavailable ? "unavailable" : "ok",
+			issues: i.issues,
+			trackIndex: i.ti,
+			repairTrack: i.layer0,
+			boundRepairTracks: i.attached.filter((tj) => trackAt(tj).packaging === "fec-repair"),
+			symbolTrack: i.symbolNamed ?? i.attached.find((tj) => trackAt(tj).packaging === "fec-source") ?? null,
+		})),
+		issues: all,
+	};
+}

package/src/index.ts

@@ -4,5 +4,6 @@ export * from './ntp-short.js'
 export * from './signalling.js'
 export * from './serial-number.js'
 export * from './fec-block-profile.js'
-export * from './catalog-fec-source.js'
 export * from './multicast-catalog.js'
+export * from './fec-catalog.js'
+export * from './fec-bindings.js'

package/dist/catalog-fec-source.d.ts

@@ -1,88 +0,0 @@
-/** The catalog media roles that carry hang renditions. */
-export type CatalogFecRole = 'video' | 'audio';
-/** One media source's `fec` block, as `locateCatalogFecSource` found it. */
-export type CatalogFecSource = {
-    readonly dialect: 'hang';
-    readonly role: CatalogFecRole;
-    /** The rendition object. */
-    readonly entry: Record<string, unknown>;
-    /** The rendition's `fec` value, unvalidated (may be undefined). */
-    readonly fec: unknown;
-    /** JSON path of that `fec` block. */
-    readonly fecPath: string;
-} | {
-    readonly dialect: 'msf';
-    /** Index of the entry in `tracks[]`. */
-    readonly index: number;
-    /** The `tracks[]` entry (an empty object when the entry is not an object). */
-    readonly entry: Record<string, unknown>;
-    /** The entry's `fec` value, unvalidated (may be undefined). */
-    readonly fec: unknown;
-    /** JSON path of that `fec` block. */
-    readonly fecPath: string;
-};
-/**
- * Locate the catalog entry that declares one media source's `fec` block, in
- * either catalog dialect.
- *
- * A hang `video`/`audio` rendition named `source` wins, in `roles` order, over
- * a `tracks[]` entry of the same name: when a catalog carries 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. The precedence is keyed on the rendition EXISTING as an
- * object, not on it carrying `fec`: a rendition without `fec` locates with
- * `fec: undefined` and never falls through to `tracks[]`.
- *
- * Otherwise the first `tracks[]` entry named `source` locates. Returns
- * undefined when neither dialect names it, or when `catalog` is not an object.
- *
- * @param roles the hang roles to search, in order (both by default). A typed
- *   track reference passes its own role only.
- */
-export declare function locateCatalogFecSource(catalog: unknown, source: string, roles?: readonly CatalogFecRole[]): CatalogFecSource | undefined;
-/**
- * Whether an `iso-ssbg1-v1` block's optional `interleaveDepthMs` span is
- * usable: absent, or a non-negative safe integer. Zero or absence supplies no
- * elapsed deadline and still permits in-band FEC. True for every block that
- * names another profile (the span is not read) and for a non-object.
- */
-export declare function isoBlockSpanUsable(fec: unknown): boolean;
-/**
- * Whether one catalog `fec` block leaves its FEC available
- * (draft-ramadan-moq-fec §5.1): the decision the container's
- * `catalogFecUnavailable` explains with a typed reason.
- *
- * False when the block's `algorithm` is a token this receiver does not
- * implement (`fecAlgorithmUnimplemented`); when it declares an FEC instance
- * (any `algorithm` but `"none"`) and names no implemented `blockProfile` (the retired `k-padded-v1`
- * included), or carries an `iso-ssbg1-v1` span it cannot use; and when a block
- * declaring no FEC instance carries a profile token that is not implemented.
- * True for a non-object and for every other block. It reads only the profile
- * and the span: malformed geometry (`sourceSymbols`, `symbolSize`) is
- * `catalogFecDeclaresUnconfigurableInstance`'s.
- *
- * A receiver applies no FEC to a source whose block is unavailable and joins
- * none of its repair tracks, without failing the session.
- */
-export declare function catalogFecAvailable(fec: unknown): boolean;
-/**
- * Whether `algorithm` is a token this receiver does not implement
- * (draft-ramadan-moq-fec-01 4): any string but `none`, `raptorq` and
- * `reed-solomon`. Such a track is consumed without FEC and its repair tracks
- * are not joined; the catalog is not in error. An absent algorithm is not a
- * token (the hang dialect omits it) and stays implemented.
- */
-export declare function fecAlgorithmUnimplemented(algorithm: unknown): boolean;
-/** Smallest `symbolSize` under `iso-ssbg1-v1` (draft-ramadan-moq-fec-01 5.1, 6.3.4 rule 13). */
-export declare const ISO_SSBG1_MIN_SYMBOL_SIZE = 14;
-/**
- * Whether a source's `fec` block declares an FEC instance (any `algorithm`
- * but `"none"`) whose `sourceSymbols` or `symbolSize` is not a positive
- * integer, or whose `iso-ssbg1-v1` `symbolSize` is below
- * `ISO_SSBG1_MIN_SYMBOL_SIZE` (rule 13: such a symbol carries no protected
- * MMTP packet). Geometry a decoder cannot configure is a malformed catalog, not
- * "no FEC": the container's per-track resolver throws `track_fec` for exactly
- * this block, whatever its profile or span.
- */
-export declare function catalogFecDeclaresUnconfigurableInstance(fec: unknown): boolean;
-//# sourceMappingURL=catalog-fec-source.d.ts.map

package/dist/catalog-fec-source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"catalog-fec-source.d.ts","sourceRoot":"","sources":["../src/catalog-fec-source.ts"],"names":[],"mappings":"AAuBA,0DAA0D;AAC1D,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,CAAA;AAE9C,4EAA4E;AAC5E,MAAM,MAAM,gBAAgB,GACxB;IACE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC,mEAAmE;IACnE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,GACD;IACE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,CAAA;AAUL;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,SAAS,cAAc,EAAc,GAC3C,gBAAgB,GAAG,SAAS,CA4B9B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKxD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAQzD;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAErE;AAMD,gGAAgG;AAChG,eAAO,MAAM,yBAAyB,KAAK,CAAA;AAE3C;;;;;;;;GAQG;AACH,wBAAgB,wCAAwC,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAK9E"}