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

package/dist/carp-catalog.js

@@ -14,21 +14,6 @@ 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";
-}
-function parseFecBlockProfile(value, where) {
-  if (isFecBlockProfile(value))
-    return value;
-  if (value === void 0) {
-    throw new Error(`${where} is required: name the FEC block profile ("iso-ssbg1-v1")`);
-  }
-  throw new Error(`${where} must be "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
-}
-
-// ../mmt-base/dist/catalog-fec-source.js
-var ALL_ROLES = Object.freeze(["video", "audio"]);
-var ISO_SSBG1_MIN_SYMBOL_SIZE = 14;
 
 // ../mmt-base/dist/multicast-catalog.js
 var ED25519_PUBLIC_KEY_BASE64URL = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
@@ -278,320 +263,12 @@ function multicastCatalogIssues(catalog, options = {}) {
   return issues;
 }
 
-// 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 };
-}
+// ../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
+});
 
 // src/carp-catalog.ts
 var VALID_ROLE_SUFFIXES = /* @__PURE__ */ new Set(["base", "delta", "repair"]);
@@ -646,18 +323,6 @@ function validateSwitchingSet(trackNames) {
   }
   return { ok: true };
 }
-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;
@@ -818,7 +483,7 @@ function validateCmsfMmtpCatalog(value, options = {}) {
   }
   const tracks = catalog["tracks"];
   const trackRecords = [];
-  const positiveInteger2 = (input) => Number.isSafeInteger(input) && input > 0;
+  const positiveInteger = (input) => Number.isSafeInteger(input) && input > 0;
   const positiveNumber = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
   for (let index = 0; index < tracks.length; index++) {
     const raw = tracks[index];
@@ -850,7 +515,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"];
@@ -858,13 +523,13 @@ function validateCmsfMmtpCatalog(value, options = {}) {
     const groupDurationTicks = track["groupDurationTicks"];
     const keyframeIntervalMs = track["keyframeIntervalMs"];
     const keyframeIntervalTicks = track["keyframeIntervalTicks"];
-    if (groupDurationMs !== void 0 && !positiveInteger2(groupDurationMs)) {
+    if (groupDurationMs !== void 0 && !positiveInteger(groupDurationMs)) {
       catalogError("track_group_duration_ms", `${path}.groupDurationMs`, "must be a positive integer");
     }
-    if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
+    if (groupDurationTicks !== void 0 && !positiveInteger(groupDurationTicks)) {
       catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
     }
-    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
+    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger(keyframeIntervalTicks)) {
       catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
     }
     const anchor = track["presentationAnchorTicks"];
@@ -875,17 +540,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 (!positiveInteger2(timescale)) {
+      if (!positiveInteger(timescale)) {
         catalogError("track_timescale", `${path}.timescale`, "must be a positive integer");
       }
       if (groupDurationMs === void 0 && groupDurationTicks === void 0) {
@@ -899,85 +558,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 (!positiveInteger2(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++) {
@@ -1106,8 +686,6 @@ export {
   CmsfCatalogValidationError,
   archiveOrigin,
   hasSwitchingSetRole,
-  isFecCatalogConfig,
-  isFecCatalogGeometry,
   isMulticastCatalogConfig,
   isMulticastEndpoint,
   isMulticastTrackObject,