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

package/dist/no-modules.js

@@ -414,34 +414,6 @@ function isoBlocksBehindLowerBound(a, b, kMax) {
   return serial32Precedes(a, b) ? Math.floor(serial32Distance(a, b) / kMax) : 0;
 }
 
-// ../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 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 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;
-}
-
 // ../mmt-base/dist/multicast-catalog.js
 var ED25519_PUBLIC_KEY_BASE64URL = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
 var UINT32_MAX = 4294967295;
@@ -690,6 +662,538 @@ function multicastCatalogIssues(catalog, options = {}) {
   return issues;
 }
 
+// ../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",
+  "symbolSize",
+  "interleaveDepthMs",
+  "reorderToleranceMs",
+  "sourceSymbols",
+  "fec"
+];
+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`);
+    }
+    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);
+    }
+  });
+  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;
+    }
+    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;
+    }
+  }
+  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 (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);
+  }
+  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;
+      }
+    }
+  }
+  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 (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);
+      }
+    }
+    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);
+    }
+  }
+  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);
+    }
+  }
+  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 view2 = { name, packaging: kind === void 0 || kind === "mmtp-fec" ? "mmtp" : kind };
+      if (entry["fec"] !== void 0)
+        view2["fec"] = entry["fec"];
+      tracks.push(view2);
+      pointers.push(`/${role}/renditions/${escape(name)}`);
+    }
+  }
+  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 view2 = t;
+    if (!Array.isArray(view2["fec"]))
+      return;
+    view2["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: view2["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 (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 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;
+    }
+    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 } : {}
+  });
+}
+
 // src/mfu-reassembler.ts
 function fragmentProvenance(fragment) {
   if (fragment.deliveryProvenance !== void 0) return fragment.deliveryProvenance;
@@ -7365,321 +7869,6 @@ function createWasmMmtpContainerParser(config) {
   });
 }
 
-// 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 = [
-  "mmtpMode",
-  "timescale",
-  "groupDurationMs",
-  "groupDurationTicks",
-  "keyframeIntervalMs",
-  "keyframeIntervalTicks",
-  "fec",
-  "symbolSize",
-  "interleaveDepthMs"
-];
-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`);
-    }
-  }
-}
-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 (descriptor.repairLayer !== void 0) {
-      fail("track_repair_overlay", `${path}.repairLayer`, "an overlay is a separate FEC instance and carries no repairLayer");
-    }
-    for (const field of ["depends", "sourceSymbols", "repairSymbols", "priority"]) {
-      if (descriptor[field] === void 0) {
-        fail("track_repair_overlay", `${path}.${field}`, `an overlay must declare ${field}`);
-      }
-    }
-  }
-  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");
-    }
-    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 (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}`);
-      }
-    }
-  }
-}
-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`
-      );
-    }
-    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 (layerZero.scope !== void 0) {
-      fail("track_repair_overlay", `${layerZero.path}.scope`, "the track named by fec.repairTrack is base layer 0, not an overlay");
-    }
-    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 (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 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 (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)`
-      );
-    }
-    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`);
-    }
-    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}`
-      );
-    }
-    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`
-      );
-    }
-    previousPriority = priority;
-    const repairSymbols = d.repairSymbols;
-    baseLayers.push({ layer: expected, repairTrackName: d.name, repairSymbols, rsIdOffset: offset, priority });
-    offset += repairSymbols;
-  });
-  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/carp-catalog.ts
 function isTrackTimingConfig(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -7812,7 +8001,7 @@ function validateCmsfMmtpCatalog(value, options = {}) {
   }
   const tracks = catalog["tracks"];
   const trackRecords = [];
-  const positiveInteger2 = (input) => Number.isSafeInteger(input) && input > 0;
+  const positiveInteger = (input) => Number.isSafeInteger(input) && input > 0;
   const positiveNumber = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
   for (let index = 0; index < tracks.length; index++) {
     const raw = tracks[index];
@@ -7844,7 +8033,7 @@ function validateCmsfMmtpCatalog(value, options = {}) {
       );
     }
     const codec = track["codec"];
-    if (packaging !== "timeline" && packaging !== "mediatimeline" && packaging !== "eventtimeline" && packaging !== "fec-repair" && (typeof codec !== "string" || codec.length === 0)) {
+    if (packaging !== "timeline" && packaging !== "mediatimeline" && packaging !== "eventtimeline" && packaging !== "fec-repair" && packaging !== "fec-source" && (typeof codec !== "string" || codec.length === 0)) {
       catalogError("track_codec", `${path}.codec`, `codec is required for packaging=${packaging}`);
     }
     const timescale = track["timescale"];
@@ -7852,13 +8041,13 @@ function validateCmsfMmtpCatalog(value, options = {}) {
     const groupDurationTicks = track["groupDurationTicks"];
     const keyframeIntervalMs = track["keyframeIntervalMs"];
     const keyframeIntervalTicks = track["keyframeIntervalTicks"];
-    if (groupDurationMs !== void 0 && !positiveInteger2(groupDurationMs)) {
+    if (groupDurationMs !== void 0 && !positiveInteger(groupDurationMs)) {
       catalogError("track_group_duration_ms", `${path}.groupDurationMs`, "must be a positive integer");
     }
-    if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
+    if (groupDurationTicks !== void 0 && !positiveInteger(groupDurationTicks)) {
       catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
     }
-    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
+    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger(keyframeIntervalTicks)) {
       catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
     }
     const anchor = track["presentationAnchorTicks"];
@@ -7869,17 +8058,11 @@ function validateCmsfMmtpCatalog(value, options = {}) {
     if (initRef !== void 0 && (typeof initRef !== "string" || initRef.length === 0)) {
       catalogError("track_init_ref", `${path}.initRef`, "must be a non-empty string");
     }
-    if (packaging === "fec-repair") {
-      rejectRepairTrackGeometry(path, track, catalogError);
-      validateRepairTrackFields(describeRepairTrack(name, path, track), catalogError);
-    } else {
-      rejectRepairFieldsOnMediaTrack(path, track, catalogError);
-    }
     if (packaging === "mmtp") {
       if (track["mmtpMode"] !== "mfu") {
         catalogError("track_mmtp_mode", `${path}.mmtpMode`, "must be mfu");
       }
-      if (!positiveInteger2(timescale)) {
+      if (!positiveInteger(timescale)) {
         catalogError("track_timescale", `${path}.timescale`, "must be a positive integer");
       }
       if (groupDurationMs === void 0 && groupDurationTicks === void 0) {
@@ -7893,85 +8076,6 @@ function validateCmsfMmtpCatalog(value, options = {}) {
         catalogError("track_group_duration_exact", `${path}.groupDurationMs`, "does not resolve to an exact integer tick count");
       }
     }
-    if (track["fec"] !== void 0) {
-      const fec = track["fec"];
-      if (typeof fec !== "object" || fec === null || Array.isArray(fec)) {
-        catalogError("track_fec", `${path}.fec`, "FEC must be an object");
-      }
-      const config = fec;
-      const algorithm = config["algorithm"];
-      if (typeof algorithm !== "string" || algorithm.length === 0) {
-        catalogError("track_fec", `${path}.fec.algorithm`, "must be a non-empty string");
-      }
-      if ("interleaveDepth" in config || "interleaveMs" in config) {
-        catalogError("track_fec", `${path}.fec`, "interleaveDepthMs is the only supported interleave field");
-      }
-      if ("enhancementRepair" in config) {
-        catalogError(
-          "track_fec",
-          `${path}.fec.enhancementRepair`,
-          "repair layers are self-describing fec-repair tracks (depends, repairLayer); fec.enhancementRepair is not supported"
-        );
-      }
-      if (config["interleaveDepthMs"] !== void 0 && (!Number.isSafeInteger(config["interleaveDepthMs"]) || config["interleaveDepthMs"] < 0)) {
-        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a non-negative safe integer");
-      }
-      if (algorithm !== "none") {
-        for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
-          if (!positiveInteger2(config[field])) {
-            catalogError("track_fec", `${path}.fec.${field}`, "must be a positive integer");
-          }
-        }
-        if (algorithm === "raptorq" && config["symbolSize"] % 8 !== 0) {
-          catalogError("track_fec", `${path}.fec.symbolSize`, "RaptorQ symbolSize must be a multiple of 8");
-        }
-        if (typeof config["repairTrack"] !== "string" || config["repairTrack"].length === 0) {
-          catalogError("track_fec", `${path}.fec.repairTrack`, "must be a non-empty string");
-        }
-      }
-      readFecBlockProfile(config["blockProfile"], `${path}.fec.blockProfile`, algorithm !== "none", catalogError);
-      if (algorithm !== "none" && config["symbolSize"] < ISO_SSBG1_MIN_SYMBOL_SIZE) {
-        catalogError("track_fec", `${path}.fec.symbolSize`, "iso-ssbg1-v1 symbolSize must be at least 14");
-      }
-    }
-  }
-  const repairDescriptors = trackRecords.flatMap(
-    (track, index) => track["packaging"] === "fec-repair" ? [describeRepairTrack(track["name"], `$.tracks[${index}]`, track)] : []
-  );
-  const reachability = repairReachability(
-    trackRecords.filter((track) => track["packaging"] !== "fec-repair").map((track) => track["fec"])
-  );
-  for (const descriptor of repairDescriptors) {
-    assertRepairTrackReachable(descriptor, reachability, catalogError);
-    const target = dependsTarget(descriptor);
-    if (target === void 0) continue;
-    const source = trackRecords.find((candidate) => candidate["name"] === target);
-    const sourceFec = source?.["fec"];
-    if (!source || source["packaging"] !== "mmtp" || !sourceFec || sourceFec["algorithm"] === "none") {
-      catalogError(
-        "track_repair_depends",
-        `${descriptor.path}.depends`,
-        `${JSON.stringify(target)} is not an mmtp track with FEC`
-      );
-    }
-  }
-  for (let index = 0; index < trackRecords.length; index++) {
-    const track = trackRecords[index];
-    const fec = track["fec"];
-    if (!fec || fec["algorithm"] === "none") continue;
-    assembleRepairLayers(
-      {
-        name: track["name"],
-        path: `$.tracks[${index}].fec`,
-        algorithm: fec["algorithm"],
-        sourceSymbols: fec["sourceSymbols"],
-        repairSymbols: fec["repairSymbols"],
-        repairTrack: fec["repairTrack"]
-      },
-      repairDescriptors,
-      catalogError,
-      { layerZeroMustBeDeclared: true }
-    );
   }
   const switchingSets = /* @__PURE__ */ new Map();
   for (let index = 0; index < trackRecords.length; index++) {
@@ -8073,13 +8177,8 @@ var INACTIVE = Object.freeze({
 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);
+function catalogDeclaresFec(catalog, track) {
+  return resolveFecBindings(catalog).get(track)?.status === "ok";
 }
 function requireBoolean(value, field) {
   if (typeof value !== "boolean") {
@@ -8220,20 +8319,20 @@ var MmtpFecSession = class {
     failClosed: null
   };
   /**
-   * @throws when the catalog block lacks or misstates a field the session
-   *   needs: the block profile, K, P_0 (`repairSymbols`), T, `interleaveDepthMs` or
-   *   `reorderToleranceMs`. None is defaulted.
+   * @throws when the instance lacks or misstates a field the session needs:
+   *   the scheme, the block profile, K, P_0 (`repairSymbols`), T,
+   *   `interleaveDepthMs` or `reorderToleranceMs`. None is defaulted.
    */
   constructor(config) {
     const fec = config?.fec;
     if (!fec || typeof fec !== "object") {
-      throw new Error("MmtpFecSession: the catalog fec block is required");
+      throw new Error("MmtpFecSession: the catalog fec instance is required");
     }
     this.blockProfile = parseFecBlockProfile(fec.blockProfile, "fec.blockProfile");
-    if (fec.algorithm !== void 0 && fec.algorithm !== "raptorq" && fec.algorithm !== "reed-solomon") {
-      throw new Error(`MmtpFecSession: fec.algorithm ${JSON.stringify(fec.algorithm)} is not implemented`);
+    if (fec.scheme !== "raptorq" && fec.scheme !== "reed-solomon") {
+      throw new Error(`MmtpFecSession: fec.scheme ${JSON.stringify(fec.scheme)} is not implemented`);
     }
-    this.algorithm = fec.algorithm === "reed-solomon" ? "reed-solomon" : "raptorq";
+    this.algorithm = fec.scheme;
     this.sourceSymbols = requirePositiveInteger(fec.sourceSymbols, "fec.sourceSymbols");
     this.repairSymbols = requirePositiveInteger(fec.repairSymbols, "fec.repairSymbols");
     this.symbolSize = requirePositiveInteger(fec.symbolSize, "fec.symbolSize");
@@ -8575,7 +8674,7 @@ function catalogAmtNetworkSource(networkSource) {
   }
   return void 0;
 }
-function intIn(value, min, max) {
+function intIn2(value, min, max) {
   return Number.isInteger(value) && value >= min && value <= max;
 }
 function catalogAtsc3NetworkSource(networkSource) {
@@ -8583,12 +8682,12 @@ function catalogAtsc3NetworkSource(networkSource) {
   for (const raw of entries) {
     if (!raw || typeof raw !== "object") continue;
     const ns = raw;
-    if (ns.type !== "atsc3" || !intIn(ns.frequency, 1, Number.MAX_SAFE_INTEGER)) continue;
+    if (ns.type !== "atsc3" || !intIn2(ns.frequency, 1, Number.MAX_SAFE_INTEGER)) continue;
     const slsUri = typeof ns.slsUri === "string" ? ns.slsUri.trim() : "";
     return {
       frequency: ns.frequency,
-      ...intIn(ns.plpId, 0, 63) ? { plpId: ns.plpId } : {},
-      ...intIn(ns.serviceId, 0, 65535) ? { serviceId: ns.serviceId } : {},
+      ...intIn2(ns.plpId, 0, 63) ? { plpId: ns.plpId } : {},
+      ...intIn2(ns.serviceId, 0, 65535) ? { serviceId: ns.serviceId } : {},
       ...slsUri ? { slsUri } : {}
     };
   }