@tangle-network/agent-eval 0.132.0 → 0.133.1

package/dist/ledger-core-eqaI3PCD.js

@@ -1,388 +0,0 @@
-import { t as canonicalize } from "./pre-registration-DakwTRXk.js";
-import { t as Mutex } from "./concurrency-MUjT7VjM.js";
-import { closeSync, constants, existsSync, fsyncSync, linkSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import { hostname } from "node:os";
-//#region src/ledger-core/atomic-file-lock.ts
-/** Crash-safe filesystem lock shared by campaign persistence and run exclusion. */
-var AtomicFileLockError = class extends Error {
-	name = "AtomicFileLockError";
-};
-/** Report whether another lock path prevents acquisition without modifying it. */
-function probeAtomicFileLock(options) {
-	if (existsSync(recoveryPath(options.lockPath))) return {
-		acquired: false,
-		reason: "recovery"
-	};
-	const state = ownerState(options.lockPath);
-	if (state.state === "held") return {
-		acquired: false,
-		reason: "held",
-		holder: state.owner
-	};
-	return null;
-}
-/**
-* Try to acquire a complete, uniquely-owned lock inode.
-*
-* A hard link publishes fully-written owner metadata atomically. Stale-owner
-* removal is serialized so one reclaimer cannot delete a new owner's lock.
-*/
-function tryAcquireAtomicFileLock(options) {
-	const pid = options.pid ?? process.pid;
-	if (!Number.isSafeInteger(pid) || pid <= 0) throw new AtomicFileLockError("atomic file lock pid must be a positive integer");
-	const owner = {
-		pid,
-		host: hostname(),
-		nonce: randomUUID()
-	};
-	for (let attempt = 0; attempt < 8; attempt += 1) {
-		if (existsSync(recoveryPath(options.lockPath))) return {
-			acquired: false,
-			reason: "recovery"
-		};
-		if (tryLinkOwner(options.lockPath, owner, `acquire.${attempt}`)) return acquired(options.lockPath, owner);
-		const holder = ownerState(options.lockPath);
-		if (holder.state === "missing") continue;
-		if (holder.state === "held") return {
-			acquired: false,
-			reason: "held",
-			holder: holder.owner
-		};
-		const reclaimPath = recoveryPath(options.lockPath);
-		if (!tryLinkOwner(reclaimPath, owner, `reclaim.${attempt}`)) return {
-			acquired: false,
-			reason: "recovery"
-		};
-		try {
-			const current = ownerState(options.lockPath);
-			if (current.state === "held") return {
-				acquired: false,
-				reason: "held",
-				holder: current.owner
-			};
-			if (current.state === "stale") {
-				const tombstone = `${options.lockPath}.stale.${owner.nonce}.${attempt}`;
-				try {
-					renameSync(options.lockPath, tombstone);
-					unlinkSync(tombstone);
-				} catch (error) {
-					if (!isMissing(error)) throw error;
-				}
-			}
-			if (tryLinkOwner(options.lockPath, owner, `recovered.${attempt}`)) return acquired(options.lockPath, owner);
-		} finally {
-			releaseOwnedPath(reclaimPath, owner);
-		}
-	}
-	throw new AtomicFileLockError(`could not acquire atomic file lock ${options.lockPath}`);
-}
-function acquired(lockPath, owner) {
-	return {
-		acquired: true,
-		lock: {
-			owner,
-			release: () => releaseOwnedPath(lockPath, owner)
-		}
-	};
-}
-function tryLinkOwner(lockPath, owner, suffix) {
-	const ownerPath = `${lockPath}.${owner.pid}.${owner.nonce}.${suffix}.owner`;
-	const descriptor = openSync(ownerPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
-	try {
-		writeFileSync(descriptor, `${canonicalOwner(owner)}\n`, "utf8");
-		fsyncSync(descriptor);
-	} catch (error) {
-		closeSync(descriptor);
-		unlinkIfExists(ownerPath);
-		throw error;
-	}
-	closeSync(descriptor);
-	try {
-		linkSync(ownerPath, lockPath);
-		return true;
-	} catch (error) {
-		if (!isAlreadyExists(error)) throw error;
-		return false;
-	} finally {
-		unlinkIfExists(ownerPath);
-	}
-}
-function ownerState(lockPath) {
-	const owner = readOwner(lockPath);
-	if (!owner) return { state: "missing" };
-	if (owner.host !== hostname()) return {
-		state: "held",
-		owner
-	};
-	try {
-		process.kill(owner.pid, 0);
-		return {
-			state: "held",
-			owner
-		};
-	} catch (error) {
-		if (isNoSuchProcess(error)) return {
-			state: "stale",
-			owner
-		};
-		return {
-			state: "held",
-			owner
-		};
-	}
-}
-function readOwner(lockPath) {
-	let contents;
-	try {
-		contents = readFileSync(lockPath, "utf8").trim();
-	} catch (error) {
-		if (isMissing(error)) return void 0;
-		throw error;
-	}
-	let value;
-	try {
-		value = JSON.parse(contents);
-	} catch (error) {
-		throw invalidOwner(lockPath, error);
-	}
-	if (!isOwner(value)) throw invalidOwner(lockPath);
-	return value;
-}
-function isOwner(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const record = value;
-	return Object.keys(record).length === 3 && Number.isSafeInteger(record.pid) && Number(record.pid) > 0 && typeof record.host === "string" && record.host.trim().length > 0 && typeof record.nonce === "string" && record.nonce.trim().length > 0;
-}
-function invalidOwner(lockPath, cause) {
-	const error = new AtomicFileLockError(`atomic file lock has an invalid owner (${lockPath}); refusing unsafe recovery`);
-	if (cause !== void 0) Object.defineProperty(error, "cause", { value: cause });
-	return error;
-}
-function releaseOwnedPath(lockPath, owner) {
-	const current = readOwner(lockPath);
-	if (!current) return;
-	if (canonicalOwner(current) !== canonicalOwner(owner)) throw new AtomicFileLockError(`atomic file lock owner changed before release (${lockPath})`);
-	try {
-		unlinkSync(lockPath);
-	} catch (error) {
-		if (!isMissing(error)) throw error;
-	}
-}
-function canonicalOwner(owner) {
-	return JSON.stringify({
-		host: owner.host,
-		nonce: owner.nonce,
-		pid: owner.pid
-	});
-}
-function recoveryPath(lockPath) {
-	return `${lockPath}.reclaim`;
-}
-function isAlreadyExists(error) {
-	return error instanceof Error && "code" in error && error.code === "EEXIST";
-}
-function isMissing(error) {
-	return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function isNoSuchProcess(error) {
-	return error instanceof Error && "code" in error && error.code === "ESRCH";
-}
-function unlinkIfExists(path) {
-	try {
-		unlinkSync(path);
-	} catch (error) {
-		if (!isMissing(error)) throw error;
-	}
-}
-//#endregion
-//#region src/ledger-core/journal-file.ts
-/** Filesystem durability and cross-process exclusion for append-only journal files. */
-/** Append one already-serialized line; the write is fsynced (file and directory)
-* before returning so an acknowledged append survives a crash. */
-function appendLedgerLine(path, line, context) {
-	mkdirSync(dirname(path), { recursive: true });
-	const fd = openSync(path, constants.O_CREAT | constants.O_WRONLY | constants.O_APPEND, 384);
-	try {
-		writeAll(fd, Buffer.from(line, "utf8"), context);
-		fsyncSync(fd);
-	} finally {
-		closeSync(fd);
-	}
-	fsyncDirectory(dirname(path));
-}
-function withLedgerFileLock(path, context, run) {
-	const result = tryWithLedgerFileLock(path, context, run);
-	if (!result.acquired) throw context.integrityError(`${context.subject} lock is held (${path})`);
-	return result.value;
-}
-function tryWithLedgerFileLock(path, context, run) {
-	mkdirSync(dirname(path), { recursive: true });
-	const lockPath = `${path}.lock`;
-	try {
-		const acquisition = tryAcquireAtomicFileLock({ lockPath });
-		if (!acquisition.acquired) return { acquired: false };
-		try {
-			return {
-				acquired: true,
-				value: run()
-			};
-		} finally {
-			acquisition.lock.release();
-		}
-	} catch (error) {
-		if (error instanceof AtomicFileLockError) throw context.integrityError(error.message, { cause: error });
-		throw error;
-	}
-}
-function writeAll(fd, bytes, context) {
-	let offset = 0;
-	while (offset < bytes.byteLength) {
-		const written = writeSync(fd, bytes, offset, bytes.byteLength - offset);
-		if (written <= 0) throw context.integrityError("filesystem wrote zero bytes");
-		offset += written;
-	}
-}
-function fsyncDirectory(path) {
-	const fd = openSync(path, constants.O_RDONLY);
-	try {
-		fsyncSync(fd);
-	} finally {
-		closeSync(fd);
-	}
-}
-//#endregion
-//#region src/ledger-core/journal.ts
-/**
-* Generic durable append-only journal with a SHA-256 hash chain.
-*
-* The file format is canonical JSONL: every row is the canonical JSON encoding
-* (object keys sorted recursively) of one entry, and every entry hashes the
-* previous entry's hash so the log is tamper-evident. Appends are serialized
-* in-process per path and across processes via a lock file, fsynced before
-* acknowledgement, and idempotent by `eventId`. A malformed, non-canonical,
-* truncated, reordered, or conflicting log fails loudly; a bad row is never
-* skipped.
-*
-* Domain vocabulary lives entirely in the consumer's codec: entry schema
-* validation, the constant header fields stamped into every entry, the error
-* taxonomy, and the state machine replayed over verified entries.
-*/
-/** Canonical JSON encoding: object keys sorted recursively. This is the byte
-* form that is hashed and stored, so identical values always encode identically. */
-function canonicalString(value) {
-	return JSON.stringify(canonicalize(value));
-}
-function hashCanonical(value) {
-	return `sha256:${createHash("sha256").update(canonicalString(value)).digest("hex")}`;
-}
-const journalMutexes = /* @__PURE__ */ new Map();
-function mutexFor(path) {
-	const existing = journalMutexes.get(path);
-	if (existing) return existing;
-	const mutex = new Mutex();
-	journalMutexes.set(path, mutex);
-	return mutex;
-}
-/** Durable filesystem journal. Construction performs no I/O; `append` and
-* `replay` validate the complete existing file under the locks. */
-var FileLedgerJournal = class {
-	path;
-	codec;
-	mutex;
-	constructor(path, codec) {
-		this.path = resolve(path);
-		this.codec = codec;
-		this.mutex = mutexFor(this.path);
-	}
-	async replay() {
-		return this.mutex.runExclusive(() => withLedgerFileLock(this.path, this.codec, () => this.replayLocked()));
-	}
-	async append(event) {
-		return this.mutex.runExclusive(() => withLedgerFileLock(this.path, this.codec, () => {
-			const before = this.replayLocked();
-			const existing = before.entries.find((entry) => entry.event.eventId === event.eventId);
-			if (existing) {
-				if (canonicalString(existing.event) !== canonicalString(event)) throw this.codec.conflictError(`eventId ${event.eventId} already exists with different content`);
-				return {
-					entry: existing,
-					appended: false,
-					projection: before.projection
-				};
-			}
-			const material = {
-				...this.codec.header,
-				sequence: before.entries.length,
-				previousHash: before.entries.at(-1)?.entryHash ?? null,
-				event
-			};
-			const entry = {
-				...material,
-				entryHash: hashCanonical(material)
-			};
-			const projection = this.project([...before.entries, entry]);
-			appendLedgerLine(this.path, `${canonicalString(entry)}\n`, this.codec);
-			return {
-				entry,
-				appended: true,
-				projection
-			};
-		}));
-	}
-	replayLocked() {
-		const entries = this.readEntries();
-		return {
-			entries,
-			projection: this.project(entries)
-		};
-	}
-	readEntries() {
-		if (!existsSync(this.path)) return [];
-		const text = readFileSync(this.path, "utf8");
-		if (text.length === 0) return [];
-		if (!text.endsWith("\n")) throw this.codec.integrityError(`${this.codec.subject} ${this.path} has a truncated final record (missing newline)`);
-		const lines = text.slice(0, -1).split("\n");
-		const entries = [];
-		for (let index = 0; index < lines.length; index += 1) {
-			const line = lines[index];
-			if (line.length === 0) throw this.codec.integrityError(`${this.codec.subject} ${this.path} has a blank row at line ${index + 1}`);
-			let raw;
-			try {
-				raw = JSON.parse(line);
-			} catch (error) {
-				throw this.codec.integrityError(`${this.codec.subject} ${this.path} has invalid JSON at line ${index + 1}`, { cause: error });
-			}
-			const entry = this.codec.parseEntry(raw, {
-				path: this.path,
-				line: index + 1
-			});
-			if (line !== canonicalString(entry)) throw this.codec.integrityError(`${this.codec.subject} ${this.path} has non-canonical bytes at line ${index + 1}`);
-			entries.push(entry);
-		}
-		return entries;
-	}
-	project(entries) {
-		const projector = this.codec.createProjector();
-		const eventIds = /* @__PURE__ */ new Set();
-		let expectedPrevious = null;
-		for (let index = 0; index < entries.length; index += 1) {
-			const entry = entries[index];
-			this.codec.checkEntryHeader(entry, index);
-			if (entry.sequence !== index) throw this.codec.integrityError(`entry ${entry.event.eventId} has sequence ${entry.sequence}, expected ${index}`);
-			if (entry.previousHash !== expectedPrevious) throw this.codec.integrityError(`entry ${entry.event.eventId} does not extend the previous hash`);
-			const { entryHash: _entryHash, ...material } = entry;
-			const expectedHash = hashCanonical(material);
-			if (entry.entryHash !== expectedHash) throw this.codec.integrityError(`entry ${entry.event.eventId} hash mismatch: expected ${expectedHash}, got ${entry.entryHash}`);
-			expectedPrevious = entry.entryHash;
-			if (eventIds.has(entry.event.eventId)) throw this.codec.integrityError(`duplicate eventId ${entry.event.eventId} in durable ledger`);
-			eventIds.add(entry.event.eventId);
-			projector.apply(entry, index);
-		}
-		return projector.finish(entries);
-	}
-};
-//#endregion
-export { tryWithLedgerFileLock as a, probeAtomicFileLock as c, appendLedgerLine as i, tryAcquireAtomicFileLock as l, canonicalString as n, withLedgerFileLock as o, hashCanonical as r, AtomicFileLockError as s, FileLedgerJournal as t };
-
-//# sourceMappingURL=ledger-core-eqaI3PCD.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ledger-core-eqaI3PCD.js","names":[],"sources":["../src/ledger-core/atomic-file-lock.ts","../src/ledger-core/journal-file.ts","../src/ledger-core/journal.ts"],"sourcesContent":["/** Crash-safe filesystem lock shared by campaign persistence and run exclusion. */\n\nimport { randomUUID } from 'node:crypto'\nimport {\n  closeSync,\n  constants,\n  existsSync,\n  fsyncSync,\n  linkSync,\n  openSync,\n  readFileSync,\n  renameSync,\n  unlinkSync,\n  writeFileSync,\n} from 'node:fs'\nimport { hostname } from 'node:os'\n\nexport interface AtomicFileLockOwner {\n  readonly pid: number\n  readonly host: string\n  readonly nonce: string\n}\n\nexport interface AtomicFileLock {\n  readonly owner: AtomicFileLockOwner\n  release(): void\n}\n\nexport type AtomicFileLockUnavailable =\n  | { readonly acquired: false; readonly reason: 'held'; readonly holder: AtomicFileLockOwner }\n  | { readonly acquired: false; readonly reason: 'recovery' }\n\nexport type AtomicFileLockAcquisition =\n  | { readonly acquired: true; readonly lock: AtomicFileLock }\n  | AtomicFileLockUnavailable\n\nexport interface AtomicFileLockOptions {\n  readonly lockPath: string\n  readonly pid?: number\n}\n\nexport class AtomicFileLockError extends Error {\n  override readonly name = 'AtomicFileLockError'\n}\n\ntype OwnerState =\n  | { readonly state: 'missing' }\n  | { readonly state: 'stale'; readonly owner: AtomicFileLockOwner }\n  | { readonly state: 'held'; readonly owner: AtomicFileLockOwner }\n\n/** Report whether another lock path prevents acquisition without modifying it. */\nexport function probeAtomicFileLock(\n  options: AtomicFileLockOptions,\n): AtomicFileLockUnavailable | null {\n  if (existsSync(recoveryPath(options.lockPath))) return { acquired: false, reason: 'recovery' }\n  const state = ownerState(options.lockPath)\n  if (state.state === 'held') {\n    return { acquired: false, reason: 'held', holder: state.owner }\n  }\n  return null\n}\n\n/**\n * Try to acquire a complete, uniquely-owned lock inode.\n *\n * A hard link publishes fully-written owner metadata atomically. Stale-owner\n * removal is serialized so one reclaimer cannot delete a new owner's lock.\n */\nexport function tryAcquireAtomicFileLock(\n  options: AtomicFileLockOptions,\n): AtomicFileLockAcquisition {\n  const pid = options.pid ?? process.pid\n  if (!Number.isSafeInteger(pid) || pid <= 0) {\n    throw new AtomicFileLockError('atomic file lock pid must be a positive integer')\n  }\n  const owner: AtomicFileLockOwner = { pid, host: hostname(), nonce: randomUUID() }\n  for (let attempt = 0; attempt < 8; attempt += 1) {\n    if (existsSync(recoveryPath(options.lockPath))) {\n      return { acquired: false, reason: 'recovery' }\n    }\n    if (tryLinkOwner(options.lockPath, owner, `acquire.${attempt}`)) {\n      return acquired(options.lockPath, owner)\n    }\n\n    const holder = ownerState(options.lockPath)\n    if (holder.state === 'missing') continue\n    if (holder.state === 'held') {\n      return { acquired: false, reason: 'held', holder: holder.owner }\n    }\n\n    const reclaimPath = recoveryPath(options.lockPath)\n    if (!tryLinkOwner(reclaimPath, owner, `reclaim.${attempt}`)) {\n      return { acquired: false, reason: 'recovery' }\n    }\n    try {\n      const current = ownerState(options.lockPath)\n      if (current.state === 'held') {\n        return { acquired: false, reason: 'held', holder: current.owner }\n      }\n      if (current.state === 'stale') {\n        const tombstone = `${options.lockPath}.stale.${owner.nonce}.${attempt}`\n        try {\n          renameSync(options.lockPath, tombstone)\n          unlinkSync(tombstone)\n        } catch (error) {\n          if (!isMissing(error)) throw error\n        }\n      }\n      if (tryLinkOwner(options.lockPath, owner, `recovered.${attempt}`)) {\n        return acquired(options.lockPath, owner)\n      }\n    } finally {\n      releaseOwnedPath(reclaimPath, owner)\n    }\n  }\n\n  throw new AtomicFileLockError(`could not acquire atomic file lock ${options.lockPath}`)\n}\n\nfunction acquired(lockPath: string, owner: AtomicFileLockOwner): AtomicFileLockAcquisition {\n  return {\n    acquired: true,\n    lock: {\n      owner,\n      release: () => releaseOwnedPath(lockPath, owner),\n    },\n  }\n}\n\nfunction tryLinkOwner(lockPath: string, owner: AtomicFileLockOwner, suffix: string): boolean {\n  const ownerPath = `${lockPath}.${owner.pid}.${owner.nonce}.${suffix}.owner`\n  const descriptor = openSync(\n    ownerPath,\n    constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,\n    0o600,\n  )\n  try {\n    writeFileSync(descriptor, `${canonicalOwner(owner)}\\n`, 'utf8')\n    fsyncSync(descriptor)\n  } catch (error) {\n    closeSync(descriptor)\n    unlinkIfExists(ownerPath)\n    throw error\n  }\n  closeSync(descriptor)\n\n  try {\n    linkSync(ownerPath, lockPath)\n    return true\n  } catch (error) {\n    if (!isAlreadyExists(error)) throw error\n    return false\n  } finally {\n    unlinkIfExists(ownerPath)\n  }\n}\n\nfunction ownerState(lockPath: string): OwnerState {\n  const owner = readOwner(lockPath)\n  if (!owner) return { state: 'missing' }\n  if (owner.host !== hostname()) return { state: 'held', owner }\n  try {\n    process.kill(owner.pid, 0)\n    return { state: 'held', owner }\n  } catch (error) {\n    if (isNoSuchProcess(error)) return { state: 'stale', owner }\n    return { state: 'held', owner }\n  }\n}\n\nfunction readOwner(lockPath: string): AtomicFileLockOwner | undefined {\n  let contents: string\n  try {\n    contents = readFileSync(lockPath, 'utf8').trim()\n  } catch (error) {\n    if (isMissing(error)) return undefined\n    throw error\n  }\n\n  let value: unknown\n  try {\n    value = JSON.parse(contents)\n  } catch (error) {\n    throw invalidOwner(lockPath, error)\n  }\n  if (!isOwner(value)) throw invalidOwner(lockPath)\n  return value\n}\n\nfunction isOwner(value: unknown): value is AtomicFileLockOwner {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false\n  const record = value as Record<string, unknown>\n  return (\n    Object.keys(record).length === 3 &&\n    Number.isSafeInteger(record.pid) &&\n    Number(record.pid) > 0 &&\n    typeof record.host === 'string' &&\n    record.host.trim().length > 0 &&\n    typeof record.nonce === 'string' &&\n    record.nonce.trim().length > 0\n  )\n}\n\nfunction invalidOwner(lockPath: string, cause?: unknown): AtomicFileLockError {\n  const error = new AtomicFileLockError(\n    `atomic file lock has an invalid owner (${lockPath}); refusing unsafe recovery`,\n  )\n  if (cause !== undefined) Object.defineProperty(error, 'cause', { value: cause })\n  return error\n}\n\nfunction releaseOwnedPath(lockPath: string, owner: AtomicFileLockOwner): void {\n  const current = readOwner(lockPath)\n  if (!current) return\n  if (canonicalOwner(current) !== canonicalOwner(owner)) {\n    throw new AtomicFileLockError(`atomic file lock owner changed before release (${lockPath})`)\n  }\n  try {\n    unlinkSync(lockPath)\n  } catch (error) {\n    if (!isMissing(error)) throw error\n  }\n}\n\nfunction canonicalOwner(owner: AtomicFileLockOwner): string {\n  return JSON.stringify({ host: owner.host, nonce: owner.nonce, pid: owner.pid })\n}\n\nfunction recoveryPath(lockPath: string): string {\n  return `${lockPath}.reclaim`\n}\n\nfunction isAlreadyExists(error: unknown): boolean {\n  return error instanceof Error && 'code' in error && error.code === 'EEXIST'\n}\n\nfunction isMissing(error: unknown): boolean {\n  return error instanceof Error && 'code' in error && error.code === 'ENOENT'\n}\n\nfunction isNoSuchProcess(error: unknown): boolean {\n  return error instanceof Error && 'code' in error && error.code === 'ESRCH'\n}\n\nfunction unlinkIfExists(path: string): void {\n  try {\n    unlinkSync(path)\n  } catch (error) {\n    if (!isMissing(error)) throw error\n  }\n}\n","/** Filesystem durability and cross-process exclusion for append-only journal files. */\n\nimport { closeSync, constants, fsyncSync, mkdirSync, openSync, writeSync } from 'node:fs'\nimport { dirname } from 'node:path'\nimport { AtomicFileLockError, tryAcquireAtomicFileLock } from './atomic-file-lock'\n\n/** How a journal binding reports file-layer faults in its own error taxonomy. */\nexport interface LedgerFileContext {\n  /** Noun used in error messages, e.g. 'search ledger'. */\n  subject: string\n  integrityError(message: string, options?: { cause?: unknown }): Error\n}\n\n/** Append one already-serialized line; the write is fsynced (file and directory)\n * before returning so an acknowledged append survives a crash. */\nexport function appendLedgerLine(path: string, line: string, context: LedgerFileContext): void {\n  mkdirSync(dirname(path), { recursive: true })\n  const fd = openSync(path, constants.O_CREAT | constants.O_WRONLY | constants.O_APPEND, 0o600)\n  try {\n    writeAll(fd, Buffer.from(line, 'utf8'), context)\n    fsyncSync(fd)\n  } finally {\n    closeSync(fd)\n  }\n  fsyncDirectory(dirname(path))\n}\n\nexport function withLedgerFileLock<T>(path: string, context: LedgerFileContext, run: () => T): T {\n  const result = tryWithLedgerFileLock(path, context, run)\n  if (!result.acquired) {\n    throw context.integrityError(`${context.subject} lock is held (${path})`)\n  }\n  return result.value\n}\n\nexport type FileLockResult<T> = { acquired: true; value: T } | { acquired: false }\n\nexport function tryWithLedgerFileLock<T>(\n  path: string,\n  context: LedgerFileContext,\n  run: () => T,\n): FileLockResult<T> {\n  mkdirSync(dirname(path), { recursive: true })\n  const lockPath = `${path}.lock`\n  try {\n    const acquisition = tryAcquireAtomicFileLock({ lockPath })\n    if (!acquisition.acquired) return { acquired: false }\n    try {\n      return { acquired: true, value: run() }\n    } finally {\n      acquisition.lock.release()\n    }\n  } catch (error) {\n    if (error instanceof AtomicFileLockError) {\n      throw context.integrityError(error.message, { cause: error })\n    }\n    throw error\n  }\n}\n\nfunction writeAll(fd: number, bytes: Buffer, context: LedgerFileContext): void {\n  let offset = 0\n  while (offset < bytes.byteLength) {\n    const written = writeSync(fd, bytes, offset, bytes.byteLength - offset)\n    if (written <= 0) throw context.integrityError('filesystem wrote zero bytes')\n    offset += written\n  }\n}\n\nfunction fsyncDirectory(path: string): void {\n  const fd = openSync(path, constants.O_RDONLY)\n  try {\n    fsyncSync(fd)\n  } finally {\n    closeSync(fd)\n  }\n}\n","/**\n * Generic durable append-only journal with a SHA-256 hash chain.\n *\n * The file format is canonical JSONL: every row is the canonical JSON encoding\n * (object keys sorted recursively) of one entry, and every entry hashes the\n * previous entry's hash so the log is tamper-evident. Appends are serialized\n * in-process per path and across processes via a lock file, fsynced before\n * acknowledgement, and idempotent by `eventId`. A malformed, non-canonical,\n * truncated, reordered, or conflicting log fails loudly; a bad row is never\n * skipped.\n *\n * Domain vocabulary lives entirely in the consumer's codec: entry schema\n * validation, the constant header fields stamped into every entry, the error\n * taxonomy, and the state machine replayed over verified entries.\n */\n\nimport { createHash } from 'node:crypto'\nimport { existsSync, readFileSync } from 'node:fs'\nimport { resolve } from 'node:path'\nimport { Mutex } from '../concurrency'\nimport { canonicalize } from '../pre-registration'\nimport { appendLedgerLine, type LedgerFileContext, withLedgerFileLock } from './journal-file'\n\nexport type LedgerHash = `sha256:${string}`\n\n/** Canonical JSON encoding: object keys sorted recursively. This is the byte\n * form that is hashed and stored, so identical values always encode identically. */\nexport function canonicalString(value: unknown): string {\n  return JSON.stringify(canonicalize(value))\n}\n\nexport function hashCanonical(value: unknown): LedgerHash {\n  return `sha256:${createHash('sha256').update(canonicalString(value)).digest('hex')}`\n}\n\n/** Minimum shape of a journal event: the idempotency key. */\nexport interface LedgerEventBase {\n  eventId: string\n}\n\n/** Chain envelope every entry carries in addition to the journal's constant\n * header fields. `entryHash` covers the header, sequence, previous hash, and\n * event, so any rewrite of history invalidates every later entry. */\nexport interface LedgerChainFields<Event extends LedgerEventBase> {\n  sequence: number\n  previousHash: LedgerHash | null\n  event: Event\n  entryHash: LedgerHash\n}\n\nexport type LedgerEntryOf<Header extends object, Event extends LedgerEventBase> = Header &\n  LedgerChainFields<Event>\n\nexport interface LedgerLineContext {\n  path: string\n  line: number\n}\n\n/** Domain state machine replayed over chain-verified entries in order.\n * `apply` throws (via the codec's error taxonomy) on an invalid transition;\n * `finish` builds the consumer's projection once every entry was applied. */\nexport interface LedgerProjector<Entry, Projection> {\n  apply(entry: Entry, index: number): void\n  finish(entries: Entry[]): Projection\n}\n\nexport interface LedgerJournalCodec<\n  Header extends object,\n  Event extends LedgerEventBase,\n  Projection,\n> extends LedgerFileContext {\n  /** Constant fields stamped into every entry and covered by its hash. */\n  header: Header\n  conflictError(message: string): Error\n  /** Validate one parsed JSON row into a typed entry. Must reject malformed\n   * rows and non-canonical event encodings with the binding's own errors;\n   * the journal itself verifies the stored bytes and the hash chain. */\n  parseEntry(raw: unknown, context: LedgerLineContext): LedgerEntryOf<Header, Event>\n  /** Reject an entry whose constant header fields do not match this journal. */\n  checkEntryHeader(entry: LedgerEntryOf<Header, Event>, index: number): void\n  createProjector(): LedgerProjector<LedgerEntryOf<Header, Event>, Projection>\n}\n\nexport interface LedgerReplayResult<Entry, Projection> {\n  entries: Entry[]\n  projection: Projection\n}\n\nexport interface LedgerAppendResult<Entry, Projection> {\n  entry: Entry\n  /** False when the exact event was already durably present. */\n  appended: boolean\n  projection: Projection\n}\n\n// One async mutex per resolved journal path so concurrent appends from a single\n// process queue up instead of failing on the held cross-process lock file.\nconst journalMutexes = new Map<string, Mutex>()\n\nfunction mutexFor(path: string): Mutex {\n  const existing = journalMutexes.get(path)\n  if (existing) return existing\n  const mutex = new Mutex()\n  journalMutexes.set(path, mutex)\n  return mutex\n}\n\n/** Durable filesystem journal. Construction performs no I/O; `append` and\n * `replay` validate the complete existing file under the locks. */\nexport class FileLedgerJournal<Header extends object, Event extends LedgerEventBase, Projection> {\n  readonly path: string\n  private readonly codec: LedgerJournalCodec<Header, Event, Projection>\n  private readonly mutex: Mutex\n\n  constructor(path: string, codec: LedgerJournalCodec<Header, Event, Projection>) {\n    this.path = resolve(path)\n    this.codec = codec\n    this.mutex = mutexFor(this.path)\n  }\n\n  async replay(): Promise<LedgerReplayResult<LedgerEntryOf<Header, Event>, Projection>> {\n    return this.mutex.runExclusive(() =>\n      withLedgerFileLock(this.path, this.codec, () => this.replayLocked()),\n    )\n  }\n\n  async append(\n    event: Event,\n  ): Promise<LedgerAppendResult<LedgerEntryOf<Header, Event>, Projection>> {\n    return this.mutex.runExclusive(() =>\n      withLedgerFileLock(this.path, this.codec, () => {\n        const before = this.replayLocked()\n        const existing = before.entries.find((entry) => entry.event.eventId === event.eventId)\n        if (existing) {\n          if (canonicalString(existing.event) !== canonicalString(event)) {\n            throw this.codec.conflictError(\n              `eventId ${event.eventId} already exists with different content`,\n            )\n          }\n          return { entry: existing, appended: false, projection: before.projection }\n        }\n\n        const material = {\n          ...this.codec.header,\n          sequence: before.entries.length,\n          previousHash: before.entries.at(-1)?.entryHash ?? null,\n          event,\n        }\n        const entry = { ...material, entryHash: hashCanonical(material) }\n\n        // Apply the state transition before spending an append: an entry the\n        // projector rejects must never reach the durable file.\n        const projection = this.project([...before.entries, entry])\n        appendLedgerLine(this.path, `${canonicalString(entry)}\\n`, this.codec)\n        return { entry, appended: true, projection }\n      }),\n    )\n  }\n\n  private replayLocked(): LedgerReplayResult<LedgerEntryOf<Header, Event>, Projection> {\n    const entries = this.readEntries()\n    return { entries, projection: this.project(entries) }\n  }\n\n  private readEntries(): LedgerEntryOf<Header, Event>[] {\n    if (!existsSync(this.path)) return []\n    const text = readFileSync(this.path, 'utf8')\n    if (text.length === 0) return []\n    if (!text.endsWith('\\n')) {\n      throw this.codec.integrityError(\n        `${this.codec.subject} ${this.path} has a truncated final record (missing newline)`,\n      )\n    }\n\n    const lines = text.slice(0, -1).split('\\n')\n    const entries: LedgerEntryOf<Header, Event>[] = []\n    for (let index = 0; index < lines.length; index += 1) {\n      const line = lines[index]!\n      if (line.length === 0) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} has a blank row at line ${index + 1}`,\n        )\n      }\n      let raw: unknown\n      try {\n        raw = JSON.parse(line)\n      } catch (error) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} has invalid JSON at line ${index + 1}`,\n          { cause: error },\n        )\n      }\n      const entry = this.codec.parseEntry(raw, { path: this.path, line: index + 1 })\n      if (line !== canonicalString(entry)) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} has non-canonical bytes at line ${index + 1}`,\n        )\n      }\n      entries.push(entry)\n    }\n    return entries\n  }\n\n  private project(entries: LedgerEntryOf<Header, Event>[]): Projection {\n    const projector = this.codec.createProjector()\n    const eventIds = new Set<string>()\n    let expectedPrevious: LedgerHash | null = null\n    for (let index = 0; index < entries.length; index += 1) {\n      const entry = entries[index]!\n      this.codec.checkEntryHeader(entry, index)\n      if (entry.sequence !== index) {\n        throw this.codec.integrityError(\n          `entry ${entry.event.eventId} has sequence ${entry.sequence}, expected ${index}`,\n        )\n      }\n      if (entry.previousHash !== expectedPrevious) {\n        throw this.codec.integrityError(\n          `entry ${entry.event.eventId} does not extend the previous hash`,\n        )\n      }\n      const { entryHash: _entryHash, ...material } = entry\n      const expectedHash = hashCanonical(material)\n      if (entry.entryHash !== expectedHash) {\n        throw this.codec.integrityError(\n          `entry ${entry.event.eventId} hash mismatch: expected ${expectedHash}, got ${entry.entryHash}`,\n        )\n      }\n      expectedPrevious = entry.entryHash\n      if (eventIds.has(entry.event.eventId)) {\n        throw this.codec.integrityError(\n          `duplicate eventId ${entry.event.eventId} in durable ledger`,\n        )\n      }\n      eventIds.add(entry.event.eventId)\n      projector.apply(entry, index)\n    }\n    return projector.finish(entries)\n  }\n}\n"],"mappings":"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"}

package/dist/metrics-C9YY1OcL.js

@@ -1,239 +0,0 @@
-//#region src/metrics.ts
-/** Per-1K token pricing for exact model ids. */
-const MODEL_PRICING = {
-	"gpt-4o": {
-		input: .0025,
-		output: .01
-	},
-	"gpt-4o-mini": {
-		input: 15e-5,
-		output: 6e-4
-	},
-	"gpt-4-turbo": {
-		input: .01,
-		output: .03
-	},
-	"claude-sonnet-4-20250514": {
-		input: .003,
-		output: .015
-	},
-	"claude-opus-4-20250514": {
-		input: .015,
-		output: .075
-	},
-	"claude-3-haiku-20240307": {
-		input: 25e-5,
-		output: .00125
-	}
-};
-/** Family-level pricing fallbacks (per-1K), matched against a normalized id
-*  after exact lookup misses. Ordered — first match wins. Covers the model
-*  ids actually used through the Tangle router + cli-bridge harnesses
-*  (`claude-code/sonnet`, `opencode/zai-coding-plan/glm-5.1`,
-*  `kimi-code/kimi-k2.6`, `deepseek-v4-pro`, `anthropic/claude-sonnet-4-6`, …),
-*  none of which appear in the exact table above — without this they priced
-*  to a silent $0, blanking every cost/Pareto axis downstream. */
-const FAMILY_PRICING = [
-	[/claude.*opus/, {
-		input: .015,
-		output: .075
-	}],
-	[/claude.*haiku/, {
-		input: 8e-4,
-		output: .004
-	}],
-	[/claude.*sonnet|claude-code|claude-sonnet/, {
-		input: .003,
-		output: .015
-	}],
-	[/gpt-4o-mini/, {
-		input: 15e-5,
-		output: 6e-4
-	}],
-	[/gpt-5|gpt-4\.1|o[134]\b/, {
-		input: .00125,
-		output: .01
-	}],
-	[/gpt-4o|gpt-4/, {
-		input: .0025,
-		output: .01
-	}],
-	[/deepseek/, {
-		input: 3e-4,
-		output: .0011
-	}],
-	[/glm|zhipu|zai/, {
-		input: 6e-4,
-		output: .0022
-	}],
-	[/kimi|moonshot/, {
-		input: 6e-4,
-		output: .0025
-	}],
-	[/qwen/, {
-		input: 4e-4,
-		output: .0012
-	}],
-	[/gemini.*flash/, {
-		input: 1e-4,
-		output: 4e-4
-	}],
-	[/gemini/, {
-		input: .00125,
-		output: .005
-	}],
-	[/llama/, {
-		input: 2e-4,
-		output: 6e-4
-	}]
-];
-/** Normalize a model id for pricing: drop a `@snapshot` suffix, lowercase,
-*  and keep the final harness/provider-prefixed segment so family regexes
-*  match (`opencode/zai-coding-plan/glm-5.1` → `glm-5.1`). */
-function normalizeModelId(model) {
-	return (model.split("@")[0] ?? model).trim().toLowerCase();
-}
-/** Resolve pricing for a model id: exact table, then family fallback.
-*  Returns null when the id matches nothing (caller decides — never a
-*  silent-zero masquerading as a real $0 cost). */
-function resolveModelPricing(model) {
-	if (MODEL_PRICING[model]) return MODEL_PRICING[model];
-	const id = normalizeModelId(model);
-	if (MODEL_PRICING[id]) return MODEL_PRICING[id];
-	for (const [pattern, price] of FAMILY_PRICING) if (pattern.test(id)) return price;
-	return null;
-}
-/** True when `model` has known pricing (exact or family). Lets cost-aware
-*  callers distinguish a real $0 from an unpriced model. */
-function isModelPriced(model) {
-	return resolveModelPricing(model) !== null;
-}
-const warnedUnpricedModels = /* @__PURE__ */ new Set();
-/** Estimate token count from string length (chars / 4 approximation) */
-function estimateTokens(text) {
-	return Math.ceil(text.length / 4);
-}
-/** Calculate cost in USD from token counts and model. Unknown models warn
-*  once (not a silent zero) and return 0 so callers that ignore pricing keep
-*  working; cost-sensitive callers should gate on {@link isModelPriced}. */
-function estimateCost(inputTokens, outputTokens, model) {
-	const pricing = resolveModelPricing(model);
-	if (!pricing) {
-		if (!warnedUnpricedModels.has(model)) {
-			warnedUnpricedModels.add(model);
-			console.warn(`estimateCost: no pricing for model "${model}" — returning 0; add it to MODEL_PRICING/FAMILY_PRICING (cost/Pareto axes will be blank until then)`);
-		}
-		return 0;
-	}
-	return inputTokens / 1e3 * pricing.input + outputTokens / 1e3 * pricing.output;
-}
-/**
-* TokenCounter — accumulates token usage and cost across turns.
-*/
-var TokenCounter = class {
-	totalInput = 0;
-	totalOutput = 0;
-	totalCost = 0;
-	model;
-	constructor(model = "gpt-4o") {
-		this.model = model;
-	}
-	/** Record tokens for a turn, returns per-turn cost */
-	record(inputTokens, outputTokens) {
-		this.totalInput += inputTokens;
-		this.totalOutput += outputTokens;
-		const cost = estimateCost(inputTokens, outputTokens, this.model);
-		this.totalCost += cost;
-		return cost;
-	}
-	/** Estimate and record from raw text */
-	recordFromText(inputText, outputText) {
-		const inputTokens = estimateTokens(inputText);
-		const outputTokens = estimateTokens(outputText);
-		return {
-			inputTokens,
-			outputTokens,
-			cost: this.record(inputTokens, outputTokens)
-		};
-	}
-	getTotalInput() {
-		return this.totalInput;
-	}
-	getTotalOutput() {
-		return this.totalOutput;
-	}
-	getTotalCost() {
-		return this.totalCost;
-	}
-};
-/**
-* MetricsCollector — collects per-turn metrics from the product.
-*
-* After each turn, queries the product's APIs to measure state changes.
-*/
-var MetricsCollector = class {
-	client;
-	workspaceId;
-	metrics = [];
-	constructor(client, workspaceId) {
-		this.client = client;
-		this.workspaceId = workspaceId;
-	}
-	/** Collect metrics after a turn completes */
-	async collect(turn, responseLatencyMs, responseChars, codeBlocksProduced, blocksExtracted, completionCriteriaMet, completionCriteriaTotal, qualityScore, inputTokens = 0, outputTokens = 0, estimatedCostUsd = 0) {
-		const state = await this.getState();
-		const m = {
-			turn,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			tasks: state.tasks,
-			events: state.events,
-			proposals: state.proposals,
-			vaultFiles: state.vaultFiles.length,
-			responseLatencyMs,
-			responseChars,
-			codeBlocksProduced,
-			blocksExtracted,
-			qualityScore,
-			inputTokens,
-			outputTokens,
-			estimatedCostUsd,
-			totalCostUsd: estimatedCostUsd,
-			completionPercent: completionCriteriaTotal > 0 ? completionCriteriaMet / completionCriteriaTotal * 100 : 0
-		};
-		this.metrics.push(m);
-		return m;
-	}
-	/** Get current product state */
-	async getState() {
-		const [tasks, events, approvals, vaultFiles] = await Promise.all([
-			this.client.getTasks(this.workspaceId),
-			this.client.getEvents(this.workspaceId),
-			this.client.getApprovals(this.workspaceId),
-			this.client.getVaultTree(this.workspaceId)
-		]);
-		return {
-			tasks: tasks.length,
-			events: events.length,
-			proposals: {
-				pending: approvals.filter((a) => a.status === "pending").length,
-				approved: approvals.filter((a) => a.status === "approved").length,
-				rejected: approvals.filter((a) => a.status === "rejected").length
-			},
-			vaultFiles,
-			codeBlocks: 0,
-			generations: 0
-		};
-	}
-	/** Get all collected metrics */
-	getMetrics() {
-		return [...this.metrics];
-	}
-	/** Get convergence curve (completion% over turns) */
-	getConvergenceCurve() {
-		return this.metrics.map((m) => m.completionPercent);
-	}
-};
-//#endregion
-export { estimateTokens as a, estimateCost as i, MetricsCollector as n, isModelPriced as o, TokenCounter as r, resolveModelPricing as s, MODEL_PRICING as t };
-
-//# sourceMappingURL=metrics-C9YY1OcL.js.map