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

package/dist/fec-state.d.ts

@@ -1,6 +1,3 @@
-import { isoBlockSpanUsable } from '@blockcast/mmt-base';
-/** The optional elapsed-span rule lives in mmt-base beside the other catalog FEC rules. */
-export { isoBlockSpanUsable };
 /** Smallest positive catalog elapsed span; zero/absence means no elapsed deadline. */
 export declare const MIN_INTERLEAVE_DEPTH_MS = 1;
 /** Why FEC is not protecting this session. */
@@ -54,47 +51,12 @@ export interface FecStateEvidence<S extends object> {
     readonly multicastLegJoined: boolean;
 }
 /**
- * Whether one catalog `fec` block (a hang rendition's `fec` or an MSF/CMSF
- * track's `fec`) declares an FEC instance a receiver can configure: source
- * symbols per block (K) and a symbol size (T) are both positive integers, the
- * algorithm is neither `none` nor a token this receiver does not implement
- * (`fecAlgorithmUnimplemented`, draft-ramadan-moq-fec-01 4), `blockProfile` names the implemented profile
- * `iso-ssbg1-v1` (BLO-35597), and the block carries that profile's usable
- * span field (`isoBlockSpanUsable`); zero/absence still permits in-band FEC. Total: it never throws, and answers false for
- * any other value.
- *
- * `resolveCatalogTrackFec` reads this predicate, so the players' parameters and
- * this state never disagree. Of the blocks this rejects, it returns no FEC
- * geometry only for `algorithm: "none"`. One with any other algorithm is a
- * malformed catalog (`FecCatalogConfig` marks both fields REQUIRED; the MSF
- * schema and `validateCmsfMmtpCatalog` enforce them on `tracks[]`, but the
- * hang dialect's `renditions` schema is permissive, so this is where a hang
- * block fails closed), and `resolveCatalogTrackFec` throws a `RepairContractError` for
- * it (`track_fec` unless another repair-contract violation fires first),
- * whether or not the source has repair layers, rather than silently dropping
- * the track's repair subscription.
- *
- * The block profile is part of this predicate because the profile selects the
- * block math and is never defaulted: draft-ramadan-moq-fec §5.1 defines one,
- * `iso-ssbg1-v1`, and a receiver MUST NOT apply FEC under any other token. The
- * retired `k-padded-v1` is simply not a known profile. `resolveCatalogTrackFec`
- * and `MulticastManager.configureMultiTrack` resolve such a track to no FEC
- * with a typed `TrackFecUnavailable` reason (`catalogFecUnavailable`: code
- * `track_fec_block_profile_unimplemented` for an unimplemented token,
- * `track_fec_block_profile` for an absent one), scoped to that track, so their
- * parameters and this state still agree. The CMSF conformance validator
- * (`validateCmsfMmtpCatalog`) rejects the catalog with the same code. An
- * `iso-ssbg1-v1` instance with an invalid span is likewise unavailable for its
- * track alone. Zero or absence supplies no elapsed deadline and uses bounded
- * receiver-local state while decoding in-band FEC.
- *
- * The repair-contract resolvers (`resolveRepairLayers`) gate a `depends` target
- * on `algorithm` alone and never read a source's `symbolSize`. They check its
- * `sourceSymbols` for the RaptorQ K bound, and require a positive integer
- * `sourceSymbols` and `repairSymbols` only when the source has repair layers or
- * an overlay beyond layer 0.
+ * Whether the catalog gives the named source track FEC this receiver can run:
+ * its base instance is `ok` (`resolveFecBindings`, draft-ramadan-moq-fec-catalog-00).
+ * `resolveCatalogTrackFec` reads the same binding, so the players' parameters
+ * and this state never disagree. Total: never throws.
  */
-export declare function catalogDeclaresFec(fec: unknown): boolean;
+export declare function catalogDeclaresFec(catalog: unknown, track: string): boolean;
 /**
  * Resolve a player's FEC state. First match wins:
  *

package/dist/fec-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fec-state.d.ts","sourceRoot":"","sources":["../src/fec-state.ts"],"names":[],"mappings":"AAeA,OAAO,EAIL,kBAAkB,EACnB,MAAM,qBAAqB,CAAA;AAE5B,2FAA2F;AAC3F,OAAO,EAAE,kBAAkB,EAAE,CAAA;AAE7B,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,8CAA8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,cAAc,GAAG,qBAAqB,CAAA;AAEzF,kDAAkD;AAClD,eAAO,MAAM,oBAAoB,EAAE,SAAS,iBAAiB,EAIlD,CAAA;AAEX,4DAA4D;AAC5D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,UAAU,GAAG,gBAAgB,CAAA;AAIvE,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;CACnC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE/E,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAA;AAE7E,sEAAsE;AACtE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AAEhD,uDAAuD;AACvD,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,MAAM;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IACpC;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAA;IAC5C,gFAAgF;IAChF,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;CACrC;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAUxD;AASD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;AACrH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,aAAa,CAAC,CAAA"}
+{"version":3,"file":"fec-state.d.ts","sourceRoot":"","sources":["../src/fec-state.ts"],"names":[],"mappings":"AAiBA,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,8CAA8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,cAAc,GAAG,qBAAqB,CAAA;AAEzF,kDAAkD;AAClD,eAAO,MAAM,oBAAoB,EAAE,SAAS,iBAAiB,EAIlD,CAAA;AAEX,4DAA4D;AAC5D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,UAAU,GAAG,gBAAgB,CAAA;AAIvE,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;CACnC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE/E,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAA;AAE7E,sEAAsE;AACtE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AAEhD,uDAAuD;AACvD,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,MAAM;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IACpC;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAA;IAC5C,gFAAgF;IAChF,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;CACrC;AAcD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE3E;AASD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;AACrH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,aAAa,CAAC,CAAA"}

package/dist/fec-state.js

@@ -12,36 +12,537 @@ var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
 var FEC_BLOCK_PROFILES = Object.freeze([
   "iso-ssbg1-v1"
 ]);
-function isFecBlockProfile(value) {
-  return value === "iso-ssbg1-v1";
-}
 
-// ../mmt-base/dist/catalog-fec-source.js
-var ALL_ROLES = Object.freeze(["video", "audio"]);
-function recordOf(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function isoBlockSpanUsable(fec) {
-  const block = recordOf(fec);
-  if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1")
-    return true;
-  const ms = block["interleaveDepthMs"];
-  return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
+// ../mmt-base/dist/fec-catalog.js
+var DEFAULT_SCHEMES = ["reed-solomon", "raptorq"];
+var DEFAULT_PROFILES = ["moq-object-v1", "iso-ssbg1-v1"];
+var RS_MAX_BLOCK = 255;
+var RAPTORQ_MAX_K = 56403;
+var MAX_24 = 16777215;
+var ISO_MIN_T = 14;
+var GEOMETRY_KEYS = [
+  "scheme",
+  "blockProfile",
+  "mmtpMode",
+  "timescale",
+  "symbolSize",
+  "interleaveDepthMs",
+  "reorderToleranceMs",
+  "sourceSymbols",
+  "fec"
+];
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+var isInt = (v) => typeof v === "number" && Number.isInteger(v);
+var intIn = (v, lo, hi = Number.MAX_SAFE_INTEGER) => isInt(v) && v >= lo && v <= hi;
+var profileAdmits = (profile, packaging) => profile !== "iso-ssbg1-v1" || packaging === "mmtp";
+function validateFecCatalog(catalog, receiver = {}) {
+  const schemes = receiver.schemes ?? DEFAULT_SCHEMES;
+  const profiles = receiver.blockProfiles ?? DEFAULT_PROFILES;
+  const overlays = receiver.overlays ?? true;
+  const all = [];
+  const report = (code, path, inst) => {
+    const issue = { code, path };
+    all.push(issue);
+    inst?.issues.push(issue);
+  };
+  const tracks = isObj(catalog) && Array.isArray(catalog.tracks) ? catalog.tracks : [];
+  if (!isObj(catalog) || !Array.isArray(catalog.tracks))
+    report("fec_member", "/tracks");
+  let rejectAll = false;
+  tracks.forEach((t, ti) => {
+    if (!isObj(t))
+      return;
+    if (has(t, "enhancementRepair")) {
+      rejectAll = true;
+      report("fec_enhancement_repair", `/tracks/${ti}/enhancementRepair`);
+    }
+    if (Array.isArray(t.fec))
+      t.fec.forEach((o, ii) => {
+        if (isObj(o) && has(o, "enhancementRepair")) {
+          rejectAll = true;
+          report("fec_enhancement_repair", `/tracks/${ti}/fec/${ii}/enhancementRepair`);
+        }
+      });
+  });
+  const key = (ns, name) => JSON.stringify([ns ?? null, name]);
+  const byName = /* @__PURE__ */ new Map();
+  tracks.forEach((t, ti) => {
+    if (isObj(t) && typeof t.name === "string") {
+      const k = key(t.namespace, t.name);
+      if (!byName.has(k))
+        byName.set(k, ti);
+    }
+  });
+  const trackAt = (ti) => tracks[ti];
+  const insts = [];
+  tracks.forEach((t, ti) => {
+    if (!isObj(t) || !has(t, "fec") || t.packaging === "fec-repair" || t.packaging === "fec-source")
+      return;
+    if (!Array.isArray(t.fec)) {
+      report("fec_member", `/tracks/${ti}/fec`);
+      return;
+    }
+    t.fec.forEach((o, ii) => {
+      const path = `/tracks/${ti}/fec/${ii}`;
+      const inst = {
+        path,
+        ti,
+        track: t,
+        obj: isObj(o) ? o : null,
+        id: null,
+        unavailable: false,
+        overlay: false,
+        issues: [],
+        layer0: null,
+        symbolNamed: null,
+        attached: []
+      };
+      insts.push(inst);
+      if (!inst.obj)
+        return report("fec_member", path, inst);
+      const o2 = inst.obj;
+      if (!has(o2, "instanceId"))
+        inst.id = 0;
+      else if (intIn(o2.instanceId, 0, 255))
+        inst.id = o2.instanceId;
+      else
+        report("fec_member", `${path}/instanceId`, inst);
+      inst.overlay = has(o2, "scope");
+    });
+  });
+  const declaresFec = insts.length > 0;
+  for (const inst of insts) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const avail = (field, impl) => {
+      const p = `${inst.path}/${field}`;
+      const absent = field === "scheme" ? "fec_scheme_absent" : "fec_block_profile_absent";
+      const unimpl = field === "scheme" ? "fec_scheme_unimplemented" : "fec_block_profile_unimplemented";
+      if (!has(o, field))
+        return report(absent, p, inst), false;
+      if (typeof o[field] !== "string")
+        return report("fec_member", p, inst), true;
+      if (!impl.includes(o[field]))
+        return report(unimpl, p, inst), false;
+      return true;
+    };
+    if (!avail("scheme", schemes) || !avail("blockProfile", profiles))
+      inst.unavailable = true;
+    else if (typeof o.blockProfile === "string" && !profileAdmits(o.blockProfile, inst.track.packaging)) {
+      report("fec_block_profile_packaging", `${inst.path}/blockProfile`, inst);
+      inst.unavailable = true;
+    }
+  }
+  const live = (i) => !i.unavailable;
+  for (const inst of insts.filter(live)) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const p = inst.path;
+    for (const m of ["sourceSymbols", "repairSymbols", "symbolSize"])
+      if (!intIn(o[m], 1))
+        report("fec_member", `${p}/${m}`, inst);
+    if (typeof o.repairTrack !== "string")
+      report("fec_member", `${p}/repairTrack`, inst);
+    if (has(o, "symbolTrack") && typeof o.symbolTrack !== "string")
+      report("fec_member", `${p}/symbolTrack`, inst);
+    if (has(o, "interleaveDepthMs")) {
+      const d = o.interleaveDepthMs;
+      if (!intIn(d, 0) || d === 0 && o.blockProfile !== "iso-ssbg1-v1")
+        report("fec_member", `${p}/interleaveDepthMs`, inst);
+    }
+    if (has(o, "reorderToleranceMs")) {
+      const r = o.reorderToleranceMs;
+      if (typeof r !== "number" || !Number.isFinite(r) || r < 0)
+        report("fec_member", `${p}/reorderToleranceMs`, inst);
+    }
+    if (has(o, "label") && typeof o.label !== "string")
+      report("fec_member", `${p}/label`, inst);
+    if (inst.overlay && o.scope !== "keyframe")
+      report("fec_member", `${p}/scope`, inst);
+  }
+  const idGroups = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    if (inst.id !== null) {
+      const k = `${inst.ti}:${inst.id}`;
+      idGroups.set(k, [...idGroups.get(k) ?? [], inst]);
+    }
+  for (const group of idGroups.values())
+    if (group.length > 1)
+      for (const inst of group.filter(live))
+        report("fec_instance_id", inst.obj && has(inst.obj, "instanceId") ? `${inst.path}/instanceId` : inst.path, inst);
+  const nameUses = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    for (const field of ["repairTrack", "symbolTrack"])
+      if (inst.obj && typeof inst.obj[field] === "string") {
+        const k = key(inst.track.namespace, inst.obj[field]);
+        nameUses.set(k, [...nameUses.get(k) ?? [], { inst, field }]);
+      }
+  const namedBy = /* @__PURE__ */ new Map();
+  for (const [k, uses] of nameUses) {
+    const tj = byName.get(k);
+    for (const { inst, field } of uses) {
+      const path = `${inst.path}/${field}`;
+      if (tj === void 0 || trackAt(tj).packaging !== (field === "repairTrack" ? "fec-repair" : "fec-source")) {
+        if (live(inst))
+          report("fec_naming", path, inst);
+      } else if (uses.length > 1) {
+        if (live(inst))
+          report("fec_naming", path, inst);
+        if (!namedBy.has(tj))
+          namedBy.set(tj, inst);
+      } else {
+        namedBy.set(tj, inst);
+        if (field === "repairTrack")
+          inst.layer0 = tj;
+        else
+          inst.symbolNamed = tj;
+      }
+    }
+  }
+  const owner = /* @__PURE__ */ new Map();
+  if (declaresFec)
+    tracks.forEach((t, tj) => {
+      if (!isObj(t) || t.packaging !== "fec-repair" && t.packaging !== "fec-source")
+        return;
+      const tp = `/tracks/${tj}`;
+      const named = namedBy.get(tj);
+      if (named) {
+        owner.set(tj, named);
+        if (!live(named))
+          return;
+        if (has(t, "source") && t.source !== named.track.name)
+          report("fec_resolution", `${tp}/source`, named);
+        if (has(t, "instanceId") && t.instanceId !== named.id)
+          report("fec_resolution", `${tp}/instanceId`, named);
+        return;
+      }
+      if (!has(t, "source"))
+        return report("fec_orphan", tp);
+      const id = has(t, "instanceId") ? t.instanceId : 0;
+      const src = typeof t.source === "string" ? byName.get(key(t.namespace, t.source)) : void 0;
+      const target = src === void 0 ? void 0 : insts.find((i) => i.ti === src && i.id === id);
+      if (!target)
+        return report("fec_naming", has(t, "instanceId") && src !== void 0 ? `${tp}/instanceId` : `${tp}/source`);
+      owner.set(tj, target);
+      target.attached.push(tj);
+    });
+  for (const [tj, inst] of owner) {
+    if (!live(inst))
+      continue;
+    const t = trackAt(tj);
+    const tp = `/tracks/${tj}`;
+    const symbol = t.packaging === "fec-source";
+    if (has(t, "source") && typeof t.source !== "string")
+      report("fec_member", `${tp}/source`, inst);
+    if (has(t, "instanceId") && !intIn(t.instanceId, 0, 255))
+      report("fec_member", `${tp}/instanceId`, inst);
+    for (const m of ["repairLayer", "repairSymbols"]) {
+      if (!has(t, m))
+        continue;
+      if (symbol || !intIn(t[m], m === "repairLayer" ? 0 : 1))
+        report("fec_member", `${tp}/${m}`, inst);
+    }
+    if (has(t, "priority") && !intIn(t.priority, symbol ? 0 : 192, 255))
+      report("fec_member", `${tp}/priority`, inst);
+    for (const k of Object.keys(t))
+      if (GEOMETRY_KEYS.includes(k) || k.startsWith("groupDuration"))
+        report("fec_track_geometry", `${tp}/${k.replace(/~/g, "~0").replace(/\//g, "~1")}`, inst);
+  }
+  for (const inst of insts.filter(live)) {
+    const o = inst.obj;
+    if (!o)
+      continue;
+    const repairs = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-repair");
+    const symbols = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-source");
+    if (symbols.length + (inst.symbolNamed !== null ? 1 : 0) > 1)
+      for (const tj of symbols)
+        report("fec_symbol_tracks", `/tracks/${tj}`, inst);
+    const l0 = inst.layer0 === null ? null : trackAt(inst.layer0);
+    const l0p = `/tracks/${inst.layer0}`;
+    if (inst.overlay) {
+      if (l0 && has(l0, "repairLayer"))
+        report("fec_overlay", `${l0p}/repairLayer`, inst);
+      for (const tj of repairs)
+        report("fec_overlay", has(trackAt(tj), "repairLayer") ? `/tracks/${tj}/repairLayer` : `/tracks/${tj}`, inst);
+    } else {
+      if (l0 && has(l0, "repairLayer") && l0.repairLayer !== 0)
+        report("fec_layers", `${l0p}/repairLayer`, inst);
+      if (l0 && has(l0, "repairSymbols") && intIn(o.repairSymbols, 1) && l0.repairSymbols !== o.repairSymbols)
+        report("fec_layer0", `${l0p}/repairSymbols`, inst);
+      const layers = [];
+      for (const tj of repairs) {
+        const t = trackAt(tj);
+        if (!has(t, "repairLayer"))
+          report("fec_member", `/tracks/${tj}/repairLayer`, inst);
+        else if (t.repairLayer === 0)
+          report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+        else if (intIn(t.repairLayer, 1))
+          layers.push({ tj, layer: t.repairLayer });
+        if (!has(t, "repairSymbols"))
+          report("fec_member", `/tracks/${tj}/repairSymbols`, inst);
+      }
+      const counts = /* @__PURE__ */ new Map();
+      for (const { layer } of layers)
+        counts.set(layer, (counts.get(layer) ?? 0) + 1);
+      let missing = 1;
+      while (counts.has(missing))
+        missing++;
+      for (const { tj, layer } of layers)
+        if (counts.get(layer) > 1 || layer > missing)
+          report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+      const chain = [
+        { layer: 0, tj: inst.layer0, pri: l0 && intIn(l0.priority, 192, 255) ? l0.priority : l0 && has(l0, "priority") ? null : 240 },
+        ...layers.map(({ tj, layer }) => {
+          const pr = trackAt(tj).priority;
+          return { layer, tj, pri: intIn(pr, 192, 255) ? pr : null };
+        })
+      ].sort((a, b) => a.layer - b.layer);
+      let prev = null;
+      for (const c of chain) {
+        if (c.pri === null)
+          continue;
+        if (prev !== null && c.pri < prev)
+          report("fec_priority", `/tracks/${c.tj}/priority`, inst);
+        prev = Math.max(prev ?? c.pri, c.pri);
+      }
+    }
+    const K = o.sourceSymbols;
+    const T = o.symbolSize;
+    const P0 = o.repairSymbols;
+    if (intIn(K, 1) && intIn(P0, 1)) {
+      let P = P0;
+      if (!inst.overlay)
+        for (const tj of repairs) {
+          const t = trackAt(tj);
+          if (intIn(t.repairLayer, 1) && intIn(t.repairSymbols, 1))
+            P += t.repairSymbols;
+        }
+      if (P > MAX_24 || K + P - 1 > MAX_24)
+        report("fec_bounds", inst.path, inst);
+      else if (o.scheme === "reed-solomon" && K + P > RS_MAX_BLOCK)
+        report("fec_bounds", inst.path, inst);
+    }
+    if (o.scheme === "raptorq" && intIn(K, 1) && K > RAPTORQ_MAX_K)
+      report("fec_bounds", `${inst.path}/sourceSymbols`, inst);
+    if (intIn(T, 1)) {
+      if (o.scheme === "raptorq" && T % 8 !== 0)
+        report("fec_bounds", `${inst.path}/symbolSize`, inst);
+      else if (o.blockProfile === "iso-ssbg1-v1" && T < ISO_MIN_T)
+        report("fec_bounds", `${inst.path}/symbolSize`, inst);
+    }
+  }
+  const overlayTracks = new Set(insts.filter((i) => live(i) && i.overlay).map((i) => i.ti));
+  for (const ti of overlayTracks) {
+    const ofTrack = insts.filter((i) => i.ti === ti && live(i));
+    const ovs = ofTrack.filter((i) => i.overlay);
+    if (!overlays) {
+      for (const ov of ovs)
+        report("fec_overlay_unsupported", `${ov.path}/scope`, ov);
+      for (const i of ofTrack)
+        i.issues.length === 0 && i.issues.push({ code: "fec_overlay_unsupported", path: `${ovs[0].path}/scope` });
+      continue;
+    }
+    if (ovs.length > 1)
+      for (const ov of ovs)
+        report("fec_overlay", `${ov.path}/scope`, ov);
+    for (const ov of ovs)
+      if (ov.obj?.blockProfile !== "iso-ssbg1-v1")
+        report("fec_overlay", `${ov.path}/blockProfile`, ov);
+    const cause = ovs.flatMap((ov) => ov.issues).find((x) => x.code === "fec_overlay");
+    if (cause) {
+      for (const ov of ovs)
+        if (ov.issues.length === 0)
+          ov.issues.push(cause);
+    }
+  }
+  const rule4 = all.find((x) => x.code === "fec_enhancement_repair");
+  if (rejectAll && rule4) {
+    for (const i of insts)
+      if (i.issues.length === 0)
+        i.issues.push(rule4);
+  }
+  return {
+    instances: insts.map((i) => ({
+      path: i.path,
+      track: typeof i.track.name === "string" ? i.track.name : null,
+      instanceId: i.id,
+      outcome: rejectAll || !i.unavailable && i.issues.length > 0 ? "violation" : i.unavailable ? "unavailable" : "ok",
+      issues: i.issues,
+      trackIndex: i.ti,
+      repairTrack: i.layer0,
+      boundRepairTracks: i.attached.filter((tj) => trackAt(tj).packaging === "fec-repair"),
+      symbolTrack: i.symbolNamed ?? i.attached.find((tj) => trackAt(tj).packaging === "fec-source") ?? null
+    })),
+    issues: all
+  };
 }
-function fecAlgorithmUnimplemented(algorithm) {
-  return typeof algorithm === "string" && algorithm !== "none" && algorithm !== "raptorq" && algorithm !== "reed-solomon";
+
+// ../mmt-base/dist/fec-bindings.js
+var RUNTIME_FEC_RECEIVER = Object.freeze({
+  schemes: Object.freeze(["raptorq", "reed-solomon"]),
+  blockProfiles: Object.freeze(["iso-ssbg1-v1"]),
+  overlays: true
+});
+var DEFAULT_FEC_REPAIR_PRIORITY = 240;
+var recordOf = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+var escape = (s) => s.replace(/~/g, "~0").replace(/\//g, "~1");
+function fecCatalogTracks(catalog) {
+  const root = recordOf(catalog) ?? {};
+  const tracks = [];
+  const pointers = [];
+  const hangNames = /* @__PURE__ */ new Set();
+  for (const role of ["video", "audio"]) {
+    for (const [name, r] of Object.entries(recordOf(recordOf(root[role])?.["renditions"]) ?? {})) {
+      const entry = recordOf(r);
+      if (!entry)
+        continue;
+      hangNames.add(name);
+      const kind = recordOf(entry["container"])?.["kind"];
+      const view = { name, packaging: kind === void 0 || kind === "mmtp-fec" ? "mmtp" : kind };
+      if (entry["fec"] !== void 0)
+        view["fec"] = entry["fec"];
+      tracks.push(view);
+      pointers.push(`/${role}/renditions/${escape(name)}`);
+    }
+  }
+  const hangRenditions = tracks.length;
+  for (const [name, r] of Object.entries(recordOf(recordOf(root["repair"])?.["renditions"]) ?? {})) {
+    hangNames.add(name);
+    tracks.push({ packaging: "fec-repair", ...recordOf(r), name });
+    pointers.push(`/repair/renditions/${escape(name)}`);
+  }
+  const raw = Array.isArray(root["tracks"]) ? root["tracks"] : [];
+  const named = new Set(hangNames);
+  raw.forEach((t, i) => {
+    const name = recordOf(t)?.["name"];
+    if (typeof name === "string")
+      named.add(name);
+    if (typeof name === "string" && hangNames.has(name))
+      return;
+    tracks.push(t);
+    pointers.push(`/tracks/${i}`);
+  });
+  tracks.slice(0, hangRenditions).forEach((t, ti) => {
+    const view = t;
+    if (!Array.isArray(view["fec"]))
+      return;
+    view["fec"].forEach((o, ii) => {
+      const repairTrack = recordOf(o)?.["repairTrack"];
+      if (typeof repairTrack !== "string" || named.has(repairTrack))
+        return;
+      named.add(repairTrack);
+      const instanceId = recordOf(o)?.["instanceId"];
+      tracks.push({ name: repairTrack, packaging: "fec-repair", source: view["name"], ...instanceId === void 0 ? {} : { instanceId } });
+      pointers.push(`${pointers[ti]}/fec/${ii}/repairTrack`);
+    });
+  });
+  return { tracks, pointers };
 }
-function isPositiveSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+function resolveFecBindings(catalog, receiver = RUNTIME_FEC_RECEIVER) {
+  const { tracks, pointers } = fecCatalogTracks(catalog);
+  const report = validateFecCatalog({ tracks }, receiver);
+  const at = (path) => {
+    const m = /^\/tracks\/(\d+)(.*)$/.exec(path);
+    return m ? pointers[Number(m[1])] + m[2] : path;
+  };
+  const trackAt = (i) => recordOf(tracks[i]) ?? {};
+  const nameAt = (i) => i === null ? void 0 : trackAt(i)["name"];
+  const why = (i) => Object.freeze({
+    code: i.issues[0]?.code ?? "fec_member",
+    path: at(i.issues[0]?.path ?? i.path),
+    outcome: i.outcome === "unavailable" ? "unavailable" : "violation"
+  });
+  const out = /* @__PURE__ */ new Map();
+  tracks.forEach((t, ti) => {
+    const track = recordOf(t);
+    const name = track?.["name"];
+    if (!track || typeof name !== "string" || out.has(name))
+      return;
+    if (track["packaging"] === "fec-repair" || track["packaging"] === "fec-source")
+      return;
+    const fec = track["fec"];
+    if (fec === void 0)
+      return;
+    if (!Array.isArray(fec)) {
+      const reason = { code: "fec_member", path: at(`/tracks/${ti}/fec`), outcome: "violation" };
+      out.set(name, Object.freeze({ status: "unavailable", track: name, pointer: pointers[ti], reason: Object.freeze(reason) }));
+      return;
+    }
+    if (fec.length === 0)
+      return;
+    const insts = report.instances.filter((i) => i.trackIndex === ti);
+    const isOverlay = (i) => Object.hasOwn(recordOf(fec[Number(i.path.split("/").pop())]) ?? {}, "scope");
+    const bases = insts.filter((i) => !isOverlay(i));
+    const okBases = bases.filter((i) => i.outcome === "ok");
+    if (okBases.length !== 1) {
+      const reason = (
+        // No base instance at all (overlay-only `fec`) is a count of 0, not
+        // the overlay's own issue.
+        okBases.length > 1 || bases.length === 0 ? Object.freeze({ code: "fec_base_instances", path: at(`/tracks/${ti}/fec`), outcome: "violation" }) : why(bases[0] ?? insts[0])
+      );
+      out.set(name, Object.freeze({ status: "unavailable", track: name, pointer: pointers[ti], reason }));
+      return;
+    }
+    const b = okBases[0];
+    const base = geometry(recordOf(fec[Number(b.path.split("/").pop())]), b.instanceId, nameAt(b.symbolTrack));
+    const priorityOf = (i) => {
+      const p = i === null ? void 0 : trackAt(i)["priority"];
+      return typeof p === "number" ? p : DEFAULT_FEC_REPAIR_PRIORITY;
+    };
+    const layers = [
+      { layer: 0, repairTrackName: base.repairTrack, repairSymbols: base.repairSymbols, rsIdOffset: 0, priority: priorityOf(b.repairTrack) }
+    ];
+    const more = b.boundRepairTracks.map((tj) => ({ tj, layer: trackAt(tj)["repairLayer"] })).sort((x, y) => x.layer - y.layer);
+    let offset = base.repairSymbols;
+    for (const { tj, layer } of more) {
+      const repairSymbols = trackAt(tj)["repairSymbols"];
+      layers.push({ layer, repairTrackName: nameAt(tj), repairSymbols, rsIdOffset: offset, priority: priorityOf(tj) });
+      offset += repairSymbols;
+    }
+    let overlay;
+    let overlayUnavailable;
+    const ov = insts.find(isOverlay);
+    if (ov?.outcome === "ok") {
+      const g = geometry(recordOf(fec[Number(ov.path.split("/").pop())]), ov.instanceId, nameAt(ov.symbolTrack));
+      overlay = Object.freeze({
+        repairTrackName: g.repairTrack,
+        scope: "keyframe",
+        sourceSymbols: g.sourceSymbols,
+        repairSymbols: g.repairSymbols,
+        priority: priorityOf(ov.repairTrack),
+        geometry: g
+      });
+    } else if (ov)
+      overlayUnavailable = why(ov);
+    out.set(name, Object.freeze({
+      status: "ok",
+      track: name,
+      pointer: pointers[ti],
+      base,
+      layers: Object.freeze(layers.map((l) => Object.freeze(l))),
+      totalBaseRepairSymbols: offset,
+      ...overlay ? { overlay } : {},
+      ...overlayUnavailable ? { overlayUnavailable } : {}
+    }));
+  });
+  return out;
 }
-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;
+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/fec-state.ts
@@ -60,13 +561,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") {
@@ -97,7 +593,6 @@ export {
   FEC_INACTIVE_REASONS,
   MIN_INTERLEAVE_DEPTH_MS,
   catalogDeclaresFec,
-  isoBlockSpanUsable,
   resolveFecState
 };
 //# sourceMappingURL=fec-state.js.map