@tangle-network/agent-eval 0.217.1 → 0.219.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-9jJ2fKSX.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-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";
 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-CR4QikYp.js";
-import { a as verifyMerkleInclusion, i as merkleSalt, n as merkleLeafHash, r as merkleRoot, t as merkleInclusionProof } from "../ledger-core-DrJhbms9.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";
 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

@@ -0,0 +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";
+export { LockHolderDeathReason, LockHolderIdentity, LockHolderRecord, LockHolderUnknownReason, LockHolderVerdict, LockIdentity, LockIdentityStats, lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity };

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

@@ -0,0 +1,181 @@
+import { readFileSync, readlinkSync } from "node:fs";
+import { hostname } from "node:os";
+//#region src/ledger-core/lock-holder.ts
+/**
+* The one dead-owner rule: whether a lock's recorded holder is provably dead.
+*
+* A lock is safe to take over only when its holder is proved dead. A pid alone
+* proves nothing: the OS hands a dead holder's pid to a later process, and a
+* filesystem hands a removed lock's inode to the next lock. So a holder record
+* carries the pid's OS start token, the boot id, the pid namespace, the host,
+* and the identity of the lock it was written for, and the verdict is `dead`
+* only when those facts prove it. Anything the record or this host cannot
+* settle is `unknown`, and a caller keeps treating the lock as held.
+*
+* This module imports only Node built-ins, so lock owners in other packages can
+* import `@tangle-network/agent-eval/lock-holder` without loading the rest of
+* the package.
+*/
+function lockIdentity(stats) {
+	return {
+		dev: stats.dev.toString(),
+		ino: stats.ino.toString(),
+		birthtimeNs: stats.birthtimeNs.toString()
+	};
+}
+/**
+* The identity to record for `pid` on this host. The start token is read for
+* `pid` itself, so a lock taken on behalf of another live process records that
+* process. Fields the host cannot report are omitted, which leaves a later
+* verdict on the record `unknown` rather than wrong.
+*/
+function readLockHolderIdentity(pid = process.pid) {
+	const processStart = readProcessStart(pid);
+	const { bootId, pidNamespace } = ownHostIdentity();
+	return {
+		pid,
+		host: hostname(),
+		...processStart ? { processStart } : {},
+		...bootId ? { bootId } : {},
+		...pidNamespace ? { pidNamespace } : {}
+	};
+}
+/**
+* Decide whether `record`'s holder is dead, alive, or unknown.
+*
+* `currentLock` is the identity of the lock as it is now. `dead` needs a record
+* with a start token and a lock identity, written for this very lock (equal dev,
+* ino and a nonzero birthtime), on this host and pid namespace, and then a
+* rebooted host, a gone pid, or a pid whose start token changed. `alive` needs
+* the pid present with the recorded start token. Everything else is `unknown`,
+* so a live holder's lock is never taken.
+*/
+function lockHolderVerdict(record, currentLock) {
+	if (!record || !Number.isSafeInteger(record.pid) || record.pid <= 0) return unknown("unreadable record");
+	if (record.host !== hostname()) return unknown("other host");
+	if (!record.processStart || !record.lock) return unknown("incomplete record");
+	if (!currentLock || currentLock.birthtimeNs === "0" || currentLock.dev !== record.lock.dev || currentLock.ino !== record.lock.ino || currentLock.birthtimeNs !== record.lock.birthtimeNs) return unknown("lock changed");
+	const own = ownHostIdentity();
+	if (record.pidNamespace !== own.pidNamespace) return unknown("other pid namespace");
+	if (record.bootId === void 0 !== (own.bootId === void 0)) return unknown("boot id unavailable");
+	if (record.bootId !== own.bootId) return {
+		liveness: "dead",
+		reason: "host rebooted"
+	};
+	if (pidIsGone(record.pid)) return {
+		liveness: "dead",
+		reason: "pid gone"
+	};
+	const start = readProcessStart(record.pid);
+	if (start === void 0) return unknown("start token unavailable");
+	if (start !== record.processStart) return {
+		liveness: "dead",
+		reason: "pid reused"
+	};
+	return { liveness: "alive" };
+}
+/**
+* Read a holder record from parsed JSON. The required fields are `pid` and
+* `host`; an identity field that is missing or malformed is dropped, which
+* leaves the holder named but never provably dead.
+*/
+function parseLockHolderRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	if (!Number.isSafeInteger(record.pid) || record.pid <= 0) return void 0;
+	if (typeof record.host !== "string" || record.host.length === 0) return void 0;
+	const processStart = text(record.processStart);
+	const bootId = text(record.bootId);
+	const pidNamespace = text(record.pidNamespace);
+	const lock = parseLockIdentity(record.lock);
+	return {
+		pid: record.pid,
+		host: record.host,
+		...processStart ? { processStart } : {},
+		...bootId ? { bootId } : {},
+		...pidNamespace ? { pidNamespace } : {},
+		...lock ? { lock } : {}
+	};
+}
+function parseLockIdentity(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const lock = value;
+	if (!decimal(lock.dev) || !decimal(lock.ino) || !decimal(lock.birthtimeNs)) return void 0;
+	return {
+		dev: lock.dev,
+		ino: lock.ino,
+		birthtimeNs: lock.birthtimeNs
+	};
+}
+function unknown(reason) {
+	return {
+		liveness: "unknown",
+		reason
+	};
+}
+function text(field) {
+	return typeof field === "string" && field.length > 0 ? field : void 0;
+}
+function decimal(field) {
+	return typeof field === "string" && /^\d+$/u.test(field);
+}
+/** Only ESRCH proves a pid gone; EPERM means it exists under another user. */
+function pidIsGone(pid) {
+	try {
+		process.kill(pid, 0);
+		return false;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "ESRCH";
+	}
+}
+let hostIdentity;
+function ownHostIdentity() {
+	if (hostIdentity) return hostIdentity;
+	const bootId = readOptional(() => readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim());
+	const pidNamespace = readOptional(() => readlinkSync("/proc/self/ns/pid"));
+	hostIdentity = {
+		...bootId ? { bootId } : {},
+		...pidNamespace ? { pidNamespace } : {}
+	};
+	return hostIdentity;
+}
+/**
+* The OS start token of a live pid: the same for a process's whole life and
+* different for every later holder of its pid. `undefined` when the host cannot
+* report one.
+*/
+function readProcessStart(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0 || process.platform === "win32") return void 0;
+	if (process.platform === "linux") {
+		const stat = readOptional(() => readFileSync(`/proc/${pid}/stat`, "utf8"));
+		if (stat === void 0) return void 0;
+		const startTime = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u)[19];
+		return startTime !== void 0 && /^\d+$/u.test(startTime) ? startTime : void 0;
+	}
+	const childProcess = process.getBuiltinModule?.("node:child_process");
+	if (!childProcess) return void 0;
+	return readOptional(() => childProcess.execFileSync("ps", [
+		"-o",
+		"lstart=",
+		"-p",
+		String(pid)
+	], {
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	}).trim());
+}
+function readOptional(read) {
+	try {
+		return read() || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity };
+
+//# sourceMappingURL=lock-holder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lock-holder.js","names":[],"sources":["../../src/ledger-core/lock-holder.ts"],"sourcesContent":["/**\n * The one dead-owner rule: whether a lock's recorded holder is provably dead.\n *\n * A lock is safe to take over only when its holder is proved dead. A pid alone\n * proves nothing: the OS hands a dead holder's pid to a later process, and a\n * filesystem hands a removed lock's inode to the next lock. So a holder record\n * carries the pid's OS start token, the boot id, the pid namespace, the host,\n * and the identity of the lock it was written for, and the verdict is `dead`\n * only when those facts prove it. Anything the record or this host cannot\n * settle is `unknown`, and a caller keeps treating the lock as held.\n *\n * This module imports only Node built-ins, so lock owners in other packages can\n * import `@tangle-network/agent-eval/lock-holder` without loading the rest of\n * the package.\n */\n\nimport { readFileSync, readlinkSync } from 'node:fs'\nimport { hostname } from 'node:os'\n\n/**\n * Identity of one lock path's inode, as decimal strings from a bigint `stat`.\n * ext4 hands a removed directory's inode to the next one at once (two\n * directories created 1.4 ms apart got the same inode on drew-gtr-pro), so dev\n * and ino alone can match a stale record to a live holder's new lock; the\n * nanosecond birthtime tells them apart.\n */\nexport interface LockIdentity {\n  readonly dev: string\n  readonly ino: string\n  readonly birthtimeNs: string\n}\n\n/** Who holds a lock: the process and the facts that tell it from a later holder of its pid. */\nexport interface LockHolderIdentity {\n  readonly pid: number\n  readonly host: string\n  /** OS start token of `pid`: Linux `/proc/<pid>/stat` starttime, elsewhere `ps` lstart. */\n  readonly processStart?: string\n  readonly bootId?: string\n  readonly pidNamespace?: string\n}\n\n/** A holder record as a lock owner writes it: the holder and the lock it was written for. */\nexport interface LockHolderRecord extends LockHolderIdentity {\n  readonly lock?: LockIdentity\n}\n\nexport type LockHolderDeathReason = 'pid gone' | 'pid reused' | 'host rebooted'\n\nexport type LockHolderUnknownReason =\n  | 'unreadable record'\n  | 'other host'\n  | 'incomplete record'\n  | 'lock changed'\n  | 'other pid namespace'\n  | 'boot id unavailable'\n  | 'start token unavailable'\n\nexport type LockHolderVerdict =\n  | { readonly liveness: 'dead'; readonly reason: LockHolderDeathReason }\n  | { readonly liveness: 'alive' }\n  | { readonly liveness: 'unknown'; readonly reason: LockHolderUnknownReason }\n\n/** Stat fields `lockIdentity` reads; pass `statSync(path, { bigint: true })` or its fstat/lstat. */\nexport interface LockIdentityStats {\n  readonly dev: bigint\n  readonly ino: bigint\n  readonly birthtimeNs: bigint\n}\n\nexport function lockIdentity(stats: LockIdentityStats): LockIdentity {\n  return {\n    dev: stats.dev.toString(),\n    ino: stats.ino.toString(),\n    birthtimeNs: stats.birthtimeNs.toString(),\n  }\n}\n\n/**\n * The identity to record for `pid` on this host. The start token is read for\n * `pid` itself, so a lock taken on behalf of another live process records that\n * process. Fields the host cannot report are omitted, which leaves a later\n * verdict on the record `unknown` rather than wrong.\n */\nexport function readLockHolderIdentity(pid: number = process.pid): LockHolderIdentity {\n  const processStart = readProcessStart(pid)\n  const { bootId, pidNamespace } = ownHostIdentity()\n  return {\n    pid,\n    host: hostname(),\n    ...(processStart ? { processStart } : {}),\n    ...(bootId ? { bootId } : {}),\n    ...(pidNamespace ? { pidNamespace } : {}),\n  }\n}\n\n/**\n * Decide whether `record`'s holder is dead, alive, or unknown.\n *\n * `currentLock` is the identity of the lock as it is now. `dead` needs a record\n * with a start token and a lock identity, written for this very lock (equal dev,\n * ino and a nonzero birthtime), on this host and pid namespace, and then a\n * rebooted host, a gone pid, or a pid whose start token changed. `alive` needs\n * the pid present with the recorded start token. Everything else is `unknown`,\n * so a live holder's lock is never taken.\n */\nexport function lockHolderVerdict(\n  record: LockHolderRecord | undefined,\n  currentLock: LockIdentity | undefined,\n): LockHolderVerdict {\n  if (!record || !Number.isSafeInteger(record.pid) || record.pid <= 0) {\n    return unknown('unreadable record')\n  }\n  if (record.host !== hostname()) return unknown('other host')\n  if (!record.processStart || !record.lock) return unknown('incomplete record')\n  if (\n    !currentLock ||\n    currentLock.birthtimeNs === '0' ||\n    currentLock.dev !== record.lock.dev ||\n    currentLock.ino !== record.lock.ino ||\n    currentLock.birthtimeNs !== record.lock.birthtimeNs\n  ) {\n    return unknown('lock changed')\n  }\n  const own = ownHostIdentity()\n  if (record.pidNamespace !== own.pidNamespace) return unknown('other pid namespace')\n  if ((record.bootId === undefined) !== (own.bootId === undefined)) {\n    return unknown('boot id unavailable')\n  }\n  if (record.bootId !== own.bootId) return { liveness: 'dead', reason: 'host rebooted' }\n  if (pidIsGone(record.pid)) return { liveness: 'dead', reason: 'pid gone' }\n  const start = readProcessStart(record.pid)\n  if (start === undefined) return unknown('start token unavailable')\n  if (start !== record.processStart) return { liveness: 'dead', reason: 'pid reused' }\n  return { liveness: 'alive' }\n}\n\n/**\n * Read a holder record from parsed JSON. The required fields are `pid` and\n * `host`; an identity field that is missing or malformed is dropped, which\n * leaves the holder named but never provably dead.\n */\nexport function parseLockHolderRecord(value: unknown): LockHolderRecord | undefined {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined\n  const record = value as Record<string, unknown>\n  if (!Number.isSafeInteger(record.pid) || (record.pid as number) <= 0) return undefined\n  if (typeof record.host !== 'string' || record.host.length === 0) return undefined\n  const processStart = text(record.processStart)\n  const bootId = text(record.bootId)\n  const pidNamespace = text(record.pidNamespace)\n  const lock = parseLockIdentity(record.lock)\n  return {\n    pid: record.pid as number,\n    host: record.host,\n    ...(processStart ? { processStart } : {}),\n    ...(bootId ? { bootId } : {}),\n    ...(pidNamespace ? { pidNamespace } : {}),\n    ...(lock ? { lock } : {}),\n  }\n}\n\nfunction parseLockIdentity(value: unknown): LockIdentity | undefined {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined\n  const lock = value as Record<string, unknown>\n  if (!decimal(lock.dev) || !decimal(lock.ino) || !decimal(lock.birthtimeNs)) return undefined\n  return { dev: lock.dev, ino: lock.ino, birthtimeNs: lock.birthtimeNs }\n}\n\nfunction unknown(reason: LockHolderUnknownReason): LockHolderVerdict {\n  return { liveness: 'unknown', reason }\n}\n\nfunction text(field: unknown): string | undefined {\n  return typeof field === 'string' && field.length > 0 ? field : undefined\n}\n\nfunction decimal(field: unknown): field is string {\n  return typeof field === 'string' && /^\\d+$/u.test(field)\n}\n\n/** Only ESRCH proves a pid gone; EPERM means it exists under another user. */\nfunction pidIsGone(pid: number): boolean {\n  try {\n    process.kill(pid, 0)\n    return false\n  } catch (error) {\n    return error instanceof Error && 'code' in error && error.code === 'ESRCH'\n  }\n}\n\ninterface HostIdentity {\n  readonly bootId?: string\n  readonly pidNamespace?: string\n}\n\nlet hostIdentity: HostIdentity | undefined\n\nfunction ownHostIdentity(): HostIdentity {\n  if (hostIdentity) return hostIdentity\n  const bootId = readOptional(() => readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim())\n  const pidNamespace = readOptional(() => readlinkSync('/proc/self/ns/pid'))\n  hostIdentity = {\n    ...(bootId ? { bootId } : {}),\n    ...(pidNamespace ? { pidNamespace } : {}),\n  }\n  return hostIdentity\n}\n\n/**\n * The OS start token of a live pid: the same for a process's whole life and\n * different for every later holder of its pid. `undefined` when the host cannot\n * report one.\n */\nfunction readProcessStart(pid: number): string | undefined {\n  if (!Number.isSafeInteger(pid) || pid <= 0 || process.platform === 'win32') return undefined\n  if (process.platform === 'linux') {\n    const stat = readOptional(() => readFileSync(`/proc/${pid}/stat`, 'utf8'))\n    if (stat === undefined) return undefined\n    // The comm field is parenthesized and may hold spaces, so fields are counted after its close.\n    const startTime = stat\n      .slice(stat.lastIndexOf(')') + 1)\n      .trim()\n      .split(/\\s+/u)[19]\n    return startTime !== undefined && /^\\d+$/u.test(startTime) ? startTime : undefined\n  }\n  // `ps` lstart has 1 s resolution, so a pid reused within the same second reads\n  // as alive and keeps the lock: the safe direction. child_process is resolved\n  // on use so bundles that import this module never load it at startup.\n  const childProcess = process.getBuiltinModule?.('node:child_process') as\n    | typeof import('node:child_process')\n    | undefined\n  if (!childProcess) return undefined\n  return readOptional(() =>\n    childProcess\n      .execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {\n        encoding: 'utf8',\n        stdio: ['ignore', 'pipe', 'ignore'],\n      })\n      .trim(),\n  )\n}\n\nfunction readOptional(read: () => string): string | undefined {\n  try {\n    return read() || undefined\n  } catch {\n    return undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAsEA,SAAgB,aAAa,OAAwC;CACnE,OAAO;EACL,KAAK,MAAM,IAAI,SAAS;EACxB,KAAK,MAAM,IAAI,SAAS;EACxB,aAAa,MAAM,YAAY,SAAS;CAC1C;AACF;;;;;;;AAQA,SAAgB,uBAAuB,MAAc,QAAQ,KAAyB;CACpF,MAAM,eAAe,iBAAiB,GAAG;CACzC,MAAM,EAAE,QAAQ,iBAAiB,gBAAgB;CACjD,OAAO;EACL;EACA,MAAM,SAAS;EACf,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC;EACvC,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAC3B,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC;CACzC;AACF;;;;;;;;;;;AAYA,SAAgB,kBACd,QACA,aACmB;CACnB,IAAI,CAAC,UAAU,CAAC,OAAO,cAAc,OAAO,GAAG,KAAK,OAAO,OAAO,GAChE,OAAO,QAAQ,mBAAmB;CAEpC,IAAI,OAAO,SAAS,SAAS,GAAG,OAAO,QAAQ,YAAY;CAC3D,IAAI,CAAC,OAAO,gBAAgB,CAAC,OAAO,MAAM,OAAO,QAAQ,mBAAmB;CAC5E,IACE,CAAC,eACD,YAAY,gBAAgB,OAC5B,YAAY,QAAQ,OAAO,KAAK,OAChC,YAAY,QAAQ,OAAO,KAAK,OAChC,YAAY,gBAAgB,OAAO,KAAK,aAExC,OAAO,QAAQ,cAAc;CAE/B,MAAM,MAAM,gBAAgB;CAC5B,IAAI,OAAO,iBAAiB,IAAI,cAAc,OAAO,QAAQ,qBAAqB;CAClF,IAAK,OAAO,WAAW,KAAA,OAAgB,IAAI,WAAW,KAAA,IACpD,OAAO,QAAQ,qBAAqB;CAEtC,IAAI,OAAO,WAAW,IAAI,QAAQ,OAAO;EAAE,UAAU;EAAQ,QAAQ;CAAgB;CACrF,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;EAAE,UAAU;EAAQ,QAAQ;CAAW;CACzE,MAAM,QAAQ,iBAAiB,OAAO,GAAG;CACzC,IAAI,UAAU,KAAA,GAAW,OAAO,QAAQ,yBAAyB;CACjE,IAAI,UAAU,OAAO,cAAc,OAAO;EAAE,UAAU;EAAQ,QAAQ;CAAa;CACnF,OAAO,EAAE,UAAU,QAAQ;AAC7B;;;;;;AAOA,SAAgB,sBAAsB,OAA8C;CAClF,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GAAG,OAAO,KAAA;CAChF,MAAM,SAAS;CACf,IAAI,CAAC,OAAO,cAAc,OAAO,GAAG,KAAM,OAAO,OAAkB,GAAG,OAAO,KAAA;CAC7E,IAAI,OAAO,OAAO,SAAS,YAAY,OAAO,KAAK,WAAW,GAAG,OAAO,KAAA;CACxE,MAAM,eAAe,KAAK,OAAO,YAAY;CAC7C,MAAM,SAAS,KAAK,OAAO,MAAM;CACjC,MAAM,eAAe,KAAK,OAAO,YAAY;CAC7C,MAAM,OAAO,kBAAkB,OAAO,IAAI;CAC1C,OAAO;EACL,KAAK,OAAO;EACZ,MAAM,OAAO;EACb,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC;EACvC,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAC3B,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC;EACvC,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;CACzB;AACF;AAEA,SAAS,kBAAkB,OAA0C;CACnE,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GAAG,OAAO,KAAA;CAChF,MAAM,OAAO;CACb,IAAI,CAAC,QAAQ,KAAK,GAAG,KAAK,CAAC,QAAQ,KAAK,GAAG,KAAK,CAAC,QAAQ,KAAK,WAAW,GAAG,OAAO,KAAA;CACnF,OAAO;EAAE,KAAK,KAAK;EAAK,KAAK,KAAK;EAAK,aAAa,KAAK;CAAY;AACvE;AAEA,SAAS,QAAQ,QAAoD;CACnE,OAAO;EAAE,UAAU;EAAW;CAAO;AACvC;AAEA,SAAS,KAAK,OAAoC;CAChD,OAAO,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ,KAAA;AACjE;AAEA,SAAS,QAAQ,OAAiC;CAChD,OAAO,OAAO,UAAU,YAAY,SAAS,KAAK,KAAK;AACzD;;AAGA,SAAS,UAAU,KAAsB;CACvC,IAAI;EACF,QAAQ,KAAK,KAAK,CAAC;EACnB,OAAO;CACT,SAAS,OAAO;EACd,OAAO,iBAAiB,SAAS,UAAU,SAAS,MAAM,SAAS;CACrE;AACF;AAOA,IAAI;AAEJ,SAAS,kBAAgC;CACvC,IAAI,cAAc,OAAO;CACzB,MAAM,SAAS,mBAAmB,aAAa,mCAAmC,MAAM,CAAC,CAAC,KAAK,CAAC;CAChG,MAAM,eAAe,mBAAmB,aAAa,mBAAmB,CAAC;CACzE,eAAe;EACb,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAC3B,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC;CACzC;CACA,OAAO;AACT;;;;;;AAOA,SAAS,iBAAiB,KAAiC;CACzD,IAAI,CAAC,OAAO,cAAc,GAAG,KAAK,OAAO,KAAK,QAAQ,aAAa,SAAS,OAAO,KAAA;CACnF,IAAI,QAAQ,aAAa,SAAS;EAChC,MAAM,OAAO,mBAAmB,aAAa,SAAS,IAAI,QAAQ,MAAM,CAAC;EACzE,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;EAE/B,MAAM,YAAY,KACf,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC,CAAC,CAChC,KAAK,CAAC,CACN,MAAM,MAAM,CAAC,CAAC;EACjB,OAAO,cAAc,KAAA,KAAa,SAAS,KAAK,SAAS,IAAI,YAAY,KAAA;CAC3E;CAIA,MAAM,eAAe,QAAQ,mBAAmB,oBAAoB;CAGpE,IAAI,CAAC,cAAc,OAAO,KAAA;CAC1B,OAAO,mBACL,aACG,aAAa,MAAM;EAAC;EAAM;EAAW;EAAM,OAAO,GAAG;CAAC,GAAG;EACxD,UAAU;EACV,OAAO;GAAC;GAAU;GAAQ;EAAQ;CACpC,CAAC,CAAC,CACD,KAAK,CACV;AACF;AAEA,SAAS,aAAa,MAAwC;CAC5D,IAAI;EACF,OAAO,KAAK,KAAK,KAAA;CACnB,QAAQ;EACN;CACF;AACF"}

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

@@ -1,6 +1,6 @@
 import { s as ValidationError } from "./errors-BcOs5MKW.js";
 import { t as LEDGER_HASH_PATTERN } from "./canonical-Dq2hOQ8L.js";
-import "./journal-CR4QikYp.js";
+import "./journal-C7om8Gum.js";
 import { sha256Bytes } from "@tangle-network/agent-interface";
 //#region src/ledger-core/merkle.ts
 /**
@@ -166,4 +166,4 @@ function fromHex(hex) {
 //#endregion
 export { verifyMerkleInclusion as a, merkleSalt as i, merkleLeafHash as n, merkleRoot as r, merkleInclusionProof as t };
 
-//# sourceMappingURL=ledger-core-DrJhbms9.js.map
+//# sourceMappingURL=ledger-core-CAxUdDk0.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"ledger-core-DrJhbms9.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-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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"}