@tangle-network/agent-eval 0.216.0 → 0.216.1

package/dist/{search-ledger-d7V8o9Lk.js → search-ledger-CVUGLDZp.js}

@@ -1,36 +1,35 @@
-import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { i as modelHasSnapshot, s as searchCellRunId } from "./run-record-DlTZ_lqe.js";
-import { n as MemoryLedgerJournal, r as replayLedgerText, t as FileLedgerJournal } from "./journal-DvKCvjty.js";
-import "./ledger-core-B2hahzrt.js";
-import { a as SearchLedgerError, i as SearchLedgerConflictError, o as SearchLedgerIntegrityError, t as SEARCH_LEDGER_FILE_CONTEXT } from "./search-ledger-file-BqOo-bVo.js";
-import { n as evaluationClaimSchema } from "./claim-BXcZw-jo.js";
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-B2RqLofv.js";
+import { i as modelHasSnapshot, s as searchCellRunId } from "./run-record-Boc5IUTp.js";
+import { n as MemoryLedgerJournal, r as replayLedgerText, t as FileLedgerJournal } from "./journal-DfRz9kps.js";
+import "./ledger-core-Gq7yp8lP.js";
+import { a as SearchLedgerError, i as SearchLedgerConflictError, o as SearchLedgerIntegrityError, t as SEARCH_LEDGER_FILE_CONTEXT } from "./search-ledger-file-DDQUgvCg.js";
+import { n as evaluationClaimSchema } from "./claim-q4HQhK1G.js";
+import { t as roundDecimal } from "./round-decimal-COrKglMh.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
-//#region src/campaign/search-ledger-ordering.ts
-function artifactKey(artifact) {
-	return canonicalString(artifact);
+//#region src/campaign/search-ledger-constraints.ts
+/** Shared ledger limits and structural event constraints for writers and replay. */
+const USD_TOLERANCE = 1e-9;
+function assertStageSplit(cellId, stage, split, isRoot) {
+	if (!{
+		root: ["train", "selection"],
+		train: ["train"],
+		screen: ["selection"],
+		rung: ["selection"],
+		claim: ["test"],
+		external: ["train", "selection"]
+	}[stage].includes(split)) throw integrity(`cell ${cellId}: a ${stage} cell cannot run on the ${split} split`);
+	if (stage === "root" && !isRoot) throw integrity(`cell ${cellId}: only the root node runs root cells`);
 }
-function compareStrings(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
+function assertUnique(values, label, eventId) {
+	if (new Set(values).size !== values.length) throw integrity(`event ${eventId} contains duplicate ${label} values`);
+}
+function integrity(message) {
+	return new SearchLedgerIntegrityError(message);
 }
 //#endregion
-//#region src/campaign/search-state.ts
-/**
-* `SearchState`: the one projection of a search ledger.
-*
-* The same code checks every invariant for the producer's journal, the kernel,
-* and the Intelligence verifier, and builds the read model they share. It keeps
-* compact indexes (nodes, edges, cells, per-unit score sums, running audit
-* totals), not the raw event list, and applies each entry in time proportional
-* to that entry, so a search of any length appends at a constant cost.
-*
-* The journal asks for a snapshot after every append. A snapshot is a
-* `SearchStateView` that reads the live indexes, so taking one costs nothing.
-* The view is valid until the state applies its next entry; a read after that
-* throws rather than returning numbers from a later ledger position. Read the
-* ledger's state again to see newer entries. The audit, header, head and claim
-* on a view are plain values and stay readable.
-*/
+//#region src/campaign/search-state-identity.ts
+/** Canonical identities for search nodes, cells, and split task sets. */
 /** Deterministic node id: identical content in one search is one node. */
 function searchNodeId(searchId, artifactDigest) {
 	return `node_${shortDigest([searchId, artifactDigest])}`;
@@ -54,13 +53,17 @@ function searchTaskSetDigest(tasks) {
 function shortDigest(value) {
 	return createHash("sha256").update(canonicalString(value)).digest("hex").slice(0, 32);
 }
-const MAX_LABEL_CHARS = 200;
-const USD_TOLERANCE = 1e-9;
-const SPLITS = [
-	"train",
-	"selection",
-	"test"
-];
+//#endregion
+//#region src/campaign/search-ledger-ordering.ts
+function artifactKey(artifact) {
+	return canonicalString(artifact);
+}
+function compareStrings(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+//#endregion
+//#region src/campaign/search-state-view.ts
+/** Position-bound search snapshots and deterministic scored-unit reads. */
 /**
 * Per-unit means of scored cells, in unitId order. Each unit sums its cells in
 * cellId order, so the result depends on the set of cells alone, never on the
@@ -86,6 +89,151 @@ function searchUnitScores(cells) {
 	});
 }
 /**
+* A read of `SearchState` at one ledger position. Header, head, audit and
+* claim are values. Node, edge, cell and score reads go to the live indexes and
+* throw once the state has applied a later entry.
+*/
+var SearchStateView = class {
+	searchId;
+	header;
+	closed;
+	head;
+	/** `occurredAt` of the head entry; a writer stamps later events at or after it. */
+	lastOccurredAt;
+	audit;
+	completion;
+	/**
+	* The admission rule's room: `headroomUsd` is the largest reservation a new
+	* non-claim cell or operation may hold (committed spend, open holds and the
+	* unspent claim reserve all count against the cap), or null when the search
+	* declares no cap. `claimReserveUsd` is what claim cells may still draw.
+	*/
+	budget;
+	state;
+	version;
+	constructor(state, version) {
+		this.state = state;
+		this.version = version;
+		this.searchId = state.searchId;
+		this.header = state.readHeader();
+		this.closed = state.readClosed();
+		this.head = state.readHead();
+		this.lastOccurredAt = state.readLastOccurredAt();
+		this.audit = state.readAudit();
+		this.budget = state.readBudget();
+		const reasons = state.incompleteReasons();
+		if (!this.closed) reasons.unshift("search is open");
+		this.completion = {
+			complete: this.closed !== null,
+			reasons
+		};
+	}
+	/** The node the search started from: the first registered. */
+	get rootNodeId() {
+		return this.live().readNodeIds()[0] ?? null;
+	}
+	node(nodeId) {
+		return this.live().readNode(nodeId);
+	}
+	hasNode(nodeId) {
+		return this.live().readHasNode(nodeId);
+	}
+	/** Node ids in registration order. */
+	nodeIds() {
+		return [...this.live().readNodeIds()];
+	}
+	/** Nodes in registration order. */
+	nodes() {
+		const state = this.live();
+		return state.readNodeIds().map((nodeId) => state.readNode(nodeId));
+	}
+	nodeIdForDigest(artifactDigest) {
+		return this.live().readNodeIdForDigest(artifactDigest);
+	}
+	edge(edgeId) {
+		return this.live().readEdge(edgeId);
+	}
+	/** Edges in ledger order. */
+	edges() {
+		const state = this.live();
+		return state.readEdgeIds().map((edgeId) => state.readEdge(edgeId));
+	}
+	cell(cellId) {
+		return this.live().readCell(cellId);
+	}
+	/** Cells in allocation order, optionally of one node. */
+	cells(filter = {}) {
+		const state = this.live();
+		return state.readCellIds(filter.nodeId).map((cellId) => state.readCell(cellId));
+	}
+	operation(operationId) {
+		return this.live().readOperation(operationId);
+	}
+	/** A node's scored cells on one split, in allocation order. Unscored cells
+	* (errored, cancelled or in flight) are absent, never zero. */
+	scoredCells(nodeId, split) {
+		return this.live().readScoredCells(nodeId, split);
+	}
+	/** Per-unit score means of a node on one split, in unitId order. */
+	unitScores(nodeId, split) {
+		return searchUnitScores(this.scoredCells(nodeId, split));
+	}
+	/** The lineage a RunRecord mint needs for one cell attempt. */
+	lineage(coordinates) {
+		const state = this.live();
+		if (coordinates.searchId !== this.searchId) throw new SearchLedgerError(`coordinates name search ${coordinates.searchId}, not ${this.searchId}`);
+		const cell = state.readCell(coordinates.cellId);
+		if (!cell || cell.nodeId !== coordinates.nodeId) throw new SearchLedgerError(`cell ${coordinates.cellId} of node ${coordinates.nodeId} is not in search ${this.searchId}`);
+		if (coordinates.attempt < 1 || coordinates.attempt > cell.attempts) throw new SearchLedgerError(`cell ${coordinates.cellId} has ${cell.attempts} settled attempt(s), not attempt ${coordinates.attempt}`);
+		const node = state.readNode(cell.nodeId);
+		if (node.depth === null) throw new SearchLedgerError(`node ${node.nodeId} has unknown lineage, so its depth is unknown`);
+		const containment = this.header?.containment ?? null;
+		return {
+			depth: node.depth,
+			ordinal: node.ordinal,
+			rep: cell.rep,
+			containingRunId: containment ? searchCellRunId({
+				cellId: containment.cellId,
+				attempt: containment.attempt
+			}) : null
+		};
+	}
+	live() {
+		if (!this.state.isAt(this.version)) throw new SearchLedgerError(`this SearchStateView is from sequence ${this.head?.sequence ?? -1}, and the ledger has moved on; read the ledger's state again`);
+		return this.state;
+	}
+};
+function nodeView(record) {
+	const latest = record.decisions.at(-1)?.decision ?? null;
+	return {
+		nodeId: record.event.nodeId,
+		ordinal: record.ordinal,
+		artifactDigest: record.event.artifactDigest,
+		artifact: record.event.artifact,
+		surfaces: record.event.surfaces,
+		primaryParentId: record.primaryParentId,
+		depth: record.depth,
+		parents: [...record.parents],
+		children: [...record.children],
+		edgeIds: [...record.edgeIds],
+		status: latest?.status ?? null,
+		rung: latest?.status === "advanced" ? latest.rung : null,
+		finalist: record.finalist,
+		decisions: [...record.decisions],
+		cellCount: record.cellIds.length,
+		spend: { ...record.spend },
+		registeredSequence: record.registeredSequence,
+		updatedSequence: record.updatedSequence
+	};
+}
+//#endregion
+//#region src/campaign/search-state-projection.ts
+const SPLITS = [
+	"train",
+	"selection",
+	"test"
+];
+/**
 * The pure, incremental projection of one search ledger. `apply` refuses any
 * entry that breaks an invariant; the journal then discards this instance and
 * replays into a new one, so a refused entry leaves no partial state behind.
@@ -254,7 +402,7 @@ var SearchState = class {
 			if (seen.length > 0) throw integrity(`test units ${seen.join(", ")} also appear in train or selection, but the splits declare heldOutUnits`);
 		}
 		const { budget } = event;
-		if (budget.maxUsd !== null && budget.reservedClaimUsd > budget.maxUsd + USD_TOLERANCE) throw integrity(`the claim reserve $${budget.reservedClaimUsd} exceeds the search cap $${budget.maxUsd}`);
+		if (budget.maxUsd !== null && budget.reservedClaimUsd > budget.maxUsd + 1e-9) throw integrity(`the claim reserve $${budget.reservedClaimUsd} exceeds the search cap $${budget.maxUsd}`);
 		this.header = event;
 	}
 	startOperation(event) {
@@ -336,7 +484,7 @@ var SearchState = class {
 		const child = this.nodes.get(event.childNodeId);
 		if (!child) throw integrity(`edge ${event.edgeId} names unregistered child ${event.childNodeId}`);
 		this.assertSearching(`edge ${event.edgeId}`);
-		if (event.label.length > MAX_LABEL_CHARS) throw integrity(`edge ${event.edgeId} label exceeds ${MAX_LABEL_CHARS} characters`);
+		if (event.label.length > 200) throw integrity(`edge ${event.edgeId} label exceeds 200 characters`);
 		if (event.diffs.length !== event.parents.length) throw integrity(`edge ${event.edgeId} needs one diff per parent`);
 		assertUnique(event.parents.map((parent) => canonicalString(parent)), "parent", event.eventId);
 		const { operator, attribution, parents } = event;
@@ -633,8 +781,8 @@ var SearchState = class {
 		const hold = reservation?.usd ?? 0;
 		if (maxUsd === null || hold === 0) return;
 		const remainingClaim = Math.max(0, reservedClaimUsd - this.claimUsedUsd);
-		if (claim && hold <= remainingClaim + USD_TOLERANCE) return;
-		if (this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + (claim ? 0 : remainingClaim) + hold > maxUsd + USD_TOLERANCE) throw integrity(`${subject} is not admissible: committed $${round(this.audit.spend.committedUsd)} + open $${round(this.audit.spend.openReservationUsd)} + claim reserve $${round(remainingClaim)} + hold $${round(hold)} exceeds the cap $${maxUsd}`);
+		if (claim && hold <= remainingClaim + 1e-9) return;
+		if (this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + (claim ? 0 : remainingClaim) + hold > maxUsd + 1e-9) throw integrity(`${subject} is not admissible: committed $${roundDecimal(this.audit.spend.committedUsd, 6)} + open $${roundDecimal(this.audit.spend.openReservationUsd, 6)} + claim reserve $${roundDecimal(remainingClaim, 6)} + hold $${roundDecimal(hold, 6)} exceeds the cap $${maxUsd}`);
 	}
 	/** @internal The largest hold a new non-claim cell or operation may take,
 	* and the claim reserve still unspent. */
@@ -738,168 +886,10 @@ var SearchState = class {
 		return scored;
 	}
 };
-/**
-* A read of `SearchState` at one ledger position. Header, head, audit and
-* claim are values. Node, edge, cell and score reads go to the live indexes and
-* throw once the state has applied a later entry.
-*/
-var SearchStateView = class {
-	searchId;
-	header;
-	closed;
-	head;
-	/** `occurredAt` of the head entry; a writer stamps later events at or after it. */
-	lastOccurredAt;
-	audit;
-	completion;
-	/**
-	* The admission rule's room: `headroomUsd` is the largest reservation a new
-	* non-claim cell or operation may hold (committed spend, open holds and the
-	* unspent claim reserve all count against the cap), or null when the search
-	* declares no cap. `claimReserveUsd` is what claim cells may still draw.
-	*/
-	budget;
-	state;
-	version;
-	constructor(state, version) {
-		this.state = state;
-		this.version = version;
-		this.searchId = state.searchId;
-		this.header = state.readHeader();
-		this.closed = state.readClosed();
-		this.head = state.readHead();
-		this.lastOccurredAt = state.readLastOccurredAt();
-		this.audit = state.readAudit();
-		this.budget = state.readBudget();
-		const reasons = state.incompleteReasons();
-		if (!this.closed) reasons.unshift("search is open");
-		this.completion = {
-			complete: this.closed !== null,
-			reasons
-		};
-	}
-	/** The node the search started from: the first registered. */
-	get rootNodeId() {
-		return this.live().readNodeIds()[0] ?? null;
-	}
-	node(nodeId) {
-		return this.live().readNode(nodeId);
-	}
-	hasNode(nodeId) {
-		return this.live().readHasNode(nodeId);
-	}
-	/** Node ids in registration order. */
-	nodeIds() {
-		return [...this.live().readNodeIds()];
-	}
-	/** Nodes in registration order. */
-	nodes() {
-		const state = this.live();
-		return state.readNodeIds().map((nodeId) => state.readNode(nodeId));
-	}
-	nodeIdForDigest(artifactDigest) {
-		return this.live().readNodeIdForDigest(artifactDigest);
-	}
-	edge(edgeId) {
-		return this.live().readEdge(edgeId);
-	}
-	/** Edges in ledger order. */
-	edges() {
-		const state = this.live();
-		return state.readEdgeIds().map((edgeId) => state.readEdge(edgeId));
-	}
-	cell(cellId) {
-		return this.live().readCell(cellId);
-	}
-	/** Cells in allocation order, optionally of one node. */
-	cells(filter = {}) {
-		const state = this.live();
-		return state.readCellIds(filter.nodeId).map((cellId) => state.readCell(cellId));
-	}
-	operation(operationId) {
-		return this.live().readOperation(operationId);
-	}
-	/** A node's scored cells on one split, in allocation order. Unscored cells
-	* (errored, cancelled or in flight) are absent, never zero. */
-	scoredCells(nodeId, split) {
-		return this.live().readScoredCells(nodeId, split);
-	}
-	/** Per-unit score means of a node on one split, in unitId order. */
-	unitScores(nodeId, split) {
-		return searchUnitScores(this.scoredCells(nodeId, split));
-	}
-	/** The lineage a RunRecord mint needs for one cell attempt. */
-	lineage(coordinates) {
-		const state = this.live();
-		if (coordinates.searchId !== this.searchId) throw new SearchLedgerError(`coordinates name search ${coordinates.searchId}, not ${this.searchId}`);
-		const cell = state.readCell(coordinates.cellId);
-		if (!cell || cell.nodeId !== coordinates.nodeId) throw new SearchLedgerError(`cell ${coordinates.cellId} of node ${coordinates.nodeId} is not in search ${this.searchId}`);
-		if (coordinates.attempt < 1 || coordinates.attempt > cell.attempts) throw new SearchLedgerError(`cell ${coordinates.cellId} has ${cell.attempts} settled attempt(s), not attempt ${coordinates.attempt}`);
-		const node = state.readNode(cell.nodeId);
-		if (node.depth === null) throw new SearchLedgerError(`node ${node.nodeId} has unknown lineage, so its depth is unknown`);
-		const containment = this.header?.containment ?? null;
-		return {
-			depth: node.depth,
-			ordinal: node.ordinal,
-			rep: cell.rep,
-			containingRunId: containment ? searchCellRunId({
-				cellId: containment.cellId,
-				attempt: containment.attempt
-			}) : null
-		};
-	}
-	live() {
-		if (!this.state.isAt(this.version)) throw new SearchLedgerError(`this SearchStateView is from sequence ${this.head?.sequence ?? -1}, and the ledger has moved on; read the ledger's state again`);
-		return this.state;
-	}
-};
-function nodeView(record) {
-	const latest = record.decisions.at(-1)?.decision ?? null;
-	return {
-		nodeId: record.event.nodeId,
-		ordinal: record.ordinal,
-		artifactDigest: record.event.artifactDigest,
-		artifact: record.event.artifact,
-		surfaces: record.event.surfaces,
-		primaryParentId: record.primaryParentId,
-		depth: record.depth,
-		parents: [...record.parents],
-		children: [...record.children],
-		edgeIds: [...record.edgeIds],
-		status: latest?.status ?? null,
-		rung: latest?.status === "advanced" ? latest.rung : null,
-		finalist: record.finalist,
-		decisions: [...record.decisions],
-		cellCount: record.cellIds.length,
-		spend: { ...record.spend },
-		registeredSequence: record.registeredSequence,
-		updatedSequence: record.updatedSequence
-	};
-}
-function assertStageSplit(cellId, stage, split, isRoot) {
-	if (!{
-		root: ["train", "selection"],
-		train: ["train"],
-		screen: ["selection"],
-		rung: ["selection"],
-		claim: ["test"],
-		external: ["train", "selection"]
-	}[stage].includes(split)) throw integrity(`cell ${cellId}: a ${stage} cell cannot run on the ${split} split`);
-	if (stage === "root" && !isRoot) throw integrity(`cell ${cellId}: only the root node runs root cells`);
-}
-function assertUnique(values, label, eventId) {
-	if (new Set(values).size !== values.length) throw integrity(`event ${eventId} contains duplicate ${label} values`);
-}
 function count(value, noun, predicate) {
 	const verb = predicate.replace(/^(has|is) /, (word) => value === 1 ? word : word === "has " ? "have " : "are ");
 	return `${value} ${value === 1 ? noun : `${noun}s`} ${verb}`;
 }
-function round(usd) {
-	return Math.round(usd * 1e6) / 1e6;
-}
-function integrity(message) {
-	return new SearchLedgerIntegrityError(message);
-}
 //#endregion
 //#region src/campaign/search-ledger-types.ts
 /**
@@ -1590,6 +1580,6 @@ function formatZodError(error) {
 	return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`).join("; ");
 }
 //#endregion
-export { validateSearchLedgerEvent as a, SearchStateView as c, searchTaskSetDigest as d, searchUnitScores as f, replaySearchLedgerText as i, searchCellId as l, openSearchLedger as n, SEARCH_LEDGER_SCHEMA as o, parseSearchLedgerLine as r, SearchState as s, FileSearchLedger as t, searchNodeId as u };
+export { validateSearchLedgerEvent as a, SearchStateView as c, searchNodeId as d, searchTaskSetDigest as f, replaySearchLedgerText as i, searchUnitScores as l, openSearchLedger as n, SEARCH_LEDGER_SCHEMA as o, USD_TOLERANCE as p, parseSearchLedgerLine as r, SearchState as s, FileSearchLedger as t, searchCellId as u };
 
-//# sourceMappingURL=search-ledger-d7V8o9Lk.js.map
+//# sourceMappingURL=search-ledger-CVUGLDZp.js.map