@blockcast/mmt-container 0.1.0-main.0399efef1f07

package/dist/carp-catalog.js

@@ -0,0 +1,873 @@
+// src/multicast-auth-catalog.ts
+var RAW_ED25519_KEY_LENGTH = 32;
+var SOURCE_AUTH_SCOPE_LENGTH = 32;
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function encodeBase64Url(bytes) {
+  let output = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    output += BASE64URL_ALPHABET[b0 >> 2];
+    output += BASE64URL_ALPHABET[(b0 & 3) << 4 | (b1 === void 0 ? 0 : b1 >> 4)];
+    if (b1 === void 0) break;
+    output += BASE64URL_ALPHABET[(b1 & 15) << 2 | (b2 === void 0 ? 0 : b2 >> 6)];
+    if (b2 === void 0) break;
+    output += BASE64URL_ALPHABET[b2 & 63];
+  }
+  return output;
+}
+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;
+})();
+function decodeBase64Url(text) {
+  if (text.length % 4 === 1) {
+    throw new Error(`[multicast-auth-catalog] invalid unpadded base64url length for "${text}"`);
+  }
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const value = code < 128 ? BASE64URL_DECODE_TABLE[code] : -1;
+    if (value === void 0 || value < 0) {
+      throw new Error(`[multicast-auth-catalog] invalid base64url character in "${text}"`);
+    }
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  const decoded = Uint8Array.from(bytes);
+  if (encodeBase64Url(decoded) !== text) {
+    throw new Error(`[multicast-auth-catalog] non-canonical base64url encoding "${text}"`);
+  }
+  return decoded;
+}
+function decodeAuthScope(authScope) {
+  const bytes = decodeBase64Url(authScope);
+  if (bytes.byteLength !== SOURCE_AUTH_SCOPE_LENGTH) {
+    throw new Error(
+      `[multicast-auth-catalog] authScope must decode to ${SOURCE_AUTH_SCOPE_LENGTH} raw bytes, got ${bytes.byteLength}`
+    );
+  }
+  return bytes;
+}
+function decodeEd25519PublicKey(publicKey) {
+  const bytes = decodeBase64Url(publicKey);
+  if (bytes.byteLength !== RAW_ED25519_KEY_LENGTH) {
+    throw new Error(
+      `[multicast-auth-catalog] public key must decode to ${RAW_ED25519_KEY_LENGTH} raw bytes, got ${bytes.byteLength}`
+    );
+  }
+  return bytes;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isValidAuthScopeField(value) {
+  if (!isNonEmptyString(value)) return false;
+  try {
+    decodeAuthScope(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidPublicKeyField(value) {
+  if (!isNonEmptyString(value)) return false;
+  try {
+    decodeEd25519PublicKey(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasOnlyKeys(object, allowed) {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(object).every((key) => allowedKeys.has(key));
+}
+function isMulticastAuthTrackConfig(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  return hasOnlyKeys(o, ["mediaTrack", "manifestTrack", "authScope", "sourceSymbolFormat"]) && isNonEmptyString(o["mediaTrack"]) && isNonEmptyString(o["manifestTrack"]) && o["mediaTrack"] !== o["manifestTrack"] && isValidAuthScopeField(o["authScope"]) && isNonEmptyString(o["sourceSymbolFormat"]);
+}
+var VALID_COMPACTION = /* @__PURE__ */ new Set(["merkle", "none"]);
+var VALID_ENFORCEMENT = /* @__PURE__ */ new Set(["shadow", "enforce"]);
+function hasUniqueMulticastAuthTrackBindings(tracks) {
+  const bindings = tracks.flatMap((track) => {
+    if (typeof track !== "object" || track === null) return [];
+    const value = track;
+    if (typeof value["mediaTrack"] !== "string" || typeof value["sourceSymbolFormat"] !== "string") {
+      return [];
+    }
+    return [JSON.stringify([value["mediaTrack"], value["sourceSymbolFormat"]])];
+  });
+  return new Set(bindings).size === bindings.length;
+}
+function isMulticastAuthConfig(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  if (o["scheme"] !== "bc-provenance") return false;
+  if (o["hash"] !== "blake3") return false;
+  if (o["sig"] !== "ed25519") return false;
+  if (!hasOnlyKeys(o, ["scheme", "hash", "sig", "publicKey", "keyId", "previousKey", "compaction", "enforcement", "tracks"])) return false;
+  if (!isValidPublicKeyField(o["publicKey"])) return false;
+  if (!isNonEmptyString(o["keyId"])) return false;
+  if (o["previousKey"] !== void 0 && !isValidPublicKeyField(o["previousKey"])) return false;
+  if (o["previousKey"] === o["publicKey"]) return false;
+  if (typeof o["compaction"] !== "string" || !VALID_COMPACTION.has(o["compaction"])) return false;
+  if (o["enforcement"] !== void 0) {
+    if (typeof o["enforcement"] !== "string" || !VALID_ENFORCEMENT.has(o["enforcement"])) return false;
+  }
+  if (!Array.isArray(o["tracks"]) || o["tracks"].length === 0) return false;
+  const tracks = o["tracks"];
+  if (!tracks.every((t) => isMulticastAuthTrackConfig(t))) return false;
+  const typedTracks = tracks;
+  const scopes = typedTracks.map((t) => t.authScope);
+  if (new Set(scopes).size !== scopes.length) return false;
+  if (!hasUniqueMulticastAuthTrackBindings(typedTracks)) return false;
+  const manifestTracks = typedTracks.map((t) => t.manifestTrack);
+  if (new Set(manifestTracks).size !== manifestTracks.length) return false;
+  return true;
+}
+function resolveMulticastAuthMode(playerMode, auth) {
+  if (playerMode !== void 0) return playerMode;
+  if (auth === void 0) return "off";
+  return auth.enforcement ?? "shadow";
+}
+function resolveMulticastAuthCatalog(catalog, playerMode) {
+  if (typeof catalog !== "object" || catalog === null || Array.isArray(catalog)) {
+    throw new Error("[multicast-auth-catalog] catalog must be an object");
+  }
+  const root = catalog;
+  const rawAuth = root["multicast.auth"];
+  if (rawAuth === void 0) {
+    if (playerMode === "enforce") {
+      throw new Error("[multicast-auth-catalog] player enforce mode requires multicast.auth");
+    }
+    return void 0;
+  }
+  if (!isMulticastAuthConfig(rawAuth)) {
+    throw new Error("[multicast-auth-catalog] invalid multicast.auth v2 block");
+  }
+  const rawTracks = root["tracks"];
+  if (!Array.isArray(rawTracks)) {
+    throw new Error("[multicast-auth-catalog] catalog tracks must be an array");
+  }
+  const catalogTrackNames = new Set(
+    rawTracks.flatMap(
+      (track) => typeof track === "object" && track !== null && typeof track["name"] === "string" ? [track["name"]] : []
+    )
+  );
+  for (const track of rawAuth.tracks) {
+    if (!catalogTrackNames.has(track.mediaTrack)) {
+      throw new Error(`[multicast-auth-catalog] unknown mediaTrack "${track.mediaTrack}"`);
+    }
+    if (!catalogTrackNames.has(track.manifestTrack)) {
+      throw new Error(`[multicast-auth-catalog] unknown manifestTrack "${track.manifestTrack}"`);
+    }
+  }
+  return {
+    keyId: rawAuth.keyId,
+    acceptedPublicKeys: [
+      decodeEd25519PublicKey(rawAuth.publicKey),
+      ...rawAuth.previousKey === void 0 ? [] : [decodeEd25519PublicKey(rawAuth.previousKey)]
+    ],
+    mode: resolveMulticastAuthMode(playerMode, rawAuth),
+    compaction: rawAuth.compaction,
+    tracks: rawAuth.tracks.map((track) => ({
+      ...track,
+      authScope: decodeAuthScope(track.authScope)
+    }))
+  };
+}
+
+// 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);
+};
+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
+var VALID_ROLE_SUFFIXES = /* @__PURE__ */ new Set(["base", "delta", "repair"]);
+function parseTrackRole(trackName) {
+  if (trackName === "") {
+    throw new Error("[carp-catalog] empty track name");
+  }
+  for (let i = 0; i < trackName.length; i++) {
+    const cp = trackName.charCodeAt(i);
+    if (cp <= 31 || cp === 127 || cp > 126) {
+      throw new Error(
+        `[carp-catalog] track name contains non-ASCII or control character (code point 0x${cp.toString(16)}) in "${trackName}"`
+      );
+    }
+  }
+  const lastSlash = trackName.lastIndexOf("/");
+  if (lastSlash === -1) {
+    return "single";
+  }
+  const suffix = trackName.slice(lastSlash + 1);
+  if (suffix === "") {
+    throw new Error(
+      `[carp-catalog] empty role suffix in track name "${trackName}"; track names must not end with "/"`
+    );
+  }
+  if (!VALID_ROLE_SUFFIXES.has(suffix)) {
+    throw new Error(
+      `[carp-catalog] unknown role suffix "${suffix}" in track name "${trackName}"; expected one of: base, delta, repair`
+    );
+  }
+  return suffix;
+}
+function hasSwitchingSetRole(names) {
+  return names.some((name) => {
+    const lastSlash = name.lastIndexOf("/");
+    if (lastSlash === -1) return false;
+    const suffix = name.slice(lastSlash + 1);
+    return suffix === "base" || suffix === "delta";
+  });
+}
+function validateSwitchingSet(trackNames) {
+  if (trackNames.length === 0) return { ok: true };
+  const roles = trackNames.map(parseTrackRole);
+  if (roles.every((r) => r === "single")) {
+    return { ok: true };
+  }
+  const presentRoles = new Set(roles.filter((r) => r !== "single"));
+  const required = ["base", "delta", "repair"];
+  const missing = required.filter((r) => !presentRoles.has(r));
+  if (missing.length > 0) {
+    return { ok: false, missing };
+  }
+  return { ok: true };
+}
+function isFecCatalogConfig(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 === "none" || algorithm === "raptorq" || algorithm === "reed-solomon") && 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 isMulticastTrackObject(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  return typeof o["name"] === "string" && typeof o["packetId"] === "number";
+}
+function isMulticastEndpoint(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  const protocol = o["protocol"] ?? (typeof o["sourceAddress"] === "string" && o["sourceAddress"].length > 0 ? "ssm" : void 0);
+  return typeof protocol === "string" && (protocol === "ssm" || protocol === "asm" || protocol === "amt" || protocol === "atsc3") && typeof o["groupAddress"] === "string" && o["groupAddress"].length > 0 && typeof o["port"] === "number" && o["port"] > 0 && o["port"] <= 65535 && Array.isArray(o["tracks"]) && o["tracks"].every((t) => typeof t === "string" || isMulticastTrackObject(t));
+}
+function isMulticastCatalogConfig(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  return Array.isArray(o["endpoints"]) && o["endpoints"].every((ep) => isMulticastEndpoint(ep));
+}
+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;
+}
+var CmsfCatalogValidationError = class extends Error {
+  constructor(code, path, message) {
+    super(`[cmsf:${code}] ${path}: ${message}`);
+    this.code = code;
+    this.path = path;
+    this.name = "CmsfCatalogValidationError";
+  }
+};
+function catalogError(code, path, message) {
+  throw new CmsfCatalogValidationError(code, path, message);
+}
+function validateCmsfMmtpCatalog(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    catalogError("catalog_object", "$", "catalog must be an object");
+  }
+  const catalog = value;
+  const rawVersion = catalog["version"];
+  const normalizedVersion = typeof rawVersion === "string" ? Number.isFinite(Number(rawVersion)) ? Number(rawVersion) : rawVersion.startsWith("draft-ietf-moq-catalogformat") ? 1 : NaN : rawVersion;
+  if (!Number.isInteger(normalizedVersion) || normalizedVersion <= 0) {
+    catalogError("catalog_version", "$.version", "version must be a positive integer or a recognized format tag");
+  }
+  catalog["version"] = normalizedVersion;
+  if (!Array.isArray(catalog["tracks"])) {
+    catalogError("catalog_tracks", "$.tracks", "tracks must be an array");
+  }
+  const common = typeof catalog["commonTrackFields"] === "object" && catalog["commonTrackFields"] !== null && !Array.isArray(catalog["commonTrackFields"]) ? catalog["commonTrackFields"] : {};
+  const tracks = catalog["tracks"];
+  const trackRecords = [];
+  const effective = (track, field) => track[field] ?? common[field];
+  const positiveInteger2 = (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];
+    const path = `$.tracks[${index}]`;
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      catalogError("track_object", path, "track must be an object");
+    }
+    const track = raw;
+    const name = track["name"];
+    if (typeof name !== "string" || name.length === 0) {
+      catalogError("track_name", `${path}.name`, "name must be a non-empty string");
+    }
+    trackRecords.push(track);
+    const packaging = effective(track, "packaging");
+    if (typeof packaging !== "string" || packaging.length === 0) {
+      catalogError("track_packaging", `${path}.packaging`, "packaging must be a non-empty string");
+    }
+    const trackHasIsLive = Object.prototype.hasOwnProperty.call(track, "isLive");
+    const hasIsLive = trackHasIsLive || Object.prototype.hasOwnProperty.call(common, "isLive");
+    const isLive = trackHasIsLive ? track["isLive"] : common["isLive"];
+    if (hasIsLive && typeof isLive !== "boolean") {
+      catalogError("track_is_live", `${path}.isLive`, "isLive must be a boolean");
+    }
+    track["isLive"] = isLive ?? true;
+    const selectionValue = effective(track, "selectionParams");
+    const selection = typeof selectionValue === "object" && selectionValue !== null && !Array.isArray(selectionValue) ? selectionValue : void 0;
+    const codec = selection?.["codec"] ?? effective(track, "codec");
+    if (packaging !== "timeline" && packaging !== "mediatimeline" && packaging !== "eventtimeline" && packaging !== "fec-repair" && (typeof codec !== "string" || codec.length === 0)) {
+      catalogError("track_codec", `${path}.codec`, `codec is required for packaging=${packaging}`);
+    }
+    const timescale = effective(track, "timescale");
+    const groupDurationMs = effective(track, "groupDurationMs");
+    const groupDurationTicks = effective(track, "groupDurationTicks");
+    const keyframeIntervalMs = effective(track, "keyframeIntervalMs");
+    const keyframeIntervalTicks = effective(track, "keyframeIntervalTicks");
+    if (groupDurationMs !== void 0 && !positiveInteger2(groupDurationMs)) {
+      catalogError("track_group_duration_ms", `${path}.groupDurationMs`, "must be a positive integer");
+    }
+    if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
+      catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
+    }
+    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
+      catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
+    }
+    if (packaging === "fec-repair") {
+      rejectRepairTrackGeometry(path, track, catalogError);
+      validateRepairTrackFields(describeRepairTrack(name, path, track), catalogError);
+    } else {
+      rejectRepairFieldsOnMediaTrack(path, track, catalogError);
+    }
+    if (packaging === "mmtp") {
+      const mmtpMode = effective(track, "mmtpMode");
+      if (mmtpMode !== "mpu" && mmtpMode !== "mfu") {
+        catalogError("track_mmtp_mode", `${path}.mmtpMode`, "must be mpu or mfu");
+      }
+      if (!positiveInteger2(timescale)) {
+        catalogError("track_timescale", `${path}.timescale`, "must be a positive integer");
+      }
+      if (groupDurationMs === void 0 && groupDurationTicks === void 0) {
+        catalogError(
+          "track_group_duration_ms",
+          path,
+          "groupDurationMs or groupDurationTicks must be a positive integer"
+        );
+      }
+      if (groupDurationTicks === void 0 && BigInt(groupDurationMs) * BigInt(timescale) % 1000n !== 0n) {
+        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 (algorithm !== "none" && algorithm !== "raptorq" && algorithm !== "reed-solomon") {
+        catalogError("track_fec", `${path}.fec.algorithm`, "algorithm is not supported");
+      }
+      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 && !positiveInteger2(config["interleaveDepthMs"])) {
+        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a positive 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 (typeof config["repairTrack"] !== "string" || config["repairTrack"].length === 0) {
+          catalogError("track_fec", `${path}.fec.repairTrack`, "must be a non-empty string");
+        }
+      }
+    }
+  }
+  const repairDescriptors = trackRecords.flatMap(
+    (track, index) => effective(track, "packaging") === "fec-repair" ? [describeRepairTrack(track["name"], `$.tracks[${index}]`, track)] : []
+  );
+  const reachability = repairReachability(
+    trackRecords.filter((track) => effective(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 || effective(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++) {
+    const track = trackRecords[index];
+    if (effective(track, "packaging") !== "mmtp") continue;
+    const altGroup = effective(track, "altGroup");
+    if (!Number.isSafeInteger(altGroup)) continue;
+    const timescale = BigInt(effective(track, "timescale"));
+    const durationTicks = effective(track, "groupDurationTicks");
+    const ticks = durationTicks !== void 0 ? BigInt(durationTicks) : BigInt(effective(track, "groupDurationMs")) * timescale / 1000n;
+    const anchor = switchingSets.get(altGroup);
+    if (anchor && ticks * anchor.timescale !== anchor.ticks * timescale) {
+      catalogError("track_switching_set", `$.tracks[${index}]`, `group duration does not match ${JSON.stringify(anchor.name)} in altGroup ${altGroup}`);
+    }
+    if (!anchor) switchingSets.set(altGroup, { name: track["name"], ticks, timescale });
+  }
+  const multicast = catalog["multicast"];
+  if (typeof multicast === "object" && multicast !== null && !Array.isArray(multicast)) {
+    const endpoints = multicast["endpoints"];
+    if (Array.isArray(endpoints)) {
+      for (let endpointIndex = 0; endpointIndex < endpoints.length; endpointIndex++) {
+        const endpoint = endpoints[endpointIndex];
+        if (typeof endpoint !== "object" || endpoint === null || Array.isArray(endpoint)) continue;
+        const refs = endpoint["tracks"];
+        if (!Array.isArray(refs)) continue;
+        const packetIds = /* @__PURE__ */ new Map();
+        for (let refIndex = 0; refIndex < refs.length; refIndex++) {
+          const ref = refs[refIndex];
+          if (typeof ref !== "object" || ref === null || Array.isArray(ref)) continue;
+          const trackRef = ref;
+          const refPath = `$.multicast.endpoints[${endpointIndex}].tracks[${refIndex}]`;
+          const name = trackRef["name"];
+          if (typeof name !== "string" || !trackRecords.some((track) => track["name"] === name)) {
+            catalogError("multicast_track", `${refPath}.name`, `unknown catalog track ${JSON.stringify(name)}`);
+          }
+          const packetId = trackRef["packetId"];
+          if (!Number.isSafeInteger(packetId) || packetId < 0 || packetId > 65535) {
+            catalogError("multicast_packet_id", `${refPath}.packetId`, "packetId must be an integer from 0 to 65535");
+          }
+          const previous = packetIds.get(packetId);
+          if (previous !== void 0) {
+            catalogError("multicast_packet_id", `${refPath}.packetId`, `packetId is already assigned to ${JSON.stringify(previous)}`);
+          }
+          packetIds.set(packetId, name);
+        }
+      }
+    }
+  }
+  try {
+    resolveMulticastAuthCatalog(catalog);
+  } catch (error) {
+    catalogError(
+      "multicast_auth",
+      "$.multicast.auth",
+      error instanceof Error ? error.message : "invalid multicast.auth v2 block"
+    );
+  }
+  return catalog;
+}
+function resolveGroupDurationTicks(timing, timescale) {
+  if (!Number.isFinite(timescale) || !Number.isInteger(timescale) || timescale <= 0) {
+    throw new Error(
+      `[carp-catalog] resolveGroupDurationTicks: timescale must be a positive integer Hz, got ${timescale}`
+    );
+  }
+  if (!isTrackTimingConfig(timing)) {
+    throw new Error(
+      `[carp-catalog] resolveGroupDurationTicks: invalid TrackTimingConfig: ${JSON.stringify(timing)}`
+    );
+  }
+  if (timing.groupDurationTicks !== void 0) {
+    return timing.groupDurationTicks;
+  }
+  if (timing.groupDurationMs === void 0) {
+    throw new Error(
+      "[carp-catalog] resolveGroupDurationTicks: groupDurationMs is required when groupDurationTicks is absent"
+    );
+  }
+  const product = timing.groupDurationMs * timescale;
+  if (product % 1e3 !== 0) {
+    throw new Error(
+      `[carp-catalog] resolveGroupDurationTicks: groupDurationMs=${timing.groupDurationMs} at timescale=${timescale} produces non-integer ticks (${product / 1e3}); publisher must use groupDurationTicks override (mmt-00 \xA74.4.4)`
+    );
+  }
+  return product / 1e3;
+}
+function validateSwitchingSetTiming(tracks) {
+  if (tracks.length === 0) return { ok: true };
+  const ticksByTrack = tracks.map((t) => ({
+    name: t.name,
+    ticks: resolveGroupDurationTicks(t.timing, t.timescale),
+    timescale: t.timescale
+  }));
+  const expectedTicks = ticksByTrack[0].ticks;
+  const expectedTimescale = ticksByTrack[0].timescale;
+  const mismatches = ticksByTrack.slice(1).filter(
+    (t) => BigInt(t.ticks) * BigInt(expectedTimescale) !== BigInt(expectedTicks) * BigInt(t.timescale)
+  ).map(({ name, ticks }) => ({ name, ticks }));
+  if (mismatches.length === 0) return { ok: true };
+  return { ok: false, expectedTicks, mismatches };
+}
+export {
+  CmsfCatalogValidationError,
+  hasSwitchingSetRole,
+  isFecCatalogConfig,
+  isMulticastCatalogConfig,
+  isMulticastEndpoint,
+  isMulticastTrackObject,
+  isTrackTimingConfig,
+  parseTrackRole,
+  resolveGroupDurationMs,
+  resolveGroupDurationTicks,
+  validateCmsfMmtpCatalog,
+  validateSwitchingSet,
+  validateSwitchingSetTiming
+};
+//# sourceMappingURL=carp-catalog.js.map