@tangle-network/agent-eval 0.212.0 → 0.214.0

package/dist/ledger-core-B2hahzrt.js

@@ -0,0 +1,248 @@
+import { s as ValidationError } from "./errors-Dngq5h35.js";
+import { t as LEDGER_HASH_PATTERN } from "./canonical-BsZVgBhW.js";
+import "./journal-DvKCvjty.js";
+import { sha256Bytes } from "@tangle-network/agent-interface";
+//#region src/ledger-core/merkle.ts
+/**
+* Merkle proofs over an append-only list of leaves (RFC 9162 §2.1, the
+* Certificate Transparency tree).
+*
+* A hash chain proves a whole log against its head, but proving one entry means
+* replaying everything before it. This tree proves any one leaf against a root
+* with ⌈log₂ n⌉ hashes (inclusion), and proves that a larger tree only appended
+* to a smaller one (consistency). A verifier holding a root can therefore check
+* a single event, or that a later checkpoint extends an earlier one, without
+* reading the rest of the log.
+*
+* Leaves and interior nodes are domain-separated (0x00 and 0x01 prefixes), so a
+* leaf can never be presented as an interior node. Content that may later be
+* redacted takes a random 32-byte salt: a verifier then needs only the leaf's
+* hash, and short content cannot be guessed back from that hash. The salt must
+* be stored apart from anything that is shared after redaction.
+*
+* Builders refuse malformed input by throwing; verifiers never throw and return
+* a typed outcome, because a proof is external evidence and a bad one is a
+* finding, not a crash.
+*/
+const SALT_PATTERN = /^[a-f0-9]{64}$/;
+const LEAF_PREFIX = 0;
+const NODE_PREFIX = 1;
+const encoder = new TextEncoder();
+/** Root of the empty tree: SHA-256 of no bytes. */
+const MERKLE_EMPTY_ROOT = sha256Bytes(/* @__PURE__ */ new Uint8Array(0));
+/** A fresh random salt for {@link merkleLeafHash}: 32 bytes as 64 lowercase hex characters. */
+function merkleSalt() {
+	return toHex(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)));
+}
+/**
+* Leaf hash of `content`: SHA-256(0x00 ‖ salt ‖ content). Without a salt this is
+* exactly the RFC 9162 leaf hash. Strings are hashed as UTF-8.
+*/
+function merkleLeafHash(content, salt) {
+	const bytes = typeof content === "string" ? encoder.encode(content) : content;
+	if (salt === void 0) return digest(LEAF_PREFIX, bytes);
+	if (!SALT_PATTERN.test(salt)) throw new ValidationError("merkle salt must be 32 bytes as 64 lowercase hex characters");
+	return digest(LEAF_PREFIX, fromHex(salt), bytes);
+}
+/** Root over leaf hashes, in order. The empty list has {@link MERKLE_EMPTY_ROOT}. */
+function merkleRoot(leaves) {
+	const nodes = decodeLeaves(leaves);
+	return nodes.length === 0 ? MERKLE_EMPTY_ROOT : toLedgerHash(subtreeRoot(nodes, 0, nodes.length));
+}
+/** Inclusion proof for the leaf at `leafIndex` (RFC 9162 §2.1.3.1). */
+function merkleInclusionProof(leaves, leafIndex) {
+	const nodes = decodeLeaves(leaves);
+	if (!Number.isSafeInteger(leafIndex) || leafIndex < 0 || leafIndex >= nodes.length) throw new ValidationError(`merkle leaf index ${leafIndex} is outside a tree of ${nodes.length} leaves`);
+	const path = [];
+	inclusionPath(nodes, leafIndex, 0, nodes.length, path);
+	return {
+		leafIndex,
+		treeSize: nodes.length,
+		path: path.map(toLedgerHash)
+	};
+}
+/**
+* Consistency proof that the first `oldSize` leaves are the tree of that size
+* (RFC 9162 §2.1.4.1). Sizes 0 and `leaves.length` need no path.
+*/
+function merkleConsistencyProof(leaves, oldSize) {
+	const nodes = decodeLeaves(leaves);
+	if (!Number.isSafeInteger(oldSize) || oldSize < 0 || oldSize > nodes.length) throw new ValidationError(`merkle old size ${oldSize} is outside a tree of ${nodes.length} leaves`);
+	const path = [];
+	if (oldSize > 0 && oldSize < nodes.length) subproof(nodes, oldSize, 0, nodes.length, true, path);
+	return {
+		oldSize,
+		newSize: nodes.length,
+		path: path.map(toLedgerHash)
+	};
+}
+/** Check that `leaf` is in the tree with `root` at the proof's index (RFC 9162 §2.1.3.2). */
+function verifyMerkleInclusion(leaf, proof, root) {
+	const { leafIndex, treeSize } = proof;
+	if (!isSize(treeSize) || !isSize(leafIndex) || leafIndex >= treeSize) return refused(`leaf index ${leafIndex} is outside a tree of ${treeSize} leaves`);
+	const decoded = decodeAll([
+		leaf,
+		root,
+		...proof.path
+	]);
+	if (decoded === void 0) return refused("proof carries a malformed hash");
+	const [leafBytes, rootBytes, ...path] = decoded;
+	let fn = leafIndex;
+	let sn = treeSize - 1;
+	let r = leafBytes;
+	for (const p of path) {
+		if (sn === 0) return refused("proof path is longer than the tree is deep");
+		if (fn % 2 === 1 || fn === sn) {
+			r = node(p, r);
+			if (fn % 2 === 0) while (fn % 2 === 0 && fn !== 0) {
+				fn = Math.floor(fn / 2);
+				sn = Math.floor(sn / 2);
+			}
+		} else r = node(r, p);
+		fn = Math.floor(fn / 2);
+		sn = Math.floor(sn / 2);
+	}
+	if (sn !== 0) return refused("proof path is shorter than the tree is deep");
+	return equal(r, rootBytes) ? { verified: true } : refused("leaf does not hash to the root");
+}
+/** Check that the tree with `newRoot` extends the tree with `oldRoot` (RFC 9162 §2.1.4.2). */
+function verifyMerkleConsistency(proof, oldRoot, newRoot) {
+	const { oldSize, newSize } = proof;
+	if (!isSize(oldSize) || !isSize(newSize) || oldSize > newSize) return refused(`old size ${oldSize} does not precede new size ${newSize}`);
+	const decoded = decodeAll([
+		oldRoot,
+		newRoot,
+		...proof.path
+	]);
+	if (decoded === void 0) return refused("proof carries a malformed hash");
+	const [oldBytes, newBytes, ...given] = decoded;
+	if (oldSize === 0 || oldSize === newSize) {
+		if (given.length !== 0) return refused("a trivial consistency proof must be empty");
+		if (oldSize === 0) return oldRoot === MERKLE_EMPTY_ROOT ? { verified: true } : refused("the empty tree has a different root");
+		return equal(oldBytes, newBytes) ? { verified: true } : refused("equal sizes with different roots");
+	}
+	const path = isPowerOfTwo(oldSize) ? [oldBytes, ...given] : given;
+	if (path.length === 0) return refused("consistency proof is empty");
+	let fn = oldSize - 1;
+	let sn = newSize - 1;
+	while (fn % 2 === 1) {
+		fn = Math.floor(fn / 2);
+		sn = Math.floor(sn / 2);
+	}
+	let fr = path[0];
+	let sr = fr;
+	for (const c of path.slice(1)) {
+		if (sn === 0) return refused("proof path is longer than the tree is deep");
+		if (fn % 2 === 1 || fn === sn) {
+			fr = node(c, fr);
+			sr = node(c, sr);
+			if (fn % 2 === 0) while (fn % 2 === 0 && fn !== 0) {
+				fn = Math.floor(fn / 2);
+				sn = Math.floor(sn / 2);
+			}
+		} else sr = node(sr, c);
+		fn = Math.floor(fn / 2);
+		sn = Math.floor(sn / 2);
+	}
+	if (sn !== 0) return refused("proof path is shorter than the tree is deep");
+	if (!equal(fr, oldBytes)) return refused("proof does not rebuild the old root");
+	if (!equal(sr, newBytes)) return refused("proof does not rebuild the new root");
+	return { verified: true };
+}
+function subtreeRoot(nodes, start, end) {
+	if (end - start === 1) return nodes[start];
+	const k = largestPowerOfTwoBelow(end - start);
+	return node(subtreeRoot(nodes, start, start + k), subtreeRoot(nodes, start + k, end));
+}
+function inclusionPath(nodes, index, start, end, path) {
+	if (end - start === 1) return;
+	const k = largestPowerOfTwoBelow(end - start);
+	if (index < start + k) {
+		inclusionPath(nodes, index, start, start + k, path);
+		path.push(subtreeRoot(nodes, start + k, end));
+	} else {
+		inclusionPath(nodes, index, start + k, end, path);
+		path.push(subtreeRoot(nodes, start, start + k));
+	}
+}
+function subproof(nodes, oldSize, start, end, complete, path) {
+	if (end - start === oldSize) {
+		if (!complete) path.push(subtreeRoot(nodes, start, end));
+		return;
+	}
+	const k = largestPowerOfTwoBelow(end - start);
+	if (oldSize <= k) {
+		subproof(nodes, oldSize, start, start + k, complete, path);
+		path.push(subtreeRoot(nodes, start + k, end));
+	} else {
+		subproof(nodes, oldSize - k, start + k, end, false, path);
+		path.push(subtreeRoot(nodes, start, start + k));
+	}
+}
+function node(left, right) {
+	return fromHex(digest(NODE_PREFIX, left, right).slice(7));
+}
+function digest(prefix, ...parts) {
+	const length = parts.reduce((total, part) => total + part.length, 1);
+	const bytes = new Uint8Array(length);
+	bytes[0] = prefix;
+	let offset = 1;
+	for (const part of parts) {
+		bytes.set(part, offset);
+		offset += part.length;
+	}
+	return sha256Bytes(bytes);
+}
+function decodeLeaves(leaves) {
+	const decoded = decodeAll(leaves);
+	if (decoded === void 0) throw new ValidationError("merkle leaves must be sha256:<64 lowercase hex> hashes");
+	return decoded;
+}
+function decodeAll(hashes) {
+	const out = [];
+	for (const hash of hashes) {
+		if (typeof hash !== "string" || !LEDGER_HASH_PATTERN.test(hash)) return void 0;
+		out.push(fromHex(hash.slice(7)));
+	}
+	return out;
+}
+function toLedgerHash(bytes) {
+	return `sha256:${toHex(bytes)}`;
+}
+function largestPowerOfTwoBelow(n) {
+	let k = 1;
+	while (k * 2 < n) k *= 2;
+	return k;
+}
+function isPowerOfTwo(n) {
+	if (n < 1) return false;
+	let m = n;
+	while (m % 2 === 0) m /= 2;
+	return m === 1;
+}
+function isSize(n) {
+	return Number.isSafeInteger(n) && n >= 0;
+}
+function equal(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function refused(reason) {
+	return {
+		verified: false,
+		reason
+	};
+}
+function toHex(bytes) {
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+//#endregion
+export { merkleRoot as a, verifyMerkleInclusion as c, merkleLeafHash as i, merkleConsistencyProof as n, merkleSalt as o, merkleInclusionProof as r, verifyMerkleConsistency as s, MERKLE_EMPTY_ROOT as t };
+
+//# sourceMappingURL=ledger-core-B2hahzrt.js.map

package/dist/ledger-core-B2hahzrt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger-core-B2hahzrt.js","names":[],"sources":["../src/ledger-core/merkle.ts"],"sourcesContent":["/**\n * Merkle proofs over an append-only list of leaves (RFC 9162 §2.1, the\n * Certificate Transparency tree).\n *\n * A hash chain proves a whole log against its head, but proving one entry means\n * replaying everything before it. This tree proves any one leaf against a root\n * with ⌈log₂ n⌉ hashes (inclusion), and proves that a larger tree only appended\n * to a smaller one (consistency). A verifier holding a root can therefore check\n * a single event, or that a later checkpoint extends an earlier one, without\n * reading the rest of the log.\n *\n * Leaves and interior nodes are domain-separated (0x00 and 0x01 prefixes), so a\n * leaf can never be presented as an interior node. Content that may later be\n * redacted takes a random 32-byte salt: a verifier then needs only the leaf's\n * hash, and short content cannot be guessed back from that hash. The salt must\n * be stored apart from anything that is shared after redaction.\n *\n * Builders refuse malformed input by throwing; verifiers never throw and return\n * a typed outcome, because a proof is external evidence and a bad one is a\n * finding, not a crash.\n */\nimport { sha256Bytes } from '@tangle-network/agent-interface'\nimport { ValidationError } from '../errors'\nimport { LEDGER_HASH_PATTERN, type LedgerHash } from './canonical'\n\n/** Proof that one leaf is at `leafIndex` in a tree of `treeSize` leaves. */\nexport interface MerkleInclusionProof {\n  readonly leafIndex: number\n  readonly treeSize: number\n  readonly path: readonly LedgerHash[]\n}\n\n/** Proof that the first `oldSize` leaves of a `newSize` tree are unchanged. */\nexport interface MerkleConsistencyProof {\n  readonly oldSize: number\n  readonly newSize: number\n  readonly path: readonly LedgerHash[]\n}\n\nexport type MerkleVerification =\n  | { readonly verified: true }\n  | { readonly verified: false; readonly reason: string }\n\nconst SALT_PATTERN = /^[a-f0-9]{64}$/\nconst LEAF_PREFIX = 0x00\nconst NODE_PREFIX = 0x01\nconst encoder = new TextEncoder()\n\n/** Root of the empty tree: SHA-256 of no bytes. */\nexport const MERKLE_EMPTY_ROOT: LedgerHash = sha256Bytes(new Uint8Array(0)) as LedgerHash\n\n/** A fresh random salt for {@link merkleLeafHash}: 32 bytes as 64 lowercase hex characters. */\nexport function merkleSalt(): string {\n  return toHex(globalThis.crypto.getRandomValues(new Uint8Array(32)))\n}\n\n/**\n * Leaf hash of `content`: SHA-256(0x00 ‖ salt ‖ content). Without a salt this is\n * exactly the RFC 9162 leaf hash. Strings are hashed as UTF-8.\n */\nexport function merkleLeafHash(content: Uint8Array | string, salt?: string): LedgerHash {\n  const bytes = typeof content === 'string' ? encoder.encode(content) : content\n  if (salt === undefined) return digest(LEAF_PREFIX, bytes)\n  if (!SALT_PATTERN.test(salt)) {\n    throw new ValidationError('merkle salt must be 32 bytes as 64 lowercase hex characters')\n  }\n  return digest(LEAF_PREFIX, fromHex(salt), bytes)\n}\n\n/** Root over leaf hashes, in order. The empty list has {@link MERKLE_EMPTY_ROOT}. */\nexport function merkleRoot(leaves: readonly LedgerHash[]): LedgerHash {\n  const nodes = decodeLeaves(leaves)\n  return nodes.length === 0 ? MERKLE_EMPTY_ROOT : toLedgerHash(subtreeRoot(nodes, 0, nodes.length))\n}\n\n/** Inclusion proof for the leaf at `leafIndex` (RFC 9162 §2.1.3.1). */\nexport function merkleInclusionProof(\n  leaves: readonly LedgerHash[],\n  leafIndex: number,\n): MerkleInclusionProof {\n  const nodes = decodeLeaves(leaves)\n  if (!Number.isSafeInteger(leafIndex) || leafIndex < 0 || leafIndex >= nodes.length) {\n    throw new ValidationError(\n      `merkle leaf index ${leafIndex} is outside a tree of ${nodes.length} leaves`,\n    )\n  }\n  const path: Uint8Array[] = []\n  inclusionPath(nodes, leafIndex, 0, nodes.length, path)\n  return { leafIndex, treeSize: nodes.length, path: path.map(toLedgerHash) }\n}\n\n/**\n * Consistency proof that the first `oldSize` leaves are the tree of that size\n * (RFC 9162 §2.1.4.1). Sizes 0 and `leaves.length` need no path.\n */\nexport function merkleConsistencyProof(\n  leaves: readonly LedgerHash[],\n  oldSize: number,\n): MerkleConsistencyProof {\n  const nodes = decodeLeaves(leaves)\n  if (!Number.isSafeInteger(oldSize) || oldSize < 0 || oldSize > nodes.length) {\n    throw new ValidationError(\n      `merkle old size ${oldSize} is outside a tree of ${nodes.length} leaves`,\n    )\n  }\n  const path: Uint8Array[] = []\n  if (oldSize > 0 && oldSize < nodes.length) subproof(nodes, oldSize, 0, nodes.length, true, path)\n  return { oldSize, newSize: nodes.length, path: path.map(toLedgerHash) }\n}\n\n/** Check that `leaf` is in the tree with `root` at the proof's index (RFC 9162 §2.1.3.2). */\nexport function verifyMerkleInclusion(\n  leaf: LedgerHash,\n  proof: MerkleInclusionProof,\n  root: LedgerHash,\n): MerkleVerification {\n  const { leafIndex, treeSize } = proof\n  if (!isSize(treeSize) || !isSize(leafIndex) || leafIndex >= treeSize) {\n    return refused(`leaf index ${leafIndex} is outside a tree of ${treeSize} leaves`)\n  }\n  const decoded = decodeAll([leaf, root, ...proof.path])\n  if (decoded === undefined) return refused('proof carries a malformed hash')\n  const [leafBytes, rootBytes, ...path] = decoded as [Uint8Array, Uint8Array, ...Uint8Array[]]\n  let fn = leafIndex\n  let sn = treeSize - 1\n  let r = leafBytes\n  for (const p of path) {\n    if (sn === 0) return refused('proof path is longer than the tree is deep')\n    if (fn % 2 === 1 || fn === sn) {\n      r = node(p, r)\n      if (fn % 2 === 0) {\n        while (fn % 2 === 0 && fn !== 0) {\n          fn = Math.floor(fn / 2)\n          sn = Math.floor(sn / 2)\n        }\n      }\n    } else {\n      r = node(r, p)\n    }\n    fn = Math.floor(fn / 2)\n    sn = Math.floor(sn / 2)\n  }\n  if (sn !== 0) return refused('proof path is shorter than the tree is deep')\n  return equal(r, rootBytes) ? { verified: true } : refused('leaf does not hash to the root')\n}\n\n/** Check that the tree with `newRoot` extends the tree with `oldRoot` (RFC 9162 §2.1.4.2). */\nexport function verifyMerkleConsistency(\n  proof: MerkleConsistencyProof,\n  oldRoot: LedgerHash,\n  newRoot: LedgerHash,\n): MerkleVerification {\n  const { oldSize, newSize } = proof\n  if (!isSize(oldSize) || !isSize(newSize) || oldSize > newSize) {\n    return refused(`old size ${oldSize} does not precede new size ${newSize}`)\n  }\n  const decoded = decodeAll([oldRoot, newRoot, ...proof.path])\n  if (decoded === undefined) return refused('proof carries a malformed hash')\n  const [oldBytes, newBytes, ...given] = decoded as [Uint8Array, Uint8Array, ...Uint8Array[]]\n  if (oldSize === 0 || oldSize === newSize) {\n    if (given.length !== 0) return refused('a trivial consistency proof must be empty')\n    if (oldSize === 0) {\n      return oldRoot === MERKLE_EMPTY_ROOT\n        ? { verified: true }\n        : refused('the empty tree has a different root')\n    }\n    return equal(oldBytes, newBytes)\n      ? { verified: true }\n      : refused('equal sizes with different roots')\n  }\n  const path = isPowerOfTwo(oldSize) ? [oldBytes, ...given] : given\n  if (path.length === 0) return refused('consistency proof is empty')\n  let fn = oldSize - 1\n  let sn = newSize - 1\n  while (fn % 2 === 1) {\n    fn = Math.floor(fn / 2)\n    sn = Math.floor(sn / 2)\n  }\n  let fr = path[0] as Uint8Array\n  let sr = fr\n  for (const c of path.slice(1)) {\n    if (sn === 0) return refused('proof path is longer than the tree is deep')\n    if (fn % 2 === 1 || fn === sn) {\n      fr = node(c, fr)\n      sr = node(c, sr)\n      if (fn % 2 === 0) {\n        while (fn % 2 === 0 && fn !== 0) {\n          fn = Math.floor(fn / 2)\n          sn = Math.floor(sn / 2)\n        }\n      }\n    } else {\n      sr = node(sr, c)\n    }\n    fn = Math.floor(fn / 2)\n    sn = Math.floor(sn / 2)\n  }\n  if (sn !== 0) return refused('proof path is shorter than the tree is deep')\n  if (!equal(fr, oldBytes)) return refused('proof does not rebuild the old root')\n  if (!equal(sr, newBytes)) return refused('proof does not rebuild the new root')\n  return { verified: true }\n}\n\nfunction subtreeRoot(nodes: readonly Uint8Array[], start: number, end: number): Uint8Array {\n  if (end - start === 1) return nodes[start] as Uint8Array\n  const k = largestPowerOfTwoBelow(end - start)\n  return node(subtreeRoot(nodes, start, start + k), subtreeRoot(nodes, start + k, end))\n}\n\nfunction inclusionPath(\n  nodes: readonly Uint8Array[],\n  index: number,\n  start: number,\n  end: number,\n  path: Uint8Array[],\n): void {\n  if (end - start === 1) return\n  const k = largestPowerOfTwoBelow(end - start)\n  if (index < start + k) {\n    inclusionPath(nodes, index, start, start + k, path)\n    path.push(subtreeRoot(nodes, start + k, end))\n  } else {\n    inclusionPath(nodes, index, start + k, end, path)\n    path.push(subtreeRoot(nodes, start, start + k))\n  }\n}\n\nfunction subproof(\n  nodes: readonly Uint8Array[],\n  oldSize: number,\n  start: number,\n  end: number,\n  complete: boolean,\n  path: Uint8Array[],\n): void {\n  if (end - start === oldSize) {\n    if (!complete) path.push(subtreeRoot(nodes, start, end))\n    return\n  }\n  const k = largestPowerOfTwoBelow(end - start)\n  if (oldSize <= k) {\n    subproof(nodes, oldSize, start, start + k, complete, path)\n    path.push(subtreeRoot(nodes, start + k, end))\n  } else {\n    subproof(nodes, oldSize - k, start + k, end, false, path)\n    path.push(subtreeRoot(nodes, start, start + k))\n  }\n}\n\nfunction node(left: Uint8Array, right: Uint8Array): Uint8Array {\n  return fromHex(digest(NODE_PREFIX, left, right).slice('sha256:'.length))\n}\n\nfunction digest(prefix: number, ...parts: Uint8Array[]): LedgerHash {\n  const length = parts.reduce((total, part) => total + part.length, 1)\n  const bytes = new Uint8Array(length)\n  bytes[0] = prefix\n  let offset = 1\n  for (const part of parts) {\n    bytes.set(part, offset)\n    offset += part.length\n  }\n  return sha256Bytes(bytes) as LedgerHash\n}\n\nfunction decodeLeaves(leaves: readonly LedgerHash[]): Uint8Array[] {\n  const decoded = decodeAll(leaves)\n  if (decoded === undefined) {\n    throw new ValidationError('merkle leaves must be sha256:<64 lowercase hex> hashes')\n  }\n  return decoded\n}\n\nfunction decodeAll(hashes: readonly string[]): Uint8Array[] | undefined {\n  const out: Uint8Array[] = []\n  for (const hash of hashes) {\n    if (typeof hash !== 'string' || !LEDGER_HASH_PATTERN.test(hash)) return undefined\n    out.push(fromHex(hash.slice('sha256:'.length)))\n  }\n  return out\n}\n\nfunction toLedgerHash(bytes: Uint8Array): LedgerHash {\n  return `sha256:${toHex(bytes)}`\n}\n\nfunction largestPowerOfTwoBelow(n: number): number {\n  let k = 1\n  while (k * 2 < n) k *= 2\n  return k\n}\n\nfunction isPowerOfTwo(n: number): boolean {\n  if (n < 1) return false\n  let m = n\n  while (m % 2 === 0) m /= 2\n  return m === 1\n}\n\nfunction isSize(n: number): boolean {\n  return Number.isSafeInteger(n) && n >= 0\n}\n\nfunction equal(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false\n  return true\n}\n\nfunction refused(reason: string): MerkleVerification {\n  return { verified: false, reason }\n}\n\nfunction toHex(bytes: Uint8Array): string {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')\n}\n\nfunction fromHex(hex: string): Uint8Array {\n  const bytes = new Uint8Array(hex.length / 2)\n  for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16)\n  return bytes\n}\n"],"mappings":"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"}

package/dist/{llm-judge-BtMxSe1e.js → llm-judge-Dw0rDpve.js}

@@ -11,14 +11,14 @@ import { i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledg
 import { B as assertCampaignDesign, D as FinalEvidenceError, E as FinalEvidenceConflictError, F as surfaceHash, G as campaignSplitDigest, H as assertCompleteCampaign, I as surfaceHashMatches, L as BackendIntegrityError, M as renderSurfaceDiff, N as surfaceContentHash, P as surfaceDispatchRef, U as campaignCoverage, V as assertCampaignSplitIdentity, W as campaignScenarioIdentity, b as campaignMeanCompositeOrNull, q as formatCoverageFailures, t as createCampaignEvidenceReceipt, v as campaignBreakdown, y as campaignMeanComposite } from "./campaign-evidence-OcUciD-N.js";
 import { m as mapConcurrent } from "./journal-DvKCvjty.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import { S as fsCampaignStorage, g as isRecord, h as isExternalTextCandidate, x as createRunCostLedger } from "./external-optimizer-subprocess-DitxECD3.js";
+import { S as fsCampaignStorage, g as isRecord, h as isExternalTextCandidate, x as createRunCostLedger } from "./external-optimizer-subprocess-CA3aXT8I.js";
 import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-BXcZw-jo.js";
 import { f as redactText, n as REDACTION_VERSION, o as detectCredential, s as detectPersonalData } from "./redact-Dk1ZdJEm.js";
 import { t as detectRewardHacking } from "./reward-hacking-BFcQgkux.js";
 import { t as assertProposalFindings } from "./proposal-findings-CXblsskH.js";
-import { O as paretoFrontier, a as searchPolicyView, i as searchExpansionIndex, k as paretoFrontierWithCrowding, m as EXPANSION_OPERATORS, n as runSearch, t as SEARCH_KERNEL_SOURCE, x as estimateNode } from "./search-kernel-BIXWM7YV.js";
-import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, u as searchNodeId } from "./search-ledger-aMTNQn_m.js";
-import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-nwrtXxC_.js";
+import { O as paretoFrontier, a as searchPolicyView, i as searchExpansionIndex, k as paretoFrontierWithCrowding, m as EXPANSION_OPERATORS, n as runSearch, t as SEARCH_KERNEL_SOURCE, x as estimateNode } from "./search-kernel-BztlERLv.js";
+import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, u as searchNodeId } from "./search-ledger-d7V8o9Lk.js";
+import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-CBvz3u_S.js";
 import { C as combineAbortSignals, d as stripFencedJson, o as costReceiptFromLlm, s as costReceiptFromLlmError, u as maximumChargeForLlmRequest } from "./llm-client-C_o62yG1.js";
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
@@ -6174,4 +6174,4 @@ function firstString(value) {
 //#endregion
 export { captureFinalEvidencePolicy as $, assertCompleteSearchHistory as A, searchReceiptAccounting as B, incumbentWithOperatorBandit as C, surfaceDiff as D, searchEdgeId as E, verifySearchHistoryArtifact as F, captureJudge as G, uniform as H, verifySearchHistoryReceipt as I, redTeamDataset as J, defaultProductionGate as K, campaignCellSearchResult as L, assertSearchHistoryMatchesState as M, createSearchHistoryReceipt as N, surfaceNode as O, searchHistoryCoverageRow as P, assertIndependentEvaluationSplit as Q, searchModelIdentity as R, incumbent as S, developmentClaim as T, runFinalComparison as U, asha as V, openAutoPr as W, scoreRedTeamOutput as X, redTeamReport as Y, runCanaries as Z, isProposedCandidate as _, transientDispatchFailure as a, resolveRunDir as at, beam as b, compareOptimizationMethods as c, buildCellSchedule as ct, combineComparisonCosts as d, evaluationUnitMap as et, costFromLedgerSummary as f, runOptimization as g, runImprovementLoop as h, quotaExhaustedUntil as i, planCampaignRun as it, assertSearchHistoryAdmissionOptions as j, SearchHistoryRequiredError as k, optimizationTokenUsageFromSummary as l, cellCachePath as lt, readGepaCandidatePopulationArtifact as m, JudgeParseError as n, runEval as nt, aggregateRunScore as o, tangleTracesRoot as ot, assertGepaCandidatePopulationSummary as p, DEFAULT_RED_TEAM_CORPUS as q, isTransientTransportFailure as r, runCampaign as rt, clamp01 as s, readCachedCell as st, llmJudge as t, reserveFinalEvidence as tt, executeOptimizationMethod as u, computeManifestHash as ut, labelTrustRank as v, SearchRecorder as w, crowdedFrontierParent as x, aide as y, searchProposalExecution as z };
 
-//# sourceMappingURL=llm-judge-BtMxSe1e.js.map
+//# sourceMappingURL=llm-judge-Dw0rDpve.js.map