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

package/dist/mmtp-container-parser.no-modules.js

@@ -477,34 +477,6 @@ var BlockcastMmt = (() => {
     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;
@@ -753,6 +725,538 @@ var BlockcastMmt = (() => {
     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;
@@ -7464,321 +7968,6 @@ var BlockcastMmt = (() => {
     });
   }
 
-  // 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;
@@ -7911,7 +8100,7 @@ var BlockcastMmt = (() => {
     }
     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];
@@ -7943,7 +8132,7 @@ var BlockcastMmt = (() => {
         );
       }
       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"];
@@ -7951,13 +8140,13 @@ var BlockcastMmt = (() => {
       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"];
@@ -7968,17 +8157,11 @@ var BlockcastMmt = (() => {
       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) {
@@ -7992,85 +8175,6 @@ var BlockcastMmt = (() => {
           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++) {
@@ -8218,13 +8322,8 @@ var BlockcastMmt = (() => {
   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") {
@@ -8334,9 +8433,9 @@ var BlockcastMmt = (() => {
   var _decoder, _blocks, _settled, _have, _newest, _prunedAt, _repairPacketId, _newestSource, _heldLayers, _anchorHorizon, _stats3, _MmtpFecSession_instances, drop_fn2, noteNewest_fn, blockStartOf_fn, countHeld_fn, noteMixed_fn, behindHorizon_fn, settle_fn, settleClean_fn, settleDecoded_fn, retireBehindHorizon_fn;
   var MmtpFecSession = class {
     /**
-     * @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) {
       __privateAdd(this, _MmtpFecSession_instances);
@@ -8374,13 +8473,13 @@ var BlockcastMmt = (() => {
       });
       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");
@@ -8734,7 +8833,7 @@ var BlockcastMmt = (() => {
     }
     return void 0;
   }
-  function intIn(value, min, max) {
+  function intIn2(value, min, max) {
     return Number.isInteger(value) && value >= min && value <= max;
   }
   function catalogAtsc3NetworkSource(networkSource) {
@@ -8742,12 +8841,12 @@ var BlockcastMmt = (() => {
     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 } : {}
       };
     }