@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/judge-calibration-DFtEMlde.d.ts

@@ -0,0 +1,146 @@
+//#region src/judge-calibration.d.ts
+/**
+ * Judge calibration — measure judge quality against human gold + bias.
+ *
+ * Workflow:
+ *   1. Build a golden set: {itemId, humanScore}[].
+ *   2. Run candidate judges; each produces {itemId, score}.
+ *   3. `calibrateJudge(golden, candidate)` reports κ + Pearson + MAE.
+ *   4. `calibrateJudgeContinuous(golden, candidate)` adds quadratic-weighted
+ *      κ over the un-rounded [0,1] scores plus ICC(2,1), Pearson, Spearman,
+ *      and bootstrap CIs — use this for fine-grained judges where rounding
+ *      to int discards information (e.g. 0.78 vs 0.81 both round to 1 and
+ *      look "perfectly agreed" to integer κ).
+ *   5. Run bias probes (positional, verbosity, self-preference) to
+ *      detect systematic score inflation.
+ *   6. For N≥2 judges on the same items, `continuousAgreement(scores)`
+ *      reports ICC(2,1) + κ_w + Pearson + Spearman with bootstrap CIs.
+ *
+ * Returns actionable diagnostics, not a single number. Consumers then
+ * decide whether to trust the judge, retrain it, or add a tie-breaker.
+ */
+interface GoldenItem {
+  itemId: string;
+  humanScore: number;
+  /** Optional group used for per-group bias audits (e.g. model-of-output family). */
+  group?: string;
+}
+interface CandidateScore {
+  itemId: string;
+  score: number;
+  /** Optional — enables positional-bias analysis (did order matter?). */
+  positionOfAInput?: 'first' | 'second';
+}
+interface CalibrationResult {
+  n: number;
+  pearson: number;
+  /** Cohen's κ with quadratic weights over integer-rounded scores. */
+  kappa: number;
+  /** Mean absolute error vs human. */
+  mae: number;
+  /** Worst-5 miscalibrations (largest |judge - human|). */
+  worstItems: Array<{
+    itemId: string;
+    judge: number;
+    human: number;
+    delta: number;
+  }>;
+}
+/**
+ * Measure judge quality against human gold labels: computes Cohen's κ, Pearson correlation, and MAE over matched item ids.
+ */
+declare function calibrateJudge(golden: GoldenItem[], candidate: CandidateScore[]): CalibrationResult;
+interface PositionalBiasResult {
+  /**
+   * Score delta (first-position - second-position) averaged across items
+   * presented in both positions. Non-zero = positional bias.
+   */
+  avgDelta: number;
+  n: number;
+}
+/**
+ * Feed the same items to the judge twice with A/B swapped and pass all
+ * results here. Items that don't appear in both positions are ignored.
+ */
+declare function positionalBias(scores: CandidateScore[]): PositionalBiasResult;
+interface VerbosityBiasResult {
+  /** Pearson correlation between output length and score. Strong positive = verbosity bias. */
+  pearson: number;
+  n: number;
+}
+declare function verbosityBias(samples: Array<{
+  outputLen: number;
+  score: number;
+}>): VerbosityBiasResult;
+interface SelfPreferenceResult {
+  /** Mean judge score when judge's family matches output's family. */
+  inFamilyMean: number;
+  outOfFamilyMean: number;
+  deltaMean: number;
+  n: number;
+}
+/**
+ * Pass the same scenarios scored with judge-model X grading outputs from
+ * model X (in-family) and model Y (out-of-family). Non-zero delta
+ * indicates self-preference.
+ */
+declare function selfPreference(samples: Array<{
+  score: number;
+  inFamily: boolean;
+}>): SelfPreferenceResult;
+interface ContinuousAgreement {
+  /** Cohen's κ_w with quadratic weights, computed on raw [0,1] scores. */
+  weightedKappa: number;
+  /** ICC(2,1): two-way random effects, absolute agreement, single rater. */
+  icc: number;
+  /** Pearson product-moment correlation (averaged over rater pairs if N>2). */
+  pearson: number;
+  /** Spearman rank correlation (averaged over rater pairs if N>2). */
+  spearman: number;
+  /** 95% bootstrap percentile CIs over items. */
+  ci: {
+    icc: [number, number];
+    weightedKappa: [number, number];
+  };
+  /** Number of complete items (no NaN across raters). */
+  n: number;
+  /** Number of raters. */
+  raters: number;
+}
+interface ContinuousAgreementOptions {
+  /** Bootstrap iterations. Default 1000. Set to 0 to skip CIs (CI = [NaN, NaN]). */
+  bootstrap?: number;
+  /** κ weighting scheme. Default 'quadratic'. */
+  weights?: 'linear' | 'quadratic';
+  /** PRNG seed for reproducible bootstrap. Default 0xC0FFEE. */
+  seed?: number;
+  /** Confidence level for percentile CI. Default 0.95. */
+  ciLevel?: number;
+}
+/**
+ * Inter-rater agreement on continuous (typically [0,1]) scores.
+ *
+ * `scores` has shape [n_items][n_raters]. Rows with any non-finite entry
+ * are dropped. Returns NaN metrics if fewer than 2 raters or 2 complete
+ * items remain.
+ */
+declare function continuousAgreement(scores: number[][], opts?: ContinuousAgreementOptions): ContinuousAgreement;
+interface ContinuousCalibrationResult extends CalibrationResult {
+  /** Cohen's κ_w computed on raw (un-rounded) scores. */
+  weightedKappaContinuous: number;
+  /** ICC(2,1) treating golden + candidate as two raters. */
+  icc: number;
+  spearman: number;
+  ci: {
+    icc: [number, number];
+    weightedKappa: [number, number];
+  };
+}
+/**
+ * Extends `calibrateJudge` with continuous-value agreement metrics while
+ * retaining its base calibration summary.
+ */
+declare function calibrateJudgeContinuous(golden: GoldenItem[], candidate: CandidateScore[], opts?: ContinuousAgreementOptions): ContinuousCalibrationResult;
+//#endregion
+export { ContinuousCalibrationResult as a, SelfPreferenceResult as c, calibrateJudgeContinuous as d, continuousAgreement as f, verbosityBias as h, ContinuousAgreementOptions as i, VerbosityBiasResult as l, selfPreference as m, CandidateScore as n, GoldenItem as o, positionalBias as p, ContinuousAgreement as r, PositionalBiasResult as s, CalibrationResult as t, calibrateJudge as u };
+//# sourceMappingURL=judge-calibration-DFtEMlde.d.ts.map

package/dist/judge-calibration-DFtEMlde.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-calibration-DFtEMlde.d.ts","names":[],"sources":["../src/judge-calibration.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;UAuBiB;EACf;EACA;;EAEA;;UAGe;EACf;EACA;;EAEA;;UAGe;EACf;EACA;;EAEA;;EAEA;;EAEA,YAAY;IAAQ;IAAgB;IAAe;IAAe;;;;;;iBAMpD,eACd,QAAQ,cACR,WAAW,mBACV;UA0Bc;;;;;EAKf;EACA;;;;;;iBAOc,eAAe,QAAQ,mBAAmB;UAgBzC;;EAEf;EACA;;iBAGc,cACd,SAAS;EAAQ;EAAmB;KACnC;UAYc;;EAEf;EACA;EACA;EACA;;;;;;;iBAQc,eACd,SAAS;EAAQ;EAAe;KAC/B;UA8Ec;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;IACE;IACA;;;EAGF;;EAEA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;;;iBAUc,oBACd,oBACA,OAAM,6BACL;UAqEc,oCAAoC;;EAEnD;;EAEA;EACA;EACA;IACE;IACA;;;;;;;iBAQY,yBACd,QAAQ,cACR,WAAW,kBACX,OAAM,6BACL"}

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

@@ -0,0 +1,2 @@
+import { C as AtomicFileLockUnavailable, S as AtomicFileLockOwner, T as tryAcquireAtomicFileLock, _ as withLedgerFileLock, a as LedgerEventBase, b as AtomicFileLockError, c as LedgerLineContext, d as canonicalString, f as hashCanonical, g as tryWithLedgerFileLock, h as appendLedgerLine, i as LedgerEntryOf, l as LedgerProjector, m as LedgerFileContext, n as LedgerAppendResult, o as LedgerHash, p as FileLockResult, r as LedgerChainFields, s as LedgerJournalCodec, t as FileLedgerJournal, u as LedgerReplayResult, v as AtomicFileLock, w as probeAtomicFileLock, x as AtomicFileLockOptions, y as AtomicFileLockAcquisition } from "../index-BAvgST_9.js";
+export { type AtomicFileLock, type AtomicFileLockAcquisition, AtomicFileLockError, type AtomicFileLockOptions, type AtomicFileLockOwner, type AtomicFileLockUnavailable, FileLedgerJournal, type FileLockResult, type LedgerAppendResult, type LedgerChainFields, type LedgerEntryOf, type LedgerEventBase, type LedgerFileContext, type LedgerHash, type LedgerJournalCodec, type LedgerLineContext, type LedgerProjector, type LedgerReplayResult, appendLedgerLine, canonicalString, hashCanonical, probeAtomicFileLock, tryAcquireAtomicFileLock, tryWithLedgerFileLock, withLedgerFileLock };

package/dist/ledger-core/index.js

@@ -0,0 +1,2 @@
+import { a as tryWithLedgerFileLock, c as probeAtomicFileLock, i as appendLedgerLine, l as tryAcquireAtomicFileLock, n as canonicalString, o as withLedgerFileLock, r as hashCanonical, s as AtomicFileLockError, t as FileLedgerJournal } from "../ledger-core-DtZz1RG0.js";
+export { AtomicFileLockError, FileLedgerJournal, appendLedgerLine, canonicalString, hashCanonical, probeAtomicFileLock, tryAcquireAtomicFileLock, tryWithLedgerFileLock, withLedgerFileLock };

package/dist/ledger-core-DtZz1RG0.js

@@ -0,0 +1,388 @@
+import { t as canonicalize } from "./pre-registration-DakwTRXk.js";
+import { t as Mutex } from "./concurrency-DIxRZF_J.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-DtZz1RG0.js.map

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

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