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

package/dist/catalog-fec-params.js

@@ -24,397 +24,541 @@ function parseFecBlockProfile(value, where) {
   throw new Error(`${where} must be "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
 }
 
-// ../mmt-base/dist/catalog-fec-source.js
-var ALL_ROLES = Object.freeze(["video", "audio"]);
-function recordOf(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function locateCatalogFecSource(catalog, source, roles = ALL_ROLES) {
-  const root = recordOf(catalog);
-  if (root === void 0)
-    return void 0;
-  for (const role of roles) {
-    const renditions = recordOf(recordOf(root[role])?.["renditions"]);
-    if (renditions === void 0 || !Object.hasOwn(renditions, source))
-      continue;
-    const entry2 = recordOf(renditions[source]);
-    if (entry2 === void 0)
-      continue;
-    return Object.freeze({
-      dialect: "hang",
-      role,
-      entry: entry2,
-      fec: entry2["fec"],
-      fecPath: `$.${role}.renditions[${JSON.stringify(source)}].fec`
-    });
-  }
-  const tracks = root["tracks"];
-  if (!Array.isArray(tracks))
-    return void 0;
-  const index = tracks.findIndex((track) => recordOf(track)?.["name"] === source);
-  if (index < 0)
-    return void 0;
-  const entry = recordOf(tracks[index]) ?? {};
-  return Object.freeze({
-    dialect: "msf",
-    index,
-    entry,
-    fec: entry["fec"],
-    fecPath: `$.tracks[${index}].fec`
-  });
-}
-function isoBlockSpanUsable(fec) {
-  const block = recordOf(fec);
-  if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1")
-    return true;
-  const ms = block["interleaveDepthMs"];
-  return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
-}
-function catalogFecAvailable(fec) {
-  const block = recordOf(fec);
-  if (block === void 0)
-    return true;
-  if (fecAlgorithmUnimplemented(block["algorithm"]))
-    return false;
-  const declaresFecInstance = block["algorithm"] !== "none";
-  const profile = block["blockProfile"];
-  const profileOk = isFecBlockProfile(profile) || profile === void 0 && !declaresFecInstance;
-  return profileOk && (!declaresFecInstance || isoBlockSpanUsable(block));
-}
-function fecAlgorithmUnimplemented(algorithm) {
-  return typeof algorithm === "string" && algorithm !== "none" && algorithm !== "raptorq" && algorithm !== "reed-solomon";
-}
-function isPositiveSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-var ISO_SSBG1_MIN_SYMBOL_SIZE = 14;
-function catalogFecDeclaresUnconfigurableInstance(fec) {
-  const block = recordOf(fec);
-  if (block === void 0 || block["algorithm"] === "none" || fecAlgorithmUnimplemented(block["algorithm"]))
-    return false;
-  if (!(isPositiveSafeInteger(block["sourceSymbols"]) && isPositiveSafeInteger(block["symbolSize"])))
-    return true;
-  return block["blockProfile"] === "iso-ssbg1-v1" && block["symbolSize"] < ISO_SSBG1_MIN_SYMBOL_SIZE;
-}
-
-// src/catalog-fec-params.ts
-import { catalogFecInterleaveMs } from "@blockcast/mmt-fec";
-
-// src/repair-layers.ts
-var REPAIR_PRIORITY_MIN = 192;
-var REPAIR_PRIORITY_MAX = 255;
-var DEFAULT_REPAIR_PRIORITY = 240;
-var MAX_RAPTORQ_SOURCE_SYMBOLS = 56403;
-var MAX_REPAIR_SYMBOLS = 16777215;
-var MAX_ENCODING_SYMBOL_ID = 16777215;
-var MAX_REED_SOLOMON_BLOCK_SYMBOLS = 255;
-var RepairContractError = class extends Error {
-  constructor(code, path, message) {
-    super(`[repair-layers:${code}] ${path}: ${message}`);
-    this.code = code;
-    this.path = path;
-    this.name = "RepairContractError";
-  }
-};
-var throwRepairContractError = (code, path, message) => {
-  throw new RepairContractError(code, path, message);
-};
-function readFecBlockProfile(value, path, declaresFecInstance, fail) {
-  if (value === void 0 && !declaresFecInstance) return void 0;
-  if (isFecBlockProfile(value)) return value;
-  if (typeof value === "string" && value.length > 0) {
-    return fail(
-      "track_fec_block_profile_unimplemented",
-      path,
-      `${JSON.stringify(value)} is not an implemented FEC block profile; only "iso-ssbg1-v1" is implemented`
-    );
-  }
-  try {
-    return parseFecBlockProfile(value, "blockProfile");
-  } catch (error) {
-    return fail("track_fec_block_profile", path, error.message);
-  }
-}
-var REPAIR_FIELDS = ["depends", "repairLayer", "repairSymbols", "priority", "scope", "sourceSymbols"];
-var REPAIR_TRACK_GEOMETRY_KEYS = [
+// ../mmt-base/dist/fec-catalog.js
+var DEFAULT_SCHEMES = ["reed-solomon", "raptorq"];
+var DEFAULT_PROFILES = ["moq-object-v1", "iso-ssbg1-v1"];
+var RS_MAX_BLOCK = 255;
+var RAPTORQ_MAX_K = 56403;
+var MAX_24 = 16777215;
+var ISO_MIN_T = 14;
+var GEOMETRY_KEYS = [
+  "scheme",
+  "blockProfile",
   "mmtpMode",
   "timescale",
-  "groupDurationMs",
-  "groupDurationTicks",
-  "keyframeIntervalMs",
-  "keyframeIntervalTicks",
-  "fec",
   "symbolSize",
-  "interleaveDepthMs"
+  "interleaveDepthMs",
+  "reorderToleranceMs",
+  "sourceSymbols",
+  "fec"
 ];
-var REPAIR_TRACK_ONLY_KEYS = ["repairLayer", "repairSymbols", "sourceSymbols", "scope"];
-function rejectRepairTrackGeometry(path, fields, fail) {
-  for (const key of REPAIR_TRACK_GEOMETRY_KEYS) {
-    if (fields[key] !== void 0) {
-      fail(
-        "track_repair_geometry",
-        `${path}.${key}`,
-        "a repair track carries no block geometry; it is shared with the source track's fec object"
-      );
-    }
-  }
-}
-function repairReachability(fecObjects) {
-  let declaresFecSource = false;
-  const layerZeroNames = /* @__PURE__ */ new Set();
-  for (const candidate of fecObjects) {
-    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) continue;
-    const fec = candidate;
-    if (fec["algorithm"] === "none") continue;
-    declaresFecSource = true;
-    const repairTrack = fec["repairTrack"];
-    if (typeof repairTrack === "string" && repairTrack.length > 0) layerZeroNames.add(repairTrack);
-  }
-  return { declaresFecSource, layerZeroNames };
-}
-function assertRepairTrackReachable(descriptor, reachability, fail) {
-  if (dependsTarget(descriptor) !== void 0) return;
-  if (reachability.declaresFecSource && !reachability.layerZeroNames.has(descriptor.name)) {
-    fail(
-      "track_repair_depends",
-      `${descriptor.path}.depends`,
-      "no source names this repair track in fec.repairTrack and it declares no depends"
-    );
-  }
-}
-function rejectRepairFieldsOnMediaTrack(path, fields, fail) {
-  for (const key of REPAIR_TRACK_ONLY_KEYS) {
-    if (fields[key] !== void 0) {
-      fail("track_repair_layer", `${path}.${key}`, `${key} is a repair track field`);
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+var isInt = (v) => typeof v === "number" && Number.isInteger(v);
+var intIn = (v, lo, hi = Number.MAX_SAFE_INTEGER) => isInt(v) && v >= lo && v <= hi;
+var profileAdmits = (profile, packaging) => profile !== "iso-ssbg1-v1" || packaging === "mmtp";
+function validateFecCatalog(catalog, receiver = {}) {
+  const schemes = receiver.schemes ?? DEFAULT_SCHEMES;
+  const profiles = receiver.blockProfiles ?? DEFAULT_PROFILES;
+  const overlays = receiver.overlays ?? true;
+  const all = [];
+  const report = (code, path, inst) => {
+    const issue = { code, path };
+    all.push(issue);
+    inst?.issues.push(issue);
+  };
+  const tracks = isObj(catalog) && Array.isArray(catalog.tracks) ? catalog.tracks : [];
+  if (!isObj(catalog) || !Array.isArray(catalog.tracks))
+    report("fec_member", "/tracks");
+  let rejectAll = false;
+  tracks.forEach((t, ti) => {
+    if (!isObj(t))
+      return;
+    if (has(t, "enhancementRepair")) {
+      rejectAll = true;
+      report("fec_enhancement_repair", `/tracks/${ti}/enhancementRepair`);
     }
-  }
-}
-function describeRepairTrack(name, path, fields) {
-  const descriptor = { name, path };
-  for (const field of REPAIR_FIELDS) {
-    if (field in fields) descriptor[field] = fields[field];
-  }
-  return descriptor;
-}
-function isSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value);
-}
-function positiveInteger(value) {
-  return isSafeInteger(value) && value > 0;
-}
-function dependsTarget(descriptor) {
-  const depends = descriptor.depends;
-  return Array.isArray(depends) && depends.length === 1 && typeof depends[0] === "string" && depends[0].length > 0 ? depends[0] : void 0;
-}
-function validateRepairTrackFields(descriptor, fail) {
-  const { path } = descriptor;
-  if (descriptor.depends !== void 0 && dependsTarget(descriptor) === void 0) {
-    fail("track_repair_depends", `${path}.depends`, "must name exactly one source track");
-  }
-  if (descriptor.repairLayer !== void 0 && (!isSafeInteger(descriptor.repairLayer) || descriptor.repairLayer < 0)) {
-    fail("track_repair_layer", `${path}.repairLayer`, "must be a non-negative integer");
-  }
-  if (descriptor.repairSymbols !== void 0 && (!positiveInteger(descriptor.repairSymbols) || descriptor.repairSymbols > MAX_REPAIR_SYMBOLS)) {
-    fail("track_repair_layer", `${path}.repairSymbols`, `must be a positive integer at most ${MAX_REPAIR_SYMBOLS}`);
-  }
-  if (descriptor.priority !== void 0 && (!isSafeInteger(descriptor.priority) || descriptor.priority < REPAIR_PRIORITY_MIN || descriptor.priority > REPAIR_PRIORITY_MAX)) {
-    fail(
-      "track_repair_priority",
-      `${path}.priority`,
-      `must be an integer from ${REPAIR_PRIORITY_MIN} to ${REPAIR_PRIORITY_MAX} (MoQT scale, lower first)`
-    );
-  }
-  if (descriptor.scope !== void 0) {
-    if (descriptor.scope !== "keyframe") {
-      fail("track_repair_overlay", `${path}.scope`, 'must be "keyframe"');
+    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`);
+        }
+      });
+  });
+  const key = (ns, name) => JSON.stringify([ns ?? null, name]);
+  const byName = /* @__PURE__ */ new Map();
+  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);
     }
-    if (descriptor.repairLayer !== void 0) {
-      fail("track_repair_overlay", `${path}.repairLayer`, "an overlay is a separate FEC instance and carries no repairLayer");
+  });
+  const trackAt = (ti) => tracks[ti];
+  const insts = [];
+  tracks.forEach((t, ti) => {
+    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;
     }
-    for (const field of ["depends", "sourceSymbols", "repairSymbols", "priority"]) {
-      if (descriptor[field] === void 0) {
-        fail("track_repair_overlay", `${path}.${field}`, `an overlay must declare ${field}`);
-      }
+    t.fec.forEach((o, ii) => {
+      const path = `/tracks/${ti}/fec/${ii}`;
+      const 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;
+  for (const inst of insts) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const avail = (field, impl) => {
+      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]))
+        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;
     }
   }
-  if (descriptor.sourceSymbols !== void 0) {
-    if (descriptor.scope === void 0) {
-      fail("track_repair_overlay", `${path}.sourceSymbols`, "only an overlay (scope: keyframe) declares its own sourceSymbols");
+  const live = (i) => !i.unavailable;
+  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 (!positiveInteger(descriptor.sourceSymbols) || descriptor.sourceSymbols > MAX_RAPTORQ_SOURCE_SYMBOLS) {
-      fail(
-        "track_fec_bounds",
-        `${path}.sourceSymbols`,
-        `must be a positive integer at most ${MAX_RAPTORQ_SOURCE_SYMBOLS} (RFC 6330 source block limit)`
-      );
+    if (has(o, "reorderToleranceMs")) {
+      const r = o.reorderToleranceMs;
+      if (typeof r !== "number" || !Number.isFinite(r) || r < 0)
+        report("fec_member", `${p}/reorderToleranceMs`, inst);
     }
-  }
-  if (isSafeInteger(descriptor.repairLayer) && descriptor.repairLayer >= 1) {
-    for (const field of ["depends", "repairSymbols", "priority"]) {
-      if (descriptor[field] === void 0) {
-        fail("track_repair_layer", `${path}.${field}`, `repair layer ${descriptor.repairLayer} must declare ${field}`);
+    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);
+  }
+  const idGroups = /* @__PURE__ */ new Map();
+  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);
+  const nameUses = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    for (const field of ["repairTrack", "symbolTrack"])
+      if (inst.obj && typeof inst.obj[field] === "string") {
+        const k = key(inst.track.namespace, inst.obj[field]);
+        nameUses.set(k, [...nameUses.get(k) ?? [], { inst, field }]);
+      }
+  const namedBy = /* @__PURE__ */ new Map();
+  for (const [k, uses] of nameUses) {
+    const tj = byName.get(k);
+    for (const { inst, field } of uses) {
+      const path = `${inst.path}/${field}`;
+      if (tj === void 0 || 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;
       }
     }
   }
-}
-function assembleRepairLayers(source, descriptors, fail = throwRepairContractError, options = {}) {
-  const layerZeroName = typeof source.repairTrack === "string" && source.repairTrack.length > 0 ? source.repairTrack : void 0;
-  const layerZero = layerZeroName === void 0 ? void 0 : descriptors.find((d) => d.name === layerZeroName);
-  if (layerZeroName !== void 0 && layerZero === void 0 && options.layerZeroMustBeDeclared) {
-    fail("track_repair_track", `${source.path}.repairTrack`, `unknown FEC repair track ${JSON.stringify(layerZeroName)}`);
-  }
-  const dependents = descriptors.filter((d) => d.name !== layerZeroName && dependsTarget(d) === source.name);
-  const k = positiveInteger(source.sourceSymbols) ? source.sourceSymbols : 0;
-  if (source.algorithm === "raptorq" && k > MAX_RAPTORQ_SOURCE_SYMBOLS) {
-    fail(
-      "track_fec_bounds",
-      `${source.path}.sourceSymbols`,
-      `must be at most ${MAX_RAPTORQ_SOURCE_SYMBOLS} (RFC 6330 source block limit)`
-    );
-  }
-  if (layerZeroName === void 0) {
-    if (dependents.length === 0) return void 0;
-    fail(
-      "track_repair_layer",
-      `${dependents[0].path}.depends`,
-      `repair layers of ${JSON.stringify(source.name)} require a layer 0 (fec.repairTrack) on the source`
-    );
-  }
-  const layered = dependents.length > 0;
-  let layerZeroSymbols = 0;
-  if (positiveInteger(source.repairSymbols)) {
-    layerZeroSymbols = source.repairSymbols;
-  } else if (layered) {
-    fail("track_fec", `${source.path}.repairSymbols`, "layered or overlay repair needs a positive integer repairSymbols on layer 0");
-  }
-  if (layered && !positiveInteger(source.sourceSymbols)) {
-    fail("track_fec", `${source.path}.sourceSymbols`, "layered or overlay repair needs a positive integer sourceSymbols on the source");
-  }
-  const reedSolomon = source.algorithm === "reed-solomon";
-  if (layered && source.algorithm !== "raptorq" && !reedSolomon) {
-    fail(
-      "track_fec",
-      `${source.path}.algorithm`,
-      "repair layers and overlays are defined only for raptorq and reed-solomon (draft-ramadan-moq-fec-01 6.3.4 rule 7)"
-    );
-  }
-  let layerZeroPriority = DEFAULT_REPAIR_PRIORITY;
-  if (layerZero !== void 0) {
-    if (layerZero.depends !== void 0 && dependsTarget(layerZero) !== source.name) {
-      fail(
-        "track_repair_depends",
-        `${layerZero.path}.depends`,
-        `layer 0 of ${JSON.stringify(source.name)} must depend on that source`
-      );
+  const owner = /* @__PURE__ */ new Map();
+  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;
+        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);
+      const id = has(t, "instanceId") ? t.instanceId : 0;
+      const src = typeof t.source === "string" ? byName.get(key(t.namespace, t.source)) : void 0;
+      const target = src === void 0 ? void 0 : insts.find((i) => i.ti === src && i.id === id);
+      if (!target)
+        return report("fec_naming", has(t, "instanceId") && src !== void 0 ? `${tp}/instanceId` : `${tp}/source`);
+      owner.set(tj, target);
+      target.attached.push(tj);
+    });
+  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 (layerZero.repairLayer !== void 0 && layerZero.repairLayer !== 0) {
-      fail("track_repair_layer", `${layerZero.path}.repairLayer`, "the track named by fec.repairTrack is layer 0");
+    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);
+  }
+  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) {
+      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 = [];
+      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);
+      }
+      const counts = /* @__PURE__ */ new Map();
+      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);
+      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 = 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);
+      }
     }
-    if (layerZero.scope !== void 0) {
-      fail("track_repair_overlay", `${layerZero.path}.scope`, "the track named by fec.repairTrack is base layer 0, not an overlay");
+    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 (layerZero.repairSymbols !== void 0 && layerZero.repairSymbols !== layerZeroSymbols) {
-      fail(
-        "track_repair_layer",
-        `${layerZero.path}.repairSymbols`,
-        `must agree with the source's fec.repairSymbols (${layerZeroSymbols})`
-      );
+    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);
     }
-    if (typeof layerZero.priority === "number") layerZeroPriority = layerZero.priority;
   }
-  const baseLayers = [
-    { layer: 0, repairTrackName: layerZeroName, repairSymbols: layerZeroSymbols, rsIdOffset: 0, priority: layerZeroPriority }
-  ];
-  const overlays = [];
-  for (const d of dependents) {
-    if (d.scope === void 0 && d.repairLayer === void 0) {
-      fail(
-        "track_repair_layer",
-        `${d.path}.repairLayer`,
-        `a repair track that depends on ${JSON.stringify(source.name)} must declare repairLayer (1..n) or scope: "keyframe"`
-      );
-    }
-  }
-  const layerTracks = dependents.filter((d) => d.scope === void 0).sort((a, b) => a.repairLayer - b.repairLayer);
-  for (const d of dependents) {
-    if (d.scope !== "keyframe") continue;
-    if (overlays.length === 1) {
-      fail(
-        "track_repair_overlay",
-        `${d.path}.scope`,
-        `${JSON.stringify(source.name)} already has keyframe overlay ${JSON.stringify(overlays[0].repairTrackName)}: a RAP packet carries exactly two Source FEC Payload IDs (base, then overlay), so one overlay per source`
-      );
+  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;
     }
-    const sourceSymbols = d.sourceSymbols;
-    const repairSymbols = d.repairSymbols;
-    if (sourceSymbols + repairSymbols - 1 > MAX_ENCODING_SYMBOL_ID) {
-      fail(
-        "track_fec_bounds",
-        `${d.path}.repairSymbols`,
-        `overlay sourceSymbols + repairSymbols - 1 exceeds the 24-bit ESI space (${MAX_ENCODING_SYMBOL_ID})`
-      );
+    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);
     }
-    if (reedSolomon && sourceSymbols + repairSymbols > MAX_REED_SOLOMON_BLOCK_SYMBOLS) {
-      fail(
-        "track_fec_bounds",
-        `${d.path}.repairSymbols`,
-        `reed-solomon overlay sourceSymbols + repairSymbols exceeds ${MAX_REED_SOLOMON_BLOCK_SYMBOLS} (draft-ramadan-moq-fec-01 6.3.4 rule 12)`
-      );
+  }
+  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
+  };
+}
+
+// ../mmt-base/dist/fec-bindings.js
+var RUNTIME_FEC_RECEIVER = Object.freeze({
+  schemes: Object.freeze(["raptorq", "reed-solomon"]),
+  blockProfiles: Object.freeze(["iso-ssbg1-v1"]),
+  overlays: true
+});
+var DEFAULT_FEC_REPAIR_PRIORITY = 240;
+var recordOf = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+var escape = (s) => s.replace(/~/g, "~0").replace(/\//g, "~1");
+function fecCatalogTracks(catalog) {
+  const root = recordOf(catalog) ?? {};
+  const tracks = [];
+  const pointers = [];
+  const hangNames = /* @__PURE__ */ new Set();
+  for (const role of ["video", "audio"]) {
+    for (const [name, r] of Object.entries(recordOf(recordOf(root[role])?.["renditions"]) ?? {})) {
+      const entry = recordOf(r);
+      if (!entry)
+        continue;
+      hangNames.add(name);
+      const kind = recordOf(entry["container"])?.["kind"];
+      const view = { name, packaging: kind === void 0 || kind === "mmtp-fec" ? "mmtp" : kind };
+      if (entry["fec"] !== void 0)
+        view["fec"] = entry["fec"];
+      tracks.push(view);
+      pointers.push(`/${role}/renditions/${escape(name)}`);
     }
-    overlays.push({ repairTrackName: d.name, scope: "keyframe", sourceSymbols, repairSymbols, priority: d.priority });
   }
-  let offset = layerZeroSymbols;
-  let previousPriority = layerZeroPriority;
-  layerTracks.forEach((d, i) => {
-    const expected = i + 1;
-    if (d.repairLayer === 0) {
-      fail("track_repair_layer", `${d.path}.repairLayer`, `layer 0 of ${JSON.stringify(source.name)} is ${JSON.stringify(layerZeroName)}, named by fec.repairTrack`);
+  const hangRenditions = tracks.length;
+  for (const [name, r] of Object.entries(recordOf(recordOf(root["repair"])?.["renditions"]) ?? {})) {
+    hangNames.add(name);
+    tracks.push({ packaging: "fec-repair", ...recordOf(r), name });
+    pointers.push(`/repair/renditions/${escape(name)}`);
+  }
+  const raw = Array.isArray(root["tracks"]) ? root["tracks"] : [];
+  const named = new Set(hangNames);
+  raw.forEach((t, i) => {
+    const name = recordOf(t)?.["name"];
+    if (typeof name === "string")
+      named.add(name);
+    if (typeof name === "string" && hangNames.has(name))
+      return;
+    tracks.push(t);
+    pointers.push(`/tracks/${i}`);
+  });
+  tracks.slice(0, hangRenditions).forEach((t, ti) => {
+    const view = t;
+    if (!Array.isArray(view["fec"]))
+      return;
+    view["fec"].forEach((o, ii) => {
+      const repairTrack = recordOf(o)?.["repairTrack"];
+      if (typeof repairTrack !== "string" || named.has(repairTrack))
+        return;
+      named.add(repairTrack);
+      const instanceId = recordOf(o)?.["instanceId"];
+      tracks.push({ name: repairTrack, packaging: "fec-repair", source: view["name"], ...instanceId === void 0 ? {} : { instanceId } });
+      pointers.push(`${pointers[ti]}/fec/${ii}/repairTrack`);
+    });
+  });
+  return { tracks, pointers };
+}
+function resolveFecBindings(catalog, receiver = RUNTIME_FEC_RECEIVER) {
+  const { tracks, pointers } = fecCatalogTracks(catalog);
+  const report = validateFecCatalog({ tracks }, receiver);
+  const at = (path) => {
+    const m = /^\/tracks\/(\d+)(.*)$/.exec(path);
+    return m ? pointers[Number(m[1])] + m[2] : path;
+  };
+  const trackAt = (i) => recordOf(tracks[i]) ?? {};
+  const nameAt = (i) => i === null ? void 0 : trackAt(i)["name"];
+  const why = (i) => Object.freeze({
+    code: i.issues[0]?.code ?? "fec_member",
+    path: at(i.issues[0]?.path ?? i.path),
+    outcome: i.outcome === "unavailable" ? "unavailable" : "violation"
+  });
+  const out = /* @__PURE__ */ new Map();
+  tracks.forEach((t, ti) => {
+    const track = recordOf(t);
+    const name = track?.["name"];
+    if (!track || typeof name !== "string" || out.has(name))
+      return;
+    if (track["packaging"] === "fec-repair" || track["packaging"] === "fec-source")
+      return;
+    const fec = track["fec"];
+    if (fec === void 0)
+      return;
+    if (!Array.isArray(fec)) {
+      const reason = { code: "fec_member", path: at(`/tracks/${ti}/fec`), outcome: "violation" };
+      out.set(name, Object.freeze({ status: "unavailable", track: name, pointer: pointers[ti], reason: Object.freeze(reason) }));
+      return;
     }
-    if (d.repairLayer !== expected) {
-      fail(
-        "track_repair_layer",
-        `${d.path}.repairLayer`,
-        i > 0 && d.repairLayer === layerTracks[i - 1].repairLayer ? `repair layer ${d.repairLayer} is declared twice for ${JSON.stringify(source.name)}` : `repair layers must be contiguous from 1: expected ${expected}, found ${d.repairLayer}`
+    if (fec.length === 0)
+      return;
+    const insts = report.instances.filter((i) => i.trackIndex === ti);
+    const isOverlay = (i) => Object.hasOwn(recordOf(fec[Number(i.path.split("/").pop())]) ?? {}, "scope");
+    const bases = insts.filter((i) => !isOverlay(i));
+    const okBases = bases.filter((i) => i.outcome === "ok");
+    if (okBases.length !== 1) {
+      const reason = (
+        // No base instance at all (overlay-only `fec`) is a count of 0, not
+        // the overlay's own issue.
+        okBases.length > 1 || bases.length === 0 ? Object.freeze({ code: "fec_base_instances", path: at(`/tracks/${ti}/fec`), outcome: "violation" }) : why(bases[0] ?? insts[0])
       );
+      out.set(name, Object.freeze({ status: "unavailable", track: name, pointer: pointers[ti], reason }));
+      return;
     }
-    const priority = d.priority;
-    if (priority < previousPriority) {
-      fail(
-        "track_repair_priority",
-        `${d.path}.priority`,
-        `must be at least ${previousPriority}, the priority of layer ${expected - 1}: priority is monotonic non-decreasing with layer index`
-      );
+    const b = okBases[0];
+    const base = geometry(recordOf(fec[Number(b.path.split("/").pop())]), b.instanceId, nameAt(b.symbolTrack));
+    const priorityOf = (i) => {
+      const p = i === null ? void 0 : trackAt(i)["priority"];
+      return typeof p === "number" ? p : DEFAULT_FEC_REPAIR_PRIORITY;
+    };
+    const layers = [
+      { layer: 0, repairTrackName: base.repairTrack, repairSymbols: base.repairSymbols, rsIdOffset: 0, priority: priorityOf(b.repairTrack) }
+    ];
+    const more = b.boundRepairTracks.map((tj) => ({ tj, layer: trackAt(tj)["repairLayer"] })).sort((x, y) => x.layer - y.layer);
+    let offset = base.repairSymbols;
+    for (const { tj, layer } of more) {
+      const repairSymbols = trackAt(tj)["repairSymbols"];
+      layers.push({ layer, repairTrackName: nameAt(tj), repairSymbols, rsIdOffset: offset, priority: priorityOf(tj) });
+      offset += repairSymbols;
     }
-    previousPriority = priority;
-    const repairSymbols = d.repairSymbols;
-    baseLayers.push({ layer: expected, repairTrackName: d.name, repairSymbols, rsIdOffset: offset, priority });
-    offset += repairSymbols;
+    let overlay;
+    let overlayUnavailable;
+    const ov = insts.find(isOverlay);
+    if (ov?.outcome === "ok") {
+      const g = geometry(recordOf(fec[Number(ov.path.split("/").pop())]), ov.instanceId, nameAt(ov.symbolTrack));
+      overlay = Object.freeze({
+        repairTrackName: g.repairTrack,
+        scope: "keyframe",
+        sourceSymbols: g.sourceSymbols,
+        repairSymbols: g.repairSymbols,
+        priority: priorityOf(ov.repairTrack),
+        geometry: g
+      });
+    } else if (ov)
+      overlayUnavailable = why(ov);
+    out.set(name, Object.freeze({
+      status: "ok",
+      track: name,
+      pointer: pointers[ti],
+      base,
+      layers: Object.freeze(layers.map((l) => Object.freeze(l))),
+      totalBaseRepairSymbols: offset,
+      ...overlay ? { overlay } : {},
+      ...overlayUnavailable ? { overlayUnavailable } : {}
+    }));
+  });
+  return out;
+}
+function geometry(o, instanceId, symbolTrack) {
+  return Object.freeze({
+    instanceId,
+    scheme: o["scheme"],
+    blockProfile: o["blockProfile"],
+    sourceSymbols: o["sourceSymbols"],
+    repairSymbols: o["repairSymbols"],
+    symbolSize: o["symbolSize"],
+    ...typeof o["interleaveDepthMs"] === "number" ? { interleaveDepthMs: o["interleaveDepthMs"] } : {},
+    ...typeof o["reorderToleranceMs"] === "number" ? { reorderToleranceMs: o["reorderToleranceMs"] } : {},
+    repairTrack: o["repairTrack"],
+    ...symbolTrack !== void 0 ? { symbolTrack } : {}
   });
-  const totalBaseRepairSymbols = offset;
-  if (totalBaseRepairSymbols > MAX_REPAIR_SYMBOLS) {
-    fail(
-      "track_fec_bounds",
-      `${layerTracks.length === 0 ? source.path : layerTracks[layerTracks.length - 1].path}.repairSymbols`,
-      `total repair symbols across base layers exceeds the 24-bit RS_ID space (${MAX_REPAIR_SYMBOLS})`
-    );
-  }
-  if (k + totalBaseRepairSymbols - 1 > MAX_ENCODING_SYMBOL_ID) {
-    fail(
-      "track_fec_bounds",
-      `${source.path}.sourceSymbols`,
-      `sourceSymbols + total base repair symbols - 1 exceeds the 24-bit ESI space (${MAX_ENCODING_SYMBOL_ID})`
-    );
-  }
-  if (reedSolomon && k + totalBaseRepairSymbols > MAX_REED_SOLOMON_BLOCK_SYMBOLS) {
-    fail(
-      "track_fec_bounds",
-      `${source.path}.sourceSymbols`,
-      `reed-solomon sourceSymbols + total base repair symbols exceeds ${MAX_REED_SOLOMON_BLOCK_SYMBOLS} (draft-ramadan-moq-fec-01 6.3.4 rule 12)`
-    );
-  }
-  return { sourceTrackName: source.name, baseLayers, overlays, totalBaseRepairSymbols };
 }
 
+// src/catalog-fec-params.ts
+import { catalogFecInterleaveMs } from "@blockcast/mmt-fec";
+
 // src/carp-catalog.ts
 function isTrackTimingConfig(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -452,28 +596,13 @@ function resolveGroupDurationMs(timing, timescale) {
   return durationMs;
 }
 
-// src/fec-state.ts
-var FEC_INACTIVE_REASONS = Object.freeze([
-  "no-catalog-fec",
-  "reliable-moq",
-  "no-multicast-bridge"
-]);
-var INACTIVE = Object.freeze({
-  "no-catalog-fec": Object.freeze({ state: "inactive", reason: "no-catalog-fec" }),
-  "reliable-moq": Object.freeze({ state: "inactive", reason: "reliable-moq" }),
-  "no-multicast-bridge": Object.freeze({ state: "inactive", reason: "no-multicast-bridge" })
-});
-function recordOf2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function isPositiveSafeInteger2(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-function catalogDeclaresFec(fec) {
-  const block = recordOf2(fec);
-  if (block === void 0 || block["algorithm"] === "none" || fecAlgorithmUnimplemented(block["algorithm"])) return false;
-  return isPositiveSafeInteger2(block["sourceSymbols"]) && isPositiveSafeInteger2(block["symbolSize"]) && isFecBlockProfile(block["blockProfile"]) && isoBlockSpanUsable(block) && !catalogFecDeclaresUnconfigurableInstance(block);
-}
+// src/repair-layers.ts
+var REPAIR_PRIORITY_MIN = 192;
+var REPAIR_PRIORITY_MAX = 255;
+var DEFAULT_REPAIR_PRIORITY = 240;
+var MAX_RAPTORQ_SOURCE_SYMBOLS = 56403;
+var MAX_REPAIR_SYMBOLS = 16777215;
+var MAX_ENCODING_SYMBOL_ID = 16777215;
 
 // src/catalog-fec-params.ts
 var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
@@ -528,137 +657,50 @@ function joinedRepairSymbolCount(params, joinedRepairTrackNames) {
   }
   return total;
 }
-function recordOf3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+function bindingOf(catalog, source) {
+  if (!catalog) return void 0;
+  const name = typeof source === "string" ? source : source.name;
+  const binding = resolveFecBindings(catalog).get(name);
+  if (binding === void 0 || typeof source === "string") return binding;
+  const role = binding.pointer.split("/")[1];
+  return role === "tracks" || role === source.type ? binding : void 0;
 }
-function msfTracks(catalog) {
-  const raw = catalog.tracks;
-  if (!Array.isArray(raw)) return void 0;
-  return { tracks: raw.map((t) => recordOf3(t) ?? {}) };
+function catalogTrackFecUnavailable(catalog, source) {
+  const binding = bindingOf(catalog, source);
+  return binding?.status === "unavailable" ? binding.reason : void 0;
 }
 function resolveRepairLayers(catalog, source) {
-  if (!catalog) return void 0;
-  const sourceName = typeof source === "string" ? source : source.name;
-  const hang = catalog;
-  const roles = 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 = recordOf3(hang.repair?.renditions) ?? {};
-    const descriptors2 = Object.entries(repairRenditions).map(([name, entry]) => {
-      const path = `$.repair.renditions[${JSON.stringify(name)}]`;
-      const fields = recordOf3(entry);
-      if (fields === void 0) {
-        throwRepairContractError("track_repair_layer", path, "a repair rendition must be an object");
-      }
-      rejectRepairTrackGeometry(path, fields, throwRepairContractError);
-      return describeRepairTrack(name, path, fields);
-    });
-    const fecOfRendition = (entry) => {
-      const fec2 = recordOf3(recordOf3(entry)?.["fec"]);
-      return fec2 !== void 0 && fec2["algorithm"] !== "none" ? fec2 : void 0;
-    };
-    const mediaRenditions = [
-      ...Object.values(recordOf3(hang.video?.renditions) ?? {}),
-      ...Object.values(recordOf3(hang.audio?.renditions) ?? {})
-    ];
-    const reachability2 = repairReachability(mediaRenditions.map((entry) => recordOf3(entry)?.["fec"]));
-    for (const d of descriptors2) {
-      validateRepairTrackFields(d, throwRepairContractError);
-      assertRepairTrackReachable(d, reachability2, throwRepairContractError);
-      const target = dependsTarget(d);
-      if (target === void 0) continue;
-      const targetFec = fecOfRendition(hang.video?.renditions?.[target]) ?? fecOfRendition(hang.audio?.renditions?.[target]);
-      if (targetFec === void 0) {
-        throwRepairContractError(
-          "track_repair_depends",
-          `${d.path}.depends`,
-          `${JSON.stringify(target)} is not a video or audio rendition with FEC`
-        );
-      }
+  const binding = bindingOf(catalog, source);
+  if (binding?.status !== "ok") return void 0;
+  const overlays = binding.overlay ? [
+    {
+      repairTrackName: binding.overlay.repairTrackName,
+      scope: "keyframe",
+      sourceSymbols: binding.overlay.sourceSymbols,
+      repairSymbols: binding.overlay.repairSymbols,
+      priority: binding.overlay.priority
     }
-    const layers2 = assembleRepairLayers(
-      geometryOf(sourceName, `${renditionPath}.fec`, recordOf3(rendition["fec"])),
-      descriptors2,
-      throwRepairContractError
-    );
-    return catalogFecUnavailable(rendition["fec"], `${renditionPath}.fec`) === void 0 ? layers2 : void 0;
-  }
-  const msf = msfTracks(catalog);
-  if (!msf || located?.dialect !== "msf") return void 0;
-  const msfIndex = located.index;
-  const track = msf.tracks[msfIndex];
-  const fec = recordOf3(track["fec"]);
-  const packagingOf = (t) => t["packaging"];
-  const fecOfTrack = (t) => {
-    const trackFec = recordOf3(t?.["fec"]);
-    return trackFec !== void 0 && trackFec["algorithm"] !== "none" ? trackFec : void 0;
+  ] : [];
+  return {
+    sourceTrackName: binding.track,
+    baseLayers: binding.layers,
+    overlays,
+    totalBaseRepairSymbols: binding.totalBaseRepairSymbols
   };
-  const descriptors = [];
-  const mediaTracks = [];
-  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 === void 0) continue;
-    const targetTrack = msf.tracks.find((t) => t["name"] === target);
-    if (targetTrack === void 0 || packagingOf(targetTrack) !== "mmtp" || fecOfTrack(targetTrack) === void 0) {
-      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`) === void 0 ? layers : void 0;
 }
 function moqtPriority(value) {
   return Number.isSafeInteger(value) && value >= 0 && value <= 255 ? value : null;
 }
 function catalogRepairTarget(catalog, source) {
-  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;
-  const roles = 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) => recordOf3(r) !== void 0);
-  const fec = rendition === void 0 ? recordOf3(entry?.["fec"]) : recordOf3(rendition.fec);
-  if (!fec || !(catalogFecInterleaveMs(fec) ?? 0)) return null;
-  const sourcePriority = entry === void 0 ? 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.tracks;
+  const entry = m && Array.isArray(tracks) ? tracks[Number(m[1])] : void 0;
+  const sourcePriority = entry ? moqtPriority(entry["priority"]) : null;
   return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
 }
-function geometryOf(name, path, fec) {
-  return {
-    name,
-    path,
-    algorithm: fec?.["algorithm"],
-    sourceSymbols: fec?.["sourceSymbols"],
-    repairSymbols: fec?.["repairSymbols"],
-    repairTrack: fec?.["repairTrack"]
-  };
-}
 function numericField(value) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
   return Number.isFinite(n) && n > 0 ? n : void 0;
@@ -667,79 +709,28 @@ function nonNegativeField(value) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
   return Number.isFinite(n) && n >= 0 ? n : void 0;
 }
-function blockProfileUnavailable(value, path, declaresFecInstance) {
-  try {
-    readFecBlockProfile(value, path, declaresFecInstance, throwRepairContractError);
-    return void 0;
-  } 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 });
-  }
-}
-function isoSpanUnavailable(fec, path, declaresFecInstance) {
-  if (!declaresFecInstance || isoBlockSpanUsable(fec)) return void 0;
-  return Object.freeze({
-    code: "track_fec",
-    path,
-    message: `[repair-layers:track_fec] ${path}: must be a non-negative safe integer in milliseconds`
-  });
-}
-function catalogFecUnavailable(fec, fecPath) {
-  if (catalogFecAvailable(fec)) return void 0;
-  const block = recordOf3(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 === void 0) {
-    throw new Error(`catalogFecUnavailable: ${fecPath} is unavailable but no reason applies (rule drift)`);
-  }
-  return reason;
-}
-function fecParams(catalog, track, rendition, fps, sampleRate) {
+function fecParams(catalog, track, fps, sampleRate) {
   const mediaRate = sampleRate === void 0 ? { fps } : { fps, sampleRate };
-  const fec = rendition?.fec;
-  if (!fec || !track) return { ...NO_FEC, ...mediaRate };
+  const binding = track ? bindingOf(catalog, track) : void 0;
+  if (binding === void 0) return { ...NO_FEC, ...mediaRate };
+  if (binding.status === "unavailable") return { ...NO_FEC, ...mediaRate, fecUnavailable: binding.reason };
+  const { base } = binding;
   const repair = resolveRepairLayers(catalog, track);
-  const fecPath = `$.${track.type}.renditions[${JSON.stringify(track.name)}].fec`;
-  if (!catalogDeclaresFec(fec)) {
-    if (catalogFecDeclaresUnconfigurableInstance(fec)) {
-      const kValid = Number.isSafeInteger(fec.sourceSymbols) && (fec.sourceSymbols ?? 0) > 0;
-      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"
-      );
-    }
-    const fecUnavailable = catalogFecUnavailable(fec, fecPath);
-    return fecUnavailable === void 0 ? { ...NO_FEC, ...mediaRate } : { ...NO_FEC, ...mediaRate, fecUnavailable };
-  }
-  const fecBlockProfile = readFecBlockProfile(fec.blockProfile, `${fecPath}.blockProfile`, true, throwRepairContractError);
   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
   };
 }
@@ -753,11 +744,10 @@ function resolveCatalogTrackFec(catalog, tracks) {
   const catalogFps = numericField(video?.framerate);
   const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
   const audioFps = sampleRate ? sampleRate / 1024 : void 0;
-  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, video, catalogFps);
+  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, catalogFps);
   const audioParams = fecParams(
     catalog,
     audioTrackName ? { name: audioTrackName, type: "audio" } : void 0,
-    audio,
     audioFps,
     sampleRate
   );
@@ -767,12 +757,12 @@ function resolveCatalogTrackFec(catalog, tracks) {
       const rendition2 = audioRenditions?.[track.name];
       if (!rendition2) return { ...NO_FEC };
       const rate = numericField(rendition2.sampleRate ?? rendition2.samplerate);
-      return fecParams(catalog, { name: track.name, type: "audio" }, rendition2, rate ? rate / 1024 : void 0, rate);
+      return fecParams(catalog, { name: track.name, type: "audio" }, rate ? rate / 1024 : void 0, 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 {
     videoTrackName,
@@ -794,33 +784,18 @@ export {
   MAX_REPAIR_SYMBOLS,
   REPAIR_PRIORITY_MAX,
   REPAIR_PRIORITY_MIN,
-  REPAIR_TRACK_GEOMETRY_KEYS,
-  REPAIR_TRACK_ONLY_KEYS,
-  RepairContractError,
-  assembleRepairLayers,
-  assertRepairTrackReachable,
-  catalogFecAvailable,
-  catalogFecDeclaresUnconfigurableInstance,
   catalogFecInterleaveMs,
   catalogFecMediaUnitsPerSecond,
-  catalogFecUnavailable,
   catalogGroupDurationMs,
   catalogKeyframeCadenceMs,
   catalogRepairTarget,
-  dependsTarget,
-  describeRepairTrack,
-  fecAlgorithmUnimplemented,
+  catalogTrackFecUnavailable,
   isFecBlockProfile,
   joinedRepairSymbolCount,
-  locateCatalogFecSource,
   parseFecBlockProfile,
-  readFecBlockProfile,
-  rejectRepairFieldsOnMediaTrack,
-  rejectRepairTrackGeometry,
-  repairReachability,
   resolveCatalogTrackFec,
   resolveCatalogTrackGroupDurationMs,
   resolveRepairLayers,
-  validateRepairTrackFields
+  validateFecCatalog
 };
 //# sourceMappingURL=catalog-fec-params.js.map