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

package/dist/multicast-manager.js

@@ -425,31 +425,536 @@ 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;
+// ../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
+  };
 }
-function catalogFecAvailable(fec) {
-  const block = recordOf(fec);
-  if (block === void 0)
-    return true;
-  if (fecAlgorithmUnimplemented(block["algorithm"]))
-    return false;
-  const declaresFecInstance = block["algorithm"] !== "none";
-  const profile = block["blockProfile"];
-  const profileOk = isFecBlockProfile(profile) || profile === void 0 && !declaresFecInstance;
-  return profileOk && (!declaresFecInstance || isoBlockSpanUsable(block));
+
+// ../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 fecAlgorithmUnimplemented(algorithm) {
-  return typeof algorithm === "string" && algorithm !== "none" && algorithm !== "raptorq" && algorithm !== "reed-solomon";
+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
@@ -969,10 +1474,10 @@ function deriveBlockClassifierGeometry(input) {
     keyframeInterval
   };
 }
-function keyframeIntervalMediaTicks(geometry, mediaTimescale) {
-  if (geometry.trackKind !== "video" || geometry.mode !== "classifying") return null;
+function keyframeIntervalMediaTicks(geometry2, mediaTimescale) {
+  if (geometry2.trackKind !== "video" || geometry2.mode !== "classifying") return null;
   if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0) return null;
-  const { ticks, timescale } = geometry.keyframeInterval;
+  const { ticks, timescale } = geometry2.keyframeInterval;
   if (!Number.isSafeInteger(ticks) || !Number.isSafeInteger(timescale)) return null;
   const scaled = BigInt(ticks) * BigInt(mediaTimescale);
   const divisor = BigInt(timescale);
@@ -1007,11 +1512,11 @@ var BlockClassifier = class {
   /** MPU → movie_fragment_sequence_number observed in it. */
   #mpuFragments = /* @__PURE__ */ new Map();
   #lastRap = null;
-  constructor(geometry) {
-    this.#geometry = geometry;
+  constructor(geometry2) {
+    this.#geometry = geometry2;
     this.#mode = "classifying";
     this.#reason = null;
-    this.reset(geometry);
+    this.reset(geometry2);
   }
   get geometry() {
     return this.#geometry;
@@ -1031,16 +1536,16 @@ var BlockClassifier = class {
     return this.#mpuBoundsRaps;
   }
   /** Begin a fresh epoch (catalog change or track reset). */
-  reset(geometry = this.#geometry) {
-    this.#geometry = geometry;
+  reset(geometry2 = this.#geometry) {
+    this.#geometry = geometry2;
     this.#blocks.clear();
     this.#clearContiguityLedger();
     this.#mpuFragments.clear();
     this.#lastRap = null;
     this.#mpuBoundsRaps = true;
-    if (geometry.trackKind === "video" && geometry.mode === "all-protected") {
+    if (geometry2.trackKind === "video" && geometry2.mode === "all-protected") {
       this.#mode = "all-protected";
-      this.#reason = geometry.reason;
+      this.#reason = geometry2.reason;
     } else {
       this.#mode = "classifying";
       this.#reason = null;
@@ -1156,15 +1661,15 @@ var BlockClassifier = class {
   }
   #checkInvariants(sbn, block, evidence) {
     if (this.#mode === "all-protected" || this.#geometry.trackKind !== "video") return null;
-    const geometry = this.#geometry;
-    if (geometry.mode !== "classifying") return null;
+    const geometry2 = this.#geometry;
+    if (geometry2.mode !== "classifying") return null;
     if (evidence.rap && evidence.idx !== void 0 && evidence.idx !== 0) {
       return "rap-not-mpu-start";
     }
-    if (evidence.idx !== void 0 && evidence.idx >= geometry.gopFrames) {
+    if (evidence.idx !== void 0 && evidence.idx >= geometry2.gopFrames) {
       return "mpu-longer-than-gop";
     }
-    if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0 && block.idxMax - block.idxMin >= geometry.interleaveUnits) {
+    if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0 && block.idxMax - block.idxMin >= geometry2.interleaveUnits) {
       return "block-wider-than-interleave";
     }
     if (evidence.mpu !== void 0 && evidence.movieFragment !== void 0) {
@@ -1280,11 +1785,11 @@ var BlockClassifier = class {
   #classify(block) {
     if (block.rapSeen || block.mpus.size >= 2) return "keyframe";
     if (this.#mode === "all-protected") return "unknown";
-    const geometry = this.#geometry;
-    if (geometry.trackKind !== "video" || geometry.mode !== "classifying") return "unknown";
+    const geometry2 = this.#geometry;
+    if (geometry2.trackKind !== "video" || geometry2.mode !== "classifying") return "unknown";
     if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0) {
-      const span = geometry.interleaveUnits - 1;
-      if (block.idxMax - span >= 1 && block.idxMin + span <= geometry.gopFrames - 1) {
+      const span = geometry2.interleaveUnits - 1;
+      if (block.idxMax - span >= 1 && block.idxMin + span <= geometry2.gopFrames - 1) {
         return "delta";
       }
     }
@@ -2682,15 +3187,15 @@ var FECManager = class _FECManager {
    */
   #refreshDeliveryGapWindow() {
     let windowMs;
-    const consider = (geometry, packetId) => {
+    const consider = (geometry2, packetId) => {
       if (!this.#hasCatalogTimingForPacket(packetId)) return;
-      if (geometry?.trackKind !== "video" || geometry.mode !== "classifying") return;
-      const { ticks, timescale } = geometry.keyframeInterval;
+      if (geometry2?.trackKind !== "video" || geometry2.mode !== "classifying") return;
+      const { ticks, timescale } = geometry2.keyframeInterval;
       const ms = ticks / timescale * 1e3;
       if (Number.isFinite(ms) && ms > 0 && (windowMs === void 0 || ms > windowMs)) windowMs = ms;
     };
-    for (const [streamKey, geometry] of this.#streamGeometries) {
-      consider(geometry, this.#parseStreamKey(streamKey).packetId);
+    for (const [streamKey, geometry2] of this.#streamGeometries) {
+      consider(geometry2, this.#parseStreamKey(streamKey).packetId);
     }
     for (const [packetId, config] of this.#trackConfigs) consider(config.geometry, packetId);
     this.#deliveryGaps.setWindowMs(windowMs);
@@ -2938,8 +3443,8 @@ var FECManager = class _FECManager {
       for (const [key, classifier] of [...this.#classifiers]) {
         if (!this.#belongsToPacket(key, packetId)) continue;
         const stream = this.#parseStreamKey(key);
-        const geometry = this.#geometryFor(stream.packetId, stream.catalogTrackName);
-        if (hasCatalogTiming && JSON.stringify(geometry) === JSON.stringify(classifier.geometry)) continue;
+        const geometry2 = this.#geometryFor(stream.packetId, stream.catalogTrackName);
+        if (hasCatalogTiming && JSON.stringify(geometry2) === JSON.stringify(classifier.geometry)) continue;
         this.#classifiers.delete(key);
         if (!hasCatalogTiming) continue;
         this.#applyClassifierChanges(stream.packetId, stream.catalogTrackName, classifier.retire());
@@ -12675,12 +13180,12 @@ function assertPositiveMs(name, value) {
     );
   }
 }
-function duplicateRetentionMs(geometry) {
-  assertPositiveMs("blockSpanMs", geometry.blockSpanMs);
-  assertPositiveMs("blockLifetimeMs", geometry.blockLifetimeMs);
-  const untilTerminalMs = geometry.blockLifetimeMs;
-  const terminalRecordMs = geometry.blockLifetimeMs;
-  return geometry.blockSpanMs + untilTerminalMs + terminalRecordMs;
+function duplicateRetentionMs(geometry2) {
+  assertPositiveMs("blockSpanMs", geometry2.blockSpanMs);
+  assertPositiveMs("blockLifetimeMs", geometry2.blockLifetimeMs);
+  const untilTerminalMs = geometry2.blockLifetimeMs;
+  const terminalRecordMs = geometry2.blockLifetimeMs;
+  return geometry2.blockSpanMs + untilTerminalMs + terminalRecordMs;
 }
 var GenerationalNumberSet = class {
   #members = /* @__PURE__ */ new Set();
@@ -13086,8 +13591,6 @@ var MmtpRouter = class {
   // Callbacks (legacy — used when per-track callbacks are not registered)
   #onVideoFrame = null;
   #onAudioFrame = null;
-  // Init segment (ftyp+moov) from MMTP MPU metadata — needed for MSE SourceBuffer
-  #onInitSegment = null;
   // Per-track init segment callbacks keyed by packetId
   #trackInitCallbacks = /* @__PURE__ */ new Map();
   // Track whether init has been delivered per physical stream — prevent duplicates
@@ -13350,11 +13853,10 @@ var MmtpRouter = class {
     };
   }
   /**
-   * Init segments delivered for a packetId with no `onTrackInit` handler
-   * since construction, whether the deprecated aggregate `onInitSegment`
-   * callback then received them or nothing did. A supported deployment reads
-   * 0 here; a non-zero value is the evidence that blocks removing the
-   * aggregate callback (MOQT-01, BLO-21181).
+   * Init segments rejected since construction because their packetId had no
+   * `onTrackInit` handler. A rejected init is delivered nowhere; there is no
+   * aggregate fallback (removed in 1.0.0, MOQT-01 / BLO-21181). A supported
+   * deployment reads 0 here.
    */
   get unmappedInitDeliveryCount() {
     return this.#unmappedInitDeliveries;
@@ -13531,20 +14033,10 @@ var MmtpRouter = class {
   onTrackPacket(packetId, cb) {
     this.#trackPacketCallbacks.set(packetId, cb);
   }
-  /**
-   * Register an init segment callback (ftyp+moov from MMTP MPU metadata).
-   * Receives an init only for a packetId with no `onTrackInit` handler.
-   *
-   * @deprecated Use onTrackInit(packetId, cb). Still delivered as a fallback;
-   * removed in the 1.0.0 major, no earlier than one minor release after this
-   * deprecation reaches the `latest` dist-tag (BLO-21181). Count fallback
-   * deliveries with `unmappedInitDeliveryCount`.
-   */
-  onInitSegment(cb) {
-    this.#onInitSegment = cb;
-  }
   /** Register an init segment callback for a specific MMTP packetId.
-   *  Called when FT=0 init arrives via direct source or FEC recovery. */
+   *  Called when FT=0 init arrives via direct source or FEC recovery. An init
+   *  for a packetId with no handler is rejected and counted by
+   *  `unmappedInitDeliveryCount`. */
   onTrackInit(packetId, cb) {
     this.#trackInitCallbacks.set(packetId, cb);
   }
@@ -14944,16 +15436,15 @@ var MmtpRouter = class {
     if (this.#trackInitDelivered.has(streamKey)) return;
     if (data.byteLength <= 8) return;
     this.#trackInitDelivered.add(streamKey);
+    const track = `packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`}`;
     const cb = this.#trackInitCallbacks.get(packetId);
-    if (cb) {
-      cb(data);
-    } else {
+    if (!cb) {
       this.#unmappedInitDeliveries++;
-      this.#onInitSegment?.(data);
+      console.log(`[MmtpRouter] Init rejected for ${track}: no onTrackInit handler`);
+      return;
     }
-    console.log(
-      `[MmtpRouter] Init delivered for packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`} (${data.byteLength}B)`
-    );
+    cb(data);
+    console.log(`[MmtpRouter] Init delivered for ${track} (${data.byteLength}B)`);
   }
   /**
    * Core MMTP packet processing — source packets → play + FEC, repair → FEC only.
@@ -16416,8 +16907,12 @@ var FEC_BLOCK_PROFILES2 = Object.freeze([
   "iso-ssbg1-v1"
 ]);
 
-// node_modules/@blockcast/mmt-base/dist/catalog-fec-source.js
-var ALL_ROLES2 = Object.freeze(["video", "audio"]);
+// node_modules/@blockcast/mmt-base/dist/fec-bindings.js
+var RUNTIME_FEC_RECEIVER2 = Object.freeze({
+  schemes: Object.freeze(["raptorq", "reed-solomon"]),
+  blockProfiles: Object.freeze(["iso-ssbg1-v1"]),
+  overlays: true
+});
 
 // node_modules/@blockcast/mmt-transport/dist/multicast-orchestrator.js
 var DEFAULT_DWELL_MS = 3e3;
@@ -17594,6 +18089,10 @@ function getMulticastGlobals() {
 function hasMulticastGateway() {
   return typeof getMulticastGlobals().multicast?.subscribe === "function";
 }
+function senderOf(event) {
+  const sourceAddress = event.sourceAddress;
+  return typeof sourceAddress === "string" ? sourceAddress : void 0;
+}
 function normalizeBytesEventDetail(detail) {
   const value = detail && typeof detail === "object" && "data" in detail ? detail.data : detail;
   if (value instanceof Uint8Array) return value;
@@ -17640,7 +18139,8 @@ var MulticastTransport = class {
     bytesReceived: 0,
     packetsDroppedUnregisteredPid: 0,
     packetsDroppedUnparseable: 0,
-    packetsDroppedSignaling: 0
+    packetsDroppedSignaling: 0,
+    packetsDroppedForeignSender: 0
   };
   // join() calls by how they resolved; see joinStats.
   #joinsSucceeded = 0;
@@ -17665,6 +18165,11 @@ var MulticastTransport = class {
   // per packet once a count outgrows the small-integer range.
   #acceptedBytesByPacketId = /* @__PURE__ */ new Map();
   #packetIds = null;
+  // The sender S this join's accepted packets came from, once known; see
+  // packetsDroppedForeignSender. Cleared by every join and by a silence
+  // failback, so a replacement publisher is not locked out.
+  #sender = void 0;
+  #lockedTo;
   // What the live join delivers with each accepted packet. A field, not a
   // listener closure, so an in-place admission change (setContext) applies
   // from the next packet on without rejoining.
@@ -17686,9 +18191,15 @@ var MulticastTransport = class {
   #joinGeneration = 0;
   // The provider to subscribe through; window.multicast when unset.
   #gateway;
+  /**
+   * `lockedTo` reads the sender another transport is locked to (a repair
+   * group follows its media join, whose publisher sends both). While it reads
+   * a sender, this join admits only that one; until then its own lock applies.
+   */
   constructor(onPacket, options = {}) {
     this.#onPacket = onPacket;
     this.#gateway = options.gateway;
+    this.#lockedTo = options.lockedTo;
   }
   static isAvailable() {
     return hasMulticastGateway();
@@ -17697,6 +18208,7 @@ var MulticastTransport = class {
     const generation = ++this.#joinGeneration;
     this.#releaseSubscription();
     this.#dataPlaneLive = false;
+    this.#sender = void 0;
     if (this.#disposed) return this.#declined(generation, "disposed");
     const gateway = this.#gateway ?? getMulticastGlobals().multicast;
     if (typeof gateway?.subscribe !== "function") {
@@ -17738,7 +18250,8 @@ var MulticastTransport = class {
       }
       this.#subscription = subscription;
       const live = () => !this.#disposed && generation === this.#joinGeneration;
-      const packetListener = subscriptionDeliversPacketBatches(subscription) ? {
+      const anySource = !config.sourceAddress && !config.senderAddress && !config.atsc3;
+      const packetListener = !anySource && subscriptionDeliversPacketBatches(subscription) ? {
         type: "packets",
         listener: (event) => {
           if (!live()) return;
@@ -17748,7 +18261,7 @@ var MulticastTransport = class {
         type: "bytes",
         listener: (event) => {
           if (!live()) return;
-          if (this.#deliver(event.detail)) this.#resetWatchdog();
+          if (this.#deliver(event.detail, senderOf(event))) this.#resetWatchdog();
         }
       };
       this.#packetListener = packetListener;
@@ -17839,13 +18352,13 @@ var MulticastTransport = class {
    * One packet from the subscription: filter, count, and hand it to the
    * callback. Returns whether it was delivered; the caller notes liveness.
    */
-  #deliver(detail) {
+  #deliver(detail, sourceAddress) {
     const packet = normalizeBytesEventDetail(detail);
     if (!packet) {
       this.#stats.packetsDroppedUnparseable++;
       return false;
     }
-    if (!this.#acceptPacket(packet)) return false;
+    if (!this.#acceptPacket(packet, sourceAddress)) return false;
     this.#onPacket(packet, this.#context);
     return true;
   }
@@ -17886,11 +18399,15 @@ var MulticastTransport = class {
       throw failures[0];
     }
   }
-  /** Feed a raw packet from an external source (e.g., AMT tunnel or ASM subscription). */
-  feedPacket(data, context) {
+  /**
+   * Feed a raw packet from an external source (e.g., AMT tunnel or ASM
+   * subscription). `sourceAddress` is the datagram's sender when the source
+   * knows it; see packetsDroppedForeignSender.
+   */
+  feedPacket(data, context, sourceAddress) {
     if (this.#disposed) return;
     const packet = data instanceof Uint8Array ? data : new Uint8Array(data);
-    if (!this.#acceptPacket(packet)) return;
+    if (!this.#acceptPacket(packet, sourceAddress)) return;
     this.#onPacket(packet, context);
     this.#resetWatchdog();
   }
@@ -18040,6 +18557,10 @@ var MulticastTransport = class {
   get withdrawnPacketIdDrops() {
     return this.#withdrawnPacketIdDrops;
   }
+  /** The sender this join is locked to; undefined until one is known. */
+  get sender() {
+    return this.#sender;
+  }
   /** Whether a subscription is live: joined, and not yet released or replaced. */
   get joined() {
     return this.#subscription !== null;
@@ -18202,11 +18723,16 @@ var MulticastTransport = class {
     this.#withdrawnPacketIds.clear();
   }
   /** The ingress filter; an accepted packet is counted here, once. */
-  #acceptPacket(packet) {
+  #acceptPacket(packet, sourceAddress) {
+    const owner = this.#lockedTo?.() ?? this.#sender;
+    if (sourceAddress !== void 0 && owner !== void 0 && sourceAddress !== owner) {
+      this.#stats.packetsDroppedForeignSender++;
+      return false;
+    }
     const packetId = readMMTPPacketId(packet);
     if (packetId === null) {
       if (!this.#packetIds) {
-        this.#countAccepted(packet, null);
+        this.#countAccepted(packet, null, sourceAddress);
         return true;
       }
       this.#stats.packetsDroppedUnparseable++;
@@ -18217,14 +18743,15 @@ var MulticastTransport = class {
       return false;
     }
     if (!this.#packetIds || this.#packetIds.has(packetId)) {
-      this.#countAccepted(packet, packetId);
+      this.#countAccepted(packet, packetId, sourceAddress);
       return true;
     }
     this.#recordUnregisteredPidDrop(packetId);
     return false;
   }
   /** Receive counters for one accepted packet; `packetId` is null when it has none. */
-  #countAccepted(packet, packetId) {
+  #countAccepted(packet, packetId, sourceAddress) {
+    this.#sender ??= sourceAddress;
     this.#stats.packetsReceived++;
     this.#stats.bytesReceived += packet.byteLength;
     if (packetId === null) return;
@@ -18295,6 +18822,7 @@ var MulticastTransport = class {
       console.warn(
         `[MulticastTransport] No packets for ${this.#failbackWindowMs}ms; failing back to MoQ`
       );
+      this.#sender = void 0;
       this.#onFailback({ kind: "silence", windowMs: this.#failbackWindowMs });
     }, delayMs);
   }
@@ -21030,35 +21558,6 @@ var BcProvenanceV2Receiver = class {
 // src/multicast-manager.ts
 import { deriveFecInterleaveDepth as deriveFecInterleaveDepth3, FecBlockMapper as FecBlockMapper2 } from "@blockcast/mmt-fec";
 
-// src/repair-layers.ts
-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);
-  }
-}
-
 // src/carp-catalog.ts
 var VALID_ROLE_SUFFIXES = /* @__PURE__ */ new Set(["base", "delta", "repair"]);
 function parseTrackRole(trackName) {
@@ -21098,61 +21597,6 @@ function hasSwitchingSetRole(names) {
     return suffix === "base" || suffix === "delta";
   });
 }
-function isFecCatalogGeometry(obj) {
-  if (typeof obj !== "object" || obj === null) return false;
-  const o = obj;
-  const algorithm = o["algorithm"];
-  const symbolSize = o["symbolSize"];
-  return typeof algorithm === "string" && algorithm.length > 0 && typeof o["sourceSymbols"] === "number" && o["sourceSymbols"] >= 1 && typeof o["repairSymbols"] === "number" && o["repairSymbols"] >= 1 && typeof symbolSize === "number" && symbolSize >= 1 && (algorithm !== "raptorq" || symbolSize % 8 === 0) && typeof o["repairTrack"] === "string" && o["repairTrack"].length > 0;
-}
-function isFecCatalogConfig(obj) {
-  if (!isFecCatalogGeometry(obj)) return false;
-  const o = obj;
-  return isFecBlockProfile(o["blockProfile"]) || o["algorithm"] === "none" && o["blockProfile"] === void 0;
-}
-
-// src/catalog-fec-params.ts
-import { catalogFecInterleaveMs } from "@blockcast/mmt-fec";
-var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
-function recordOf2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function blockProfileUnavailable(value, path, declaresFecInstance) {
-  try {
-    readFecBlockProfile(value, path, declaresFecInstance, throwRepairContractError);
-    return void 0;
-  } catch (error) {
-    if (!(error instanceof RepairContractError) || error.code !== "track_fec_block_profile" && error.code !== "track_fec_block_profile_unimplemented") {
-      throw error;
-    }
-    return Object.freeze({ code: error.code, path: error.path, message: error.message });
-  }
-}
-function isoSpanUnavailable(fec, path, declaresFecInstance) {
-  if (!declaresFecInstance || isoBlockSpanUsable(fec)) return void 0;
-  return Object.freeze({
-    code: "track_fec",
-    path,
-    message: `[repair-layers:track_fec] ${path}: must be a non-negative safe integer in milliseconds`
-  });
-}
-function catalogFecUnavailable(fec, fecPath) {
-  if (catalogFecAvailable(fec)) return void 0;
-  const block = recordOf2(fec);
-  if (fecAlgorithmUnimplemented(block["algorithm"])) {
-    return Object.freeze({
-      code: "track_fec_algorithm_unimplemented",
-      path: `${fecPath}.algorithm`,
-      message: `algorithm ${JSON.stringify(block["algorithm"])} is not implemented: the track plays without FEC`
-    });
-  }
-  const declaresFecInstance = block["algorithm"] !== "none";
-  const reason = blockProfileUnavailable(block["blockProfile"], `${fecPath}.blockProfile`, declaresFecInstance) ?? isoSpanUnavailable(block, `${fecPath}.interleaveDepthMs`, declaresFecInstance);
-  if (reason === void 0) {
-    throw new Error(`catalogFecUnavailable: ${fecPath} is unavailable but no reason applies (rule drift)`);
-  }
-  return reason;
-}
 
 // src/multicast-manager.ts
 function freezeIngress(tracks, flow) {
@@ -21510,20 +21954,25 @@ function altGroupKey(track) {
 function repairTrackNamesBySource(tracks) {
   const bySource = /* @__PURE__ */ new Map();
   const add2 = (source, repair) => {
-    if (!source || !repair) return;
+    if (typeof source !== "string" || typeof repair !== "string" || !source || !repair) return;
     const names = bySource.get(source) ?? /* @__PURE__ */ new Set();
     names.add(repair);
     bySource.set(source, names);
   };
   for (const track of tracks) {
-    const repairTrack = typeof track.fec === "object" && track.fec !== null ? track.fec.repairTrack : void 0;
-    if (typeof repairTrack === "string") add2(track.name, repairTrack);
-    if (track.packaging === "fec-repair" && Array.isArray(track.depends) && track.depends.length === 1) {
-      add2(track.depends[0], track.name);
+    if (Array.isArray(track.fec)) {
+      for (const instance of track.fec) add2(track.name, instance?.repairTrack);
     }
+    if (track.packaging === "fec-repair") add2(track.source, track.name);
   }
   return bySource;
 }
+function boundRepairNames(binding) {
+  if (binding?.status !== "ok") return [];
+  const names = binding.layers.map((layer) => layer.repairTrackName);
+  if (binding.overlay) names.push(binding.overlay.repairTrackName);
+  return names;
+}
 var MulticastManager = class {
   #fec;
   #router;
@@ -21949,7 +22398,7 @@ var MulticastManager = class {
       jitterBufferMs: config.fecReorderToleranceMs
     }) : void 0;
     const trackKind = config.trackKind ?? this.#router.trackKindFor(packetId);
-    const geometry = trackKind === void 0 || interleaveDepthMs === 0 ? void 0 : deriveBlockClassifierGeometry({
+    const geometry2 = trackKind === void 0 || interleaveDepthMs === 0 ? void 0 : deriveBlockClassifierGeometry({
       trackKind,
       framerate: config.fps,
       interleaveDepthMs,
@@ -21966,7 +22415,7 @@ var MulticastManager = class {
       timeoutMs: deliveryWindowMs,
       ...trackKind === void 0 ? {} : { trackKind },
       ...config.codec === void 0 ? {} : { codec: config.codec },
-      ...geometry === void 0 ? {} : { geometry }
+      ...geometry2 === void 0 ? {} : { geometry: geometry2 }
     };
     this.#fec.configureTrack(packetId, fecConfig, catalogTrackName);
     this.#configureTrackMapper(packetId, fecConfig);
@@ -22086,10 +22535,6 @@ var MulticastManager = class {
   onTrackPacket(packetId, cb) {
     this.#router.onTrackPacket(packetId, cb);
   }
-  /** @deprecated Use onTrackInit(packetId, cb); see MmtpRouter.onInitSegment. */
-  onInitSegment(cb) {
-    this.#router.onInitSegment(cb);
-  }
   onTrackInit(packetId, cb) {
     this.#router.onTrackInit(packetId, cb);
   }
@@ -22313,15 +22758,21 @@ var MulticastManager = class {
         tracks: Object.freeze(endpoint.tracks.map(({ name, packetId }) => Object.freeze({ name, packetId }))),
         ...endpoint.flow === void 0 ? {} : { flow: endpoint.flow }
       };
-      const onPacket = (packet) => {
-        if (!released) this.#router.feedPacket(packet, "multicast", ingress);
+      let sender;
+      const onPacket = (packet, sourceAddress) => {
+        if (released) return;
+        if (sourceAddress !== void 0 && sourceAddress !== (this.#transport.sender ?? (sender ??= sourceAddress))) return;
+        this.#router.feedPacket(packet, "multicast", ingress);
       };
       const fail = (error) => console.warn(`[MulticastManager] repair group ${endpoint.group}:${endpoint.port} not joined`, error);
       if (typeof provider === "function") {
         Promise.resolve().then(() => provider(endpoint, onPacket)).then((release2) => released ? safely(release2) : releases.push(release2), fail);
         continue;
       }
-      const transport = new MulticastTransport((packet) => onPacket(packet), { gateway: provider });
+      const transport = new MulticastTransport((packet) => onPacket(packet), {
+        gateway: provider,
+        lockedTo: () => this.#transport.sender
+      });
       releases.push(() => transport.dispose());
       void transport.join({
         sourceAddress: endpoint.source,
@@ -22600,8 +23051,8 @@ var MulticastManager = class {
    *  transport attribution in FEC path counters.
    *  The `router` accessor above is already public.
    */
-  feedPacket(data, ingress) {
-    this.#transport.feedPacket(data, ingress);
+  feedPacket(data, ingress, sourceAddress) {
+    this.#transport.feedPacket(data, ingress, sourceAddress);
   }
   /**
    * Declare how packets given to feedPacket() reach this manager. A consumer
@@ -22634,20 +23085,18 @@ var MulticastManager = class {
    * D-17: Builds altGroup → track-name index for getSwitchingSet() (repair legs excluded).
    * D-26: Registers packetId → TrackRole on MmtpRouter for block-complete fanout.
    *
-   * FEC availability is per track (draft-ramadan-moq-fec §5.1). A media track
-   * whose `fec` names no implemented `blockProfile` (only `iso-ssbg1-v1` is
-   * implemented; the retired `k-padded-v1` is not), or an `iso-ssbg1-v1` span
-   * it cannot use, is consumed without FEC: it gets no decoder, and none of
-   * its repair tracks (layer 0 by `fec.repairTrack`, further layers and the
-   * overlay by `depends`) is given an owner, so the router drops their packets
-   * before any decoder. Those legs keep the `repair` role and their owner's
-   * switching set. Neither the call nor any other track's FEC fails on that
-   * account; `trackFecUnavailable(name)` reports the reason. FEC a previous
-   * call configured on a packetId this call does not is released
-   * (FECManager.releasePacket); frames its release gate held are delivered in
-   * order, each gap stalled. FEC wired by hand (setFecDecoder) is left alone.
-   * Geometry a decoder could not configure (K, P, T, `repairTrack`,
-   * algorithm) still throws.
+   * FEC is per track and per instance (`resolveFecBindings`,
+   * draft-ramadan-moq-fec-catalog-00 array, fec-core-00 10.3). A media track
+   * whose base instance is not `ok` (an invalid instance, a profile other than
+   * `iso-ssbg1-v1`, a draft-01 object `fec`) is consumed without FEC: it gets
+   * no decoder, and none of its repair tracks is given an owner, so the router
+   * drops their packets before any decoder. Those legs keep the `repair` role
+   * and their owner's switching set. Neither the call nor any other track's
+   * FEC fails on that account; `trackFecUnavailable(name)` reports the reason.
+   * FEC a previous call configured on a packetId this call does not is
+   * released (FECManager.releasePacket); frames its release gate held are
+   * delivered in order, each gap stalled. FEC wired by hand (setFecDecoder) is
+   * left alone.
    *
    * @param catalog - Multi-track catalog (tracks array with name, altGroup, fec, packetId).
    * @param wasmDecoderSource - One WASM FEC decoder for a single FEC stream, or
@@ -22655,32 +23104,21 @@ var MulticastManager = class {
    */
   configureMultiTrack(catalog, wasmDecoderSource) {
     const repairNamesBySource = repairTrackNamesBySource(catalog.tracks);
-    const declaredRepairNames = /* @__PURE__ */ new Set();
-    for (const names of repairNamesBySource.values()) {
-      for (const name of names) declaredRepairNames.add(name);
-    }
+    const bindings = resolveFecBindings({
+      tracks: catalog.tracks.map(
+        (track) => track.packaging === void 0 ? { ...track, packaging: "mmtp" } : track
+      )
+    });
     const fecUnavailableByTrack = /* @__PURE__ */ new Map();
-    for (let i = 0; i < catalog.tracks.length; i++) {
-      const track = catalog.tracks[i];
-      if (track.fec === void 0 || track.packaging === "fec-repair" || declaredRepairNames.has(track.name)) {
-        continue;
-      }
-      const fecUnavailable = catalogFecUnavailable(track.fec, `$.tracks[${i}].fec`);
-      if (fecUnavailable === void 0) continue;
-      fecUnavailableByTrack.set(track.name, fecUnavailable);
-      const layerZero = track.fec.repairTrack;
-      if (typeof layerZero === "string" && layerZero.length > 0) {
-        const names = repairNamesBySource.get(track.name) ?? /* @__PURE__ */ new Set();
-        names.add(layerZero);
-        repairNamesBySource.set(track.name, names);
-      }
+    for (const binding of bindings.values()) {
+      if (binding.status === "unavailable") fecUnavailableByTrack.set(binding.track, binding.reason);
     }
-    const unownedRepairNames = /* @__PURE__ */ new Set();
-    for (const sourceName of fecUnavailableByTrack.keys()) {
-      for (const repairName of repairNamesBySource.get(sourceName) ?? []) {
-        unownedRepairNames.add(repairName);
-      }
+    const ownedRepairNames = /* @__PURE__ */ new Set();
+    const claimed = /* @__PURE__ */ new Map();
+    for (const binding of bindings.values()) {
+      for (const name of boundRepairNames(binding)) claimed.set(name, (claimed.get(name) ?? 0) + 1);
     }
+    for (const [name, count] of claimed) if (count === 1) ownedRepairNames.add(name);
     const repairOwnerGroup = /* @__PURE__ */ new Map();
     for (const track of catalog.tracks) {
       for (const repairName of repairNamesBySource.get(track.name) ?? []) {
@@ -22726,15 +23164,8 @@ var MulticastManager = class {
     const fecTrackIndexes = [];
     for (let i = 0; i < catalog.tracks.length; i++) {
       const track = catalog.tracks[i];
-      if (resolvedRoles[i] === "repair" || track.fec === void 0) continue;
-      const unavailable = fecUnavailableByTrack.has(track.name);
-      if (!(unavailable ? isFecCatalogGeometry(track.fec) : isFecCatalogConfig(track.fec))) {
-        throw new Error(
-          `[MulticastManager] invalid fec config for track '${track.name}'`
-        );
-      }
-      if (unavailable) continue;
-      if (track.packetId !== void 0) fecTrackIndexes.push(i);
+      if (resolvedRoles[i] === "repair" || track.packetId === void 0) continue;
+      if (bindings.get(track.name)?.status === "ok") fecTrackIndexes.push(i);
     }
     const fecDecoders = /* @__PURE__ */ new Map();
     if (wasmDecoderSource !== void 0 && fecTrackIndexes.length > 0) {
@@ -22805,11 +23236,12 @@ var MulticastManager = class {
         }
         continue;
       }
-      if (track.fec !== void 0 && !fecUnavailableByTrack.has(track.name)) {
-        const fecCfg = track.fec;
+      const binding = bindings.get(track.name);
+      if (binding?.status === "ok") {
+        const fecCfg = binding.base;
         if (track.packetId !== void 0) {
-          for (const repairName of repairNamesBySource.get(track.name) ?? []) {
-            if (unownedRepairNames.has(repairName)) continue;
+          for (const repairName of boundRepairNames(binding)) {
+            if (!ownedRepairNames.has(repairName)) continue;
             const repairTrack = catalogTracksByName.get(repairName);
             if (repairTrack?.packetId !== void 0) {
               this.#router.setRepairPacketIdOwner(repairTrack.packetId, track.packetId);
@@ -22851,14 +23283,11 @@ var MulticastManager = class {
   }
   /**
    * Why `configureMultiTrack` consumes the named catalog track without FEC
-   * although its `fec` block declares one (draft-ramadan-moq-fec §5.1): no
-   * implemented `blockProfile` (`track_fec_block_profile_unimplemented`, e.g.
-   * the retired `k-padded-v1`; `track_fec_block_profile` when absent), or an
-   * invalid `iso-ssbg1-v1` span (`track_fec`). Absent/zero spans keep in-band
-   * decoding enabled. The same reason the hang
-   * resolver reports (`catalogFecUnavailable`). Undefined for every other
-   * track, and for every track before the first call; each call replaces the
-   * previous call's answers.
+   * although it declares some: its base instance is not `ok`, with the
+   * validator's code and path (`TrackFecUnavailable`), the same reason the
+   * hang resolver reports (`catalogTrackFecUnavailable`). Undefined for every
+   * other track, and for every track before the first call; each call
+   * replaces the previous call's answers.
    */
   trackFecUnavailable(trackName) {
     return this.#fecUnavailableByTrack.get(trackName);