@blockcast/mmt-container 0.4.1 → 0.5.0-main.34c7b9c2cfa0

package/dist/multicast-auth-catalog.d.ts

@@ -14,7 +14,7 @@
  * The rules are `multicastCatalogIssues` in `@blockcast/mmt-base`, shared with
  * the transport receivers; this module decodes what they admit.
  */
-import { type ManifestKey } from "@blockcast/mmt-manifest-verify";
+import { type BcpV2Key } from "@blockcast/mmt-manifest-verify";
 export type MulticastAuthScheme = "bc-provenance";
 export type MulticastAuthSig = "ed25519";
 /** Default `maxAuthDelayMs` and `manifestTimerMs` of an endpoint's `auth`. */
@@ -82,10 +82,12 @@ export interface ResolvedMulticastAuthFlow {
         name: string;
         packetId: number;
     }>;
+    /** `ctx` recomputed from the catalog (7.2.4); present when `namespaceFields` was given. */
+    ctx?: Uint8Array;
 }
 export interface ResolvedMulticastAuthConfig {
     /** Decoded keys, ascending by `firstEpoch`. */
-    keys: ManifestKey[];
+    keys: BcpV2Key[];
     minEpoch: number;
     flows: ResolvedMulticastAuthFlow[];
 }
@@ -98,10 +100,16 @@ export interface ResolvedMulticastAuthConfig {
  * `firstEpoch`, the retired root key) throws, so nothing is admitted and
  * nothing falls back to unauthenticated reception. An endpoint the rules make
  * a receiver ignore yields no flow; the others still bind.
+ *
+ * `namespaceFields` are the Track Namespace Fields of the catalog track, as
+ * MOQT carries them. With them every flow carries the recomputed `ctx`, which
+ * the receiver compares against each record; without them `ctx` is carried
+ * blind (7.2.4).
  */
 export declare function resolveMulticastAuthCatalog(catalog: unknown, options?: {
     requireAuth?: boolean;
     catalogNamespace?: string;
+    namespaceFields?: readonly (string | Uint8Array)[];
 }): ResolvedMulticastAuthConfig | undefined;
 /** The key that signs a record of `kid` at `epoch`, or `undefined` when that
  * `kid` does not sign it (7.2.7: such a record is dropped before verification). */

package/dist/multicast-auth-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multicast-auth-catalog.d.ts","sourceRoot":"","sources":["../src/multicast-auth-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElF,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC;AAClD,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAIzC,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAK5C;wCACwC;AACxC,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAczD;AAUD;yEACyE;AACzE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAyBxD;AAED;6DAC6D;AAC7D,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAQpE;AAED;2EAC2E;AAC3E,MAAM,WAAW,gBAAgB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IACnC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EAAE,CAAC,CAAC;IACX,GAAG,EAAE,gBAAgB,CAAC;IACtB,8DAA8D;IAC9D,IAAI,EAAE,gBAAgB,EAAE,CAAC;IACzB,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,oFAAoF;AACpF,MAAM,WAAW,kBAAkB;IAClC,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,8BAA8B;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uCAAuC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;4BAC4B;AAC5B,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,mBAAmB,CAE9E;AAED,2EAA2E;AAC3E,MAAM,WAAW,yBAAyB;IACzC,sDAAsD;IACtD,aAAa,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,2BAA2B;IAC3C,+CAA+C;IAC/C,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,yBAAyB,EAAE,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAO,GAChE,2BAA2B,GAAG,SAAS,CA6CzC;AAED;mFACmF;AACnF,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,2BAA2B,EACrC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACX,UAAU,GAAG,SAAS,CAExB"}
+{"version":3,"file":"multicast-auth-catalog.d.ts","sourceRoot":"","sources":["../src/multicast-auth-catalog.ts"],"names":[],"mappings":"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"}

package/dist/multicast-auth-catalog.js

@@ -264,25 +264,324 @@ function multicastCatalogIssues(catalog, options = {}) {
   return issues;
 }
 
-// ../mmt-manifest-verify/dist/source-auth.js
-var SOURCE_AUTH_MAX_TRUE_LENGTH = 16 * 1024 * 1024;
-var SIGNATURE_DOMAIN = new TextEncoder().encode("blockcast-mmt-root-v1\0\0\0");
-
-// ../mmt-manifest-verify/dist/verifier.js
-function manifestKeyFor(keys, epoch, kid) {
-  if (new Set(keys.map((key) => key.kid)).size !== keys.length)
-    return void 0;
-  if (new Set(keys.map((key) => key.firstEpoch)).size !== keys.length)
-    return void 0;
-  let signer;
-  for (const key of keys) {
-    if (key.firstEpoch <= epoch && (signer === void 0 || key.firstEpoch > signer.firstEpoch))
-      signer = key;
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
   }
-  if (signer === void 0 || kid !== void 0 && signer.kid !== kid)
-    return void 0;
-  return signer.publicKey;
 }
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/sha256.js
+var sha2562 = sha256;
 
 // ../mmt-manifest-verify/dist/bc-provenance-v2.js
 var BCPV2_HEADER_LENGTH = 68;
@@ -291,6 +590,58 @@ var BCPV2_MIN_RECORD_LENGTH = BCPV2_HEADER_LENGTH + 32 + BCPV2_SIGNATURE_LENGTH;
 var text = new TextEncoder();
 var MAGIC = Uint8Array.from([77, 72, 77, 50]);
 var SIGNING_DOMAIN = text.encode("mcast-manifest-v2\0");
+function u16(value) {
+  const result = new Uint8Array(2);
+  new DataView(result.buffer).setUint16(0, value);
+  return result;
+}
+function u32(value) {
+  const result = new Uint8Array(4);
+  new DataView(result.buffer).setUint32(0, value);
+  return result;
+}
+function concat(parts) {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.byteLength, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  return out;
+}
+function lp16(value) {
+  const bytes = typeof value === "string" ? text.encode(value) : value;
+  if (bytes.byteLength > 65535)
+    throw new Error("lp16 field exceeds u16 length");
+  return concat([u16(bytes.byteLength), bytes]);
+}
+function bcProvenanceV2ParamsHash(params) {
+  const fec = params.fec;
+  return sha2562(concat([
+    text.encode("BCPV2-params"),
+    lp16(params.codec),
+    u32(params.timescale),
+    u32(params.groupDurationTicks),
+    lp16(fec ? fec.algorithm : "none"),
+    u32(fec?.sourceSymbols ?? 0),
+    u32(fec?.repairSymbols ?? 0),
+    u32(fec?.symbolSize ?? 0),
+    u32(fec?.interleaveDepthMs ?? 0)
+  ]));
+}
+function bcProvenanceV2Ctx(namespace, packetIds, params) {
+  const ids = [...packetIds].sort((a, b) => a - b);
+  if (namespace.length > 65535 || ids.length > 65535)
+    throw new Error("ctx field count exceeds u16");
+  return sha2562(concat([
+    text.encode("BCPV2-ctx"),
+    u16(namespace.length),
+    ...namespace.map(lp16),
+    u16(ids.length),
+    ...ids.map(u16),
+    bcProvenanceV2ParamsHash(params)
+  ]));
+}
 
 // src/multicast-auth-catalog.ts
 var RAW_ED25519_KEY_LENGTH = 32;
@@ -374,10 +725,21 @@ function resolveMulticastAuthCatalog(catalog, options = {}) {
   }
   const ignored = new Set(issues.map((issue) => issue.endpointIndex));
   const endpoints = multicast["endpoints"] ?? [];
+  const catalogTracks = catalog["tracks"] ?? [];
   const flows = [];
   endpoints.forEach((endpoint, endpointIndex) => {
     if (ignored.has(endpointIndex)) return;
     const flowAuth = endpoint["auth"];
+    const tracks = (endpoint["tracks"] ?? []).map(({ name, packetId }) => ({
+      name,
+      packetId
+    }));
+    let ctx;
+    if (options.namespaceFields !== void 0) {
+      const params = ctxParams(catalogTracks, tracks);
+      if (params === void 0) return;
+      ctx = bcProvenanceV2Ctx(options.namespaceFields, tracks.map((track) => track.packetId), params);
+    }
     flows.push({
       endpointIndex,
       source: endpoint["sourceAddress"] ?? flowAuth.senderAddress,
@@ -389,10 +751,8 @@ function resolveMulticastAuthCatalog(catalog, options = {}) {
       maxAuthDelayMs: flowAuth.maxAuthDelayMs ?? DEFAULT_MAX_AUTH_DELAY_MS,
       manifestTimerMs: flowAuth.manifestTimerMs ?? DEFAULT_MANIFEST_TIMER_MS,
       ...flowAuth.manifestTrack === void 0 ? {} : { manifestTrack: flowAuth.manifestTrack },
-      tracks: (endpoint["tracks"] ?? []).map(({ name, packetId }) => ({
-        name,
-        packetId
-      }))
+      tracks,
+      ...ctx === void 0 ? {} : { ctx }
     });
   });
   return {
@@ -401,8 +761,43 @@ function resolveMulticastAuthCatalog(catalog, options = {}) {
     flows
   };
 }
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= 4294967295 ? value : 0;
+}
+function ctxParams(catalogTracks, listed) {
+  const byName = new Map(catalogTracks.map((track) => [track["name"], track]));
+  const ordered = [...listed].sort((a, b) => a.packetId - b.packetId).map(({ name }) => byName.get(name));
+  let entry = ordered.find((track) => track !== void 0 && track["packaging"] !== "fec-repair");
+  if (entry === void 0) {
+    const repair = ordered.find((track) => track !== void 0);
+    if (repair === void 0) return void 0;
+    const depends = repair["depends"];
+    entry = Array.isArray(depends) && depends.length === 1 ? byName.get(depends[0]) : catalogTracks.find((track) => track["fec"]?.["repairTrack"] === repair["name"]);
+    if (entry === void 0) return void 0;
+  }
+  const timescale = positiveInteger(entry["timescale"]);
+  const ms = positiveInteger(entry["groupDurationMs"]);
+  const groupDurationTicks = positiveInteger(entry["groupDurationTicks"]) || positiveInteger(timescale && ms * timescale % 1e3 === 0 ? ms * timescale / 1e3 : 0);
+  const fec = entry["fec"];
+  return {
+    codec: typeof entry["codec"] === "string" ? entry["codec"] : "",
+    timescale,
+    groupDurationTicks,
+    ...fec === void 0 || fec === null ? {} : {
+      fec: {
+        algorithm: typeof fec["algorithm"] === "string" ? fec["algorithm"] : "",
+        sourceSymbols: positiveInteger(fec["sourceSymbols"]),
+        repairSymbols: positiveInteger(fec["repairSymbols"]),
+        symbolSize: positiveInteger(fec["symbolSize"]),
+        interleaveDepthMs: positiveInteger(fec["interleaveDepthMs"])
+      }
+    }
+  };
+}
 function multicastAuthKeyFor(resolved, kid, epoch) {
-  return manifestKeyFor(resolved.keys, epoch, kid);
+  const signers = resolved.keys.filter((key) => key.firstEpoch <= epoch);
+  const signer = signers[signers.length - 1];
+  return signer?.kid === kid ? signer.publicKey : void 0;
 }
 export {
   DEFAULT_MANIFEST_TIMER_MS,
@@ -414,4 +809,9 @@ export {
   multicastAuthKeyFor,
   resolveMulticastAuthCatalog
 };
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=multicast-auth-catalog.js.map