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

package/dist/browser-runtime.js

@@ -957,79 +957,6 @@ function isoBlocksBehindLowerBound(a, b, kMax) {
   return serial32Precedes(a, b) ? Math.floor(serial32Distance(a, b) / kMax) : 0;
 }
 
-// ../mmt-base/dist/catalog-fec-source.js
-var ALL_ROLES = Object.freeze(["video", "audio"]);
-function recordOf(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function locateCatalogFecSource(catalog, source, roles = ALL_ROLES) {
-  const root = recordOf(catalog);
-  if (root === void 0)
-    return void 0;
-  for (const role of roles) {
-    const renditions = recordOf(recordOf(root[role])?.["renditions"]);
-    if (renditions === void 0 || !Object.hasOwn(renditions, source))
-      continue;
-    const entry2 = recordOf(renditions[source]);
-    if (entry2 === void 0)
-      continue;
-    return Object.freeze({
-      dialect: "hang",
-      role,
-      entry: entry2,
-      fec: entry2["fec"],
-      fecPath: `$.${role}.renditions[${JSON.stringify(source)}].fec`
-    });
-  }
-  const tracks = root["tracks"];
-  if (!Array.isArray(tracks))
-    return void 0;
-  const index = tracks.findIndex((track) => recordOf(track)?.["name"] === source);
-  if (index < 0)
-    return void 0;
-  const entry = recordOf(tracks[index]) ?? {};
-  return Object.freeze({
-    dialect: "msf",
-    index,
-    entry,
-    fec: entry["fec"],
-    fecPath: `$.tracks[${index}].fec`
-  });
-}
-function isoBlockSpanUsable(fec) {
-  const block = recordOf(fec);
-  if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1")
-    return true;
-  const ms = block["interleaveDepthMs"];
-  return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
-}
-function catalogFecAvailable(fec) {
-  const block = recordOf(fec);
-  if (block === void 0)
-    return true;
-  if (fecAlgorithmUnimplemented(block["algorithm"]))
-    return false;
-  const declaresFecInstance = block["algorithm"] !== "none";
-  const profile = block["blockProfile"];
-  const profileOk = isFecBlockProfile(profile) || profile === void 0 && !declaresFecInstance;
-  return profileOk && (!declaresFecInstance || isoBlockSpanUsable(block));
-}
-function fecAlgorithmUnimplemented(algorithm) {
-  return typeof algorithm === "string" && algorithm !== "none" && algorithm !== "raptorq" && algorithm !== "reed-solomon";
-}
-function isPositiveSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-var ISO_SSBG1_MIN_SYMBOL_SIZE = 14;
-function catalogFecDeclaresUnconfigurableInstance(fec) {
-  const block = recordOf(fec);
-  if (block === void 0 || block["algorithm"] === "none" || fecAlgorithmUnimplemented(block["algorithm"]))
-    return false;
-  if (!(isPositiveSafeInteger(block["sourceSymbols"]) && isPositiveSafeInteger(block["symbolSize"])))
-    return true;
-  return block["blockProfile"] === "iso-ssbg1-v1" && block["symbolSize"] < ISO_SSBG1_MIN_SYMBOL_SIZE;
-}
-
 // ../mmt-base/dist/multicast-catalog.js
 var ED25519_PUBLIC_KEY_BASE64URL = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
 var UINT32_MAX = 4294967295;
@@ -1095,22 +1022,22 @@ function authIssues(auth) {
   const firstEpochs = /* @__PURE__ */ new Set();
   for (let index = 0; index < keys.length; index++) {
     const key = keys[index];
-    const at = `.keys[${index}]`;
+    const at2 = `.keys[${index}]`;
     if (!isObject(key) || Object.keys(key).some((member) => !KEY_MEMBERS.has(member))) {
-      return issue(at, "a key is exactly {kid, publicKey, firstEpoch}");
+      return issue(at2, "a key is exactly {kid, publicKey, firstEpoch}");
     }
     if (!isIntegerIn(key["kid"], 0, UINT32_MAX))
-      return issue(`${at}.kid`, "kid must be an unsigned 32-bit integer");
+      return issue(`${at2}.kid`, "kid must be an unsigned 32-bit integer");
     if (typeof key["publicKey"] !== "string" || !ED25519_PUBLIC_KEY_BASE64URL.test(key["publicKey"])) {
-      return issue(`${at}.publicKey`, "publicKey must be a 32-octet Ed25519 key in canonical unpadded base64url");
+      return issue(`${at2}.publicKey`, "publicKey must be a 32-octet Ed25519 key in canonical unpadded base64url");
     }
     if (!isIntegerIn(key["firstEpoch"], 0, UINT32_MAX)) {
-      return issue(`${at}.firstEpoch`, "firstEpoch must be an unsigned 32-bit integer");
+      return issue(`${at2}.firstEpoch`, "firstEpoch must be an unsigned 32-bit integer");
     }
     if (kids.has(key["kid"]))
-      return issue(`${at}.kid`, `kid ${key["kid"]} is repeated; the catalog holds no key set`);
+      return issue(`${at2}.kid`, `kid ${key["kid"]} is repeated; the catalog holds no key set`);
     if (firstEpochs.has(key["firstEpoch"])) {
-      return issue(`${at}.firstEpoch`, `firstEpoch ${key["firstEpoch"]} is repeated; the catalog holds no key set`);
+      return issue(`${at2}.firstEpoch`, `firstEpoch ${key["firstEpoch"]} is repeated; the catalog holds no key set`);
     }
     kids.add(key["kid"]);
     firstEpochs.add(key["firstEpoch"]);
@@ -1120,36 +1047,36 @@ function authIssues(auth) {
   }
   return [];
 }
-function endpointAuthIssue(endpoint, mode, at) {
+function endpointAuthIssue(endpoint, mode, at2) {
   const auth = endpoint["auth"];
   if (!isObject(auth))
-    return { path: `${at}.auth`, message: "auth must be an object" };
+    return { path: `${at2}.auth`, message: "auth must be an object" };
   const unknown = Object.keys(auth).filter((key) => !ENDPOINT_AUTH_MEMBERS.has(key));
   if (unknown.length > 0)
-    return { path: `${at}.auth`, message: `auth has unknown member(s) ${unknown.join(", ")}` };
+    return { path: `${at2}.auth`, message: `auth has unknown member(s) ${unknown.join(", ")}` };
   if (!isIntegerIn(auth["manifestPort"], 1, 65535)) {
-    return { path: `${at}.auth.manifestPort`, message: "manifestPort must be an integer from 1 to 65535" };
+    return { path: `${at2}.auth.manifestPort`, message: "manifestPort must be an integer from 1 to 65535" };
   }
   if (!isIntegerIn(auth["streamId"], 0, UINT32_MAX)) {
-    return { path: `${at}.auth.streamId`, message: "streamId must be an unsigned 32-bit integer" };
+    return { path: `${at2}.auth.streamId`, message: "streamId must be an unsigned 32-bit integer" };
   }
   if (mode === "ssm" && auth["senderAddress"] !== void 0) {
-    return { path: `${at}.auth.senderAddress`, message: "senderAddress must not appear on an SSM endpoint; S is sourceAddress" };
+    return { path: `${at2}.auth.senderAddress`, message: "senderAddress must not appear on an SSM endpoint; S is sourceAddress" };
   }
   if (mode === "asm" && !isNonEmptyString(auth["senderAddress"])) {
-    return { path: `${at}.auth.senderAddress`, message: "a protected ASM endpoint requires senderAddress" };
+    return { path: `${at2}.auth.senderAddress`, message: "a protected ASM endpoint requires senderAddress" };
   }
   if (auth["maxAuthDelayMs"] !== void 0 && !isIntegerIn(auth["maxAuthDelayMs"], 50, 1e3)) {
-    return { path: `${at}.auth.maxAuthDelayMs`, message: "maxAuthDelayMs must be an integer from 50 to 1000" };
+    return { path: `${at2}.auth.maxAuthDelayMs`, message: "maxAuthDelayMs must be an integer from 50 to 1000" };
   }
   if (auth["manifestTimerMs"] !== void 0 && !isIntegerIn(auth["manifestTimerMs"], 1, Number.MAX_SAFE_INTEGER)) {
-    return { path: `${at}.auth.manifestTimerMs`, message: "manifestTimerMs must be an integer of at least 1" };
+    return { path: `${at2}.auth.manifestTimerMs`, message: "manifestTimerMs must be an integer of at least 1" };
   }
   if (auth["manifestTrack"] !== void 0 && !isNonEmptyString(auth["manifestTrack"])) {
-    return { path: `${at}.auth.manifestTrack`, message: "manifestTrack must be a non-empty string" };
+    return { path: `${at2}.auth.manifestTrack`, message: "manifestTrack must be a non-empty string" };
   }
   if (!isIntegerIn(endpoint["bandwidth"], 1, Number.MAX_SAFE_INTEGER)) {
-    return { path: `${at}.bandwidth`, message: "a protected endpoint requires bandwidth, which bounds the receiver's hold queues" };
+    return { path: `${at2}.bandwidth`, message: "a protected endpoint requires bandwidth, which bounds the receiver's hold queues" };
   }
   return void 0;
 }
@@ -1185,41 +1112,41 @@ function multicastCatalogIssues(catalog, options = {}) {
   const sources = [];
   for (let index = 0; index < endpoints.length; index++) {
     const endpoint = endpoints[index];
-    const at = `$.multicast.endpoints[${index}]`;
+    const at2 = `$.multicast.endpoints[${index}]`;
     const fail = (code, path, message) => {
       issues.push({ code, path, message, endpointIndex: index });
     };
     sources.push(void 0);
     if (!isObject(endpoint)) {
-      fail("multicast_endpoint", at, "endpoint must be an object");
+      fail("multicast_endpoint", at2, "endpoint must be an object");
       continue;
     }
     const protocol = endpoint["protocol"];
     if (protocol !== void 0 && protocol !== "ssm" && protocol !== "asm") {
-      fail("multicast_endpoint", `${at}.protocol`, `protocol must be "ssm" or "asm"; a bearer such as ${JSON.stringify(protocol)} is a networkSource entry (draft -01 4.2)`);
+      fail("multicast_endpoint", `${at2}.protocol`, `protocol must be "ssm" or "asm"; a bearer such as ${JSON.stringify(protocol)} is a networkSource entry (draft -01 4.2)`);
       continue;
     }
     const hasAuth = endpoint["auth"] !== void 0;
     if (protectedCatalog !== hasAuth) {
-      fail("multicast_endpoint_auth", `${at}.auth`, protectedCatalog ? "every endpoint requires auth when multicast carries auth; a receiver ignores this endpoint" : "auth names no key without multicast.auth; a receiver ignores this endpoint");
+      fail("multicast_endpoint_auth", `${at2}.auth`, protectedCatalog ? "every endpoint requires auth when multicast carries auth; a receiver ignores this endpoint" : "auth names no key without multicast.auth; a receiver ignores this endpoint");
       continue;
     }
     const sourceAddress = endpoint["sourceAddress"];
     if (sourceAddress !== void 0 && !isNonEmptyString(sourceAddress)) {
-      fail("multicast_endpoint", `${at}.sourceAddress`, "sourceAddress must be a non-empty string");
+      fail("multicast_endpoint", `${at2}.sourceAddress`, "sourceAddress must be a non-empty string");
       continue;
     }
     const mode = sourceAddress === void 0 ? "asm" : "ssm";
     if (protocol !== void 0 && protocol !== mode) {
-      fail("multicast_endpoint", `${at}.protocol`, `protocol ${JSON.stringify(protocol)} disagrees with sourceAddress, which selects ${mode}`);
+      fail("multicast_endpoint", `${at2}.protocol`, `protocol ${JSON.stringify(protocol)} disagrees with sourceAddress, which selects ${mode}`);
       continue;
     }
     if (!isIntegerIn(endpoint["port"], 1, 65535)) {
-      fail("multicast_endpoint", `${at}.port`, "port must be an integer from 1 to 65535");
+      fail("multicast_endpoint", `${at2}.port`, "port must be an integer from 1 to 65535");
       continue;
     }
     if (hasAuth) {
-      const authIssue = endpointAuthIssue(endpoint, mode, at);
+      const authIssue = endpointAuthIssue(endpoint, mode, at2);
       if (authIssue) {
         fail("multicast_endpoint_auth", authIssue.path, authIssue.message);
         continue;
@@ -1237,7 +1164,7 @@ function multicastCatalogIssues(catalog, options = {}) {
         continue;
       referenceNamespace ??= namespace;
       if (namespace !== referenceNamespace) {
-        fail("multicast_track", `${at}.tracks[${refIndex}].name`, `track ${JSON.stringify(name)} declares namespace ${JSON.stringify(namespace)}, not the catalog track's ${JSON.stringify(referenceNamespace)}`);
+        fail("multicast_track", `${at2}.tracks[${refIndex}].name`, `track ${JSON.stringify(name)} declares namespace ${JSON.stringify(namespace)}, not the catalog track's ${JSON.stringify(referenceNamespace)}`);
       }
     }
   }
@@ -1254,9 +1181,9 @@ function multicastCatalogIssues(catalog, options = {}) {
     if (!sources[index])
       continue;
     const own = tupleOf(index);
-    const at = `$.multicast.endpoints[${index}]`;
+    const at2 = `$.multicast.endpoints[${index}]`;
     if (own.manifestPort !== void 0 && own.manifestPort === own.port) {
-      issues.push({ code: "multicast_endpoint_auth", path: `${at}.auth.manifestPort`, message: "manifestPort must differ from the endpoint's own port", endpointIndex: index });
+      issues.push({ code: "multicast_endpoint_auth", path: `${at2}.auth.manifestPort`, message: "manifestPort must differ from the endpoint's own port", endpointIndex: index });
       continue;
     }
     for (let other = 0; other < endpoints.length; other++) {
@@ -1266,11 +1193,11 @@ function multicastCatalogIssues(catalog, options = {}) {
       if (peer.sg !== own.sg)
         continue;
       if (peer.port === own.port) {
-        issues.push({ code: "multicast_endpoint", path: `${at}.port`, message: `(S, G, port) is shared with endpoint ${other}; one endpoint object per multicast tuple`, endpointIndex: index });
+        issues.push({ code: "multicast_endpoint", path: `${at2}.port`, message: `(S, G, port) is shared with endpoint ${other}; one endpoint object per multicast tuple`, endpointIndex: index });
         break;
       }
       if (own.manifestPort !== void 0 && (own.manifestPort === peer.port || own.manifestPort === peer.manifestPort)) {
-        issues.push({ code: "multicast_endpoint_auth", path: `${at}.auth.manifestPort`, message: `manifestPort is a port or manifestPort of endpoint ${other} on the same (S, G)`, endpointIndex: index });
+        issues.push({ code: "multicast_endpoint_auth", path: `${at2}.auth.manifestPort`, message: `manifestPort is a port or manifestPort of endpoint ${other} on the same (S, G)`, endpointIndex: index });
         break;
       }
     }
@@ -1278,6 +1205,538 @@ function multicastCatalogIssues(catalog, options = {}) {
   return issues;
 }
 
+// ../mmt-base/dist/fec-catalog.js
+var DEFAULT_SCHEMES = ["reed-solomon", "raptorq"];
+var DEFAULT_PROFILES = ["moq-object-v1", "iso-ssbg1-v1"];
+var RS_MAX_BLOCK = 255;
+var RAPTORQ_MAX_K = 56403;
+var MAX_24 = 16777215;
+var ISO_MIN_T = 14;
+var GEOMETRY_KEYS = [
+  "scheme",
+  "blockProfile",
+  "mmtpMode",
+  "timescale",
+  "symbolSize",
+  "interleaveDepthMs",
+  "reorderToleranceMs",
+  "sourceSymbols",
+  "fec"
+];
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+var isInt = (v) => typeof v === "number" && Number.isInteger(v);
+var intIn = (v, lo, hi = Number.MAX_SAFE_INTEGER) => isInt(v) && v >= lo && v <= hi;
+var profileAdmits = (profile, packaging) => profile !== "iso-ssbg1-v1" || packaging === "mmtp";
+function validateFecCatalog(catalog, receiver = {}) {
+  const schemes = receiver.schemes ?? DEFAULT_SCHEMES;
+  const profiles = receiver.blockProfiles ?? DEFAULT_PROFILES;
+  const overlays = receiver.overlays ?? true;
+  const all = [];
+  const report = (code, path, inst) => {
+    const issue = { code, path };
+    all.push(issue);
+    inst?.issues.push(issue);
+  };
+  const tracks = isObj(catalog) && Array.isArray(catalog.tracks) ? catalog.tracks : [];
+  if (!isObj(catalog) || !Array.isArray(catalog.tracks))
+    report("fec_member", "/tracks");
+  let rejectAll = false;
+  tracks.forEach((t, ti) => {
+    if (!isObj(t))
+      return;
+    if (has(t, "enhancementRepair")) {
+      rejectAll = true;
+      report("fec_enhancement_repair", `/tracks/${ti}/enhancementRepair`);
+    }
+    if (Array.isArray(t.fec))
+      t.fec.forEach((o, ii) => {
+        if (isObj(o) && has(o, "enhancementRepair")) {
+          rejectAll = true;
+          report("fec_enhancement_repair", `/tracks/${ti}/fec/${ii}/enhancementRepair`);
+        }
+      });
+  });
+  const key = (ns, name) => JSON.stringify([ns ?? null, name]);
+  const byName = /* @__PURE__ */ new Map();
+  tracks.forEach((t, ti) => {
+    if (isObj(t) && typeof t.name === "string") {
+      const k = key(t.namespace, t.name);
+      if (!byName.has(k))
+        byName.set(k, ti);
+    }
+  });
+  const trackAt = (ti) => tracks[ti];
+  const insts = [];
+  tracks.forEach((t, ti) => {
+    if (!isObj(t) || !has(t, "fec") || t.packaging === "fec-repair" || t.packaging === "fec-source")
+      return;
+    if (!Array.isArray(t.fec)) {
+      report("fec_member", `/tracks/${ti}/fec`);
+      return;
+    }
+    t.fec.forEach((o, ii) => {
+      const path = `/tracks/${ti}/fec/${ii}`;
+      const inst = {
+        path,
+        ti,
+        track: t,
+        obj: isObj(o) ? o : null,
+        id: null,
+        unavailable: false,
+        overlay: false,
+        issues: [],
+        layer0: null,
+        symbolNamed: null,
+        attached: []
+      };
+      insts.push(inst);
+      if (!inst.obj)
+        return report("fec_member", path, inst);
+      const o2 = inst.obj;
+      if (!has(o2, "instanceId"))
+        inst.id = 0;
+      else if (intIn(o2.instanceId, 0, 255))
+        inst.id = o2.instanceId;
+      else
+        report("fec_member", `${path}/instanceId`, inst);
+      inst.overlay = has(o2, "scope");
+    });
+  });
+  const declaresFec = insts.length > 0;
+  for (const inst of insts) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const avail = (field, impl) => {
+      const p = `${inst.path}/${field}`;
+      const absent = field === "scheme" ? "fec_scheme_absent" : "fec_block_profile_absent";
+      const unimpl = field === "scheme" ? "fec_scheme_unimplemented" : "fec_block_profile_unimplemented";
+      if (!has(o, field))
+        return report(absent, p, inst), false;
+      if (typeof o[field] !== "string")
+        return report("fec_member", p, inst), true;
+      if (!impl.includes(o[field]))
+        return report(unimpl, p, inst), false;
+      return true;
+    };
+    if (!avail("scheme", schemes) || !avail("blockProfile", profiles))
+      inst.unavailable = true;
+    else if (typeof o.blockProfile === "string" && !profileAdmits(o.blockProfile, inst.track.packaging)) {
+      report("fec_block_profile_packaging", `${inst.path}/blockProfile`, inst);
+      inst.unavailable = true;
+    }
+  }
+  const live = (i) => !i.unavailable;
+  for (const inst of insts.filter(live)) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const p = inst.path;
+    for (const m of ["sourceSymbols", "repairSymbols", "symbolSize"])
+      if (!intIn(o[m], 1))
+        report("fec_member", `${p}/${m}`, inst);
+    if (typeof o.repairTrack !== "string")
+      report("fec_member", `${p}/repairTrack`, inst);
+    if (has(o, "symbolTrack") && typeof o.symbolTrack !== "string")
+      report("fec_member", `${p}/symbolTrack`, inst);
+    if (has(o, "interleaveDepthMs")) {
+      const d = o.interleaveDepthMs;
+      if (!intIn(d, 0) || d === 0 && o.blockProfile !== "iso-ssbg1-v1")
+        report("fec_member", `${p}/interleaveDepthMs`, inst);
+    }
+    if (has(o, "reorderToleranceMs")) {
+      const r = o.reorderToleranceMs;
+      if (typeof r !== "number" || !Number.isFinite(r) || r < 0)
+        report("fec_member", `${p}/reorderToleranceMs`, inst);
+    }
+    if (has(o, "label") && typeof o.label !== "string")
+      report("fec_member", `${p}/label`, inst);
+    if (inst.overlay && o.scope !== "keyframe")
+      report("fec_member", `${p}/scope`, inst);
+  }
+  const idGroups = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    if (inst.id !== null) {
+      const k = `${inst.ti}:${inst.id}`;
+      idGroups.set(k, [...idGroups.get(k) ?? [], inst]);
+    }
+  for (const group of idGroups.values())
+    if (group.length > 1)
+      for (const inst of group.filter(live))
+        report("fec_instance_id", inst.obj && has(inst.obj, "instanceId") ? `${inst.path}/instanceId` : inst.path, inst);
+  const nameUses = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    for (const field of ["repairTrack", "symbolTrack"])
+      if (inst.obj && typeof inst.obj[field] === "string") {
+        const k = key(inst.track.namespace, inst.obj[field]);
+        nameUses.set(k, [...nameUses.get(k) ?? [], { inst, field }]);
+      }
+  const namedBy = /* @__PURE__ */ new Map();
+  for (const [k, uses] of nameUses) {
+    const tj = byName.get(k);
+    for (const { inst, field } of uses) {
+      const path = `${inst.path}/${field}`;
+      if (tj === void 0 || trackAt(tj).packaging !== (field === "repairTrack" ? "fec-repair" : "fec-source")) {
+        if (live(inst))
+          report("fec_naming", path, inst);
+      } else if (uses.length > 1) {
+        if (live(inst))
+          report("fec_naming", path, inst);
+        if (!namedBy.has(tj))
+          namedBy.set(tj, inst);
+      } else {
+        namedBy.set(tj, inst);
+        if (field === "repairTrack")
+          inst.layer0 = tj;
+        else
+          inst.symbolNamed = tj;
+      }
+    }
+  }
+  const owner = /* @__PURE__ */ new Map();
+  if (declaresFec)
+    tracks.forEach((t, tj) => {
+      if (!isObj(t) || t.packaging !== "fec-repair" && t.packaging !== "fec-source")
+        return;
+      const tp = `/tracks/${tj}`;
+      const named = namedBy.get(tj);
+      if (named) {
+        owner.set(tj, named);
+        if (!live(named))
+          return;
+        if (has(t, "source") && t.source !== named.track.name)
+          report("fec_resolution", `${tp}/source`, named);
+        if (has(t, "instanceId") && t.instanceId !== named.id)
+          report("fec_resolution", `${tp}/instanceId`, named);
+        return;
+      }
+      if (!has(t, "source"))
+        return report("fec_orphan", tp);
+      const id = has(t, "instanceId") ? t.instanceId : 0;
+      const src = typeof t.source === "string" ? byName.get(key(t.namespace, t.source)) : void 0;
+      const target = src === void 0 ? void 0 : insts.find((i) => i.ti === src && i.id === id);
+      if (!target)
+        return report("fec_naming", has(t, "instanceId") && src !== void 0 ? `${tp}/instanceId` : `${tp}/source`);
+      owner.set(tj, target);
+      target.attached.push(tj);
+    });
+  for (const [tj, inst] of owner) {
+    if (!live(inst))
+      continue;
+    const t = trackAt(tj);
+    const tp = `/tracks/${tj}`;
+    const symbol = t.packaging === "fec-source";
+    if (has(t, "source") && typeof t.source !== "string")
+      report("fec_member", `${tp}/source`, inst);
+    if (has(t, "instanceId") && !intIn(t.instanceId, 0, 255))
+      report("fec_member", `${tp}/instanceId`, inst);
+    for (const m of ["repairLayer", "repairSymbols"]) {
+      if (!has(t, m))
+        continue;
+      if (symbol || !intIn(t[m], m === "repairLayer" ? 0 : 1))
+        report("fec_member", `${tp}/${m}`, inst);
+    }
+    if (has(t, "priority") && !intIn(t.priority, symbol ? 0 : 192, 255))
+      report("fec_member", `${tp}/priority`, inst);
+    for (const k of Object.keys(t))
+      if (GEOMETRY_KEYS.includes(k) || k.startsWith("groupDuration"))
+        report("fec_track_geometry", `${tp}/${k.replace(/~/g, "~0").replace(/\//g, "~1")}`, inst);
+  }
+  for (const inst of insts.filter(live)) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const repairs = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-repair");
+    const symbols = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-source");
+    if (symbols.length + (inst.symbolNamed !== null ? 1 : 0) > 1)
+      for (const tj of symbols)
+        report("fec_symbol_tracks", `/tracks/${tj}`, inst);
+    const l0 = inst.layer0 === null ? null : trackAt(inst.layer0);
+    const l0p = `/tracks/${inst.layer0}`;
+    if (inst.overlay) {
+      if (l0 && has(l0, "repairLayer"))
+        report("fec_overlay", `${l0p}/repairLayer`, inst);
+      for (const tj of repairs)
+        report("fec_overlay", has(trackAt(tj), "repairLayer") ? `/tracks/${tj}/repairLayer` : `/tracks/${tj}`, inst);
+    } else {
+      if (l0 && has(l0, "repairLayer") && l0.repairLayer !== 0)
+        report("fec_layers", `${l0p}/repairLayer`, inst);
+      if (l0 && has(l0, "repairSymbols") && intIn(o.repairSymbols, 1) && l0.repairSymbols !== o.repairSymbols)
+        report("fec_layer0", `${l0p}/repairSymbols`, inst);
+      const layers = [];
+      for (const tj of repairs) {
+        const t = trackAt(tj);
+        if (!has(t, "repairLayer"))
+          report("fec_member", `/tracks/${tj}/repairLayer`, inst);
+        else if (t.repairLayer === 0)
+          report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+        else if (intIn(t.repairLayer, 1))
+          layers.push({ tj, layer: t.repairLayer });
+        if (!has(t, "repairSymbols"))
+          report("fec_member", `/tracks/${tj}/repairSymbols`, inst);
+      }
+      const counts = /* @__PURE__ */ new Map();
+      for (const { layer } of layers)
+        counts.set(layer, (counts.get(layer) ?? 0) + 1);
+      let missing = 1;
+      while (counts.has(missing))
+        missing++;
+      for (const { tj, layer } of layers)
+        if (counts.get(layer) > 1 || layer > missing)
+          report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+      const chain = [
+        { layer: 0, tj: inst.layer0, pri: l0 && intIn(l0.priority, 192, 255) ? l0.priority : l0 && has(l0, "priority") ? null : 240 },
+        ...layers.map(({ tj, layer }) => {
+          const pr = trackAt(tj).priority;
+          return { layer, tj, pri: intIn(pr, 192, 255) ? pr : null };
+        })
+      ].sort((a, b) => a.layer - b.layer);
+      let prev = null;
+      for (const c of chain) {
+        if (c.pri === null)
+          continue;
+        if (prev !== null && c.pri < prev)
+          report("fec_priority", `/tracks/${c.tj}/priority`, inst);
+        prev = Math.max(prev ?? c.pri, c.pri);
+      }
+    }
+    const K = o.sourceSymbols;
+    const T = o.symbolSize;
+    const P0 = o.repairSymbols;
+    if (intIn(K, 1) && intIn(P0, 1)) {
+      let P = P0;
+      if (!inst.overlay)
+        for (const tj of repairs) {
+          const t = trackAt(tj);
+          if (intIn(t.repairLayer, 1) && intIn(t.repairSymbols, 1))
+            P += t.repairSymbols;
+        }
+      if (P > MAX_24 || K + P - 1 > MAX_24)
+        report("fec_bounds", inst.path, inst);
+      else if (o.scheme === "reed-solomon" && K + P > RS_MAX_BLOCK)
+        report("fec_bounds", inst.path, inst);
+    }
+    if (o.scheme === "raptorq" && intIn(K, 1) && K > RAPTORQ_MAX_K)
+      report("fec_bounds", `${inst.path}/sourceSymbols`, inst);
+    if (intIn(T, 1)) {
+      if (o.scheme === "raptorq" && T % 8 !== 0)
+        report("fec_bounds", `${inst.path}/symbolSize`, inst);
+      else if (o.blockProfile === "iso-ssbg1-v1" && T < ISO_MIN_T)
+        report("fec_bounds", `${inst.path}/symbolSize`, inst);
+    }
+  }
+  const overlayTracks = new Set(insts.filter((i) => live(i) && i.overlay).map((i) => i.ti));
+  for (const ti of overlayTracks) {
+    const ofTrack = insts.filter((i) => i.ti === ti && live(i));
+    const ovs = ofTrack.filter((i) => i.overlay);
+    if (!overlays) {
+      for (const ov of ovs)
+        report("fec_overlay_unsupported", `${ov.path}/scope`, ov);
+      for (const i of ofTrack)
+        i.issues.length === 0 && i.issues.push({ code: "fec_overlay_unsupported", path: `${ovs[0].path}/scope` });
+      continue;
+    }
+    if (ovs.length > 1)
+      for (const ov of ovs)
+        report("fec_overlay", `${ov.path}/scope`, ov);
+    for (const ov of ovs)
+      if (ov.obj?.blockProfile !== "iso-ssbg1-v1")
+        report("fec_overlay", `${ov.path}/blockProfile`, ov);
+    const cause = ovs.flatMap((ov) => ov.issues).find((x) => x.code === "fec_overlay");
+    if (cause) {
+      for (const ov of ovs)
+        if (ov.issues.length === 0)
+          ov.issues.push(cause);
+    }
+  }
+  const rule4 = all.find((x) => x.code === "fec_enhancement_repair");
+  if (rejectAll && rule4) {
+    for (const i of insts)
+      if (i.issues.length === 0)
+        i.issues.push(rule4);
+  }
+  return {
+    instances: insts.map((i) => ({
+      path: i.path,
+      track: typeof i.track.name === "string" ? i.track.name : null,
+      instanceId: i.id,
+      outcome: rejectAll || !i.unavailable && i.issues.length > 0 ? "violation" : i.unavailable ? "unavailable" : "ok",
+      issues: i.issues,
+      trackIndex: i.ti,
+      repairTrack: i.layer0,
+      boundRepairTracks: i.attached.filter((tj) => trackAt(tj).packaging === "fec-repair"),
+      symbolTrack: i.symbolNamed ?? i.attached.find((tj) => trackAt(tj).packaging === "fec-source") ?? null
+    })),
+    issues: all
+  };
+}
+
+// ../mmt-base/dist/fec-bindings.js
+var RUNTIME_FEC_RECEIVER = Object.freeze({
+  schemes: Object.freeze(["raptorq", "reed-solomon"]),
+  blockProfiles: Object.freeze(["iso-ssbg1-v1"]),
+  overlays: true
+});
+var DEFAULT_FEC_REPAIR_PRIORITY = 240;
+var recordOf = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+var escape = (s) => s.replace(/~/g, "~0").replace(/\//g, "~1");
+function fecCatalogTracks(catalog) {
+  const root = recordOf(catalog) ?? {};
+  const tracks = [];
+  const pointers = [];
+  const hangNames = /* @__PURE__ */ new Set();
+  for (const role of ["video", "audio"]) {
+    for (const [name, r] of Object.entries(recordOf(recordOf(root[role])?.["renditions"]) ?? {})) {
+      const entry = recordOf(r);
+      if (!entry)
+        continue;
+      hangNames.add(name);
+      const kind = recordOf(entry["container"])?.["kind"];
+      const view2 = { name, packaging: kind === void 0 || kind === "mmtp-fec" ? "mmtp" : kind };
+      if (entry["fec"] !== void 0)
+        view2["fec"] = entry["fec"];
+      tracks.push(view2);
+      pointers.push(`/${role}/renditions/${escape(name)}`);
+    }
+  }
+  const hangRenditions = tracks.length;
+  for (const [name, r] of Object.entries(recordOf(recordOf(root["repair"])?.["renditions"]) ?? {})) {
+    hangNames.add(name);
+    tracks.push({ packaging: "fec-repair", ...recordOf(r), name });
+    pointers.push(`/repair/renditions/${escape(name)}`);
+  }
+  const raw = Array.isArray(root["tracks"]) ? root["tracks"] : [];
+  const named = new Set(hangNames);
+  raw.forEach((t, i) => {
+    const name = recordOf(t)?.["name"];
+    if (typeof name === "string")
+      named.add(name);
+    if (typeof name === "string" && hangNames.has(name))
+      return;
+    tracks.push(t);
+    pointers.push(`/tracks/${i}`);
+  });
+  tracks.slice(0, hangRenditions).forEach((t, ti) => {
+    const view2 = t;
+    if (!Array.isArray(view2["fec"]))
+      return;
+    view2["fec"].forEach((o, ii) => {
+      const repairTrack = recordOf(o)?.["repairTrack"];
+      if (typeof repairTrack !== "string" || named.has(repairTrack))
+        return;
+      named.add(repairTrack);
+      const instanceId = recordOf(o)?.["instanceId"];
+      tracks.push({ name: repairTrack, packaging: "fec-repair", source: view2["name"], ...instanceId === void 0 ? {} : { instanceId } });
+      pointers.push(`${pointers[ti]}/fec/${ii}/repairTrack`);
+    });
+  });
+  return { tracks, pointers };
+}
+function resolveFecBindings(catalog, receiver = RUNTIME_FEC_RECEIVER) {
+  const { tracks, pointers } = fecCatalogTracks(catalog);
+  const report = validateFecCatalog({ tracks }, receiver);
+  const 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/mfu-reassembler.ts
 function fragmentProvenance(fragment) {
   if (fragment.deliveryProvenance !== void 0) return fragment.deliveryProvenance;
@@ -6279,321 +6738,6 @@ if (void 0) {
   });
 }
 
-// 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
 var VALID_ROLE_SUFFIXES = /* @__PURE__ */ new Set(["base", "delta", "repair"]);
 function parseTrackRole(trackName) {
@@ -6633,18 +6777,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;
-}
 function isMulticastTrackObject(obj) {
   if (typeof obj !== "object" || obj === null) return false;
   const o = obj;
@@ -6805,7 +6937,7 @@ function validateCmsfMmtpCatalog(value, options = {}) {
   }
   const tracks = catalog["tracks"];
   const trackRecords = [];
-  const positiveInteger3 = (input) => Number.isSafeInteger(input) && input > 0;
+  const positiveInteger2 = (input) => Number.isSafeInteger(input) && input > 0;
   const positiveNumber2 = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
   for (let index = 0; index < tracks.length; index++) {
     const raw = tracks[index];
@@ -6837,7 +6969,7 @@ function validateCmsfMmtpCatalog(value, options = {}) {
       );
     }
     const codec = track["codec"];
-    if (packaging !== "timeline" && packaging !== "mediatimeline" && packaging !== "eventtimeline" && packaging !== "fec-repair" && (typeof codec !== "string" || codec.length === 0)) {
+    if (packaging !== "timeline" && packaging !== "mediatimeline" && packaging !== "eventtimeline" && packaging !== "fec-repair" && packaging !== "fec-source" && (typeof codec !== "string" || codec.length === 0)) {
       catalogError("track_codec", `${path}.codec`, `codec is required for packaging=${packaging}`);
     }
     const timescale = track["timescale"];
@@ -6845,13 +6977,13 @@ function validateCmsfMmtpCatalog(value, options = {}) {
     const groupDurationTicks = track["groupDurationTicks"];
     const keyframeIntervalMs = track["keyframeIntervalMs"];
     const keyframeIntervalTicks = track["keyframeIntervalTicks"];
-    if (groupDurationMs !== void 0 && !positiveInteger3(groupDurationMs)) {
+    if (groupDurationMs !== void 0 && !positiveInteger2(groupDurationMs)) {
       catalogError("track_group_duration_ms", `${path}.groupDurationMs`, "must be a positive integer");
     }
-    if (groupDurationTicks !== void 0 && !positiveInteger3(groupDurationTicks)) {
+    if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
       catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
     }
-    if (keyframeIntervalMs !== void 0 && !positiveNumber2(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger3(keyframeIntervalTicks)) {
+    if (keyframeIntervalMs !== void 0 && !positiveNumber2(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
       catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
     }
     const anchor = track["presentationAnchorTicks"];
@@ -6862,17 +6994,11 @@ function validateCmsfMmtpCatalog(value, options = {}) {
     if (initRef !== void 0 && (typeof initRef !== "string" || initRef.length === 0)) {
       catalogError("track_init_ref", `${path}.initRef`, "must be a non-empty string");
     }
-    if (packaging === "fec-repair") {
-      rejectRepairTrackGeometry(path, track, catalogError);
-      validateRepairTrackFields(describeRepairTrack(name, path, track), catalogError);
-    } else {
-      rejectRepairFieldsOnMediaTrack(path, track, catalogError);
-    }
     if (packaging === "mmtp") {
       if (track["mmtpMode"] !== "mfu") {
         catalogError("track_mmtp_mode", `${path}.mmtpMode`, "must be mfu");
       }
-      if (!positiveInteger3(timescale)) {
+      if (!positiveInteger2(timescale)) {
         catalogError("track_timescale", `${path}.timescale`, "must be a positive integer");
       }
       if (groupDurationMs === void 0 && groupDurationTicks === void 0) {
@@ -6886,85 +7012,6 @@ function validateCmsfMmtpCatalog(value, options = {}) {
         catalogError("track_group_duration_exact", `${path}.groupDurationMs`, "does not resolve to an exact integer tick count");
       }
     }
-    if (track["fec"] !== void 0) {
-      const fec = track["fec"];
-      if (typeof fec !== "object" || fec === null || Array.isArray(fec)) {
-        catalogError("track_fec", `${path}.fec`, "FEC must be an object");
-      }
-      const config = fec;
-      const algorithm = config["algorithm"];
-      if (typeof algorithm !== "string" || algorithm.length === 0) {
-        catalogError("track_fec", `${path}.fec.algorithm`, "must be a non-empty string");
-      }
-      if ("interleaveDepth" in config || "interleaveMs" in config) {
-        catalogError("track_fec", `${path}.fec`, "interleaveDepthMs is the only supported interleave field");
-      }
-      if ("enhancementRepair" in config) {
-        catalogError(
-          "track_fec",
-          `${path}.fec.enhancementRepair`,
-          "repair layers are self-describing fec-repair tracks (depends, repairLayer); fec.enhancementRepair is not supported"
-        );
-      }
-      if (config["interleaveDepthMs"] !== void 0 && (!Number.isSafeInteger(config["interleaveDepthMs"]) || config["interleaveDepthMs"] < 0)) {
-        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a non-negative safe integer");
-      }
-      if (algorithm !== "none") {
-        for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
-          if (!positiveInteger3(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++) {
@@ -7333,8 +7380,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;
@@ -8501,7 +8552,7 @@ function string(value, path) {
   }
   return value;
 }
-function positiveInteger2(value, path) {
+function positiveInteger(value, path) {
   if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
     throw new Error(`${path} must be a positive integer`);
   }
@@ -8524,7 +8575,7 @@ function mpuSequenceNumber(value, path) {
   return parsed;
 }
 function port(value, path) {
-  const parsed = positiveInteger2(value, path);
+  const parsed = positiveInteger(value, path);
   if (parsed > 65535) throw new Error(`${path} must be between 1 and 65535`);
   return parsed;
 }
@@ -8605,11 +8656,11 @@ function validateDeliveryPolicy(value) {
     throw new Error("multicast.deliveryPolicy.missPolicy must be 'fail'");
   }
   return {
-    bufferWindowSegments: positiveInteger2(
+    bufferWindowSegments: positiveInteger(
       policy["bufferWindowSegments"],
       "multicast.deliveryPolicy.bufferWindowSegments"
     ),
-    requestTimeoutMs: positiveInteger2(policy["requestTimeoutMs"], "multicast.deliveryPolicy.requestTimeoutMs"),
+    requestTimeoutMs: positiveInteger(policy["requestTimeoutMs"], "multicast.deliveryPolicy.requestTimeoutMs"),
     missPolicy
   };
 }
@@ -8637,10 +8688,10 @@ function validateRouteBase(value, path, endpoints) {
       mediaObjectTemplate
     },
     fec: {
-      K: positiveInteger2(fec["K"], `${path}.fec.K`),
+      K: positiveInteger(fec["K"], `${path}.fec.K`),
       P: nonNegativeInteger(fec["P"], `${path}.fec.P`),
-      T: positiveInteger2(fec["T"], `${path}.fec.T`),
-      interleaveDepthMs: positiveInteger2(fec["interleaveDepthMs"], `${path}.fec.interleaveDepthMs`),
+      T: positiveInteger(fec["T"], `${path}.fec.T`),
+      interleaveDepthMs: positiveInteger(fec["interleaveDepthMs"], `${path}.fec.interleaveDepthMs`),
       blockProfile: parseFecBlockProfile(fec["blockProfile"], `${path}.fec.blockProfile`)
     }
   };
@@ -8693,13 +8744,13 @@ function validateRoutes(value, kind, endpoints) {
       if (repairTrack !== void 0 && (typeof repairTrack !== "string" || repairTrack.trim().length === 0)) {
         throw new Error(`${path}.mmtp.repairTrack must be a non-empty string when provided`);
       }
-      const mediaUnitsPerObject = positiveInteger2(mmtp["mediaUnitsPerObject"], `${path}.mmtp.mediaUnitsPerObject`);
+      const mediaUnitsPerObject = positiveInteger(mmtp["mediaUnitsPerObject"], `${path}.mmtp.mediaUnitsPerObject`);
       const firstMpuSequenceNumber = mpuSequenceNumber(
         mmtp["firstMpuSequenceNumber"],
         `${path}.mmtp.firstMpuSequenceNumber`
       );
       const firstObjectNumber = nonNegativeSafeInteger(mmtp["firstObjectNumber"], `${path}.mmtp.firstObjectNumber`);
-      const mpuSequencesPerObject = positiveInteger2(mmtp["mpuSequencesPerObject"], `${path}.mmtp.mpuSequencesPerObject`);
+      const mpuSequencesPerObject = positiveInteger(mmtp["mpuSequencesPerObject"], `${path}.mmtp.mpuSequencesPerObject`);
       if (mpuSequencesPerObject > mediaUnitsPerObject) {
         throw new Error(`${path}.mmtp.mpuSequencesPerObject must not exceed mediaUnitsPerObject`);
       }
@@ -8714,8 +8765,8 @@ function validateRoutes(value, kind, endpoints) {
           packetId,
           mode,
           codec: string(mmtp["codec"], `${path}.mmtp.codec`),
-          timescale: positiveInteger2(mmtp["timescale"], `${path}.mmtp.timescale`),
-          mediaUnitDurationTicks: positiveInteger2(
+          timescale: positiveInteger(mmtp["timescale"], `${path}.mmtp.timescale`),
+          mediaUnitDurationTicks: positiveInteger(
             mmtp["mediaUnitDurationTicks"],
             `${path}.mmtp.mediaUnitDurationTicks`
           ),
@@ -9217,6 +9268,7 @@ function getPhase14CatalogOverride() {
 function mergeOverrideIntoHangRenditions(catalog, override) {
   if (!override) return catalog;
   for (const track of override.tracks) {
+    if (track.packaging === "fec-repair") continue;
     const role = track.role === "audio" || track.name.startsWith("audio") ? "audio" : "video";
     const bagKey = role === "audio" ? "audio" : "video";
     const bag = catalog[bagKey] ?? { renditions: {}, priority: 1 };
@@ -9235,8 +9287,24 @@ function mergeOverrideIntoHangRenditions(catalog, override) {
     bag.renditions[track.name] = merged;
     catalog[bagKey] = bag;
   }
+  for (const track of override.tracks) {
+    if (track.packaging !== "fec-repair") continue;
+    const source = catalog["video"]?.renditions?.[track.source] ?? catalog["audio"]?.renditions?.[track.source];
+    if (!namesRepairTrack(source?.fec, track.name, track.instanceId)) continue;
+    const repair = catalog["repair"] ?? {};
+    repair.renditions ??= {};
+    const { name, packaging: _p, mmtpMode: _m, timescale: _t, groupDurationMs: _g, altGroup: _a, ...entry } = track;
+    repair.renditions[name] ??= entry;
+    catalog["repair"] = repair;
+  }
   return catalog;
 }
+function namesRepairTrack(fec, name, instanceId) {
+  const id = instanceId ?? 0;
+  return Array.isArray(fec) && fec.some(
+    (i) => typeof i === "object" && i !== null && (i.instanceId ?? 0) === id && i.repairTrack === name
+  );
+}
 function isPositiveInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value > 0;
 }
@@ -9253,7 +9321,11 @@ function mergeOverrideIntoCmsfTracks(tracks, override) {
   const existingAudioTrack = tracks.find(
     (t) => t.role === "audio" && typeof t.codec === "string" && t.codec.length > 0
   );
-  for (const ot of override.tracks) {
+  const ordered = [
+    ...override.tracks.filter((t) => t.packaging !== "fec-repair"),
+    ...override.tracks.filter((t) => t.packaging === "fec-repair")
+  ];
+  for (const ot of ordered) {
     const existing = byName.get(ot.name);
     if (existing !== void 0) {
       if (existing.fec === void 0 && ot.fec !== void 0) existing.fec = ot.fec;
@@ -9291,10 +9363,14 @@ function mergeOverrideIntoCmsfTracks(tracks, override) {
           `[phase14-catalog-override] track "${ot.name}" has no packaging \u2014 supply per-track or set top-level streamingFormat`
         );
       }
-      const role = ot.role ?? (ot.name.endsWith("/repair") ? void 0 : "video");
+      const isRepair = packaging === "fec-repair";
+      if (isRepair && !namesRepairTrack(byName.get(ot.source)?.fec, ot.name, ot.instanceId)) {
+        continue;
+      }
+      const role = ot.role ?? (isRepair ? void 0 : "video");
       const inheritedCodec = role === "audio" ? existingAudioTrack?.codec : existingVideoTrack?.codec;
       const codec = ot.codec ?? inheritedCodec;
-      if (packaging !== "timeline" && (typeof codec !== "string" || codec.length === 0)) {
+      if (packaging !== "timeline" && !isRepair && (typeof codec !== "string" || codec.length === 0)) {
         throw new Error(
           `[phase14-catalog-override] track "${ot.name}" has no codec (packaging='${packaging}') \u2014 supply per-track or ensure the publisher catalog has a ${role ?? "video"} track to inherit from`
         );
@@ -9315,14 +9391,13 @@ function mergeOverrideIntoCmsfTracks(tracks, override) {
           `[phase14-catalog-override] track "${ot.name}" has packaging='mmtp' but no valid groupDurationMs`
         );
       }
-      const entry = {
-        name: ot.name,
-        packaging,
-        codec
-      };
-      if (mmtpMode !== void 0) entry.mmtpMode = mmtpMode;
-      if (ot.timescale !== void 0) entry.timescale = ot.timescale;
-      if (ot.groupDurationMs !== void 0) entry.groupDurationMs = ot.groupDurationMs;
+      const entry = { name: ot.name, packaging };
+      if (codec !== void 0 && !isRepair) entry.codec = codec;
+      if (ot.source !== void 0) entry["source"] = ot.source;
+      if (ot.instanceId !== void 0) entry["instanceId"] = ot.instanceId;
+      if (mmtpMode !== void 0 && !isRepair) entry.mmtpMode = mmtpMode;
+      if (ot.timescale !== void 0 && !isRepair) entry.timescale = ot.timescale;
+      if (ot.groupDurationMs !== void 0 && !isRepair) entry.groupDurationMs = ot.groupDurationMs;
       if (role !== void 0) entry.role = role;
       if (ot.framerate !== void 0) entry.framerate = ot.framerate;
       if (ot.fec !== void 0) entry.fec = ot.fec;
@@ -12781,13 +12856,8 @@ var INACTIVE = Object.freeze({
 function recordOf2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function isPositiveSafeInteger2(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-function catalogDeclaresFec(fec) {
-  const block = recordOf2(fec);
-  if (block === void 0 || block["algorithm"] === "none" || fecAlgorithmUnimplemented(block["algorithm"])) return false;
-  return isPositiveSafeInteger2(block["sourceSymbols"]) && isPositiveSafeInteger2(block["symbolSize"]) && isFecBlockProfile(block["blockProfile"]) && isoBlockSpanUsable(block) && !catalogFecDeclaresUnconfigurableInstance(block);
+function catalogDeclaresFec(catalog, track) {
+  return resolveFecBindings(catalog).get(track)?.status === "ok";
 }
 function requireBoolean(value, field) {
   if (typeof value !== "boolean") {
@@ -12881,10 +12951,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);
@@ -12919,11 +12989,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;
@@ -12943,16 +13013,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;
@@ -13068,15 +13138,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) {
@@ -13135,13 +13205,13 @@ var BlockClassifier = class {
           if (compareDataUnitStarts(starts[mid], start) < 0) lo = mid + 1;
           else hi = mid;
         }
-        const at = starts[lo];
-        if (at !== void 0 && compareDataUnitStarts(at, start) === 0) {
-          if (at.sbn !== sbn) return true;
+        const at2 = starts[lo];
+        if (at2 !== void 0 && compareDataUnitStarts(at2, start) === 0) {
+          if (at2.sbn !== sbn) return true;
         } else {
           const before = starts[lo - 1];
           if (before !== void 0 && before.sbn > sbn) return true;
-          if (at !== void 0 && at.sbn < sbn) return true;
+          if (at2 !== void 0 && at2.sbn < sbn) return true;
           insertAt = lo;
         }
       }
@@ -13192,11 +13262,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";
       }
     }
@@ -14594,15 +14664,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);
@@ -14850,8 +14920,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());
@@ -19210,12 +19280,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();
@@ -19439,11 +19509,11 @@ function isStream(meta, stream) {
   return meta.packetId === stream.packetId && meta.catalogTrackName === stream.catalogTrackName;
 }
 function comparePresentation(a, b) {
-  const at = a.authoredTiming;
+  const at2 = a.authoredTiming;
   const bt = b.authoredTiming;
-  if (at !== void 0 && bt !== void 0) {
-    const left = at.presentationTime * BigInt(bt.mediaTimescale);
-    const right = bt.presentationTime * BigInt(at.mediaTimescale);
+  if (at2 !== void 0 && bt !== void 0) {
+    const left = at2.presentationTime * BigInt(bt.mediaTimescale);
+    const right = bt.presentationTime * BigInt(at2.mediaTimescale);
     return left < right ? -1 : left > right ? 1 : 0;
   }
   return a.timestamp - b.timestamp;
@@ -19622,8 +19692,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
@@ -19886,11 +19954,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;
@@ -20067,20 +20134,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);
   }
@@ -21480,16 +21537,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.
@@ -22989,6 +23045,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;
@@ -23035,7 +23095,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;
@@ -23060,6 +23121,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.
@@ -23081,9 +23147,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();
@@ -23092,6 +23164,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") {
@@ -23133,7 +23206,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;
@@ -23143,7 +23217,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;
@@ -23234,13 +23308,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;
   }
@@ -23281,11 +23355,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) {
-    if (this.#disposed) return;
+  /**
+   * 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();
   }
@@ -23435,6 +23513,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;
@@ -23597,11 +23679,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++;
@@ -23612,14 +23699,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;
@@ -23690,6 +23778,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);
   }
@@ -26440,7 +26529,7 @@ function catalogAmtNetworkSource(networkSource) {
   }
   return void 0;
 }
-function intIn(value, min, max) {
+function intIn2(value, min, max) {
   return Number.isInteger(value) && value >= min && value <= max;
 }
 function catalogAtsc3NetworkSource(networkSource) {
@@ -26448,330 +26537,18 @@ function catalogAtsc3NetworkSource(networkSource) {
   for (const raw of entries) {
     if (!raw || typeof raw !== "object") continue;
     const ns = raw;
-    if (ns.type !== "atsc3" || !intIn(ns.frequency, 1, Number.MAX_SAFE_INTEGER)) continue;
+    if (ns.type !== "atsc3" || !intIn2(ns.frequency, 1, Number.MAX_SAFE_INTEGER)) continue;
     const slsUri = typeof ns.slsUri === "string" ? ns.slsUri.trim() : "";
     return {
       frequency: ns.frequency,
-      ...intIn(ns.plpId, 0, 63) ? { plpId: ns.plpId } : {},
-      ...intIn(ns.serviceId, 0, 65535) ? { serviceId: ns.serviceId } : {},
+      ...intIn2(ns.plpId, 0, 63) ? { plpId: ns.plpId } : {},
+      ...intIn2(ns.serviceId, 0, 65535) ? { serviceId: ns.serviceId } : {},
       ...slsUri ? { slsUri } : {}
     };
   }
   return void 0;
 }
 
-// src/catalog-fec-params.ts
-var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
-function timescaleHz(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
-}
-function catalogGroupDurationMs(rendition) {
-  if (!rendition) return void 0;
-  const ticks = numericField(rendition.groupDurationTicks);
-  const ms = numericField(rendition.groupDurationMs);
-  const timescale = timescaleHz(rendition.container?.kind === "mmtp" ? rendition.container.timescale : void 0) ?? timescaleHz(rendition.timescale);
-  if (ticks !== void 0 && timescale !== void 0 && Number.isSafeInteger(ticks) && ticks <= timescale * MAX_SAFE_TICKS_PER_HZ) {
-    return resolveGroupDurationMs({ groupDurationTicks: ticks }, timescale);
-  }
-  return ms;
-}
-function resolveCatalogTrackGroupDurationMs(catalog, track) {
-  const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
-  return catalogGroupDurationMs(renditions?.[track.name]);
-}
-function positiveNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function catalogKeyframeCadenceMs(rendition) {
-  if (!rendition) return void 0;
-  const timescale = positiveNumber(rendition.timescale);
-  const ticksToMs = (ticks) => {
-    const value = positiveNumber(ticks);
-    return value !== void 0 && timescale !== void 0 ? value * 1e3 / timescale : void 0;
-  };
-  return ticksToMs(rendition.keyframeIntervalTicks) ?? positiveNumber(rendition.keyframeIntervalMs) ?? ticksToMs(rendition.keyframeDurationTicks) ?? positiveNumber(rendition.keyframeDurationMs) ?? ticksToMs(rendition.gopDurationTicks) ?? positiveNumber(rendition.gopDurationMs);
-}
-function catalogFecMediaUnitsPerSecond(type, rendition, endpointSampleRate) {
-  if (type === "video") return positiveNumber(rendition?.framerate);
-  const sampleRate = positiveNumber(endpointSampleRate ?? rendition?.sampleRate ?? rendition?.timescale);
-  return sampleRate === void 0 ? void 0 : sampleRate / 1024;
-}
-var NO_FEC = {
-  fecK: 0,
-  fecRepairCount: 0,
-  fecTotalRepairCount: 0,
-  fecSymbolSize: 0,
-  fecInterleaveMs: 0
-};
-function joinedRepairSymbolCount(params, joinedRepairTrackNames) {
-  const layers = params.repairLayers;
-  if (layers === void 0 || layers.length === 0) return params.fecRepairCount;
-  const joined = new Set(joinedRepairTrackNames);
-  let total = 0;
-  for (const layer of layers) {
-    if (joined.has(layer.repairTrackName)) total += layer.repairSymbols;
-  }
-  return total;
-}
-function recordOf3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function msfTracks(catalog) {
-  const raw = catalog.tracks;
-  if (!Array.isArray(raw)) return void 0;
-  return { tracks: raw.map((t) => recordOf3(t) ?? {}) };
-}
-function resolveRepairLayers(catalog, source) {
-  if (!catalog) return void 0;
-  const sourceName = typeof source === "string" ? source : source.name;
-  const hang = catalog;
-  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "audio" ? ["audio"] : source.type === "video" ? ["video"] : ["video", "audio"];
-  const located = locateCatalogFecSource(catalog, sourceName, roles);
-  if (located?.dialect === "hang") {
-    const renditionPath = `$.${located.role}.renditions[${JSON.stringify(sourceName)}]`;
-    const rendition = located.entry;
-    rejectRepairFieldsOnMediaTrack(renditionPath, rendition, throwRepairContractError);
-    const repairRenditions = recordOf3(hang.repair?.renditions) ?? {};
-    const descriptors2 = Object.entries(repairRenditions).map(([name, entry]) => {
-      const path = `$.repair.renditions[${JSON.stringify(name)}]`;
-      const fields = recordOf3(entry);
-      if (fields === void 0) {
-        throwRepairContractError("track_repair_layer", path, "a repair rendition must be an object");
-      }
-      rejectRepairTrackGeometry(path, fields, throwRepairContractError);
-      return describeRepairTrack(name, path, fields);
-    });
-    const fecOfRendition = (entry) => {
-      const fec2 = recordOf3(recordOf3(entry)?.["fec"]);
-      return fec2 !== void 0 && fec2["algorithm"] !== "none" ? fec2 : void 0;
-    };
-    const mediaRenditions = [
-      ...Object.values(recordOf3(hang.video?.renditions) ?? {}),
-      ...Object.values(recordOf3(hang.audio?.renditions) ?? {})
-    ];
-    const reachability2 = repairReachability(mediaRenditions.map((entry) => recordOf3(entry)?.["fec"]));
-    for (const d of descriptors2) {
-      validateRepairTrackFields(d, throwRepairContractError);
-      assertRepairTrackReachable(d, reachability2, throwRepairContractError);
-      const target = dependsTarget(d);
-      if (target === void 0) continue;
-      const targetFec = fecOfRendition(hang.video?.renditions?.[target]) ?? fecOfRendition(hang.audio?.renditions?.[target]);
-      if (targetFec === void 0) {
-        throwRepairContractError(
-          "track_repair_depends",
-          `${d.path}.depends`,
-          `${JSON.stringify(target)} is not a video or audio rendition with FEC`
-        );
-      }
-    }
-    const layers2 = assembleRepairLayers(
-      geometryOf(sourceName, `${renditionPath}.fec`, recordOf3(rendition["fec"])),
-      descriptors2,
-      throwRepairContractError
-    );
-    return catalogFecUnavailable(rendition["fec"], `${renditionPath}.fec`) === void 0 ? layers2 : void 0;
-  }
-  const msf = msfTracks(catalog);
-  if (!msf || located?.dialect !== "msf") return void 0;
-  const msfIndex = located.index;
-  const track = msf.tracks[msfIndex];
-  const fec = recordOf3(track["fec"]);
-  const packagingOf = (t) => t["packaging"];
-  const fecOfTrack = (t) => {
-    const trackFec = recordOf3(t?.["fec"]);
-    return trackFec !== void 0 && trackFec["algorithm"] !== "none" ? trackFec : void 0;
-  };
-  const descriptors = [];
-  const mediaTracks = [];
-  msf.tracks.forEach((t, i) => {
-    const path = `$.tracks[${i}]`;
-    if (packagingOf(t) === "fec-repair") {
-      rejectRepairTrackGeometry(path, t, throwRepairContractError);
-      if (typeof t["name"] === "string") descriptors.push(describeRepairTrack(t["name"], path, t));
-      return;
-    }
-    rejectRepairFieldsOnMediaTrack(path, t, throwRepairContractError);
-    mediaTracks.push(t);
-  });
-  const reachability = repairReachability(mediaTracks.map((t) => t["fec"]));
-  for (const d of descriptors) {
-    validateRepairTrackFields(d, throwRepairContractError);
-    assertRepairTrackReachable(d, reachability, throwRepairContractError);
-    const target = dependsTarget(d);
-    if (target === void 0) continue;
-    const targetTrack = msf.tracks.find((t) => t["name"] === target);
-    if (targetTrack === void 0 || packagingOf(targetTrack) !== "mmtp" || fecOfTrack(targetTrack) === void 0) {
-      throwRepairContractError(
-        "track_repair_depends",
-        `${d.path}.depends`,
-        `${JSON.stringify(target)} is not an mmtp track with FEC`
-      );
-    }
-  }
-  const layers = assembleRepairLayers(
-    geometryOf(sourceName, `$.tracks[${msfIndex}].fec`, fec),
-    descriptors,
-    throwRepairContractError,
-    { layerZeroMustBeDeclared: true }
-  );
-  return catalogFecUnavailable(fec, `$.tracks[${msfIndex}].fec`) === void 0 ? layers : void 0;
-}
-function moqtPriority2(value) {
-  return Number.isSafeInteger(value) && value >= 0 && value <= 255 ? value : null;
-}
-function catalogRepairTarget(catalog, source) {
-  const repair = resolveRepairLayers(catalog, source);
-  const layerZero = repair?.baseLayers[0];
-  if (!catalog || !layerZero) return null;
-  const sourceName = typeof source === "string" ? source : source.name;
-  const msf = msfTracks(catalog);
-  const entry = msf?.tracks.find((t) => t["name"] === sourceName);
-  const hang = catalog;
-  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "video" ? ["video"] : source.type === "audio" ? ["audio"] : ["video", "audio"];
-  const rendition = roles.map((role) => hang[role]?.renditions?.[sourceName]).find((r) => recordOf3(r) !== void 0);
-  const fec = rendition === void 0 ? recordOf3(entry?.["fec"]) : recordOf3(rendition.fec);
-  if (!fec || !(catalogFecInterleaveMs(fec) ?? 0)) return null;
-  const sourcePriority = entry === void 0 ? null : moqtPriority2(entry["priority"]);
-  return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
-}
-function geometryOf(name, path, fec) {
-  return {
-    name,
-    path,
-    algorithm: fec?.["algorithm"],
-    sourceSymbols: fec?.["sourceSymbols"],
-    repairSymbols: fec?.["repairSymbols"],
-    repairTrack: fec?.["repairTrack"]
-  };
-}
-function numericField(value) {
-  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
-  return Number.isFinite(n) && n > 0 ? n : void 0;
-}
-function nonNegativeField(value) {
-  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
-  return Number.isFinite(n) && n >= 0 ? n : void 0;
-}
-function blockProfileUnavailable(value, path, declaresFecInstance) {
-  try {
-    readFecBlockProfile(value, path, declaresFecInstance, throwRepairContractError);
-    return void 0;
-  } catch (error) {
-    if (!(error instanceof RepairContractError) || error.code !== "track_fec_block_profile" && error.code !== "track_fec_block_profile_unimplemented") {
-      throw error;
-    }
-    return Object.freeze({ code: error.code, path: error.path, message: error.message });
-  }
-}
-function isoSpanUnavailable(fec, path, declaresFecInstance) {
-  if (!declaresFecInstance || isoBlockSpanUsable(fec)) return void 0;
-  return Object.freeze({
-    code: "track_fec",
-    path,
-    message: `[repair-layers:track_fec] ${path}: must be a non-negative safe integer in milliseconds`
-  });
-}
-function catalogFecUnavailable(fec, fecPath) {
-  if (catalogFecAvailable(fec)) return void 0;
-  const block = recordOf3(fec);
-  if (fecAlgorithmUnimplemented(block["algorithm"])) {
-    return Object.freeze({
-      code: "track_fec_algorithm_unimplemented",
-      path: `${fecPath}.algorithm`,
-      message: `algorithm ${JSON.stringify(block["algorithm"])} is not implemented: the track plays without FEC`
-    });
-  }
-  const declaresFecInstance = block["algorithm"] !== "none";
-  const reason = blockProfileUnavailable(block["blockProfile"], `${fecPath}.blockProfile`, declaresFecInstance) ?? isoSpanUnavailable(block, `${fecPath}.interleaveDepthMs`, declaresFecInstance);
-  if (reason === void 0) {
-    throw new Error(`catalogFecUnavailable: ${fecPath} is unavailable but no reason applies (rule drift)`);
-  }
-  return reason;
-}
-function fecParams(catalog, track, rendition, fps, sampleRate) {
-  const mediaRate = sampleRate === void 0 ? { fps } : { fps, sampleRate };
-  const fec = rendition?.fec;
-  if (!fec || !track) return { ...NO_FEC, ...mediaRate };
-  const repair = resolveRepairLayers(catalog, track);
-  const fecPath = `$.${track.type}.renditions[${JSON.stringify(track.name)}].fec`;
-  if (!catalogDeclaresFec(fec)) {
-    if (catalogFecDeclaresUnconfigurableInstance(fec)) {
-      const kValid = Number.isSafeInteger(fec.sourceSymbols) && (fec.sourceSymbols ?? 0) > 0;
-      throwRepairContractError(
-        "track_fec",
-        `${fecPath}.${kValid ? "symbolSize" : "sourceSymbols"}`,
-        kValid && Number.isSafeInteger(fec.symbolSize) && (fec.symbolSize ?? 0) > 0 ? `iso-ssbg1-v1 symbolSize must be at least ${ISO_SSBG1_MIN_SYMBOL_SIZE}` : "must be a positive integer"
-      );
-    }
-    const fecUnavailable = catalogFecUnavailable(fec, fecPath);
-    return fecUnavailable === void 0 ? { ...NO_FEC, ...mediaRate } : { ...NO_FEC, ...mediaRate, fecUnavailable };
-  }
-  const fecBlockProfile = readFecBlockProfile(fec.blockProfile, `${fecPath}.blockProfile`, true, throwRepairContractError);
-  return {
-    fecK: fec.sourceSymbols ?? 0,
-    fecAlgorithm: fec.algorithm === "reed-solomon" ? "reed-solomon" : "raptorq",
-    fecBlockProfile,
-    fecRepairCount: fec.repairSymbols ?? 0,
-    // The wire RSB_length: every base layer's packets carry the base total (§7.1).
-    fecTotalRepairCount: repair?.totalBaseRepairSymbols ?? fec.repairSymbols ?? 0,
-    fecSymbolSize: fec.symbolSize ?? 0,
-    // Zero/absence leaves the elapsed deadline unknown; geometry stays in-band.
-    fecInterleaveMs: catalogFecInterleaveMs(fec) ?? 0,
-    // Additive, never a multiplier on the span: jitter belongs to the network
-    // path and the span belongs to the encoder, so scaling one by the other
-    // hands one network different slack per track. `numericField` rejects 0,
-    // so it cannot be reused here — a declared 0 is a legitimate value.
-    fecReorderToleranceMs: nonNegativeField(fec.reorderToleranceMs),
-    repairTrackName: fec.repairTrack,
-    repairLayers: repair?.baseLayers,
-    repairOverlays: repair?.overlays,
-    ...mediaRate
-  };
-}
-function resolveCatalogTrackFec(catalog, tracks) {
-  const videoTrackName = tracks.find((t) => t.type === "video")?.name;
-  const audioTrackName = tracks.find((t) => t.type === "audio")?.name;
-  const videoRenditions = catalog?.video?.renditions;
-  const audioRenditions = catalog?.audio?.renditions;
-  const video = videoTrackName ? videoRenditions?.[videoTrackName] : void 0;
-  const audio = audioTrackName ? audioRenditions?.[audioTrackName] : void 0;
-  const catalogFps = numericField(video?.framerate);
-  const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
-  const audioFps = sampleRate ? sampleRate / 1024 : void 0;
-  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, video, catalogFps);
-  const audioParams = fecParams(
-    catalog,
-    audioTrackName ? { name: audioTrackName, type: "audio" } : void 0,
-    audio,
-    audioFps,
-    sampleRate
-  );
-  const forTrack = (track) => {
-    if (track.type === "audio") {
-      if (track.name === audioTrackName) return audioParams;
-      const rendition2 = audioRenditions?.[track.name];
-      if (!rendition2) return { ...NO_FEC };
-      const rate = numericField(rendition2.sampleRate ?? rendition2.samplerate);
-      return fecParams(catalog, { name: track.name, type: "audio" }, rendition2, rate ? rate / 1024 : void 0, rate);
-    }
-    if (track.name === videoTrackName) return videoParams;
-    const rendition = videoRenditions?.[track.name];
-    if (!rendition) return { ...NO_FEC };
-    return fecParams(catalog, { name: track.name, type: "video" }, rendition, numericField(rendition.framerate));
-  };
-  return {
-    videoTrackName,
-    audioTrackName,
-    missingVideoRendition: videoTrackName && videoRenditions && !video ? videoTrackName : void 0,
-    missingAudioRendition: audioTrackName && audioRenditions && !audio ? audioTrackName : void 0,
-    videoForKeyframeRepair: video,
-    catalogFps,
-    video: videoParams,
-    audio: audioParams,
-    forTrack
-  };
-}
-
 // src/multicast-manager.ts
 function freezeIngress(tracks, flow) {
   return Object.freeze({
@@ -27128,20 +26905,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;
@@ -27567,7 +27349,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,
@@ -27584,7 +27366,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);
@@ -27704,10 +27486,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);
   }
@@ -27931,15 +27709,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,
@@ -28218,8 +28002,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
@@ -28252,20 +28036,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
@@ -28273,32 +28055,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) ?? []) {
@@ -28344,15 +28115,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) {
@@ -28423,11 +28187,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);
@@ -28469,14 +28234,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);
@@ -29503,33 +29265,44 @@ var MediaRouter = class {
 };
 
 // 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 recordOf3 = (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)] : recordOf3(cur)?.[key];
+  }
+  return recordOf3(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(recordOf3).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;
 
 // src/align.ts
 function secondsFromTicks(ticks, timescale) {
@@ -30578,6 +30351,187 @@ var CmcdProducer = class {
   }
 };
 
+// src/repair-layers.ts
+var REPAIR_PRIORITY_MIN = 192;
+var REPAIR_PRIORITY_MAX = 255;
+var DEFAULT_REPAIR_PRIORITY = 240;
+var MAX_RAPTORQ_SOURCE_SYMBOLS = 56403;
+var MAX_REPAIR_SYMBOLS = 16777215;
+var MAX_ENCODING_SYMBOL_ID = 16777215;
+
+// src/catalog-fec-params.ts
+var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
+function timescaleHz(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function catalogGroupDurationMs(rendition) {
+  if (!rendition) return void 0;
+  const ticks = numericField(rendition.groupDurationTicks);
+  const ms = numericField(rendition.groupDurationMs);
+  const timescale = timescaleHz(rendition.container?.kind === "mmtp" ? rendition.container.timescale : void 0) ?? timescaleHz(rendition.timescale);
+  if (ticks !== void 0 && timescale !== void 0 && Number.isSafeInteger(ticks) && ticks <= timescale * MAX_SAFE_TICKS_PER_HZ) {
+    return resolveGroupDurationMs({ groupDurationTicks: ticks }, timescale);
+  }
+  return ms;
+}
+function resolveCatalogTrackGroupDurationMs(catalog, track) {
+  const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
+  return catalogGroupDurationMs(renditions?.[track.name]);
+}
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function catalogKeyframeCadenceMs(rendition) {
+  if (!rendition) return void 0;
+  const timescale = positiveNumber(rendition.timescale);
+  const ticksToMs = (ticks) => {
+    const value = positiveNumber(ticks);
+    return value !== void 0 && timescale !== void 0 ? value * 1e3 / timescale : void 0;
+  };
+  return ticksToMs(rendition.keyframeIntervalTicks) ?? positiveNumber(rendition.keyframeIntervalMs) ?? ticksToMs(rendition.keyframeDurationTicks) ?? positiveNumber(rendition.keyframeDurationMs) ?? ticksToMs(rendition.gopDurationTicks) ?? positiveNumber(rendition.gopDurationMs);
+}
+function catalogFecMediaUnitsPerSecond(type, rendition, endpointSampleRate) {
+  if (type === "video") return positiveNumber(rendition?.framerate);
+  const sampleRate = positiveNumber(endpointSampleRate ?? rendition?.sampleRate ?? rendition?.timescale);
+  return sampleRate === void 0 ? void 0 : sampleRate / 1024;
+}
+var NO_FEC = {
+  fecK: 0,
+  fecRepairCount: 0,
+  fecTotalRepairCount: 0,
+  fecSymbolSize: 0,
+  fecInterleaveMs: 0
+};
+function joinedRepairSymbolCount(params, joinedRepairTrackNames) {
+  const layers = params.repairLayers;
+  if (layers === void 0 || layers.length === 0) return params.fecRepairCount;
+  const joined = new Set(joinedRepairTrackNames);
+  let total = 0;
+  for (const layer of layers) {
+    if (joined.has(layer.repairTrackName)) total += layer.repairSymbols;
+  }
+  return total;
+}
+function bindingOf(catalog, source) {
+  if (!catalog) return void 0;
+  const name = typeof source === "string" ? source : source.name;
+  const binding = resolveFecBindings(catalog).get(name);
+  if (binding === void 0 || typeof source === "string") return binding;
+  const role = binding.pointer.split("/")[1];
+  return role === "tracks" || role === source.type ? binding : void 0;
+}
+function catalogTrackFecUnavailable(catalog, source) {
+  const binding = bindingOf(catalog, source);
+  return binding?.status === "unavailable" ? binding.reason : void 0;
+}
+function resolveRepairLayers(catalog, source) {
+  const binding = bindingOf(catalog, source);
+  if (binding?.status !== "ok") return void 0;
+  const overlays = binding.overlay ? [
+    {
+      repairTrackName: binding.overlay.repairTrackName,
+      scope: "keyframe",
+      sourceSymbols: binding.overlay.sourceSymbols,
+      repairSymbols: binding.overlay.repairSymbols,
+      priority: binding.overlay.priority
+    }
+  ] : [];
+  return {
+    sourceTrackName: binding.track,
+    baseLayers: binding.layers,
+    overlays,
+    totalBaseRepairSymbols: binding.totalBaseRepairSymbols
+  };
+}
+function moqtPriority2(value) {
+  return Number.isSafeInteger(value) && value >= 0 && value <= 255 ? value : null;
+}
+function catalogRepairTarget(catalog, source) {
+  const binding = bindingOf(catalog, source);
+  if (binding?.status !== "ok" || !(binding.base.interleaveDepthMs ?? 0)) return null;
+  const layerZero = binding.layers[0];
+  const m = /^\/tracks\/(\d+)$/.exec(binding.pointer);
+  const tracks = catalog.tracks;
+  const entry = m && Array.isArray(tracks) ? tracks[Number(m[1])] : void 0;
+  const sourcePriority = entry ? moqtPriority2(entry["priority"]) : null;
+  return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
+}
+function numericField(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function nonNegativeField(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function fecParams(catalog, track, fps, sampleRate) {
+  const mediaRate = sampleRate === void 0 ? { fps } : { fps, sampleRate };
+  const binding = track ? bindingOf(catalog, track) : void 0;
+  if (binding === void 0) return { ...NO_FEC, ...mediaRate };
+  if (binding.status === "unavailable") return { ...NO_FEC, ...mediaRate, fecUnavailable: binding.reason };
+  const { base } = binding;
+  const repair = resolveRepairLayers(catalog, track);
+  return {
+    fecK: base.sourceSymbols,
+    fecAlgorithm: base.scheme,
+    fecBlockProfile: parseFecBlockProfile(base.blockProfile, `${binding.pointer}/fec/blockProfile`),
+    fecRepairCount: base.repairSymbols,
+    // The wire RSB_length: every base layer's packets carry the base total.
+    fecTotalRepairCount: binding.totalBaseRepairSymbols,
+    fecSymbolSize: base.symbolSize,
+    // Zero/absence leaves the elapsed deadline unknown; geometry stays in-band.
+    fecInterleaveMs: catalogFecInterleaveMs(base) ?? 0,
+    // Additive to the span, never a multiplier; a declared 0 stays 0.
+    fecReorderToleranceMs: nonNegativeField(base.reorderToleranceMs),
+    repairTrackName: base.repairTrack,
+    repairLayers: repair.baseLayers,
+    repairOverlays: repair.overlays,
+    ...mediaRate
+  };
+}
+function resolveCatalogTrackFec(catalog, tracks) {
+  const videoTrackName = tracks.find((t) => t.type === "video")?.name;
+  const audioTrackName = tracks.find((t) => t.type === "audio")?.name;
+  const videoRenditions = catalog?.video?.renditions;
+  const audioRenditions = catalog?.audio?.renditions;
+  const video = videoTrackName ? videoRenditions?.[videoTrackName] : void 0;
+  const audio = audioTrackName ? audioRenditions?.[audioTrackName] : void 0;
+  const catalogFps = numericField(video?.framerate);
+  const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
+  const audioFps = sampleRate ? sampleRate / 1024 : void 0;
+  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, catalogFps);
+  const audioParams = fecParams(
+    catalog,
+    audioTrackName ? { name: audioTrackName, type: "audio" } : void 0,
+    audioFps,
+    sampleRate
+  );
+  const forTrack = (track) => {
+    if (track.type === "audio") {
+      if (track.name === audioTrackName) return audioParams;
+      const rendition2 = audioRenditions?.[track.name];
+      if (!rendition2) return { ...NO_FEC };
+      const rate = numericField(rendition2.sampleRate ?? rendition2.samplerate);
+      return fecParams(catalog, { name: track.name, type: "audio" }, rate ? rate / 1024 : void 0, rate);
+    }
+    if (track.name === videoTrackName) return videoParams;
+    const rendition = videoRenditions?.[track.name];
+    if (!rendition) return { ...NO_FEC };
+    return fecParams(catalog, { name: track.name, type: "video" }, numericField(rendition.framerate));
+  };
+  return {
+    videoTrackName,
+    audioTrackName,
+    missingVideoRendition: videoTrackName && videoRenditions && !video ? videoTrackName : void 0,
+    missingAudioRendition: audioTrackName && audioRenditions && !audio ? audioTrackName : void 0,
+    videoForKeyframeRepair: video,
+    catalogFps,
+    video: videoParams,
+    audio: audioParams,
+    forTrack
+  };
+}
+
 // src/mmtp-fec-session.ts
 var PATH_BITS = { moq: 1, multicast: 2 };
 var MIXED_PATHS = PATH_BITS.moq | PATH_BITS.multicast;
@@ -30615,20 +30569,20 @@ var MmtpFecSession = class {
     failClosed: null
   };
   /**
-   * @throws when the catalog block lacks or misstates a field the session
-   *   needs: the block profile, K, P_0 (`repairSymbols`), T, `interleaveDepthMs` or
-   *   `reorderToleranceMs`. None is defaulted.
+   * @throws when the instance lacks or misstates a field the session needs:
+   *   the scheme, the block profile, K, P_0 (`repairSymbols`), T,
+   *   `interleaveDepthMs` or `reorderToleranceMs`. None is defaulted.
    */
   constructor(config) {
     const fec = config?.fec;
     if (!fec || typeof fec !== "object") {
-      throw new Error("MmtpFecSession: the catalog fec block is required");
+      throw new Error("MmtpFecSession: the catalog fec instance is required");
     }
     this.blockProfile = parseFecBlockProfile(fec.blockProfile, "fec.blockProfile");
-    if (fec.algorithm !== void 0 && fec.algorithm !== "raptorq" && fec.algorithm !== "reed-solomon") {
-      throw new Error(`MmtpFecSession: fec.algorithm ${JSON.stringify(fec.algorithm)} is not implemented`);
+    if (fec.scheme !== "raptorq" && fec.scheme !== "reed-solomon") {
+      throw new Error(`MmtpFecSession: fec.scheme ${JSON.stringify(fec.scheme)} is not implemented`);
     }
-    this.algorithm = fec.algorithm === "reed-solomon" ? "reed-solomon" : "raptorq";
+    this.algorithm = fec.scheme;
     this.sourceSymbols = requirePositiveInteger(fec.sourceSymbols, "fec.sourceSymbols");
     this.repairSymbols = requirePositiveInteger(fec.repairSymbols, "fec.repairSymbols");
     this.symbolSize = requirePositiveInteger(fec.symbolSize, "fec.symbolSize");
@@ -31028,6 +30982,9 @@ function wireRepairFetch(mc, opts) {
   };
   const moot = (entry) => {
     if (entry.priority !== 0) return false;
+    const rttMs = readRtt();
+    const sentAt = entry.running?.sentAt ?? performance.now();
+    if (rttMs !== null && sentAt + rttMs < entry.playoutDeadlineAt) return false;
     const last = lastSsId(entry);
     if (last === void 0) return false;
     try {
@@ -31122,7 +31079,7 @@ function wireRepairFetch(mc, opts) {
       bound: entry.bound,
       ...entry.range ? { range: true } : {}
     });
-    const run = { controller: new AbortController(), stopped: null };
+    const run = { controller: new AbortController(), sentAt: now, stopped: null };
     entry.running = run;
     if (!entry.range) {
       mc.fecManager.holdBlockForRepair(
@@ -31281,6 +31238,10 @@ function wireRepairFetch(mc, opts) {
       );
       if (promotedDeadline !== null && promotedDeadline.deadlineAt > entry2.deadlineAt) {
         entry2.deadlineAt = promotedDeadline.deadlineAt;
+        entry2.playoutDeadlineAt = Math.max(
+          entry2.playoutDeadlineAt,
+          promotedDeadline.deadlineAt - promotedDeadline.extensionMs
+        );
         entry2.anchorAt = promotedDeadline.anchorAt;
         entry2.delayMs = promotedDeadline.delayMs;
         entry2.bound = promotedDeadline.bound;
@@ -31321,15 +31282,15 @@ function wireRepairFetch(mc, opts) {
     const retentionMs = mc.fecManager.terminalRetentionMsForPacket(packetId);
     if (retentionMs === void 0) return null;
     const ceilingAt = Math.min(anchor, earliestGatedFrameAt(packetId, catalogTrackName) ?? anchor) + retentionMs;
-    const at = (delay, delayBound) => {
+    const at2 = (delay, delayBound) => {
       const presentAt = Math.min(anchor + delay, ceilingAt);
       if (waitDeadlineAt >= presentAt) return { deadlineAt: waitDeadlineAt, bound: "wait" };
       return { deadlineAt: presentAt, bound: anchor + delay <= ceilingAt ? delayBound : "retention" };
     };
-    const base = at(delayMs, "presentation");
+    const base = at2(delayMs, "presentation");
     const budgetMs = keyframeBudgetEligible(blockClass, classifierMode(packetId, catalogTrackName)) && groupCanComplete(sbn, packetId, catalogTrackName) ? readKeyframeBudget(packetId, catalogTrackName) : null;
     if (budgetMs === null || budgetMs <= delayMs) return { ...base, extensionMs: 0, anchorAt: anchor, delayMs };
-    const extended = at(budgetMs, "keyframe");
+    const extended = at2(budgetMs, "keyframe");
     return {
       ...extended,
       extensionMs: extended.deadlineAt - base.deadlineAt,
@@ -31339,8 +31300,8 @@ function wireRepairFetch(mc, opts) {
   };
   const earliestGatedFrameAt = (packetId, catalogTrackName) => {
     try {
-      const at = mc.earliestGatedFrameAtMs?.(packetId, catalogTrackName);
-      return at !== void 0 && Number.isFinite(at) ? at : void 0;
+      const at2 = mc.earliestGatedFrameAtMs?.(packetId, catalogTrackName);
+      return at2 !== void 0 && Number.isFinite(at2) ? at2 : void 0;
     } catch {
       return void 0;
     }
@@ -31412,6 +31373,7 @@ function wireRepairFetch(mc, opts) {
       priority,
       subscriberPriority: wire.subscriberPriority,
       deadlineAt: deadline.deadlineAt,
+      playoutDeadlineAt: deadline.deadlineAt - deadline.extensionMs,
       anchorAt: deadline.anchorAt,
       delayMs: deadline.delayMs,
       bound: deadline.bound,
@@ -31481,6 +31443,7 @@ function wireRepairFetch(mc, opts) {
         priority,
         subscriberPriority: wire.subscriberPriority,
         deadlineAt: deadline.deadlineAt,
+        playoutDeadlineAt: deadline.deadlineAt - deadline.extensionMs,
         anchorAt: deadline.anchorAt,
         delayMs: deadline.delayMs,
         bound: deadline.bound,
@@ -31572,9 +31535,6 @@ export {
   REPAIR_LIFECYCLE_LOG_PREFIX,
   REPAIR_PRIORITY_MAX,
   REPAIR_PRIORITY_MIN,
-  REPAIR_TRACK_GEOMETRY_KEYS,
-  REPAIR_TRACK_ONLY_KEYS,
-  RepairContractError,
   SOURCE_MEDIA_PRIORITY_MAX,
   SampleCombineError,
   SampleCombiner,
@@ -31587,8 +31547,6 @@ export {
   annexBToAvcc,
   archiveOrigin,
   asSeconds,
-  assembleRepairLayers,
-  assertRepairTrackReachable,
   avccToAnnexB,
   buildAudioInitSegment,
   buildHevcVideoInitSegment,
@@ -31596,14 +31554,12 @@ export {
   catalogAmtNetworkSource,
   catalogAtsc3NetworkSource,
   catalogDeclaresFec,
-  catalogFecAvailable,
-  catalogFecDeclaresUnconfigurableInstance,
   catalogFecInterleaveMs,
   catalogFecMediaUnitsPerSecond,
-  catalogFecUnavailable,
   catalogGroupDurationMs,
   catalogKeyframeCadenceMs,
   catalogRepairTarget,
+  catalogTrackFecUnavailable,
   classifyH264Keyframe,
   classifyHevcKeyframe,
   classifyPacket,
@@ -31619,9 +31575,7 @@ export {
   decodeLocHeader,
   decodeLocTimestamp,
   decodeTimestamp,
-  dependsTarget,
   deriveBlockClassifierGeometry,
-  describeRepairTrack,
   detectH264Keyframe,
   detectHevcKeyframe,
   driftCheck,
@@ -31638,7 +31592,6 @@ export {
   extractHevcCodecDescription,
   extractHevcParameterSets,
   extractSpsPpsFromAvcC,
-  fecAlgorithmUnimplemented,
   findAnnexBStartCode,
   forwardRepairLifecycleEvents,
   frameSamplesFromInit,
@@ -31657,8 +31610,6 @@ export {
   isCompleteAvccSample,
   isCompleteFmp4DataUnit,
   isFecBlockProfile,
-  isFecCatalogConfig,
-  isFecCatalogGeometry,
   isFmp4InitSegment,
   isHevcCodec,
   isHevcIrapNalUnitType,
@@ -31672,7 +31623,6 @@ export {
   isTrackTimingConfig,
   joinedRepairSymbolCount,
   keyframeIntervalMediaTicks,
-  locateCatalogFecSource,
   mergeOverrideIntoCmsfTracks,
   mergeOverrideIntoHangRenditions,
   mfuReassemblyTimeoutMs,
@@ -31691,15 +31641,11 @@ export {
   parseOpusFrameSamples,
   prepareHevcCmafSample,
   processMMTPWithReassembly,
-  readFecBlockProfile,
-  rejectRepairFieldsOnMediaTrack,
-  rejectRepairTrackGeometry,
   reliableMoqMfuReassembly,
   removeEmulationPrevention,
   repairFetchRange,
   repairFetchSubscriberPriority,
   repairPriorityForClass,
-  repairReachability,
   resolveCatalogTrackFec,
   resolveCatalogTrackGroupDurationMs,
   resolveDeltaFallback,
@@ -31716,8 +31662,8 @@ export {
   splitH264SampleNalUnits,
   unwrapMulticastPacket,
   validateCmsfMmtpCatalog,
+  validateFecCatalog,
   validateMulticastContainerContract,
-  validateRepairTrackFields,
   validateSwitchingSetTiming,
   videoCodecFamily,
   videoConcealModeForCodec,