@tangle-network/agent-eval 0.221.7 → 0.222.0

package/dist/ledger-core/index.d.ts

@@ -1,3 +1,3 @@
-import { A as AtomicFileLock, C as LedgerTrustedHead, D as LedgerFileContext, E as FileLockResult, F as tryAcquireAtomicFileLock, M as AtomicFileLockOptions, N as AtomicFileLockOwner, O as tryWithLedgerFileLock, P as AtomicFileLockUnavailable, S as LedgerAnchoredEntry, T as LedgerTrustedHeadSubject, _ as LedgerJournalCodec, a as merkleInclusionProof, b as LedgerProjectorSnapshotCodec, c as merkleSalt, d as FileLedgerJournalOptions, f as LedgerAppendOptions, g as LedgerEventBase, h as LedgerEntryOf, i as MerkleVerification, j as AtomicFileLockAcquisition, k as writeLedgerFileAtomically, l as verifyMerkleInclusion, m as LedgerChainFields, n as MerkleConsistencyProof, o as merkleLeafHash, p as LedgerAppendResult, r as MerkleInclusionProof, s as merkleRoot, t as LedgerProjectorSnapshot, u as FileLedgerJournal, v as LedgerLineContext, w as LedgerTrustedHeadRemoval, x as LedgerTextStore, y as LedgerProjector } from "../index-CalAsXMR.js";
-import { a as hashCanonical, i as canonicalString, n as LedgerCanonicalizationError, o as jsonDocument, r as LedgerHash, t as LEDGER_HASH_PATTERN } from "../canonical-CFpojCN5.js";
+import { A as AtomicFileLock, C as LedgerTrustedHead, D as LedgerFileContext, E as FileLockResult, F as tryAcquireAtomicFileLock, M as AtomicFileLockOptions, N as AtomicFileLockOwner, O as tryWithLedgerFileLock, P as AtomicFileLockUnavailable, S as LedgerAnchoredEntry, T as LedgerTrustedHeadSubject, _ as LedgerJournalCodec, a as merkleInclusionProof, b as LedgerProjectorSnapshotCodec, c as merkleSalt, d as FileLedgerJournalOptions, f as LedgerAppendOptions, g as LedgerEventBase, h as LedgerEntryOf, i as MerkleVerification, j as AtomicFileLockAcquisition, k as writeLedgerFileAtomically, l as verifyMerkleInclusion, m as LedgerChainFields, n as MerkleConsistencyProof, o as merkleLeafHash, p as LedgerAppendResult, r as MerkleInclusionProof, s as merkleRoot, t as LedgerProjectorSnapshot, u as FileLedgerJournal, v as LedgerLineContext, w as LedgerTrustedHeadRemoval, x as LedgerTextStore, y as LedgerProjector } from "../index-B1Bm9oJA.js";
+import { a as hashCanonical, i as canonicalString, n as LedgerCanonicalizationError, o as jsonDocument, r as LedgerHash, t as LEDGER_HASH_PATTERN } from "../canonical-gLeHiqzd.js";
 export { type AtomicFileLock, type AtomicFileLockAcquisition, type AtomicFileLockOptions, type AtomicFileLockOwner, type AtomicFileLockUnavailable, FileLedgerJournal, type FileLedgerJournalOptions, type FileLockResult, LEDGER_HASH_PATTERN, type LedgerAnchoredEntry, type LedgerAppendOptions, type LedgerAppendResult, LedgerCanonicalizationError, type LedgerChainFields, type LedgerEntryOf, type LedgerEventBase, type LedgerFileContext, type LedgerHash, type LedgerJournalCodec, type LedgerLineContext, type LedgerProjector, type LedgerProjectorSnapshot, type LedgerProjectorSnapshotCodec, type LedgerTextStore, type LedgerTrustedHead, type LedgerTrustedHeadRemoval, type LedgerTrustedHeadSubject, type MerkleConsistencyProof, type MerkleInclusionProof, type MerkleVerification, canonicalString, hashCanonical, jsonDocument, merkleInclusionProof, merkleLeafHash, merkleRoot, merkleSalt, tryAcquireAtomicFileLock, tryWithLedgerFileLock, verifyMerkleInclusion, writeLedgerFileAtomically };

package/dist/ledger-core/index.js

@@ -1,4 +1,4 @@
-import { a as hashCanonical, n as LedgerCanonicalizationError, o as jsonDocument, r as canonicalString, t as LEDGER_HASH_PATTERN } from "../canonical-Dq2hOQ8L.js";
-import { c as tryWithLedgerFileLock, f as tryAcquireAtomicFileLock, t as FileLedgerJournal, u as writeLedgerFileAtomically } from "../journal-C7om8Gum.js";
-import { a as verifyMerkleInclusion, i as merkleSalt, n as merkleLeafHash, r as merkleRoot, t as merkleInclusionProof } from "../ledger-core-CAxUdDk0.js";
+import { a as hashCanonical, n as LedgerCanonicalizationError, o as jsonDocument, r as canonicalString, t as LEDGER_HASH_PATTERN } from "../canonical-CicJlINA.js";
+import { a as tryWithLedgerFileLock, l as tryAcquireAtomicFileLock, s as writeLedgerFileAtomically, t as FileLedgerJournal } from "../journal-C1uLJi0w.js";
+import { a as verifyMerkleInclusion, i as merkleSalt, n as merkleLeafHash, r as merkleRoot, t as merkleInclusionProof } from "../ledger-core-CfT-FzPf.js";
 export { FileLedgerJournal, LEDGER_HASH_PATTERN, LedgerCanonicalizationError, canonicalString, hashCanonical, jsonDocument, merkleInclusionProof, merkleLeafHash, merkleRoot, merkleSalt, tryAcquireAtomicFileLock, tryWithLedgerFileLock, verifyMerkleInclusion, writeLedgerFileAtomically };

package/dist/ledger-core/lock-holder.d.ts

@@ -1,2 +1,2 @@
-import { a as LockHolderVerdict, c as lockHolderVerdict, d as readLockHolderIdentity, i as LockHolderUnknownReason, l as lockIdentity, n as LockHolderIdentity, o as LockIdentity, r as LockHolderRecord, s as LockIdentityStats, t as LockHolderDeathReason, u as parseLockHolderRecord } from "../lock-holder-DaJbfpci.js";
+import { a as LockHolderVerdict, c as lockHolderVerdict, d as readLockHolderIdentity, i as LockHolderUnknownReason, l as lockIdentity, n as LockHolderIdentity, o as LockIdentity, r as LockHolderRecord, s as LockIdentityStats, t as LockHolderDeathReason, u as parseLockHolderRecord } from "../lock-holder-DoxlZFkQ.js";
 export { LockHolderDeathReason, LockHolderIdentity, LockHolderRecord, LockHolderUnknownReason, LockHolderVerdict, LockIdentity, LockIdentityStats, lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity };

package/dist/ledger-core/lock-holder.js

@@ -1,6 +1,6 @@
 import { readFileSync, readlinkSync } from "node:fs";
 import { hostname } from "node:os";
-//#region src/ledger-core/lock-holder.ts
+// src/ledger-core/lock-holder.ts
 /**
 * The one dead-owner rule: whether a lock's recorded holder is provably dead.
 *
@@ -175,7 +175,6 @@ function readOptional(read) {
 		return;
 	}
 }
-//#endregion
 export { lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity };
 
 //# sourceMappingURL=lock-holder.js.map

package/dist/{ledger-core-CAxUdDk0.js → ledger-core-CfT-FzPf.js}

@@ -1,8 +1,8 @@
-import { s as ValidationError } from "./errors-BcOs5MKW.js";
-import { t as LEDGER_HASH_PATTERN } from "./canonical-Dq2hOQ8L.js";
-import "./journal-C7om8Gum.js";
+import { s as ValidationError } from "./errors-DeEEV9Vx.js";
+import { t as LEDGER_HASH_PATTERN } from "./canonical-CicJlINA.js";
+import "./journal-C1uLJi0w.js";
 import { sha256Bytes } from "@tangle-network/agent-interface";
-//#region src/ledger-core/merkle.ts
+// src/ledger-core/merkle.ts
 /**
 * Merkle proofs over an append-only list of leaves (RFC 9162 §2.1, the
 * Certificate Transparency tree).
@@ -163,7 +163,6 @@ function fromHex(hex) {
 	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
 	return bytes;
 }
-//#endregion
 export { verifyMerkleInclusion as a, merkleSalt as i, merkleLeafHash as n, merkleRoot as r, merkleInclusionProof as t };
 
-//# sourceMappingURL=ledger-core-CAxUdDk0.js.map
+//# sourceMappingURL=ledger-core-CfT-FzPf.js.map

package/dist/{ledger-core-CAxUdDk0.js.map → ledger-core-CfT-FzPf.js.map}

@@ -1 +1 @@
-{"version":3,"file":"ledger-core-CAxUdDk0.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. */\nconst 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\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\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\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\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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"}
+{"version":3,"file":"ledger-core-CfT-FzPf.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. */\nconst 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\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\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\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\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-client-b1ysZVIU.js → llm-client-kJ9EOqjt.js}

@@ -1,18 +1,9 @@
-import { t as AgentEvalError } from "./errors-BcOs5MKW.js";
-import { c as costForTokenPricing } from "./cost-ledger-BGZB6yY2.js";
-import { a as LlmCallError, o as LlmResponseError, r as parseJsonResult } from "./json-BhdsJaOQ.js";
-import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-75w4FWBj.js";
-import { t as newRecordId } from "./record-id-DUgsK5qp.js";
-//#region src/abort-signal.ts
-/** Combine active cancellation sources without wrapping a single source. */
-function combineAbortSignals(...signals) {
-	const active = [...new Set(signals.filter((signal) => signal !== void 0))];
-	if (active.length === 0) return void 0;
-	if (active.length === 1) return active[0];
-	return AbortSignal.any(active);
-}
-//#endregion
-//#region src/judge-families.ts
+import { t as AgentEvalError } from "./errors-DeEEV9Vx.js";
+import { c as costForTokenPricing } from "./cost-ledger-CS8R3IZj.js";
+import { a as LlmCallError, o as LlmResponseError, r as parseJsonResult } from "./json-DtvZNAU9.js";
+import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-DDLkP_eF.js";
+import { t as newRecordId } from "./record-id-CWZXFh58.js";
+// src/judge-families.ts
 /** Explicit `provider/...` prefix → family (models.dev / OpenRouter style). */
 const PROVIDER_PREFIX = {
 	anthropic: "anthropic",
@@ -109,8 +100,7 @@ function assertCrossFamily(models, opts = {}) {
 	if (list.length < minFamilies) throw new CrossFamilyError(`judge ensemble spans ${list.length} provider famil${list.length === 1 ? "y" : "ies"} (${list.join(", ") || "none"}) but ${minFamilies} required — a single-family ensemble is correlated bias, not independent signal`, list, models);
 	return list;
 }
-//#endregion
-//#region src/integrity/served-model.ts
+// src/integrity/served-model.ts
 /**
 * Served-model identity: prove the model that ANSWERED is the model that was
 * REQUESTED.
@@ -286,8 +276,15 @@ function assertCrossFamilyServed(pairs, opts = {}) {
 	if (list.length < minFamilies) throw new ServedCrossFamilyError(`${opts.context ? `${opts.context}: ` : ""}the models that ANSWERED span ${list.length} provider famil${list.length === 1 ? "y" : "ies"} (${list.join(", ") || "none"}) but ${minFamilies} required — served ids: ${checks.map((c) => c.served ?? "unreported").join(", ")}`, list, checks);
 	return list;
 }
-//#endregion
-//#region src/llm-client/resilience.ts
+// src/abort-signal.ts
+/** Combine active cancellation sources without wrapping a single source. */
+function combineAbortSignals(...signals) {
+	const active = [...new Set(signals.filter((signal) => signal !== void 0))];
+	if (active.length === 0) return void 0;
+	if (active.length === 1) return active[0];
+	return AbortSignal.any(active);
+}
+// src/llm-client/resilience.ts
 const DEFAULT_TIMEOUT_MS = Number(process.env.TANGLE_LLM_TIMEOUT_MS) || 3e5;
 const DEFAULT_MAXIMUM_ATTEMPTS = process.env.TANGLE_LLM_MAXIMUM_ATTEMPTS === void 0 ? 6 : Number(process.env.TANGLE_LLM_MAXIMUM_ATTEMPTS);
 function resolveMaximumAttempts(configured) {
@@ -407,8 +404,7 @@ async function sleep(ms, signal) {
 function deadlineExceeded(start, deadlineMs) {
 	return deadlineMs != null && Date.now() - start >= deadlineMs;
 }
-//#endregion
-//#region src/llm-client/wire.ts
+// src/llm-client/wire.ts
 function providerTokenCount(value) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
@@ -532,8 +528,7 @@ function parseWireToolCalls(value, model) {
 		};
 	});
 }
-//#endregion
-//#region src/llm-client/accounting.ts
+// src/llm-client/accounting.ts
 function maximumChargeForLlmRequest(request, options = {}) {
 	if (request.maxTokens === void 0) return void 0;
 	if (!Number.isInteger(request.maxTokens) || request.maxTokens <= 0) throw new RangeError(`maximumChargeForLlmRequest: maxTokens must be a positive integer`);
@@ -579,8 +574,7 @@ function providerReportedCost(raw) {
 function costReceiptFromLlmError(error, customTokenPricing) {
 	return error instanceof LlmResponseError ? costReceiptFromLlm(error.result, customTokenPricing) : void 0;
 }
-//#endregion
-//#region src/llm-client/request.ts
+// src/llm-client/request.ts
 /**
 * Low-level call. Returns raw content + usage + cost. Retries on transient
 * failures; does NOT degrade schema here — callers that want graceful
@@ -862,8 +856,7 @@ async function callLlmStructured(req, opts = {}) {
 		jsonMode: req.jsonMode ?? !req.jsonSchema
 	}, opts, true);
 }
-//#endregion
-//#region src/llm-client.ts
+// src/llm-client.ts
 /**
 * Structured-output call. Returns parsed JSON plus the raw result envelope.
 * Degrades `jsonSchema` → `jsonMode` on a 400 that names the schema param —
@@ -906,7 +899,6 @@ var LlmClient = class {
 		return callLlmJson(req, this.callOptions(per));
 	}
 };
-//#endregion
-export { judgeFamily as _, maximumChargeForLlmRequest as a, ModelSubstitutionError as c, assertServedModelPolicy as d, assertServedModels as f, assertCrossFamily as g, CrossFamilyError as h, costReceiptFromLlmError as i, assertCrossFamilyServed as l, describeServedModelCheck as m, callLlmJson as n, backoffMs as o, checkServedModel as p, costReceiptFromLlm as r, isTransientLlmError as s, LlmClient as t, assertServedModel as u, combineAbortSignals as v };
+export { assertCrossFamily as _, maximumChargeForLlmRequest as a, combineAbortSignals as c, assertServedModel as d, assertServedModelPolicy as f, CrossFamilyError as g, describeServedModelCheck as h, costReceiptFromLlmError as i, ModelSubstitutionError as l, checkServedModel as m, callLlmJson as n, backoffMs as o, assertServedModels as p, costReceiptFromLlm as r, isTransientLlmError as s, LlmClient as t, assertCrossFamilyServed as u, judgeFamily as v };
 
-//# sourceMappingURL=llm-client-b1ysZVIU.js.map
+//# sourceMappingURL=llm-client-kJ9EOqjt.js.map