@blockcast/mmt-container 0.1.0 → 0.3.0-main.288475b64b3e

package/dist/source-auth.js

@@ -0,0 +1,1209 @@
+// ../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 anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+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);
+  }
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n);
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+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 createXOFer(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/_md.js
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/_blake.js
+function G1s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 16);
+  c = c + d | 0;
+  b = rotr(b ^ c, 12);
+  return { a, b, c, d };
+}
+function G2s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 8);
+  c = c + d | 0;
+  b = rotr(b ^ c, 7);
+  return { a, b, c, d };
+}
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/blake2.js
+var BLAKE2 = class extends Hash {
+  constructor(blockLen, outputLen) {
+    super();
+    this.finished = false;
+    this.destroyed = false;
+    this.length = 0;
+    this.pos = 0;
+    anumber(blockLen);
+    anumber(outputLen);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.buffer = new Uint8Array(blockLen);
+    this.buffer32 = u32(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { blockLen, buffer, buffer32 } = this;
+    const len = data.length;
+    const offset = data.byteOffset;
+    const buf = data.buffer;
+    for (let pos = 0; pos < len; ) {
+      if (this.pos === blockLen) {
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, false);
+        swap32IfBE(buffer32);
+        this.pos = 0;
+      }
+      const take = Math.min(blockLen - this.pos, len - pos);
+      const dataOffset = offset + pos;
+      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+        swap32IfBE(data32);
+        for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+          this.length += blockLen;
+          this.compress(data32, pos32, false);
+        }
+        swap32IfBE(data32);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      this.length += take;
+      pos += take;
+    }
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    const { pos, buffer32 } = this;
+    this.finished = true;
+    clean(this.buffer.subarray(pos));
+    swap32IfBE(buffer32);
+    this.compress(buffer32, 0, true);
+    swap32IfBE(buffer32);
+    const out32 = u32(out);
+    this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    const { buffer, length, finished, destroyed, outputLen, pos } = this;
+    to || (to = new this.constructor({ dkLen: outputLen }));
+    to.set(...this.get());
+    to.buffer.set(buffer);
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    to.outputLen = outputLen;
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+  let j = 0;
+  for (let i = 0; i < rounds; i++) {
+    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+  }
+  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+
+// ../mmt-manifest-verify/node_modules/@noble/hashes/esm/blake3.js
+var B3_Flags = {
+  CHUNK_START: 1,
+  CHUNK_END: 2,
+  PARENT: 4,
+  ROOT: 8,
+  KEYED_HASH: 16,
+  DERIVE_KEY_CONTEXT: 32,
+  DERIVE_KEY_MATERIAL: 64
+};
+var B3_IV = SHA256_IV.slice();
+var B3_SIGMA = /* @__PURE__ */ (() => {
+  const Id = Array.from({ length: 16 }, (_, i) => i);
+  const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+  const res = [];
+  for (let i = 0, v = Id; i < 7; i++, v = permute(v))
+    res.push(...v);
+  return Uint8Array.from(res);
+})();
+var BLAKE3 = class _BLAKE3 extends BLAKE2 {
+  constructor(opts = {}, flags = 0) {
+    super(64, opts.dkLen === void 0 ? 32 : opts.dkLen);
+    this.chunkPos = 0;
+    this.chunksDone = 0;
+    this.flags = 0 | 0;
+    this.stack = [];
+    this.posOut = 0;
+    this.bufferOut32 = new Uint32Array(16);
+    this.chunkOut = 0;
+    this.enableXOF = true;
+    const { key, context } = opts;
+    const hasContext = context !== void 0;
+    if (key !== void 0) {
+      if (hasContext)
+        throw new Error('Only "key" or "context" can be specified at same time');
+      const k = toBytes(key).slice();
+      abytes(k, 32);
+      this.IV = u32(k);
+      swap32IfBE(this.IV);
+      this.flags = flags | B3_Flags.KEYED_HASH;
+    } else if (hasContext) {
+      const ctx = toBytes(context);
+      const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT).update(ctx).digest();
+      this.IV = u32(contextKey);
+      swap32IfBE(this.IV);
+      this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+    } else {
+      this.IV = B3_IV.slice();
+      this.flags = flags;
+    }
+    this.state = this.IV.slice();
+    this.bufferOut = u8(this.bufferOut32);
+  }
+  // Unused
+  get() {
+    return [];
+  }
+  set() {
+  }
+  b2Compress(counter, flags, buf, bufPos = 0) {
+    const { state: s, pos } = this;
+    const { h, l } = fromBig(BigInt(counter), true);
+    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
+    s[0] = v0 ^ v8;
+    s[1] = v1 ^ v9;
+    s[2] = v2 ^ v10;
+    s[3] = v3 ^ v11;
+    s[4] = v4 ^ v12;
+    s[5] = v5 ^ v13;
+    s[6] = v6 ^ v14;
+    s[7] = v7 ^ v15;
+  }
+  compress(buf, bufPos = 0, isLast = false) {
+    let flags = this.flags;
+    if (!this.chunkPos)
+      flags |= B3_Flags.CHUNK_START;
+    if (this.chunkPos === 15 || isLast)
+      flags |= B3_Flags.CHUNK_END;
+    if (!isLast)
+      this.pos = this.blockLen;
+    this.b2Compress(this.chunksDone, flags, buf, bufPos);
+    this.chunkPos += 1;
+    if (this.chunkPos === 16 || isLast) {
+      let chunk = this.state;
+      this.state = this.IV.slice();
+      for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
+        if (!(last = this.stack.pop()))
+          break;
+        this.buffer32.set(last, 0);
+        this.buffer32.set(chunk, 8);
+        this.pos = this.blockLen;
+        this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+        chunk = this.state;
+        this.state = this.IV.slice();
+      }
+      this.chunksDone++;
+      this.chunkPos = 0;
+      this.stack.push(chunk);
+    }
+    this.pos = 0;
+  }
+  _cloneInto(to) {
+    to = super._cloneInto(to);
+    const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+    to.state.set(state.slice());
+    to.stack = stack.map((i) => Uint32Array.from(i));
+    to.IV.set(IV);
+    to.flags = flags;
+    to.chunkPos = chunkPos;
+    to.chunksDone = chunksDone;
+    to.posOut = posOut;
+    to.chunkOut = chunkOut;
+    to.enableXOF = this.enableXOF;
+    to.bufferOut32.set(this.bufferOut32);
+    return to;
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+    clean(...this.stack);
+  }
+  // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
+  b2CompressOut() {
+    const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+    const { h, l } = fromBig(BigInt(this.chunkOut++));
+    swap32IfBE(buffer32);
+    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
+    out32[0] = v0 ^ v8;
+    out32[1] = v1 ^ v9;
+    out32[2] = v2 ^ v10;
+    out32[3] = v3 ^ v11;
+    out32[4] = v4 ^ v12;
+    out32[5] = v5 ^ v13;
+    out32[6] = v6 ^ v14;
+    out32[7] = v7 ^ v15;
+    out32[8] = s[0] ^ v8;
+    out32[9] = s[1] ^ v9;
+    out32[10] = s[2] ^ v10;
+    out32[11] = s[3] ^ v11;
+    out32[12] = s[4] ^ v12;
+    out32[13] = s[5] ^ v13;
+    out32[14] = s[6] ^ v14;
+    out32[15] = s[7] ^ v15;
+    swap32IfBE(buffer32);
+    swap32IfBE(out32);
+    this.posOut = 0;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    clean(this.buffer.subarray(this.pos));
+    let flags = this.flags | B3_Flags.ROOT;
+    if (this.stack.length) {
+      flags |= B3_Flags.PARENT;
+      swap32IfBE(this.buffer32);
+      this.compress(this.buffer32, 0, true);
+      swap32IfBE(this.buffer32);
+      this.chunksDone = 0;
+      this.pos = this.blockLen;
+    } else {
+      flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+    }
+    this.flags = flags;
+    this.b2CompressOut();
+  }
+  writeInto(out) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const { blockLen, bufferOut } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.b2CompressOut();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible after digest call");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.enableXOF = false;
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+};
+var blake3 = /* @__PURE__ */ createXOFer((opts) => new BLAKE3(opts));
+
+// ../mmt-manifest-verify/dist/source-auth.js
+var SOURCE_AUTH_MANIFEST_VERSION = 1;
+var SOURCE_AUTH_OBJECT_ENTRY_FRAME = 1;
+var SOURCE_AUTH_GROUP_CLOSE_FRAME = 2;
+var SOURCE_AUTH_OBJECT_ENTRY_LENGTH = 52;
+var SOURCE_AUTH_GROUP_CLOSE_LENGTH = 112;
+var SOURCE_AUTH_MAX_OBJECTS_PER_GROUP = 4096;
+var SOURCE_AUTH_MAX_TRUE_LENGTH = 16 * 1024 * 1024;
+var SOURCE_AUTH_SCOPE_LENGTH = 32;
+var SIGNATURE_DOMAIN = new TextEncoder().encode("blockcast-mmt-root-v1\0\0\0");
+function requireBytes(name, value, length) {
+  if (value.byteLength !== length) {
+    throw new Error(`${name} must be ${length} bytes, got ${value.byteLength}`);
+  }
+}
+function requireU32(name, value) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw new Error(`${name} must be an unsigned 32-bit integer`);
+  }
+}
+function requireU64(name, value) {
+  if (value < 0n || value > 0xffffffffffffffffn) {
+    throw new Error(`${name} must be an unsigned 64-bit integer`);
+  }
+}
+function requireTrueLength(value) {
+  requireU32("trueLength", value);
+  if (value > SOURCE_AUTH_MAX_TRUE_LENGTH) {
+    throw new Error(`trueLength exceeds the ${SOURCE_AUTH_MAX_TRUE_LENGTH}-byte profile maximum`);
+  }
+}
+function sourceAuthObjectDigest(object) {
+  return blake3(object);
+}
+function sourceAuthLeafHash(groupId, objectId, digest, trueLength) {
+  requireU64("groupId", groupId);
+  requireU32("objectId", objectId);
+  requireBytes("digest", digest, 32);
+  requireTrueLength(trueLength);
+  const preimage = new Uint8Array(49);
+  const view = new DataView(preimage.buffer);
+  view.setBigUint64(1, groupId);
+  view.setUint32(9, objectId);
+  preimage.set(digest, 13);
+  view.setUint32(45, trueLength);
+  return blake3(preimage);
+}
+function sourceAuthMerkleRoot(entries) {
+  if (entries.length === 0)
+    throw new Error("Merkle tree requires at least one object");
+  if (entries.length > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
+    throw new Error(`group exceeds ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP} objects`);
+  }
+  const groupId = entries[0].groupId;
+  const objectIds = /* @__PURE__ */ new Set();
+  const ordered = [...entries].sort((left, right) => left.objectId - right.objectId);
+  let level = ordered.map((entry) => {
+    if (entry.groupId !== groupId)
+      throw new Error("Merkle entries must belong to one group");
+    if (objectIds.has(entry.objectId))
+      throw new Error(`duplicate objectId ${entry.objectId}`);
+    objectIds.add(entry.objectId);
+    return sourceAuthLeafHash(entry.groupId, entry.objectId, entry.digest, entry.trueLength);
+  });
+  while (level.length > 1) {
+    const parents = [];
+    for (let index = 0; index < level.length; index += 2) {
+      const left = level[index];
+      const right = level[index + 1] ?? left;
+      const preimage = new Uint8Array(65);
+      preimage[0] = 1;
+      preimage.set(left, 1);
+      preimage.set(right, 33);
+      parents.push(blake3(preimage));
+    }
+    level = parents;
+  }
+  return level[0];
+}
+function trimRecoveredSourceAuthObject(recoveredSymbol, trueLength) {
+  requireTrueLength(trueLength);
+  if (trueLength > recoveredSymbol.byteLength) {
+    throw new Error(`true length ${trueLength} exceeds recovered object size ${recoveredSymbol.byteLength}`);
+  }
+  return recoveredSymbol.subarray(0, trueLength);
+}
+function encodeSourceAuthObjectEntry(entry) {
+  requireU32("objectId", entry.objectId);
+  requireTrueLength(entry.trueLength);
+  requireU64("groupId", entry.groupId);
+  requireBytes("digest", entry.digest, 32);
+  const frame = new Uint8Array(SOURCE_AUTH_OBJECT_ENTRY_LENGTH);
+  const view = new DataView(frame.buffer);
+  frame[0] = SOURCE_AUTH_OBJECT_ENTRY_FRAME;
+  frame[1] = SOURCE_AUTH_MANIFEST_VERSION;
+  view.setBigUint64(4, entry.groupId);
+  view.setUint32(12, entry.objectId);
+  view.setUint32(16, entry.trueLength);
+  frame.set(entry.digest, 20);
+  return frame;
+}
+function encodeSourceAuthGroupClose(close) {
+  requireU32("objectCount", close.objectCount);
+  if (close.objectCount === 0 || close.objectCount > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
+    throw new Error(`objectCount must be between 1 and ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP}`);
+  }
+  requireU64("groupId", close.groupId);
+  requireBytes("root", close.root, 32);
+  requireBytes("signature", close.signature, 64);
+  const frame = new Uint8Array(SOURCE_AUTH_GROUP_CLOSE_LENGTH);
+  const view = new DataView(frame.buffer);
+  frame[0] = SOURCE_AUTH_GROUP_CLOSE_FRAME;
+  frame[1] = SOURCE_AUTH_MANIFEST_VERSION;
+  view.setBigUint64(4, close.groupId);
+  view.setUint32(12, close.objectCount);
+  frame.set(close.root, 16);
+  frame.set(close.signature, 48);
+  return frame;
+}
+function sourceAuthSignaturePreimage(authScope, groupId, objectCount, root) {
+  requireU32("objectCount", objectCount);
+  if (objectCount === 0 || objectCount > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
+    throw new Error(`objectCount must be between 1 and ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP}`);
+  }
+  requireU64("groupId", groupId);
+  requireBytes("authScope", authScope, SOURCE_AUTH_SCOPE_LENGTH);
+  requireBytes("root", root, 32);
+  const preimage = new Uint8Array(100);
+  const view = new DataView(preimage.buffer);
+  preimage.set(SIGNATURE_DOMAIN);
+  preimage.set(authScope, 24);
+  view.setBigUint64(56, groupId);
+  view.setUint32(64, objectCount);
+  preimage.set(root, 68);
+  return preimage;
+}
+function decodeSourceAuthManifestFrame(frame) {
+  const frameType = frame[0];
+  const expectedLength = frameType === SOURCE_AUTH_OBJECT_ENTRY_FRAME ? SOURCE_AUTH_OBJECT_ENTRY_LENGTH : frameType === SOURCE_AUTH_GROUP_CLOSE_FRAME ? SOURCE_AUTH_GROUP_CLOSE_LENGTH : 0;
+  if (expectedLength === 0)
+    throw new Error(`unsupported manifest frame type ${frameType}`);
+  if (frame.byteLength !== expectedLength) {
+    throw new Error(`manifest frame has invalid length ${frame.byteLength} for type ${frameType}`);
+  }
+  if (frame[1] !== SOURCE_AUTH_MANIFEST_VERSION) {
+    throw new Error(`unsupported manifest version ${frame[1]}`);
+  }
+  if (frame[2] !== 0 || frame[3] !== 0)
+    throw new Error("manifest reserved bits must be zero");
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const groupId = view.getBigUint64(4);
+  if (frameType === SOURCE_AUTH_OBJECT_ENTRY_FRAME) {
+    const entry = {
+      kind: "object",
+      groupId,
+      objectId: view.getUint32(12),
+      trueLength: view.getUint32(16),
+      digest: frame.slice(20, 52)
+    };
+    requireTrueLength(entry.trueLength);
+    return entry;
+  }
+  const close = {
+    kind: "close",
+    groupId,
+    objectCount: view.getUint32(12),
+    root: frame.slice(16, 48),
+    signature: frame.slice(48, 112)
+  };
+  if (close.objectCount === 0 || close.objectCount > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
+    throw new Error(`objectCount must be between 1 and ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP}`);
+  }
+  return close;
+}
+
+// ../mmt-manifest-verify/dist/admission.js
+function requireU642(name, value) {
+  if (value < 0n || value > 0xffffffffffffffffn) {
+    throw new Error(`${name} must be an unsigned 64-bit integer`);
+  }
+}
+function equalBytes(left, right) {
+  if (left.byteLength !== right.byteLength)
+    return false;
+  return left.every((value, index) => value === right[index]);
+}
+var SourceAuthAdmission = class {
+  #manifestAuthenticated;
+  #entries = /* @__PURE__ */ new Map();
+  #pendingObjects = /* @__PURE__ */ new Map();
+  #entriesAwaitingObjects = /* @__PURE__ */ new Set();
+  #admissions = /* @__PURE__ */ new Map();
+  #groupId = null;
+  #closed = false;
+  constructor(options) {
+    this.#manifestAuthenticated = options.manifestAuthenticated;
+  }
+  admitObject(input) {
+    this.#requireGroup(input.groupId);
+    if (this.#closed)
+      throw new Error("source-auth group is already closed");
+    if (this.#admissions.has(input.objectId) || this.#pendingObjects.has(input.objectId)) {
+      throw new Error(`duplicate source-auth object ${input.objectId}`);
+    }
+    const entry = this.#entries.get(input.objectId);
+    if (entry) {
+      this.#entriesAwaitingObjects.delete(input.objectId);
+      return this.#verifyObject(entry, input.bytes, input.recovered ?? false);
+    }
+    if (this.#pendingObjects.size >= 1) {
+      throw new Error("source-auth media exceeds one-object manifest skew");
+    }
+    this.#pendingObjects.set(input.objectId, {
+      bytes: input.bytes,
+      recovered: input.recovered ?? false
+    });
+    return {
+      groupId: input.groupId,
+      objectId: input.objectId,
+      recovered: input.recovered ?? false,
+      state: "pending-entry"
+    };
+  }
+  admitEntry(entry) {
+    this.#requireGroup(entry.groupId);
+    if (this.#closed)
+      throw new Error("source-auth group is already closed");
+    if (this.#entries.has(entry.objectId)) {
+      throw new Error(`duplicate source-auth manifest entry ${entry.objectId}`);
+    }
+    const pending = this.#pendingObjects.get(entry.objectId);
+    if (!pending && this.#entriesAwaitingObjects.size >= 1) {
+      throw new Error("source-auth manifest exceeds one-object media skew");
+    }
+    this.#entries.set(entry.objectId, entry);
+    if (!pending) {
+      this.#entriesAwaitingObjects.add(entry.objectId);
+      return "pending-object";
+    }
+    this.#pendingObjects.delete(entry.objectId);
+    return this.#verifyObject(entry, pending.bytes, pending.recovered);
+  }
+  objectState(objectId) {
+    if (this.#pendingObjects.has(objectId))
+      return "pending-entry";
+    if (this.#entriesAwaitingObjects.has(objectId))
+      return "pending-object";
+    if (this.#closed && this.#admissions.has(objectId))
+      return "authenticated";
+    return this.#admissions.get(objectId)?.state;
+  }
+  async verifyClose(close, authScope, publicKey, subtle = globalThis.crypto.subtle) {
+    this.#requireGroup(close.groupId);
+    if (this.#closed)
+      throw new Error("source-auth group is already closed");
+    if (this.#pendingObjects.size !== 0 || this.#entriesAwaitingObjects.size !== 0) {
+      throw new Error("source-auth group closed with unmatched objects or entries");
+    }
+    if (close.objectCount !== this.#entries.size || this.#admissions.size !== this.#entries.size) {
+      throw new Error("source-auth group close object count mismatch");
+    }
+    const root = sourceAuthMerkleRoot([...this.#entries.values()]);
+    if (!equalBytes(root, close.root))
+      throw new Error("source-auth group root mismatch");
+    const verified = await subtle.verify("Ed25519", publicKey, new Uint8Array(close.signature).buffer, new Uint8Array(sourceAuthSignaturePreimage(authScope, close.groupId, close.objectCount, root)).buffer);
+    if (!verified)
+      throw new Error("source-auth group close signature failed");
+    for (const admission of this.#admissions.values())
+      admission.state = "authenticated";
+    this.#closed = true;
+  }
+  #requireGroup(groupId) {
+    requireU642("groupId", groupId);
+    if (this.#groupId === null)
+      this.#groupId = groupId;
+    else if (this.#groupId !== groupId)
+      throw new Error("source-auth group identity mismatch");
+  }
+  #verifyObject(entry, bytes, recovered) {
+    const authenticated = recovered ? trimRecoveredSourceAuthObject(bytes, entry.trueLength) : bytes;
+    if (!recovered && bytes.byteLength !== entry.trueLength) {
+      throw new Error(`direct source-auth object length mismatch for ${entry.objectId}`);
+    }
+    if (!equalBytes(sourceAuthObjectDigest(authenticated), entry.digest)) {
+      throw new Error(`source-auth object digest mismatch for ${entry.objectId}`);
+    }
+    const admission = {
+      groupId: entry.groupId,
+      objectId: entry.objectId,
+      recovered,
+      state: this.#manifestAuthenticated ? "authenticated" : "provisional"
+    };
+    this.#admissions.set(entry.objectId, admission);
+    return admission;
+  }
+};
+
+// ../mmt-manifest-verify/dist/verifier.js
+function manifestBindingId(trackName, sourceSymbolFormat) {
+  return JSON.stringify([trackName, sourceSymbolFormat]);
+}
+function createWebCryptoEd25519Verifier(subtle = globalThis.crypto.subtle) {
+  return async (publicKey, message, signature) => {
+    const keyBytes = Uint8Array.from(publicKey);
+    const messageBytes = Uint8Array.from(message);
+    const signatureBytes = Uint8Array.from(signature);
+    const key = await subtle.importKey("raw", keyBytes.buffer, "Ed25519", false, ["verify"]);
+    return subtle.verify("Ed25519", key, signatureBytes.buffer, messageBytes.buffer);
+  };
+}
+var FAILURE_REASONS = [
+  "sigInvalid",
+  "digestMismatch",
+  "manifestLate",
+  "manifestAbsent",
+  "verifierError"
+];
+var equalBytes2 = (left, right) => {
+  if (left.byteLength !== right.byteLength)
+    return false;
+  let diff = 0;
+  for (let index = 0; index < left.byteLength; index++)
+    diff |= left[index] ^ right[index];
+  return diff === 0;
+};
+var isPromiseLike = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
+var ManifestVerifier = class {
+  #config;
+  #verifySignature;
+  #onFailure;
+  #tracks = /* @__PURE__ */ new Map();
+  #stats = {
+    verified: 0,
+    failures: Object.fromEntries(FAILURE_REASONS.map((reason) => [reason, 0])),
+    quarantinedBytes: 0
+  };
+  #disposed = false;
+  constructor(options) {
+    this.#config = { ...options.manifestAuth };
+    this.#verifySignature = options.verifySignature;
+    this.#onFailure = options.onFailure;
+  }
+  get config() {
+    return this.#config;
+  }
+  get stats() {
+    let quarantined = 0;
+    for (const track of this.#tracks.values())
+      quarantined += track.quarantine.length;
+    return {
+      verified: this.#stats.verified,
+      failures: { ...this.#stats.failures },
+      quarantined,
+      quarantinedBytes: this.#stats.quarantinedBytes
+    };
+  }
+  setMode(mode) {
+    this.#config = { ...this.#config, mode };
+    if (mode !== "enforce")
+      this.#releaseAllQuarantine(false);
+  }
+  registerTrack(context) {
+    const bindingId = context.bindingId ?? context.trackName;
+    if (this.#tracks.has(bindingId)) {
+      throw new Error(`manifest binding ${bindingId} is already registered`);
+    }
+    if (!Number.isFinite(context.bitrate) || context.bitrate <= 0) {
+      throw new Error("manifest track bitrate must be > 0");
+    }
+    if (!Number.isFinite(context.groupDurationMs) || context.groupDurationMs <= 0) {
+      throw new Error("manifest track groupDurationMs must be > 0");
+    }
+    if (context.authScope.byteLength !== 32)
+      throw new Error("manifest authScope must be 32 bytes");
+    if (context.publicKey.byteLength !== 32)
+      throw new Error("manifest publicKey must be 32 bytes");
+    for (const key of context.acceptedPublicKeys ?? []) {
+      if (key.byteLength !== 32)
+        throw new Error("manifest acceptedPublicKeys must contain 32-byte keys");
+    }
+    for (const [name, value] of Object.entries({
+      broadcastNamespaceId: context.broadcastNamespaceId,
+      trackName: context.trackName,
+      codec: context.codec,
+      timing: context.timing,
+      fecGeometry: context.fecGeometry
+    })) {
+      if (value.length === 0)
+        throw new Error(`manifest ${name} must not be empty`);
+    }
+    this.#tracks.set(bindingId, {
+      context: { ...context, bindingId },
+      groups: /* @__PURE__ */ new Map(),
+      quarantine: [],
+      quarantinedBytes: 0,
+      capBytes: Math.ceil(context.bitrate * context.groupDurationMs / 8e3),
+      manifestEntries: 0,
+      maxManifestEntries: Math.ceil(context.bitrate * context.groupDurationMs / (8e3 * 52)),
+      maxGroups: context.mapper.d + 1
+    });
+  }
+  ingestManifestFrame(bindingId, frameBytes) {
+    const track = this.#requireTrack(bindingId);
+    try {
+      const frame = decodeSourceAuthManifestFrame(frameBytes);
+      const groupId = frame.groupId;
+      const group = this.#group(track, groupId);
+      if (frame.kind === "object") {
+        if (group.close || group.signaturePending || group.failed) {
+          this.#failure({ trackName: track.context.trackName, bindingId, groupId, objectId: frame.objectId }, "verifierError");
+          return;
+        }
+        if (group.entries.has(frame.objectId)) {
+          this.#failure({ trackName: track.context.trackName, bindingId, groupId, objectId: frame.objectId }, "verifierError");
+          return;
+        }
+        if (group.entries.size >= 4096 || track.manifestEntries >= track.maxManifestEntries) {
+          this.#failure({ trackName: track.context.trackName, bindingId, groupId, objectId: frame.objectId }, "verifierError");
+          return;
+        }
+        group.entries.set(frame.objectId, frame);
+        track.manifestEntries++;
+        const pending = group.pending.get(frame.objectId);
+        if (pending) {
+          this.#failure(pending.identity, "manifestLate");
+          this.#resolvePending(track, group, pending, frame);
+        }
+        if (group.pendingClose && group.entries.size === group.pendingClose.objectCount) {
+          const close = group.pendingClose;
+          group.pendingClose = void 0;
+          this.#closeGroup(track, groupId, group, close);
+        }
+        return;
+      }
+      this.#closeGroup(track, groupId, group, frame);
+    } catch {
+      this.#failure({ trackName: track.context.trackName, bindingId, groupId: 0, objectId: 0 }, "verifierError");
+    }
+  }
+  admitObject(identity, data, release, discard) {
+    if (this.#config.mode === "off") {
+      release();
+      return { action: "play", verified: false };
+    }
+    const track = this.#tracks.get(identity.bindingId ?? identity.trackName);
+    if (!track) {
+      release();
+      this.#failure(identity, "verifierError");
+      return { action: "play", verified: false, reason: "verifierError" };
+    }
+    try {
+      if (!this.#validateIdentity(track, identity)) {
+        return this.#rejectOrShadow(identity, release, "digestMismatch");
+      }
+      const group = this.#group(track, BigInt(identity.groupId));
+      if (group.failed === "sigInvalid" || group.failed === "digestMismatch") {
+        return this.#rejectOrShadow(identity, release, group.failed);
+      }
+      const entry = group.entries.get(identity.objectId);
+      if (entry)
+        return this.#admitAgainstEntry(track, group, identity, data, release, entry, discard);
+      if (this.#config.mode === "shadow" || this.#config.onMissingManifest === "fallback-shadow") {
+        release();
+        this.#failure(identity, "manifestAbsent");
+        return { action: "play", verified: false, reason: "manifestAbsent" };
+      }
+      if (!this.#quarantine(track, group, { identity, data, release, discard, bytes: data.byteLength })) {
+        return { action: "drop", verified: false };
+      }
+      return { action: "stall", verified: false };
+    } catch {
+      release();
+      this.#failure(identity, "verifierError");
+      return { action: "play", verified: false, reason: "verifierError" };
+    }
+  }
+  dispose() {
+    if (this.#disposed)
+      return;
+    this.#disposed = true;
+    this.#releaseAllQuarantine(false);
+    this.#tracks.clear();
+  }
+  #requireTrack(bindingId) {
+    const track = this.#tracks.get(bindingId);
+    if (!track)
+      throw new Error(`unknown manifest binding ${bindingId}`);
+    return track;
+  }
+  #group(track, groupId) {
+    let group = track.groups.get(groupId);
+    if (!group) {
+      group = { entries: /* @__PURE__ */ new Map(), pending: /* @__PURE__ */ new Map(), rootVerified: false };
+      track.groups.set(groupId, group);
+      while (track.groups.size > track.maxGroups) {
+        const oldest = track.groups.entries().next().value;
+        if (!oldest)
+          break;
+        const [oldestId, oldestGroup] = oldest;
+        for (const pending of [...oldestGroup.pending.values()]) {
+          this.#removePending(track, oldestGroup, pending);
+          this.#giveUpOnPending(pending);
+          this.#failure(pending.identity, "manifestAbsent");
+        }
+        track.manifestEntries -= oldestGroup.entries.size;
+        track.groups.delete(oldestId);
+      }
+    }
+    return group;
+  }
+  #validateIdentity(track, identity) {
+    const coordinates = track.context.mapper.derive(Number(identity.groupId), identity.objectId);
+    return identity.ssId === void 0 || coordinates.ssId === identity.ssId;
+  }
+  #admitAgainstEntry(track, group, identity, data, release, entry, discard) {
+    if (entry.trueLength !== data.byteLength) {
+      return this.#rejectOrShadow(identity, release, "digestMismatch");
+    }
+    const digestMatches = equalBytes2(sourceAuthObjectDigest(data.subarray(0, entry.trueLength)), entry.digest);
+    if (!digestMatches)
+      return this.#rejectOrShadow(identity, release, "digestMismatch");
+    if (!track.context.manifestChannelAuthenticated && !group.rootVerified) {
+      if (this.#config.mode === "shadow") {
+        release();
+        return { action: "play", verified: false };
+      }
+      if (!this.#quarantine(track, group, { identity, data, release, discard, bytes: data.byteLength })) {
+        return { action: "drop", verified: false };
+      }
+      return { action: "stall", verified: false };
+    }
+    release();
+    this.#stats.verified++;
+    return { action: "play", verified: true };
+  }
+  #rejectOrShadow(identity, release, reason) {
+    this.#failure(identity, reason);
+    if (this.#config.mode === "enforce") {
+      console.warn(JSON.stringify({ event: "manifest-enforce-drop", track: identity.trackName, group: String(identity.groupId), object: identity.objectId, reason }));
+      return { action: "drop", verified: false, reason };
+    }
+    release();
+    return { action: "play", verified: false, reason };
+  }
+  #resolvePending(track, group, pending, entry) {
+    this.#removePending(track, group, pending);
+    this.#admitAgainstEntry(track, group, pending.identity, pending.data, pending.release, entry, pending.discard);
+  }
+  #closeGroup(track, groupId, group, close) {
+    if (group.close || group.signaturePending)
+      return;
+    const entries = [...group.entries.values()];
+    if (entries.length !== close.objectCount) {
+      group.pendingClose = close;
+      const hadPending = group.pending.size > 0;
+      if (this.#config.onMissingManifest === "fallback-shadow" || this.#config.mode === "shadow") {
+        for (const pending of [...group.pending.values()]) {
+          this.#removePending(track, group, pending);
+          pending.release();
+          this.#failure(pending.identity, "manifestAbsent");
+        }
+      } else {
+        for (const pending of group.pending.values()) {
+          this.#failure(pending.identity, "manifestAbsent");
+        }
+      }
+      if (!hadPending) {
+        this.#failure({ trackName: track.context.trackName, groupId, objectId: 0 }, "manifestAbsent");
+      }
+      return;
+    }
+    if (!equalBytes2(sourceAuthMerkleRoot(entries), close.root)) {
+      group.failed = "digestMismatch";
+      this.#failGroup(track, groupId, group, "digestMismatch");
+      return;
+    }
+    const preimage = sourceAuthSignaturePreimage(track.context.authScope, close.groupId, close.objectCount, close.root);
+    let signatureValid;
+    try {
+      signatureValid = this.#verifyAcceptedSignature(track, preimage, close.signature);
+    } catch {
+      this.#failOpenGroup(track, groupId, group);
+      return;
+    }
+    if (isPromiseLike(signatureValid)) {
+      group.signaturePending = true;
+      void signatureValid.then((valid) => {
+        if (this.#disposed)
+          return;
+        group.signaturePending = false;
+        this.#finishGroupSignature(track, groupId, group, close, valid);
+      }, () => {
+        if (this.#disposed)
+          return;
+        group.signaturePending = false;
+        this.#failOpenGroup(track, groupId, group);
+      });
+      return;
+    }
+    this.#finishGroupSignature(track, groupId, group, close, signatureValid);
+  }
+  #finishGroupSignature(track, groupId, group, close, signatureValid) {
+    if (!signatureValid) {
+      group.failed = "sigInvalid";
+      this.#failGroup(track, groupId, group, "sigInvalid");
+      return;
+    }
+    group.failed = void 0;
+    group.close = close;
+    group.pendingClose = void 0;
+    group.rootVerified = true;
+    for (const pending of [...group.pending.values()]) {
+      const entry = group.entries.get(pending.identity.objectId);
+      if (entry)
+        this.#resolvePending(track, group, pending, entry);
+      else if (this.#config.onMissingManifest === "fallback-shadow") {
+        this.#removePending(track, group, pending);
+        pending.release();
+        this.#failure(pending.identity, "manifestAbsent");
+      }
+    }
+  }
+  #verifyAcceptedSignature(track, message, signature) {
+    const keys = track.context.acceptedPublicKeys ?? [track.context.publicKey];
+    const pending = [];
+    let hadSynchronousError = false;
+    for (const key of keys) {
+      try {
+        const result = this.#verifySignature(key, message, signature);
+        if (isPromiseLike(result)) {
+          pending.push(Promise.resolve(result).then((valid) => valid, () => "error"));
+        } else if (result) {
+          return true;
+        }
+      } catch {
+        hadSynchronousError = true;
+      }
+    }
+    if (pending.length === 0) {
+      if (hadSynchronousError)
+        throw new Error("manifest signature verifier unavailable");
+      return false;
+    }
+    return Promise.all(pending).then((results) => {
+      if (results.some((valid) => valid === true))
+        return true;
+      if (hadSynchronousError || results.some((valid) => valid === "error")) {
+        throw new Error("manifest signature verifier unavailable");
+      }
+      return false;
+    });
+  }
+  #failGroup(track, groupId, group, reason) {
+    if (group.pending.size === 0) {
+      this.#failure({ trackName: track.context.trackName, groupId, objectId: 0 }, reason);
+      return;
+    }
+    for (const pending of [...group.pending.values()]) {
+      this.#removePending(track, group, pending);
+      if (this.#rejectOrShadow(pending.identity, pending.release, reason).action === "drop") {
+        pending.discard?.();
+      }
+    }
+  }
+  #removePending(track, group, pending) {
+    if (group.pending.get(pending.identity.objectId) === pending) {
+      group.pending.delete(pending.identity.objectId);
+    }
+    const index = track.quarantine.indexOf(pending);
+    if (index >= 0)
+      track.quarantine.splice(index, 1);
+    track.quarantinedBytes -= pending.bytes;
+    this.#stats.quarantinedBytes -= pending.bytes;
+  }
+  #quarantine(track, group, pending) {
+    if (group.pending.has(pending.identity.objectId))
+      return false;
+    group.pending.set(pending.identity.objectId, pending);
+    track.quarantine.push(pending);
+    track.quarantinedBytes += pending.bytes;
+    this.#stats.quarantinedBytes += pending.bytes;
+    this.#enforceCap(track);
+    return true;
+  }
+  #enforceCap(track) {
+    while (track.quarantinedBytes > track.capBytes && track.quarantine.length > 0) {
+      const pending = track.quarantine.shift();
+      const group = track.groups.get(BigInt(pending.identity.groupId));
+      if (group)
+        group.pending.delete(pending.identity.objectId);
+      track.quarantinedBytes -= pending.bytes;
+      this.#stats.quarantinedBytes -= pending.bytes;
+      this.#giveUpOnPending(pending);
+      this.#failure(pending.identity, "manifestAbsent");
+      console.warn(`[ManifestVerifier] quarantine cap eviction track=${pending.identity.trackName} group=${pending.identity.groupId} object=${pending.identity.objectId} disposition=${this.#config.mode === "enforce" ? "drop" : "fail-open"}`);
+    }
+  }
+  /**
+   * Stop waiting for a manifest that never arrived. In `enforce` the object is
+   * discarded: an eviction is a rejection, not a deferred play, so unverified
+   * media never reaches the player two groups after the stall was recorded
+   * (BLO-30095, CTO disposition on the issue thread).
+   *
+   * Deliberately NOT used by `#failOpenGroup`/`#failOpenTrack` — failing open on
+   * a genuine verifier fault is correct and stays untouched.
+   */
+  #giveUpOnPending(pending) {
+    if (this.#config.mode !== "enforce") {
+      pending.release();
+      return;
+    }
+    pending.discard?.();
+  }
+  #failOpenTrack(track, reason) {
+    for (const pending of [...track.quarantine]) {
+      const group = track.groups.get(BigInt(pending.identity.groupId));
+      if (group)
+        this.#removePending(track, group, pending);
+      pending.release();
+      this.#failure(pending.identity, reason);
+    }
+  }
+  #failOpenGroup(track, groupId, group) {
+    const pending = [...group.pending.values()];
+    if (pending.length === 0) {
+      this.#failure({ trackName: track.context.trackName, groupId, objectId: 0 }, "verifierError");
+      return;
+    }
+    for (const object of pending) {
+      this.#removePending(track, group, object);
+      object.release();
+      this.#failure(object.identity, "verifierError");
+    }
+  }
+  #releaseAllQuarantine(countFailure) {
+    for (const track of this.#tracks.values()) {
+      for (const pending of [...track.quarantine]) {
+        const group = track.groups.get(BigInt(pending.identity.groupId));
+        if (group)
+          this.#removePending(track, group, pending);
+        pending.release();
+        if (countFailure)
+          this.#failure(pending.identity, "verifierError");
+      }
+    }
+  }
+  #failure(identity, reason) {
+    this.#stats.failures[reason]++;
+    this.#onFailure?.({
+      trackName: identity.trackName,
+      ...identity.bindingId === void 0 ? {} : { bindingId: identity.bindingId },
+      groupId: identity.groupId,
+      objectId: identity.objectId,
+      reason
+    });
+  }
+};
+export {
+  ManifestVerifier,
+  SOURCE_AUTH_GROUP_CLOSE_FRAME,
+  SOURCE_AUTH_GROUP_CLOSE_LENGTH,
+  SOURCE_AUTH_MANIFEST_VERSION,
+  SOURCE_AUTH_MAX_OBJECTS_PER_GROUP,
+  SOURCE_AUTH_MAX_TRUE_LENGTH,
+  SOURCE_AUTH_OBJECT_ENTRY_FRAME,
+  SOURCE_AUTH_OBJECT_ENTRY_LENGTH,
+  SOURCE_AUTH_SCOPE_LENGTH,
+  SourceAuthAdmission,
+  createWebCryptoEd25519Verifier,
+  decodeSourceAuthManifestFrame,
+  encodeSourceAuthGroupClose,
+  encodeSourceAuthObjectEntry,
+  manifestBindingId,
+  sourceAuthLeafHash,
+  sourceAuthMerkleRoot,
+  sourceAuthObjectDigest,
+  sourceAuthSignaturePreimage,
+  trimRecoveredSourceAuthObject
+};
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=source-auth.js.map