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

package/dist/delta-fallback-config.js

@@ -1,3 +1,550 @@
+// ../mmt-base/dist/mmtp.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "iso-ssbg1-v1"
+]);
+
+// ../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 view = { name, packaging: kind === void 0 || kind === "mmtp-fec" ? "mmtp" : kind };
+      if (entry["fec"] !== void 0)
+        view["fec"] = entry["fec"];
+      tracks.push(view);
+      pointers.push(`/${role}/renditions/${escape(name)}`);
+    }
+  }
+  const hangRenditions = tracks.length;
+  for (const [name, r] of Object.entries(recordOf(recordOf(root["repair"])?.["renditions"]) ?? {})) {
+    hangNames.add(name);
+    tracks.push({ packaging: "fec-repair", ...recordOf(r), name });
+    pointers.push(`/repair/renditions/${escape(name)}`);
+  }
+  const raw = Array.isArray(root["tracks"]) ? root["tracks"] : [];
+  const named = new Set(hangNames);
+  raw.forEach((t, i) => {
+    const name = recordOf(t)?.["name"];
+    if (typeof name === "string")
+      named.add(name);
+    if (typeof name === "string" && hangNames.has(name))
+      return;
+    tracks.push(t);
+    pointers.push(`/tracks/${i}`);
+  });
+  tracks.slice(0, hangRenditions).forEach((t, ti) => {
+    const view = t;
+    if (!Array.isArray(view["fec"]))
+      return;
+    view["fec"].forEach((o, ii) => {
+      const repairTrack = recordOf(o)?.["repairTrack"];
+      if (typeof repairTrack !== "string" || named.has(repairTrack))
+        return;
+      named.add(repairTrack);
+      const instanceId = recordOf(o)?.["instanceId"];
+      tracks.push({ name: repairTrack, packaging: "fec-repair", source: view["name"], ...instanceId === void 0 ? {} : { instanceId } });
+      pointers.push(`${pointers[ti]}/fec/${ii}/repairTrack`);
+    });
+  });
+  return { tracks, pointers };
+}
+function resolveFecBindings(catalog, receiver = RUNTIME_FEC_RECEIVER) {
+  const { tracks, pointers } = fecCatalogTracks(catalog);
+  const report = validateFecCatalog({ tracks }, receiver);
+  const at2 = (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: at2(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: at2(`/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: at2(`/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/track-session.ts
 import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
 
@@ -26,33 +573,44 @@ function isPositiveFinite(value) {
 }
 
 // src/delta-fallback-config.ts
-function resolveDeltaFallback(base, delta) {
-  const repair = base.fec?.repairTrack;
-  if (!repair) throw new Error(`[delta-fallback] base track "${base.name}" missing fec.repairTrack`);
-  const deltaFec = delta.fec;
-  if (!deltaFec?.repairTrack) throw new Error(`[delta-fallback] delta track "${delta.name}" missing fec.repairTrack`);
-  if (deltaFec.repairTrack !== repair)
-    throw new Error(
-      `[delta-fallback] inconsistent repair tracks: ${base.name} references "${repair}" but ${delta.name} references "${deltaFec.repairTrack}"`
-    );
-  if (!(typeof base.framerate === "number" && Number.isFinite(base.framerate) && base.framerate > 0))
-    throw new Error(`[delta-fallback] base track "${base.name}" missing positive framerate`);
-  if (!(isPositive(deltaFec.sourceSymbols) && isPositive(deltaFec.repairSymbols)))
-    throw new Error(`[delta-fallback] delta track "${delta.name}" missing positive fec.sourceSymbols/repairSymbols`);
+var recordOf2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+function at(root, pointer) {
+  let cur = root;
+  for (const raw of pointer.split("/").slice(1)) {
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    cur = Array.isArray(cur) ? cur[Number(key)] : recordOf2(cur)?.[key];
+  }
+  return recordOf2(cur);
+}
+function resolveDeltaFallback(catalog, baseName, deltaName) {
+  const bindings = resolveFecBindings(catalog);
+  const bound = (name, role) => {
+    const b = bindings.get(name);
+    if (!b) throw new Error(`[delta-fallback] ${role} track "${name}" declares no fec`);
+    if (b.status !== "ok")
+      throw new Error(`[delta-fallback] ${role} track "${name}" has no FEC: ${b.reason.code} at ${b.reason.path}`);
+    const track = at(catalog, b.pointer) ?? {};
+    const instance = (Array.isArray(track["fec"]) ? track["fec"] : []).map(recordOf2).find((o) => o && (o["instanceId"] ?? 0) === b.base.instanceId) ?? {};
+    return { b, track, instance };
+  };
+  const base = bound(baseName, "base");
+  const delta = bound(deltaName, "delta");
+  const framerate = base.track["framerate"];
+  if (!(typeof framerate === "number" && Number.isFinite(framerate) && framerate > 0))
+    throw new Error(`[delta-fallback] base track "${baseName}" missing positive framerate`);
+  const key = (k) => base.instance[k] ?? delta.instance[k];
   const config = {
-    framerate: base.framerate,
-    sourceSymbols: deltaFec.sourceSymbols,
-    repairSymbols: deltaFec.repairSymbols,
-    deltaFailWindowBlocks: base.fec?.deltaFailWindowBlocks ?? deltaFec.deltaFailWindowBlocks,
-    deltaProbeIntervalMs: base.fec?.deltaProbeIntervalMs ?? deltaFec.deltaProbeIntervalMs,
-    interleaveDepthMs: base.fec?.interleaveDepthMs ?? deltaFec.interleaveDepthMs
+    framerate,
+    sourceSymbols: delta.b.base.sourceSymbols,
+    repairSymbols: delta.b.base.repairSymbols,
+    deltaFailWindowBlocks: key("deltaFailWindowBlocks"),
+    deltaProbeIntervalMs: key("deltaProbeIntervalMs"),
+    interleaveDepthMs: base.b.base.interleaveDepthMs ?? delta.b.base.interleaveDepthMs
   };
-  assertDeltaFallbackConfig(config, `[delta-fallback] group ${base.name}/${delta.name}`);
-  return { repairTrackName: repair, config };
-}
-function isPositive(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0;
+  assertDeltaFallbackConfig(config, `[delta-fallback] group ${baseName}/${deltaName}`);
+  return { baseRepairTrackName: repairOf(base.b), deltaRepairTrackName: repairOf(delta.b), config };
 }
+var repairOf = (b) => b.layers[0].repairTrackName;
 export {
   resolveDeltaFallback
 };