@blockcast/mmt-container 0.1.0-main.149f78a4adae

package/dist/carp-catalog.js

@@ -0,0 +1,549 @@
+// 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/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 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];
+    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 && !positiveInteger(groupDurationMs)) {
+      catalogError("track_group_duration_ms", `${path}.groupDurationMs`, "must be a positive integer");
+    }
+    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 && !positiveInteger(keyframeIntervalTicks)) {
+      catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
+    }
+    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 (!positiveInteger(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 (config["interleaveDepthMs"] !== void 0 && !positiveInteger(config["interleaveDepthMs"])) {
+        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a positive integer");
+      }
+      if (algorithm !== "none") {
+        for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
+          if (!positiveInteger(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");
+        }
+      }
+    }
+  }
+  for (let index = 0; index < trackRecords.length; index++) {
+    const track = trackRecords[index];
+    const fec = track["fec"];
+    if (!fec || fec["algorithm"] === "none") continue;
+    const repairTrack = fec["repairTrack"];
+    const target = trackRecords.find((candidate) => candidate["name"] === repairTrack);
+    if (!target || effective(target, "packaging") !== "fec-repair") {
+      catalogError("track_repair_track", `$.tracks[${index}].fec.repairTrack`, `unknown FEC repair track ${JSON.stringify(repairTrack)}`);
+    }
+  }
+  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