@tangle-network/agent-eval 0.217.1 → 0.219.0

package/dist/{pareto-BzsxidFD.js → pareto-BiBnQXAE.js}

@@ -4,10 +4,10 @@ import { t as confidenceInterval } from "./descriptive-CVNy48rR.js";
 import { s as wilson } from "./paired-binary-B_nejA44.js";
 import { r as DECISION_PAIRED_DELTA_STATISTIC } from "./mean-BbA_JCzW.js";
 import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-D0SHb-ZL.js";
-import { a as SearchLedgerError } from "./search-ledger-file-UKCO2r8a.js";
+import { a as SearchLedgerError } from "./search-ledger-file-Bd5Tioq6.js";
 import { s as redactText } from "./redact-mtkTiJVk.js";
-import { l as searchUnitScores, p as USD_TOLERANCE, t as FileSearchLedger, u as searchCellId } from "./search-ledger-TUvB5gWH.js";
-import { t as acquireSingleRunLock } from "./single-run-lock-U58yf8N6.js";
+import { l as searchUnitScores, p as USD_TOLERANCE, t as FileSearchLedger, u as searchCellId } from "./search-ledger-CZRqtFbW.js";
+import { t as acquireSingleRunLock } from "./single-run-lock-Dekd8_Wv.js";
 //#region src/statistics/normalize-signed-zero.ts
 /** Normalize IEEE negative zero before numerical evidence reaches canonical JSON. */
 function normalizeSignedZero(value) {
@@ -262,6 +262,39 @@ function sum(values) {
 	return total;
 }
 //#endregion
+//#region src/campaign/search-kernel-artifacts.ts
+/** The artifact each node holds: kept in memory once seen, else loaded from the ledger. */
+var SearchArtifactCache = class {
+	load;
+	artifacts = /* @__PURE__ */ new Map();
+	/** Children a proposal returned, by artifact digest, until they are registered. */
+	proposed = /* @__PURE__ */ new Map();
+	constructor(load) {
+		this.load = load;
+	}
+	get(nodeId) {
+		const held = this.artifacts.get(nodeId);
+		if (held !== void 0) return held;
+		const artifact = this.load(nodeId);
+		this.artifacts.set(nodeId, artifact);
+		return artifact;
+	}
+	seed(nodeId, artifact) {
+		this.artifacts.set(nodeId, artifact);
+	}
+	/** Hold a proposed child until the ledger registers its node. */
+	propose(digest, artifact) {
+		this.proposed.set(digest, artifact);
+	}
+	/** The node registered: it takes the artifact proposed under its digest, if one is held. */
+	register(nodeId, digest) {
+		const held = this.proposed.get(digest);
+		if (held === void 0) return;
+		this.proposed.delete(digest);
+		if (!this.artifacts.has(nodeId)) this.artifacts.set(nodeId, held);
+	}
+};
+//#endregion
 //#region src/paired-promotion-power.ts
 /**
 * @module
@@ -1381,6 +1414,119 @@ var SearchKernelClaim = class {
 	}
 };
 //#endregion
+//#region src/campaign/search-kernel-completions.ts
+/** Hand-off between work that finishes asynchronously and the loop that records it. */
+/** Completions in arrival order; one waiter at a time sleeps until one arrives or `wakeUp` fires. */
+var SearchCompletionQueue = class {
+	items = [];
+	wake = null;
+	/** The next completion, or null when `wakeUp` ended the wait without one. */
+	async next() {
+		if (this.items.length === 0) await new Promise((resolve) => {
+			this.wake = resolve;
+		});
+		return this.items.shift() ?? null;
+	}
+	push(item) {
+		this.items.push(item);
+		this.wakeUp();
+	}
+	wakeUp() {
+		const wake = this.wake;
+		this.wake = null;
+		wake?.();
+	}
+};
+//#endregion
+//#region src/campaign/search-kernel-lanes.ts
+/** Execution lanes: their queues, in-flight counts, and the dollar holds sized from settled spend. */
+var SearchLanes = class {
+	host;
+	byName = /* @__PURE__ */ new Map();
+	operationCosts = [];
+	constructor(declared, host) {
+		this.host = host;
+		for (const lane of declared) {
+			if (!Number.isSafeInteger(lane.capacity) || lane.capacity < 1) throw new TypeError(`runSearch: lane ${lane.name} needs a positive integer capacity`);
+			if (!Number.isFinite(lane.cellUsd) || lane.cellUsd < 0) throw new TypeError(`runSearch: lane ${lane.name} needs a finite non-negative cellUsd`);
+			if (this.byName.has(lane.name)) throw new TypeError(`runSearch: lane ${lane.name} is declared twice`);
+			this.byName.set(lane.name, {
+				...lane,
+				inFlight: 0,
+				queues: [
+					[],
+					[],
+					[],
+					[]
+				],
+				settledCosts: []
+			});
+		}
+		if (this.byName.size === 0) throw new TypeError("runSearch: the executor declares no lane");
+	}
+	enqueue(cell) {
+		this.byName.get(cell.lane).queues[STAGE_PRIORITY[cell.stage]].push(cell.cellId);
+	}
+	queuedCount() {
+		let count = 0;
+		for (const lane of this.byName.values()) for (const queue of lane.queues) count += queue.length;
+		return count;
+	}
+	/** Concurrent slots the lanes offer, within the budget's concurrency cap. */
+	capacity() {
+		let total = 0;
+		for (const lane of this.byName.values()) total += lane.capacity;
+		const cap = this.host.state().header.budget.maxConcurrency;
+		return cap === null ? total : Math.min(cap, total);
+	}
+	/** A hard lane holds its enforced maximum. An estimate lane holds 1.5 times
+	* the 99th percentile of its settled cells once 20 settled, else its prior. */
+	cellReservation(lane) {
+		if (lane.costCap === "hard") return {
+			kind: "hard",
+			usd: lane.cellUsd
+		};
+		return {
+			kind: "estimate",
+			usd: estimate(lane.settledCosts, lane.cellUsd)
+		};
+	}
+	maxCellReservation() {
+		let most = 0;
+		for (const lane of this.byName.values()) most = Math.max(most, this.cellReservation(lane).usd);
+		return most;
+	}
+	operationReservation() {
+		return {
+			kind: "estimate",
+			usd: estimate(this.operationCosts, this.host.operationPriorUsd())
+		};
+	}
+	/** A recorded proposal's spend sizes the next proposal's hold. */
+	recordOperationCost(usd) {
+		this.operationCosts.push(usd);
+	}
+	/** Overspend took committed spend, open holds and the unspent claim reserve
+	* past the cap. Nothing new is proposed then, even at a zero-dollar prior. */
+	overCap() {
+		const state = this.host.state();
+		const { maxUsd } = state.header.budget;
+		if (maxUsd === null) return false;
+		const { committedUsd, openReservationUsd } = state.audit.spend;
+		return committedUsd + openReservationUsd + state.budget.claimReserveUsd > maxUsd + USD_TOLERANCE;
+	}
+	pastDeadline() {
+		const deadline = this.host.state().header.budget.deadline;
+		return deadline !== null && this.host.now() >= Date.parse(deadline);
+	}
+};
+function estimate(costs, prior) {
+	if (costs.length < 20) return prior;
+	const sorted = [...costs].sort((a, b) => a - b);
+	const p99 = sorted[Math.min(sorted.length - 1, Math.ceil(.99 * sorted.length) - 1)];
+	return Math.round(ESTIMATE_MARGIN * p99 * 1e9) / 1e9;
+}
+//#endregion
 //#region src/search/lenses/shared.ts
 /**
 * Shared, pure helpers for `src/search/lenses/*`.
@@ -1710,39 +1856,98 @@ function round4(value) {
 	return Math.round(value * 1e4) / 1e4;
 }
 //#endregion
-//#region src/campaign/search-kernel-runner.ts
-/** Event loop and mutable scheduling state for one ledger-backed search. */
-var SearchKernel = class {
-	options;
-	recorder;
-	maxAttempts;
-	now;
+//#region src/campaign/search-kernel-progress.ts
+var SearchNodeProgress = class {
 	state;
-	lanes = /* @__PURE__ */ new Map();
-	inFlight = /* @__PURE__ */ new Map();
-	proposal = null;
-	proposalController = null;
-	completions = [];
-	wake = null;
 	/** Unfinished cells per node. */
 	pending = /* @__PURE__ */ new Map();
 	/** Admitted nodes whose screen finished, in registration order. */
 	screened = [];
 	screenedSet = /* @__PURE__ */ new Set();
 	admitted = /* @__PURE__ */ new Set();
-	expansionOf = /* @__PURE__ */ new Map();
-	artifacts = /* @__PURE__ */ new Map();
-	/** Children a proposal returned, by artifact digest, until they are registered. */
-	proposed = /* @__PURE__ */ new Map();
-	/** Cells the ledger showed unsettled at start: an earlier process may hold their attempt. */
-	adoptable = /* @__PURE__ */ new Set();
-	operationCosts = [];
+	constructor(state) {
+		this.state = state;
+	}
+	/** Unfinished cells of a node; zero when none was ever allocated. */
+	count(nodeId) {
+		return this.pending.get(nodeId) ?? 0;
+	}
+	add(nodeId, cells) {
+		this.pending.set(nodeId, this.count(nodeId) + cells);
+	}
+	/** One of the node's cells finished; returns how many remain. */
+	release(nodeId) {
+		const left = (this.pending.get(nodeId) ?? 1) - 1;
+		this.pending.set(nodeId, left);
+		return left;
+	}
+	/** Admitted and running nothing: ready for the allocator to rank. */
+	idle(nodeId) {
+		return this.admitted.has(nodeId) && this.count(nodeId) === 0;
+	}
+	screening() {
+		return this.admitted.size - this.screenedSet.size;
+	}
+	markScreened(nodeId) {
+		if (this.screenedSet.has(nodeId)) return;
+		this.screenedSet.add(nodeId);
+		const state = this.state();
+		const ordinal = state.node(nodeId).ordinal;
+		let index = this.screened.length;
+		while (index > 0 && state.node(this.screened[index - 1]).ordinal > ordinal) index--;
+		this.screened = [
+			...this.screened.slice(0, index),
+			nodeId,
+			...this.screened.slice(index)
+		];
+	}
+};
+//#endregion
+//#region src/campaign/search-kernel-proposals.ts
+/** The one proposal in flight and the proposals that have completed. */
+var SearchProposalSlot = class {
+	/** The running proposal, or null when none runs. */
+	running = null;
+	controller = null;
 	/** Operations started: the next one's id. */
-	expansions = 0;
+	started = 0;
 	/** Proposals that completed, by operation index. A proposal an interrupted
 	* process lost counts toward none of the stop rules, so a resumed search
 	* makes the proposals the uninterrupted one would have made. */
 	completed = [];
+	begin(running, controller) {
+		this.running = running;
+		this.controller = controller;
+	}
+	end() {
+		this.running = null;
+		this.controller = null;
+	}
+	abort(reason) {
+		this.controller?.abort(reason);
+	}
+	/** Completed proposals made after the given expansion. */
+	completedAfter(expansion) {
+		return this.completed.filter((index) => index > expansion).length;
+	}
+};
+//#endregion
+//#region src/campaign/search-kernel-runner.ts
+/** Event loop and mutable scheduling state for one ledger-backed search. */
+var SearchKernel = class {
+	options;
+	recorder;
+	maxAttempts;
+	state;
+	lanes;
+	inFlight = /* @__PURE__ */ new Map();
+	proposals = new SearchProposalSlot();
+	completions = new SearchCompletionQueue();
+	progress = new SearchNodeProgress(() => this.state);
+	expansionOf = /* @__PURE__ */ new Map();
+	artifacts;
+	/** Cells the ledger showed unsettled at start: an earlier process may hold their attempt. */
+	adoptable = /* @__PURE__ */ new Set();
 	stopReason = null;
 	failure = null;
 	/** The claim's design once expansion stopped; the search then only claims. */
@@ -1751,27 +1956,15 @@ var SearchKernel = class {
 		this.options = options;
 		this.recorder = options.recorder;
 		this.maxAttempts = options.maxAttempts ?? 3;
-		this.now = options.now ?? Date.now;
 		if (!Number.isSafeInteger(this.maxAttempts) || this.maxAttempts < 1) throw new TypeError("runSearch: maxAttempts must be a positive integer");
 		const { maxExpansions } = options;
 		if (maxExpansions !== void 0 && (!Number.isSafeInteger(maxExpansions) || maxExpansions < 0)) throw new TypeError("runSearch: maxExpansions must be a non-negative integer");
-		for (const lane of options.executor.lanes()) {
-			if (!Number.isSafeInteger(lane.capacity) || lane.capacity < 1) throw new TypeError(`runSearch: lane ${lane.name} needs a positive integer capacity`);
-			if (!Number.isFinite(lane.cellUsd) || lane.cellUsd < 0) throw new TypeError(`runSearch: lane ${lane.name} needs a finite non-negative cellUsd`);
-			if (this.lanes.has(lane.name)) throw new TypeError(`runSearch: lane ${lane.name} is declared twice`);
-			this.lanes.set(lane.name, {
-				...lane,
-				inFlight: 0,
-				queues: [
-					[],
-					[],
-					[],
-					[]
-				],
-				settledCosts: []
-			});
-		}
-		if (this.lanes.size === 0) throw new TypeError("runSearch: the executor declares no lane");
+		this.lanes = new SearchLanes(options.executor.lanes(), {
+			state: () => this.state,
+			now: options.now ?? Date.now,
+			operationPriorUsd: () => options.proposer.reservationUsd ?? 0
+		});
+		this.artifacts = new SearchArtifactCache((nodeId) => options.codec.load(options.recorder, this.state.node(nodeId)));
 		const kernel = this;
 		this.claim = new SearchKernelClaim({
 			get state() {
@@ -1785,12 +1978,12 @@ var SearchKernel = class {
 			},
 			recorder: this.recorder,
 			options,
-			lanes: this.lanes,
+			lanes: this.lanes.byName,
 			refresh: () => this.refresh(),
-			cellReservation: (lane) => this.cellReservation(this.lanes.get(lane.name)),
-			maxCellReservation: () => this.maxCellReservation(),
-			operationReservation: () => this.operationReservation(),
-			enqueue: (cell) => this.enqueue(cell)
+			cellReservation: (lane) => this.lanes.cellReservation(this.lanes.byName.get(lane.name)),
+			maxCellReservation: () => this.lanes.maxCellReservation(),
+			operationReservation: () => this.lanes.operationReservation(),
+			enqueue: (cell) => this.lanes.enqueue(cell)
 		});
 	}
 	async run() {
@@ -1812,8 +2005,8 @@ var SearchKernel = class {
 		const { signal } = this.options;
 		const onAbort = () => {
 			for (const controller of this.inFlight.values()) controller.abort(signal?.reason);
-			this.proposalController?.abort(signal?.reason);
-			this.wakeUp();
+			this.proposals.abort(signal?.reason);
+			this.completions.wakeUp();
 		};
 		signal?.addEventListener("abort", onAbort, { once: true });
 		try {
@@ -1849,7 +2042,7 @@ var SearchKernel = class {
 			await this.refresh();
 		} else if (this.state.node(rootId).artifactDigest !== rootInput.artifactDigest) throw new Error(`runSearch: search ${this.recorder.searchId} started from another root artifact; a changed start is a derived search`);
 		const root = this.state.rootNodeId;
-		this.artifacts.set(root, this.options.root);
+		this.artifacts.seed(root, this.options.root);
 		this.expansionOf.set(root, -1);
 		if (this.state.audit.cells.allocated === 0) this.claim.assertReady();
 		await this.claim.restore();
@@ -1858,11 +2051,11 @@ var SearchKernel = class {
 			const operationId = `expand-${expansion}`;
 			const operation = this.state.operation(operationId);
 			if (!operation) break;
-			this.expansions = expansion + 1;
+			this.proposals.started = expansion + 1;
 			if (operation.recorded) {
-				this.operationCosts.push(operation.spentUsd);
+				this.lanes.recordOperationCost(operation.spentUsd);
 				recorded.push(expansion);
-				if (operation.outcome === "completed") this.completed.push(expansion);
+				if (operation.outcome === "completed") this.proposals.completed.push(expansion);
 				continue;
 			}
 			await this.recorder.recordOperation({
@@ -1885,24 +2078,24 @@ var SearchKernel = class {
 			const edge = this.state.edge(node.edgeIds[0]);
 			const expansion = edge.proposer?.operationId ? searchExpansionIndex(edge.proposer.operationId) : null;
 			this.expansionOf.set(node.nodeId, expansion ?? -1);
-			if (node.status !== "invalid") this.admitted.add(node.nodeId);
+			if (node.status !== "invalid") this.progress.admitted.add(node.nodeId);
 		}
 		for (const cell of this.state.cells()) {
-			const lane = cell.lane === null ? void 0 : this.lanes.get(cell.lane);
+			const lane = cell.lane === null ? void 0 : this.lanes.byName.get(cell.lane);
 			if (cell.final && lane) lane.settledCosts.push(cell.spentUsd);
 			if (this.cellDone(cell)) continue;
 			if (!lane) throw new Error(`runSearch: cell ${cell.cellId} was placed on lane ${String(cell.lane)}, which the executor does not declare`);
 			this.adoptable.add(cell.cellId);
-			this.enqueue(cell);
-			if (cell.stage !== "claim") this.pending.set(cell.nodeId, (this.pending.get(cell.nodeId) ?? 0) + 1);
+			this.lanes.enqueue(cell);
+			if (cell.stage !== "claim") this.progress.add(cell.nodeId, 1);
 		}
 		if (this.claim.plan) return;
 		for (const expansion of recorded) await this.finishProposal(expansion);
-		for (const node of this.state.nodes()) if (this.admitted.has(node.nodeId) && !isTerminal(node)) await this.allocateFor(node.nodeId);
+		for (const node of this.state.nodes()) if (this.progress.admitted.has(node.nodeId) && !isTerminal(node)) await this.allocateFor(node.nodeId);
 		for (const nodeId of this.state.nodeIds()) {
-			if (!this.admitted.has(nodeId)) continue;
-			if (this.state.node(nodeId).status === "advanced") this.markScreened(nodeId);
-			else if ((this.pending.get(nodeId) ?? 0) === 0) await this.screenDone(nodeId);
+			if (!this.progress.admitted.has(nodeId)) continue;
+			if (this.state.node(nodeId).status === "advanced") this.progress.markScreened(nodeId);
+			else if (this.progress.count(nodeId) === 0) await this.screenDone(nodeId);
 		}
 		await this.advance();
 	}
@@ -1913,36 +2106,20 @@ var SearchKernel = class {
 				this.failure ??= { error: this.options.signal?.reason ?? /* @__PURE__ */ new Error("aborted") };
 				return;
 			}
-			if (this.pastDeadline()) {
+			if (this.lanes.pastDeadline()) {
 				this.stopReason ??= "deadline";
-				if (this.queuedCount() > 0) await this.cancelQueued("deadline");
+				if (this.lanes.queuedCount() > 0) await this.cancelQueued("deadline");
 			}
 			this.dispatch();
-			const blocked = this.stopReason === null && this.proposal === null ? await this.tryExpand() : null;
-			if (!(this.inFlight.size > 0 || this.proposal !== null)) {
-				if (this.queuedCount() > 0) continue;
+			const blocked = this.stopReason === null && this.proposals.running === null ? await this.tryExpand() : null;
+			if (!(this.inFlight.size > 0 || this.proposals.running !== null)) {
+				if (this.lanes.queuedCount() > 0) continue;
 				this.stopReason ??= blocked ?? "converged";
 				return;
 			}
-			await this.handle(await this.next());
+			await this.handle(await this.completions.next());
 		}
 	}
-	/** The next completion, or null when an abort woke the loop without one. */
-	async next() {
-		if (this.completions.length === 0) await new Promise((resolve) => {
-			this.wake = resolve;
-		});
-		return this.completions.shift() ?? null;
-	}
-	push(completion) {
-		this.completions.push(completion);
-		this.wakeUp();
-	}
-	wakeUp() {
-		const wake = this.wake;
-		this.wake = null;
-		wake?.();
-	}
 	async handle(completion) {
 		if (completion === null) return;
 		if (completion.kind === "cell") await this.settle(completion);
@@ -1951,16 +2128,16 @@ var SearchKernel = class {
 	/** Abort everything in flight and record what still completes. */
 	async drain(reason) {
 		for (const controller of this.inFlight.values()) controller.abort(reason);
-		this.proposalController?.abort(reason);
-		while (this.inFlight.size > 0 || this.proposal !== null) await this.handle(await this.next());
+		this.proposals.abort(reason);
+		while (this.inFlight.size > 0 || this.proposals.running !== null) await this.handle(await this.completions.next());
 	}
 	/** Fill free lane slots with queued cells. A queued cell was admitted when
 	* it was allocated, so starting it needs no further decision. */
 	dispatch() {
 		if (this.failure || this.options.signal?.aborted) return;
-		const claimOnly = this.pastDeadline();
+		const claimOnly = this.lanes.pastDeadline();
 		const cap = this.state.header.budget.maxConcurrency;
-		for (const lane of this.lanes.values()) while (lane.inFlight < lane.capacity && (cap === null || this.inFlight.size < cap)) {
+		for (const lane of this.lanes.byName.values()) while (lane.inFlight < lane.capacity && (cap === null || this.inFlight.size < cap)) {
 			const cellId = (claimOnly ? lane.queues[STAGE_PRIORITY.claim] : lane.queues.find((waiting) => waiting.length > 0))?.shift();
 			if (cellId === void 0) break;
 			this.start(cellId, lane);
@@ -1982,19 +2159,19 @@ var SearchKernel = class {
 			lane: lane.name,
 			attempt,
 			runId: `${cellId}:${attempt}`,
-			artifact: this.artifact(cell.nodeId),
+			artifact: this.artifacts.get(cell.nodeId),
 			signal: controller.signal
 		};
 		const adopt = this.adoptable.delete(cellId);
 		this.inFlight.set(cellId, controller);
 		lane.inFlight += 1;
 		const { executor } = this.options;
-		(async () => (adopt ? await executor.adopt(work) : null) ?? await executor.run(work))().then((result) => this.push({
+		(async () => (adopt ? await executor.adopt(work) : null) ?? await executor.run(work))().then((result) => this.completions.push({
 			kind: "cell",
 			cellId,
 			attempt,
 			result
-		}), (error) => this.push({
+		}), (error) => this.completions.push({
 			kind: "cell",
 			cellId,
 			attempt,
@@ -2005,7 +2182,7 @@ var SearchKernel = class {
 		const { cellId, attempt } = completion;
 		this.inFlight.delete(cellId);
 		const before = this.state.cell(cellId);
-		const lane = this.lanes.get(before.lane);
+		const lane = this.lanes.byName.get(before.lane);
 		lane.inFlight -= 1;
 		if (!completion.result) {
 			this.failure ??= { error: completion.error };
@@ -2023,13 +2200,11 @@ var SearchKernel = class {
 		if (cell.final) lane.settledCosts.push(cell.spentUsd);
 		if (!this.cellDone(cell)) {
 			if (this.failure || this.options.signal?.aborted) return;
-			this.enqueue(cell);
+			this.lanes.enqueue(cell);
 			return;
 		}
 		if (cell.stage === "claim") return;
-		const left = (this.pending.get(cell.nodeId) ?? 1) - 1;
-		this.pending.set(cell.nodeId, left);
-		if (left === 0) await this.onNodeIdle(cell.nodeId);
+		if (this.progress.release(cell.nodeId) === 0) await this.onNodeIdle(cell.nodeId);
 	}
 	/** Every cell allocated to the node is done: its screen, or a rung. */
 	async onNodeIdle(nodeId) {
@@ -2041,7 +2216,7 @@ var SearchKernel = class {
 	* search fails or is aborted, no rung opens; a search that stopped
 	* expanding still measures the nodes that earned it. */
 	async advance() {
-		if (this.claim.plan || this.failure || this.options.signal?.aborted || this.pastDeadline()) return;
+		if (this.claim.plan || this.failure || this.options.signal?.aborted || this.lanes.pastDeadline()) return;
 		for (const decision of this.options.allocation.advance(this.allocationView())) await this.allocateFor(decision.nodeId, decision);
 	}
 	/**
@@ -2051,7 +2226,7 @@ var SearchKernel = class {
 	* becomes a parent; any other node is screened. Returns whether it was.
 	*/
 	async screenDone(nodeId) {
-		if (!this.claim.plan && !this.screenedSet.has(nodeId) && this.state.node(nodeId).status !== "advanced") {
+		if (!this.claim.plan && !this.progress.screenedSet.has(nodeId) && this.state.node(nodeId).status !== "advanced") {
 			const divergence = searchDivergence(this.state, nodeId);
 			if (divergence) {
 				await this.recorder.decideNode({
@@ -2062,25 +2237,13 @@ var SearchKernel = class {
 					reason: divergence.reason
 				});
 				await this.refresh();
-				this.admitted.delete(nodeId);
+				this.progress.admitted.delete(nodeId);
 				return false;
 			}
 		}
-		this.markScreened(nodeId);
+		this.progress.markScreened(nodeId);
 		return true;
 	}
-	markScreened(nodeId) {
-		if (this.screenedSet.has(nodeId)) return;
-		this.screenedSet.add(nodeId);
-		const ordinal = this.state.node(nodeId).ordinal;
-		let index = this.screened.length;
-		while (index > 0 && this.state.node(this.screened[index - 1]).ordinal > ordinal) index--;
-		this.screened = [
-			...this.screened.slice(0, index),
-			nodeId,
-			...this.screened.slice(index)
-		];
-	}
 	/**
 	* Allocate the cells the allocator plans for a node through its rung and the
 	* ledger lacks. With a rank decision, the rung is the decision's, and the
@@ -2099,12 +2262,12 @@ var SearchKernel = class {
 				...plan,
 				nodeId
 			});
-			const lane = this.lanes.get(laneName);
+			const lane = this.lanes.byName.get(laneName);
 			if (!lane) throw new Error(`runSearch: the executor placed a cell on unknown lane ${laneName}`);
 			return {
 				plan,
 				lane,
-				reservation: this.cellReservation(lane)
+				reservation: this.lanes.cellReservation(lane)
 			};
 		});
 		const hold = placed.reduce((sum, { reservation }) => sum + reservation.usd, 0);
@@ -2125,9 +2288,9 @@ var SearchKernel = class {
 		await this.refresh();
 		for (const { plan } of placed) {
 			const cellId = searchCellId(this.recorder.searchId, nodeId, plan.taskId, plan.split, plan.rep);
-			this.enqueue(this.state.cell(cellId));
+			this.lanes.enqueue(this.state.cell(cellId));
 		}
-		this.pending.set(nodeId, (this.pending.get(nodeId) ?? 0) + placed.length);
+		this.progress.add(nodeId, placed.length);
 		this.dispatch();
 		return true;
 	}
@@ -2135,16 +2298,8 @@ var SearchKernel = class {
 		await this.recorder.decideNode(decision);
 		await this.refresh();
 	}
-	enqueue(cell) {
-		this.lanes.get(cell.lane).queues[STAGE_PRIORITY[cell.stage]].push(cell.cellId);
-	}
-	queuedCount() {
-		let count = 0;
-		for (const lane of this.lanes.values()) for (const queue of lane.queues) count += queue.length;
-		return count;
-	}
 	async cancelQueued(reason) {
-		for (const lane of this.lanes.values()) for (const [priority, queue] of lane.queues.entries()) {
+		for (const lane of this.lanes.byName.values()) for (const [priority, queue] of lane.queues.entries()) {
 			if (priority === STAGE_PRIORITY.claim) continue;
 			for (const cellId of queue.splice(0)) {
 				const cell = this.state.cell(cellId);
@@ -2155,9 +2310,7 @@ var SearchKernel = class {
 					});
 					await this.refresh();
 				}
-				const left = (this.pending.get(cell.nodeId) ?? 1) - 1;
-				this.pending.set(cell.nodeId, left);
-				if (left === 0) this.markScreened(cell.nodeId);
+				if (this.progress.release(cell.nodeId) === 0) this.progress.markScreened(cell.nodeId);
 			}
 		}
 	}
@@ -2171,26 +2324,26 @@ var SearchKernel = class {
 		const { maxNodes, maxCells } = this.state.header.budget;
 		if (maxNodes !== null && this.state.audit.nodes >= maxNodes) return "max-nodes";
 		const { maxExpansions } = this.options;
-		if (maxExpansions !== void 0 && this.completed.length >= maxExpansions) return "max-nodes";
-		if (this.queuedCount() > 0) return "converged";
-		if (this.inFlight.size >= 2 * this.capacity()) return "converged";
+		if (maxExpansions !== void 0 && this.proposals.completed.length >= maxExpansions) return "max-nodes";
+		if (this.lanes.queuedCount() > 0) return "converged";
+		if (this.inFlight.size >= 2 * this.lanes.capacity()) return "converged";
 		const view = this.policyView();
 		const { policy } = this.options;
 		const leader = policy.leader(view);
-		if (policy.patience !== void 0 && this.completed.filter((index) => index > (this.expansionOf.get(leader) ?? -1)).length >= policy.patience) return "patience";
+		if (policy.patience !== void 0 && this.proposals.completedAfter(this.expansionOf.get(leader) ?? -1) >= policy.patience) return "patience";
 		const screen = this.options.allocation.screenSize(this.state);
-		const operation = this.operationReservation();
+		const operation = this.lanes.operationReservation();
 		const children = this.options.proposer.childrenPerProposal ?? 1;
-		const need = operation.usd + children * screen * this.maxCellReservation();
+		const need = operation.usd + children * screen * this.lanes.maxCellReservation();
 		const { headroomUsd } = this.state.budget;
-		if (headroomUsd !== null && (need > headroomUsd + 1e-9 || this.overCap())) return "budget";
+		if (headroomUsd !== null && (need > headroomUsd + 1e-9 || this.lanes.overCap())) return "budget";
 		if (maxCells !== null && this.state.audit.cells.allocated + children * screen > maxCells) return "budget";
 		const expansion = policy.expand(view);
 		if (expansion === null) return "converged";
 		const screened = new Set(view.screened);
 		if (expansion.parents.length === 0) throw new Error(`runSearch: policy ${policy.name} proposed an expansion without a parent`);
 		for (const parent of expansion.parents) if (!screened.has(parent)) throw new Error(`runSearch: policy ${policy.name} named parent ${parent}, which has not finished its screen; a node becomes a parent only after its screen completes`);
-		const index = this.expansions++;
+		const index = this.proposals.started++;
 		const operationId = `expand-${index}`;
 		await this.recorder.startOperation({
 			operationId,
@@ -2205,20 +2358,19 @@ var SearchKernel = class {
 			operator: expansion.operator,
 			parents: expansion.parents.map((nodeId) => ({
 				nodeId,
-				artifact: this.artifact(nodeId)
+				artifact: this.artifacts.get(nodeId)
 			})),
 			leader,
 			signal: controller.signal
 		};
-		this.proposalController = controller;
-		this.proposal = this.options.proposer.propose(request).then((result) => this.push({
+		const running = this.options.proposer.propose(request).then((result) => this.completions.push({
 			kind: "proposal",
 			expansion: index,
 			operationId,
 			request,
 			selection: expansion.selection,
 			result
-		}), (error) => this.push({
+		}), (error) => this.completions.push({
 			kind: "proposal",
 			expansion: index,
 			operationId,
@@ -2226,11 +2378,11 @@ var SearchKernel = class {
 			selection: expansion.selection,
 			error
 		}));
+		this.proposals.begin(running, controller);
 		return null;
 	}
 	async recordProposal(completion) {
-		this.proposal = null;
-		this.proposalController = null;
+		this.proposals.end();
 		const { operationId, expansion } = completion;
 		const { proposer, codec, admit } = this.options;
 		const result = completion.result;
@@ -2278,9 +2430,9 @@ var SearchKernel = class {
 			artifacts: [this.recorder.blob("proposal", blob)]
 		});
 		await this.refresh();
-		this.operationCosts.push(this.state.operation(operationId).spentUsd);
-		this.completed.push(expansion);
-		for (const [index, child] of blob.children.entries()) this.proposed.set(child.node.artifactDigest, result.children[index].artifact);
+		this.lanes.recordOperationCost(this.state.operation(operationId).spentUsd);
+		this.proposals.completed.push(expansion);
+		for (const [index, child] of blob.children.entries()) this.artifacts.propose(child.node.artifactDigest, result.children[index].artifact);
 		if (result.stop !== void 0 || blob.children.length === 0) this.stopReason ??= "converged";
 		await this.finishProposal(expansion);
 	}
@@ -2294,11 +2446,7 @@ var SearchKernel = class {
 		const { proposer } = this.options;
 		for (const [index, child] of blob.children.entries()) {
 			const { nodeId } = await this.recorder.registerNode(child.node);
-			const held = this.proposed.get(child.node.artifactDigest);
-			if (held !== void 0) {
-				this.proposed.delete(child.node.artifactDigest);
-				if (!this.artifacts.has(nodeId)) this.artifacts.set(nodeId, held);
-			}
+			this.artifacts.register(nodeId, child.node.artifactDigest);
 			const edgeId = await this.recorder.recordEdge({
 				childNodeId: nodeId,
 				parents: blob.parents,
@@ -2330,10 +2478,10 @@ var SearchKernel = class {
 				await this.refresh();
 				continue;
 			}
-			if (this.admitted.has(nodeId) || node.status === "invalid") continue;
-			this.admitted.add(nodeId);
+			if (this.progress.admitted.has(nodeId) || node.status === "invalid") continue;
+			this.progress.admitted.add(nodeId);
 			await this.allocateFor(nodeId);
-			if ((this.pending.get(nodeId) ?? 0) === 0) this.markScreened(nodeId);
+			if (this.progress.count(nodeId) === 0) this.progress.markScreened(nodeId);
 		}
 	}
 	async close() {
@@ -2349,7 +2497,7 @@ var SearchKernel = class {
 		const decisions = unclaimedSearchDecisions(this.state, view, leader, {
 			rule: this.options.policy.name,
 			stopReason: this.stopReason,
-			screened: this.screenedSet
+			screened: this.progress.screenedSet
 		});
 		for (const decision of decisions) await this.recorder.decideNode(decision);
 		await this.recorder.close({
@@ -2360,76 +2508,22 @@ var SearchKernel = class {
 	}
 	policyView() {
 		return searchPolicyView(this.state, {
-			screened: this.screened,
-			screening: this.admitted.size - this.screenedSet.size,
-			expansions: this.completed.length,
+			screened: this.progress.screened,
+			screening: this.progress.screening(),
+			expansions: this.proposals.completed.length,
 			maxAttempts: this.maxAttempts
 		});
 	}
 	allocationView() {
 		return {
 			state: this.state,
-			idle: (nodeId) => this.admitted.has(nodeId) && (this.pending.get(nodeId) ?? 0) === 0
+			idle: (nodeId) => this.progress.idle(nodeId)
 		};
 	}
-	artifact(nodeId) {
-		const held = this.artifacts.get(nodeId);
-		if (held !== void 0) return held;
-		const artifact = this.options.codec.load(this.recorder, this.state.node(nodeId));
-		this.artifacts.set(nodeId, artifact);
-		return artifact;
-	}
-	capacity() {
-		let total = 0;
-		for (const lane of this.lanes.values()) total += lane.capacity;
-		const cap = this.state.header.budget.maxConcurrency;
-		return cap === null ? total : Math.min(cap, total);
-	}
-	/** A hard lane holds its enforced maximum. An estimate lane holds 1.5 times
-	* the 99th percentile of its settled cells once 20 settled, else its prior. */
-	cellReservation(lane) {
-		if (lane.costCap === "hard") return {
-			kind: "hard",
-			usd: lane.cellUsd
-		};
-		return {
-			kind: "estimate",
-			usd: estimate(lane.settledCosts, lane.cellUsd)
-		};
-	}
-	maxCellReservation() {
-		let most = 0;
-		for (const lane of this.lanes.values()) most = Math.max(most, this.cellReservation(lane).usd);
-		return most;
-	}
-	operationReservation() {
-		return {
-			kind: "estimate",
-			usd: estimate(this.operationCosts, this.options.proposer.reservationUsd ?? 0)
-		};
-	}
-	/** Overspend took committed spend, open holds and the unspent claim reserve
-	* past the cap. Nothing new is proposed then, even at a zero-dollar prior. */
-	overCap() {
-		const { maxUsd } = this.state.header.budget;
-		if (maxUsd === null) return false;
-		const { committedUsd, openReservationUsd } = this.state.audit.spend;
-		return committedUsd + openReservationUsd + this.state.budget.claimReserveUsd > maxUsd + USD_TOLERANCE;
-	}
-	pastDeadline() {
-		const deadline = this.state.header.budget.deadline;
-		return deadline !== null && this.now() >= Date.parse(deadline);
-	}
 	async refresh() {
 		this.state = await this.recorder.state();
 	}
 };
-function estimate(costs, prior) {
-	if (costs.length < 20) return prior;
-	const sorted = [...costs].sort((a, b) => a - b);
-	const p99 = sorted[Math.min(sorted.length - 1, Math.ceil(.99 * sorted.length) - 1)];
-	return Math.round(ESTIMATE_MARGIN * p99 * 1e9) / 1e9;
-}
 /** Spend of work whose result was lost: unknown, with no proven floor. */
 function interruptedAccounting() {
 	return {
@@ -2536,4 +2630,4 @@ function paretoFrontierWithCrowding(candidates, objectives) {
 //#endregion
 export { normalizeSignedZero as A, SEARCH_ESTIMATOR as C, searchEstimateMethod as D, searchCellSetDigest as E, searchPosterior as O, requiredPairsForPairedPromotion as S, estimateNodeFromCells as T, planSearchClaim as _, searchDivergence as a, verifySearchClaim as b, MIN_OUTCOMES_FOR_WEIGHT as c, rankingSplit as d, summarizeSamples as f, decideSearchClaim as g, SEARCH_CLAIM_RULE as h, runSearch as i, seedFromDigest as k, operatorYield as l, searchExpansionIndex as m, paretoFrontier as n, searchPolicyView as o, SEARCH_KERNEL_SOURCE as p, paretoFrontierWithCrowding as r, EXPANSION_OPERATORS as s, dominates as t, INSUFFICIENT_FROM as u, searchClaimDecision as v, estimateNode as w, pairedPromotionPower as x, searchClaimReserveUsd as y };
 
-//# sourceMappingURL=pareto-BzsxidFD.js.map
+//# sourceMappingURL=pareto-BiBnQXAE.js.map