@tangle-network/agent-eval 0.191.0 → 0.193.0

package/dist/jev.d.ts

@@ -1,6 +1,6 @@
 import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-DbQdN3nO.js";
 import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-CeDfCRXp.js";
-import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-BmQRs661.js";
+import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-BWwRXofp.js";
 import { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, asAnalyst, asJudge, createEvaluator } from "./evaluation.js";
 import { JevAnswer, JevAnswerFor, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevRequest, parseJevResult } from "./jev-protocol.js";
 import { z } from "zod";

package/dist/{journal-c3qY0SDP.js → journal-DvKCvjty.js}

@@ -1138,6 +1138,98 @@ var FileLedgerJournal = class {
 		return first;
 	}
 };
+/**
+* A journal for runs without a filesystem. It keeps its rows as text in a
+* store and applies the file journal's rules: the same row parse, hash chain,
+* idempotent append by `eventId`, and projector transition before a row is
+* kept. It has no lock, fsync or trusted head, because its rows live and die
+* with the process that holds the store.
+*/
+var MemoryLedgerJournal = class {
+	path;
+	codec;
+	store;
+	verified = null;
+	constructor(path, codec, store) {
+		this.path = path;
+		this.codec = codec;
+		this.store = store;
+	}
+	async replay() {
+		return this.guarded(() => this.sync().journal.projector.snapshot());
+	}
+	async append(event) {
+		return this.guarded(() => {
+			const verified = this.sync();
+			const { journal, entries } = verified;
+			const existingSequence = journal.sequenceByEventId.get(event.eventId);
+			if (existingSequence !== void 0) {
+				const existing = entries[existingSequence];
+				if (canonicalString(existing.event) !== canonicalString(event)) throw this.codec.conflictError(`eventId ${event.eventId} already exists with different content`);
+				return {
+					entry: existing,
+					appended: false,
+					projection: journal.projector.snapshot()
+				};
+			}
+			const sequence = entries.length;
+			const material = {
+				...this.codec.header,
+				sequence,
+				previousHash: journal.head?.entry.entryHash ?? null,
+				event
+			};
+			const text = canonicalString({
+				...material,
+				entryHash: hashCanonical(material)
+			});
+			const entry = parseRow(text, {
+				path: this.path,
+				line: sequence + 1
+			}, this.codec);
+			admitEntry(journal, entry, Buffer.from(`${text}\n`, "utf8"), this.codec);
+			entries.push(entry);
+			verified.text = `${verified.text}${text}\n`;
+			this.store.write(this.path, verified.text);
+			return {
+				entry,
+				appended: true,
+				projection: journal.projector.snapshot()
+			};
+		});
+	}
+	/** Verify the stored text again whenever it is not the text this instance wrote. */
+	sync() {
+		const text = this.store.read(this.path) ?? "";
+		if (this.verified?.text === text) return this.verified;
+		const journal = emptyJournal(this.codec);
+		const entries = [];
+		const bytes = Buffer.from(text, "utf8");
+		for (const row of splitRows(bytes, this.path, this.codec)) {
+			const entry = parseRow(row.text, {
+				path: this.path,
+				line: entries.length + 1
+			}, this.codec);
+			admitEntry(journal, entry, Buffer.from(bytes.subarray(row.start, row.end)), this.codec);
+			entries.push(entry);
+		}
+		this.verified = {
+			text,
+			journal,
+			entries
+		};
+		return this.verified;
+	}
+	/** A refused transition can leave the projector half applied; discard it. */
+	async guarded(run) {
+		try {
+			return run();
+		} catch (error) {
+			this.verified = null;
+			throw error;
+		}
+	}
+};
 /** Verify and replay resolved immutable journal bytes without filesystem I/O. */
 function replayLedgerText(text, path, codec) {
 	const state = emptyJournal(codec);
@@ -1246,6 +1338,6 @@ function readRange(fd, start, end) {
 	return bytes;
 }
 //#endregion
-export { tryAcquireAtomicFileLock as _, verifyEntriesAgainstTrustedHead as a, appendLedgerLine as c, writeLedgerFileAtomically as d, Mutex as f, probeAtomicFileLock as g, AtomicFileLockError as h, trustedHeadPathFor as i, tryWithLedgerFileLock as l, mapConcurrentRange as m, replayLedgerText as n, projectorSnapshotPathFor as o, mapConcurrent as p, readTrustedHeadFile as r, readProjectorSnapshotFile as s, FileLedgerJournal as t, withLedgerFileLock as u };
+export { probeAtomicFileLock as _, trustedHeadPathFor as a, readProjectorSnapshotFile as c, withLedgerFileLock as d, writeLedgerFileAtomically as f, AtomicFileLockError as g, mapConcurrentRange as h, readTrustedHeadFile as i, appendLedgerLine as l, mapConcurrent as m, MemoryLedgerJournal as n, verifyEntriesAgainstTrustedHead as o, Mutex as p, replayLedgerText as r, projectorSnapshotPathFor as s, FileLedgerJournal as t, tryWithLedgerFileLock as u, tryAcquireAtomicFileLock as v };
 
-//# sourceMappingURL=journal-c3qY0SDP.js.map
+//# sourceMappingURL=journal-DvKCvjty.js.map