@blockcast/mmt-container 0.1.0 → 0.3.0-main.d9354616fdf2

package/dist/catalog-fec-params.js

@@ -0,0 +1,702 @@
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// ../mmt-base/dist/mmtp.js
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+function isFecBlockProfile(value) {
+  return value === "k-padded-v1" || value === "iso-ssbg1-v1";
+}
+function parseFecBlockProfile(value, where) {
+  if (isFecBlockProfile(value))
+    return value;
+  if (value === void 0) {
+    throw new Error(`${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`);
+  }
+  throw new Error(`${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
+}
+
+// src/catalog-fec-params.ts
+import { catalogFecInterleaveMs } from "@blockcast/mmt-fec";
+
+// src/multicast-auth-catalog.ts
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var BASE64URL_DECODE_TABLE = (() => {
+  const table = new Int8Array(128).fill(-1);
+  for (let i = 0; i < BASE64URL_ALPHABET.length; i++) {
+    table[BASE64URL_ALPHABET.charCodeAt(i)] = i;
+  }
+  return table;
+})();
+
+// 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 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;
+  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");
+  }
+  if (layered && source.algorithm !== "raptorq") {
+    fail(
+      "track_fec",
+      `${source.path}.algorithm`,
+      "repair layers and overlays are defined only for raptorq: a block code fixes its codeword length, so symbols of a larger P are not symbols of the code a receiver holding fewer layers decodes"
+    );
+  }
+  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})`
+      );
+    }
+    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})`
+    );
+  }
+  return { sourceTrackName: source.name, baseLayers, overlays, totalBaseRepairSymbols };
+}
+
+// src/carp-catalog.ts
+function isTrackTimingConfig(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  const ms = o["groupDurationMs"];
+  const ticks = o["groupDurationTicks"];
+  if (ms === void 0 && ticks === void 0) return false;
+  if (ms !== void 0 && (typeof ms !== "number" || !Number.isInteger(ms) || ms <= 0)) return false;
+  if ("groupDurationTicks" in o) {
+    if (ticks === void 0) return ms !== void 0;
+    if (typeof ticks !== "number" || !Number.isInteger(ticks) || ticks <= 0) return false;
+  }
+  return true;
+}
+function resolveGroupDurationMs(timing, timescale) {
+  if (!Number.isSafeInteger(timescale) || timescale <= 0) {
+    throw new Error(
+      `[carp-catalog] resolveGroupDurationMs: timescale must be a positive safe integer Hz, got ${timescale}`
+    );
+  }
+  if (!isTrackTimingConfig(timing)) {
+    throw new Error(
+      `[carp-catalog] resolveGroupDurationMs: invalid TrackTimingConfig: ${JSON.stringify(timing)}`
+    );
+  }
+  if (timing.groupDurationTicks === void 0) {
+    return timing.groupDurationMs;
+  }
+  const durationMs = timing.groupDurationTicks / timescale * 1e3;
+  if (!Number.isFinite(durationMs) || durationMs <= 0 || durationMs > Number.MAX_SAFE_INTEGER) {
+    throw new Error(
+      `[carp-catalog] resolveGroupDurationMs: groupDurationTicks=${timing.groupDurationTicks} at timescale=${timescale} cannot be represented as a positive safe millisecond duration`
+    );
+  }
+  return durationMs;
+}
+
+// src/fec-state.ts
+var MIN_INTERLEAVE_DEPTH_MS = 33;
+var FEC_INACTIVE_REASONS = Object.freeze([
+  "no-catalog-fec",
+  "reliable-moq",
+  "no-multicast-bridge"
+]);
+var INACTIVE = Object.freeze({
+  "no-catalog-fec": Object.freeze({ state: "inactive", reason: "no-catalog-fec" }),
+  "reliable-moq": Object.freeze({ state: "inactive", reason: "reliable-moq" }),
+  "no-multicast-bridge": Object.freeze({ state: "inactive", reason: "no-multicast-bridge" })
+});
+function recordOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function catalogDeclaresFec(fec) {
+  const block = recordOf(fec);
+  if (block === void 0 || block["algorithm"] === "none") return false;
+  return isPositiveSafeInteger(block["sourceSymbols"]) && isPositiveSafeInteger(block["symbolSize"]) && isFecBlockProfile(block["blockProfile"]) && isoBlockSpanUsable(block);
+}
+function isoBlockSpanUsable(fec) {
+  const block = recordOf(fec);
+  if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1") return true;
+  const ms = block["interleaveDepthMs"];
+  return typeof ms === "number" && Number.isFinite(ms) && ms >= MIN_INTERLEAVE_DEPTH_MS;
+}
+
+// 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]);
+}
+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 recordOf2(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) => recordOf2(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 role = roles.find((r) => recordOf2(hang[r]?.renditions?.[sourceName]) !== void 0);
+  if (role !== void 0) {
+    const renditionPath = `$.${role}.renditions[${JSON.stringify(sourceName)}]`;
+    const rendition = recordOf2(hang[role].renditions[sourceName]);
+    rejectRepairFieldsOnMediaTrack(renditionPath, rendition, throwRepairContractError);
+    const repairRenditions = recordOf2(hang.repair?.renditions) ?? {};
+    const descriptors2 = Object.entries(repairRenditions).map(([name, entry]) => {
+      const path = `$.repair.renditions[${JSON.stringify(name)}]`;
+      const fields = recordOf2(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 = recordOf2(recordOf2(entry)?.["fec"]);
+      return fec2 !== void 0 && fec2["algorithm"] !== "none" ? fec2 : void 0;
+    };
+    const mediaRenditions = [
+      ...Object.values(recordOf2(hang.video?.renditions) ?? {}),
+      ...Object.values(recordOf2(hang.audio?.renditions) ?? {})
+    ];
+    const reachability2 = repairReachability(mediaRenditions.map((entry) => recordOf2(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`
+        );
+      }
+    }
+    return assembleRepairLayers(
+      geometryOf(sourceName, `${renditionPath}.fec`, recordOf2(rendition["fec"])),
+      descriptors2,
+      throwRepairContractError
+    );
+  }
+  const msf = msfTracks(catalog);
+  const msfIndex = msf ? msf.tracks.findIndex((t) => t["name"] === sourceName) : -1;
+  if (!msf || msfIndex < 0) return void 0;
+  const track = msf.tracks[msfIndex];
+  const fec = recordOf2(track["fec"]);
+  const packagingOf = (t) => t["packaging"];
+  const fecOfTrack = (t) => {
+    const trackFec = recordOf2(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`
+      );
+    }
+  }
+  return assembleRepairLayers(geometryOf(sourceName, `$.tracks[${msfIndex}].fec`, fec), descriptors, throwRepairContractError, {
+    layerZeroMustBeDeclared: true
+  });
+}
+function moqtPriority(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 sourcePriority = entry === void 0 ? null : moqtPriority(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") throw error;
+    return Object.freeze({ code: "track_fec_block_profile", 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}: iso-ssbg1-v1 requires a block span of at least ${MIN_INTERLEAVE_DEPTH_MS} ms, which bounds its block location`
+  });
+}
+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)) {
+    const declaresFecInstance = fec.algorithm !== "none";
+    const kValid = Number.isSafeInteger(fec.sourceSymbols) && (fec.sourceSymbols ?? 0) > 0;
+    const tValid = Number.isSafeInteger(fec.symbolSize) && (fec.symbolSize ?? 0) > 0;
+    if (declaresFecInstance && !(kValid && tValid)) {
+      throwRepairContractError(
+        "track_fec",
+        `${fecPath}.${kValid ? "symbolSize" : "sourceSymbols"}`,
+        "must be a positive integer"
+      );
+    }
+    const fecUnavailable = blockProfileUnavailable(fec.blockProfile, `${fecPath}.blockProfile`, declaresFecInstance) ?? isoSpanUnavailable(fec, `${fecPath}.interleaveDepthMs`, declaresFecInstance);
+    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,
+    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,
+    // interleaveDepthMs is the FEC block span in MILLISECONDS (§5.1) — the
+    // only interleave key the catalog carries post-BLO-14526. Receivers
+    // derive D by positive round-half-up of span / GOP duration where needed.
+    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
+  };
+}
+export {
+  DEFAULT_REPAIR_PRIORITY,
+  FEC_BLOCK_PROFILES,
+  MAX_ENCODING_SYMBOL_ID,
+  MAX_RAPTORQ_SOURCE_SYMBOLS,
+  MAX_REPAIR_SYMBOLS,
+  REPAIR_PRIORITY_MAX,
+  REPAIR_PRIORITY_MIN,
+  REPAIR_TRACK_GEOMETRY_KEYS,
+  REPAIR_TRACK_ONLY_KEYS,
+  RepairContractError,
+  assembleRepairLayers,
+  assertRepairTrackReachable,
+  catalogFecInterleaveMs,
+  catalogGroupDurationMs,
+  catalogRepairTarget,
+  dependsTarget,
+  describeRepairTrack,
+  isFecBlockProfile,
+  joinedRepairSymbolCount,
+  parseFecBlockProfile,
+  readFecBlockProfile,
+  rejectRepairFieldsOnMediaTrack,
+  rejectRepairTrackGeometry,
+  repairReachability,
+  resolveCatalogTrackFec,
+  resolveCatalogTrackGroupDurationMs,
+  resolveRepairLayers,
+  validateRepairTrackFields
+};
+//# sourceMappingURL=catalog-fec-params.js.map