@tangle-network/agent-eval 0.197.0 → 0.198.0

package/dist/search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/search/lenses/edit-credit.ts","../../src/search/lenses/front.ts","../../src/search/lenses/geometry.ts","../../src/search/lenses/plateau.ts","../../src/search/lenses/landscape.ts","../../src/search/lenses/meta-search.ts","../../src/search/lenses/skill-manifold.ts","../../src/search/lenses/task-matrix.ts","../../src/search/lenses/tree.ts","../../src/search/nested-search.ts"],"mappings":";;;;;;cA4Da;;cA8BA,uBAAuB;UAKnB;;;;;;EAMf,aAAa,KAAK;;;EAGlB,QAAQ;;;EAGR;;KAGU;UAEK;EACf;EACA;EACA,UAAU;EACV;;EAEA;;UAGe;EACf;EACA;;;EAGA;;EAEA;;EAEA;;;;EAIA,YAAY;;EAEZ;;;EAGA;;EAEA;;;EAGA;EACA;;IAEE;;IAEA;;IAEA;;IAEA;;;;EAIF,QAAQ;EACR,SAAS;;;;EAIT;;UAGe;EACf;;EAEA;IACE;IACA;IACA;IACA;;;EAGF;EACA,QAAQ;;;;EAIR;;;EAGA;EACA;;EAEA;;EAEA;EACA;;;EAGA;;UAGe;;;;EAIf,UAAU,QAAQ;IAA2B;;EAC7C;IAAkB;IAAmB;MAAU;;;;EAE/C;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA;EACA;EACA;EACA,UAAU;EACV,QAAQ;;EAER;EACA;;UAGe;EACf,OAAO;EACP;EACA;;IAEE;;IAEA;;IAEA,SAAS;;;;EAIX;IAAS;IAAe;;EACxB;IAAS;IAAe;IAAwB;;;EAEhD,OAAO;EACP,QAAQ,OAAO;;;EAGf,YAAY,OAAO;EACnB;IACE;;IAEA;;IAEA;IACA;IACA;;IAEA,OAAO;;EAET,iBAAiB;;;EAGjB;;IAEE;;;IAGA;IACA;;;;EAIF,SAAS;EACT;IACE,WAAW;IACX;IACA;IACA;IACA;;IAEA;;;;;UAMa,yBAAyB;;EAExC;;;EAGA;;KAGU,mBAAmB,WAAW;EACxC,QAAQ;;;;;;iBA0CM,WAAW,OAAO,iBAAiB,SAAS,oBAAoB;;;iBA68BhE,eAAe,QAAQ,kBAAkB;EAAW;;;;UCvwCnD;EACf;EACA;;;;EAIA,MAAM,OAAO,iBAAiB;;UAGf;EACf;;;EAGA;EACA;;;EAGA;;;EAGA;;UAGe;EACf;EACA;EACA,MAAM;EACN;;;EAGA;;UAGe;EACf;EACA,OAAO;;;;;KAMG,cAAc;iBAEV,MACd,OAAO,iBACP,UAAS;EACN,MAAM;EAAW;IAAU;IAAc,OAAO;;;;;;;UC1CpC,uBAAuB;;;EAGtC;;EAEA;;EAEA;;EAEA;;UAGe,mBAAmB,eAAe,WAAW;;EAE5D;EACA;;EAEA;EACA,QAAQ;;;;;;;;;iBAqBM,cACd,OAAO,iBACP;EAAW;;;;;KC/CD,oBAAoB,KAC9B;UAIe;;EAEf;;UAGe;;;EAGf;EACA;;;;EAIA;;EAEA;;;EAGA;;;EAGA;EACA;IAAQ;IAAgB;IAAc;;;;EAGtC;EACA;EACA;EACA;;;;;;;iBAUc,cACd,MAAM,mBACN,UAAS,uBACR;UA6Ec;;;EAGf;;;EAGA;;;;;;;;;;;;;;;;;;;;;;iBAuBc,eACd,MAAM,cACN,UAAS,wBACR;;;;;;;;;;;;;;KCxGS;EACN;EAAiB;EAAc;;EAE/B;EACA;EACA;EACA,SAAS,GAAG,YAAY,GAAG;;EAG3B;EACA;EACA;EACA,OAAO,MAAM;;;iBAIH,gBAAgB;;;iBAWhB,sBAAsB;;;;;;;;;iBA6BtB,iBACd,OAAO,SAAS,qCACf;;iBAoDa,gBACd,cACA,SAAS,MAAM,0CACd;;;;;;;iBAea,iBAAiB,gBAAgB;;;iBAuBjC,iBAAiB,sBAAsB;UA2BtC;;EAEf;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,QAAQ;;EAER;;EAEA;EACA;EACA;;;EAGA;;;EAGA;EACA;EACA,QAAQ;;;EAGR;;UAGe;EACf;EACA;EACA;EACA;;;;EAIA;;EAEA;EACA;;;;EAIA;IACE;IACA;IACA;;IAEA;;;;IAIA;;IAEA;;EAEF;;UAGe;;EAEf;IAAQ;IAAgB;IAAW;IAAW;IAAe;;;;;EAI7D;;;EAGA;EACA;EACA;;UAGe;EACf;EACA;EACA;IACE;IACA;IACA;;;IAGA;MAAoB;MAAgB;;;IAEpC;;IAEA;;;IAGA;IACA;IACA;;EAEF,OAAO;;EAEP,SAAS;IAAQ;IAAgB;IAAe;;EAChD,MAAM;EACN;EACA;IACE;;IAEA;;IAEA;;;IAGA;;IAEA;;;IAGA;IACA;IACA;IACA;IACA,OAAO;;EAET,SAAS;;;;;;;iBAmBK,UACd,OAAO,iBACP,QAAO,oBACP,UAAS,mBACR,mBAAmB;;;;;;iBAw2BN,kBAAkB,wCAAwC;;;iBAkC1D,gBAAgB,MAAM,mBAAmB;;;;UCttCxC;;;;EAIf;;EAEA;EACA;IACE;IACA;IACA;IACA;IACA;;;;EAIF,WACI;IAAQ,MAAM;IAAoB;IAAc,QAAQ;;IAEtD;;;;EAIN,mBACI;IACM;IAAe,OAAO;;IACtB;IAAuB,QAAQ;;IAEnC;;;;KAII;UAQK;EACf;;EAEA;;EAEA;;;;KAKU;EAEN;EACA;;EAEA;;EAGA;;;;EAIA;EACA;EACA;;EAEA;EAAmB;;KAEb;EAEN;EACA;;EAEA;;EAEA,UAAU;;EAEV;;EAEA;EACA,OAAO;EACP,YAAY;;EAGZ;EACA,UAAU;EACV,QAAQ;EACR;EACA,OAAO;;;KAID;EAEN;EACA;;EAEA;;EAEA;;EAGA;EACA;EACA;EACA;;;EAGA;EACA;;UAGW;EACf;EACA;EACA;IAAa;IAAgB;;;EAE7B;EACA;EACA,aAAa;EACb,QAAQ;EACR,cAAc;EACd;EACA;EACA;EACA;IAAS;IAAiB;;EAC1B;IACE,UAAU;IACV;IACA;IACA;;EAEF,OAAO;EACP,QAAQ;EACR;;EAEA;;;EAGA;IAAS,OAAO;IAA+C;;;;UAIhD;;;EAGf;EACA;EACA;EACA,QAAQ;EACR;;EAEA;;UAGe;EACf,cAAc;EACd;EACA,QAAQ;EACR;EACA;IAAa;IAAc;IAAc;IAA+B;;;EAExE;;EAEA;EACA,UAAU,QAAQ,OAAO;EACzB,UAAU;;;;EAIV,YAAY;IACV;IACA;IACA;IACA,oBAAoB;IACpB,eAAe;;;UAIF;EACf,UAAU;EACV;;EAEA,gBAAgB;EAChB;;EAEA;;;;UAKe;;EAEf;EACA;EACA,cAAc;EACd,QAAQ;EACR;EACA,QAAQ;EACR,gBAAgB;EAChB,OAAO;EACP;;;EAGA;EACA;;;;EAIA;IAAa;IAAkB;;;EAE/B;;UAGe;;EAEf;;;;EAIA;;;cAIW;;;cA2BA,0BAA0B;;;;;;iBAUvB,mBAAmB,OAAO,kBAAkB;;;;;;iBAkD5C,gBAAgB,OAAO,kBAAkB;;iBAgFzC,WACd,mBAAmB,mBACnB,UAAS,oBACR,WAAW,gBAAgB;;iBA8Fd,aAAa,QAAQ,YAAY;UA+QhC;;;EAGf;;;;;;;;iBASc,qBACd,QAAQ,WAAW,gBAAgB,0BACnC,UAAS;;;UC9wBM;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;EAMA;;;;EAIA;;;EAGA,cAAc;;;;EAId;;;;EAIA;IAAU;IAAe;;;;UAIV;;EAEf;;;EAGA,MAAM;;;EAGN;EACA;EACA;EACA;;;EAGA;;EAEA,OAAO;IAAQ;IAAgB;IAAc;;;KAGnC;UAEK;EACf;EACA;EACA,QAAQ;;EAER;;;EAGA;;EAEA;EACA;;UAGe;EACf;;EAEA;;;EAGA;;;EAGA;;;EAGA;;EAEA;;UAGe;EACf;;;EAGA;;EAEA;;UAGe;EACf;EACA;;EAEA;EACA;EACA;IACE;IACA;;IAEA;IACA;;IAEA;;IAEA;IACA;;EAEF;IACE;IACA,MAAM;IACN;IACA;IACA;IACA;IACA;IACA;;;EAGF;IACE,QAAQ;MAAQ;MAAc;;;IAE9B;IACA;;EAEF;IACE;IACA;;IAEA;IACA;IACA,OAAO;MAAQ;MAAc;MAAe;;IAC5C;;;EAGF;EACA;EACA,OAAO;EACP,OAAO;EACP,SAAS;IAAQ;IAAgB;IAAuB;;EACxD,WAAW;;;EAGX;EACA;;;;;;;iBA8Cc,cACd,OAAO,iBACP,qBACA,UAAS,uBACR,mBAAmB;;;;;;iBAuSN,iBACd,MAAM,mBAAmB,qBACxB;;;;;;;;;iBAg3Ba,kBACd,aAAa,kBACb;EAAW;IACV;;iBAsEa,oBAAoB,MAAM,mBAAmB;;;UCj9C5C;EACf;EACA;;;EAGA;;UAGe;;EAEf;EACA;;UAGe;EACf;EACA;;;;EAIA;EACA;;UAGe;EACf;EACA;EACA;EACA,cAAc;EACd,cAAc;EACd,OAAO;EACP,gBAAgB;;UAGD;EACf;;;;KAKU,mBAAmB;iBAEf,WACd,OAAO,iBACP,UAAS;EACN,MAAM;EAAgB;IAAU;IAAc,OAAO;;;;;UClDzC;EACf;EACA,QAAQ;EACR;;;EAGA;EACA;EACA;;;EAGA,UAAU;EACV,UAAU;;UAGK;;;;;EAKf,OAAO;EACP;EACA;;iBAGc,KAAK,OAAO;EAC1B,MAAM;EACN;IAAU;IAAc;;;;;;KCQd,0BAA0B,YAAY;;UAGjC,qBAAqB;EACpC,QAAQ;;EAER,aAAa;;;;EAIb;EACA;IAAQ;IAAgB;IAAgB,OAAO;IAAa;;EAC5D,QAAQ;;UAGO,uBAAuB,iBAC9B,KAAK,iBAAiB;;;EAG9B,QAAQ,oBAAoB;;;EAG5B,MAAM;;;EAGN,SAAS,OAAO,qBAAqB,WAAW,QAAQ;;;EAGxD,YAAY,OAAO,qBAAqB,WAAW,QAAQ;;;iBAI7C,eAAe,aAAa;;;;;iBAS5B,kBAAkB,YAAY,oBAAoB;;;;;;;iBA6B5C,gBAAgB,SACpC,SAAS,uBAAuB,WAC/B,QAAQ"}

package/dist/search/index.js

@@ -0,0 +1,187 @@
+import { a as hashCanonical } from "../canonical-BsZVgBhW.js";
+import { _ as rankingSplit, h as operatorYield, m as MIN_OUTCOMES_FOR_WEIGHT, n as runSearch, p as EXPANSION_OPERATORS, v as summarizeSamples } from "../search-kernel-D8_kxChy.js";
+import { A as editCreditText, C as draftOnPlateau, D as EDIT_CREDIT_ESTIMATOR, E as front, O as EDIT_CREDIT_SIGNAL, S as vectorEmbedding, T as screenedNodes, _ as lineageEdits, a as skillCalibration, b as surfaceDigestEdits, c as META_SEARCH_SIGNAL, d as objectiveKey, f as renderMetaSearchText, g as lineEditDistance, h as landscape, i as nextUnitExtension, k as editCredit, l as metaSearch, m as formatLandscape, n as taskMatrix, o as skillManifold, p as searchPolicyGenome, r as formatSkillManifold, s as META_SEARCH_SCORE_SOURCE, t as tree, u as metaSearchScore, v as nearestNeighbours, w as searchPlateau, x as surfaceTextEdits, y as profileTextLines } from "../tree-DHHWsH-X.js";
+//#region src/search/nested-search.ts
+/** The deterministic id of the inner search one outer cell attempt runs. */
+function nestedSearchId(containment) {
+	const { searchId, cellId, attempt } = containment;
+	return `nested_${hashCanonical({
+		searchId,
+		cellId,
+		attempt
+	}).slice(7, 39)}`;
+}
+/**
+* The codec for a plain JSON configuration: the node is the configuration's
+* canonical JSON, and the diff names each top-level key whose value changed.
+*/
+function searchConfigCodec() {
+	return {
+		node: (recorder, config) => {
+			const artifact = recorder.blob("search-config", config);
+			return {
+				artifactDigest: hashCanonical(config),
+				artifact,
+				surfaces: [{
+					surfaceId: "search-config",
+					kind: "runtime-config",
+					artifact
+				}]
+			};
+		},
+		diff: (recorder, parent, child) => {
+			const before = asRecord(parent);
+			const after = asRecord(child);
+			const changes = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort().filter((key) => hashCanonical(before[key] ?? null) !== hashCanonical(after[key] ?? null)).map((key) => ({
+				key,
+				from: before[key] ?? null,
+				to: after[key] ?? null
+			}));
+			return recorder.blob("diff", {
+				kind: "search-config-diff",
+				changes
+			});
+		},
+		load: (recorder, node) => recorder.readBlob(node.artifact)
+	};
+}
+/**
+* Run an outer search over search configurations to its close, or continue
+* one from its ledger. The outer search must maximize (its score is lift per
+* dollar), its nodes must be `runtime-config` artifacts, and its judge must be
+* `META_SEARCH_SCORE_SOURCE`.
+*/
+async function runNestedSearch(options) {
+	const { recorder, lane, runInner, adoptInner } = options;
+	const header = (await recorder.state()).header;
+	if (!header) throw new Error(`runNestedSearch: search ${recorder.searchId} has not been opened`);
+	if (header.objective.direction !== "maximize") throw new Error("runNestedSearch: an outer search scores held-out lift per dollar, so its objective must maximize");
+	if (header.artifactKind !== "runtime-config") throw new Error(`runNestedSearch: an outer search's nodes are configurations (runtime-config), not ${header.artifactKind}`);
+	const judge = header.objective.judge;
+	if (!("uri" in judge) || judge.uri !== META_SEARCH_SCORE_SOURCE.uri || judge.revision !== META_SEARCH_SCORE_SOURCE.revision) throw new Error(`runNestedSearch: an outer search's judge must be META_SEARCH_SCORE_SOURCE (${META_SEARCH_SCORE_SOURCE.uri}@${META_SEARCH_SCORE_SOURCE.revision}), which scores its cells`);
+	const input = (work) => {
+		const containment = {
+			searchId: work.searchId,
+			cellId: work.cellId,
+			attempt: work.attempt
+		};
+		return {
+			config: work.artifact,
+			containment,
+			searchId: nestedSearchId(containment),
+			task: {
+				taskId: work.taskId,
+				unitId: work.unitId,
+				split: work.split,
+				rep: work.rep
+			},
+			signal: work.signal
+		};
+	};
+	return runSearch({
+		...options,
+		codec: options.codec ?? searchConfigCodec(),
+		executor: {
+			lanes: () => [lane],
+			place: () => lane.name,
+			async adopt(work) {
+				if (!adoptInner) return null;
+				const request = input(work);
+				const inner = await adoptInner(request);
+				return inner ? outerResult(recorder, request, inner, work.lane, null) : null;
+			},
+			async run(work) {
+				const request = input(work);
+				const startedAt = Date.now();
+				const inner = await runInner(request);
+				return outerResult(recorder, request, inner, work.lane, Date.now() - startedAt);
+			}
+		}
+	});
+}
+/** The outer cell's result from its closed inner search. */
+function outerResult(recorder, request, inner, lane, wallMs) {
+	const header = inner.header;
+	const expected = request.containment;
+	const recorded = header?.containment ?? null;
+	if (!header || recorded === null || recorded.searchId !== expected.searchId || recorded.cellId !== expected.cellId || recorded.attempt !== expected.attempt) throw new Error(`runNestedSearch: inner search ${inner.searchId} does not record outer cell ${expected.cellId} attempt ${expected.attempt} of ${expected.searchId} as its containment`);
+	if (!inner.closed) throw new Error(`runNestedSearch: inner search ${inner.searchId} is open; runInner must return it closed`);
+	const score = metaSearchScore(inner);
+	const { spend, tokens } = inner.audit;
+	const metrics = {
+		knownUsd: spend.knownUsd,
+		floorUsd: spend.floorUsd,
+		nodes: inner.audit.nodes,
+		cells: inner.audit.cells.settled
+	};
+	if (score.status === "scored") {
+		metrics.lift = score.lift;
+		metrics.testUnits = score.estimate.pairs;
+	}
+	const perUsd = score.status === "scored" ? score.liftPerUsd : null;
+	const outcome = perUsd?.status === "known" ? {
+		status: "passed",
+		score: perUsd.value,
+		metrics
+	} : {
+		status: "errored",
+		metrics,
+		error: {
+			...score.status === "unscored" ? {
+				code: `inner-${score.reason}`,
+				message: score.detail
+			} : {
+				code: `inner-cost-${perUsd.status}`,
+				message: perUsd.reason
+			},
+			retryable: false
+		}
+	};
+	const unknownCost = spend.unknownCostCells + spend.unknownCostOperations;
+	const accounting = {
+		tokens: tokens.unknownTokenAttempts > 0 ? {
+			status: "unknown",
+			reason: `${tokens.unknownTokenAttempts} attempt(s) of inner search ${inner.searchId} recorded no token usage`
+		} : {
+			status: "known",
+			inputTokens: tokens.inputTokens,
+			outputTokens: tokens.outputTokens,
+			cachedTokens: tokens.cachedTokens
+		},
+		cost: unknownCost > 0 ? {
+			status: "unknown",
+			knownLowerBoundUsd: spend.committedUsd,
+			reason: `${unknownCost} cost(s) of inner search ${inner.searchId} are known only as a floor`
+		} : {
+			status: "known",
+			usd: spend.knownUsd,
+			source: "pricing-table"
+		}
+	};
+	const nested = recorder.blob("nested-search", {
+		kind: "nested-search",
+		searchId: inner.searchId,
+		containment: expected,
+		head: inner.head,
+		score
+	});
+	return {
+		outcome,
+		accounting,
+		identity: header.identity,
+		wallMs,
+		placement: {
+			lane,
+			boxId: null
+		},
+		traceRef: { unknown: `the cell ran inner search ${inner.searchId}; its ledger records the execution` },
+		artifacts: [nested]
+	};
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : { value };
+}
+//#endregion
+export { EDIT_CREDIT_ESTIMATOR, EDIT_CREDIT_SIGNAL, EXPANSION_OPERATORS, META_SEARCH_SCORE_SOURCE, META_SEARCH_SIGNAL, MIN_OUTCOMES_FOR_WEIGHT, draftOnPlateau, editCredit, editCreditText, formatLandscape, formatSkillManifold, front, landscape, lineEditDistance, lineageEdits, metaSearch, metaSearchScore, nearestNeighbours, nestedSearchId, nextUnitExtension, objectiveKey, operatorYield, profileTextLines, rankingSplit, renderMetaSearchText, runNestedSearch, screenedNodes, searchConfigCodec, searchPlateau, searchPolicyGenome, skillCalibration, skillManifold, summarizeSamples, surfaceDigestEdits, surfaceTextEdits, taskMatrix, tree, vectorEmbedding };
+
+//# sourceMappingURL=index.js.map

package/dist/search/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/search/nested-search.ts"],"sourcesContent":["/**\n * An outer search whose cells are inner searches (search-tree-design §2.6 and\n * §12, `metaSearch`).\n *\n * `runNestedSearch` runs the one kernel, `runSearch`, over search\n * configurations. Each outer node is a configuration; each outer task names a\n * problem; each outer cell runs one inner search with its node's configuration\n * on its task's problem. The inner search records the cell attempt as its\n * `containment`, so its ledger names the outer execution it belongs to, and\n * the outer cell binds the inner search's head hash, which commits to its\n * whole chain.\n *\n * An outer cell scores `metaSearchScore` of its closed inner search: the held-\n * out lift the inner claim measured per known dollar, the `metaSearch` lens's\n * own score, so the outer climb optimizes exactly what the lens shows. An inner\n * search without such a score (open, no claim, `test-cannot-resolve`, a lift on\n * fewer than 2 test units, a claim its ledger contradicts) or with only a spend\n * floor settles its outer cell `errored`, not retryable, with the reason: the\n * score is unknown, not 0, and a node with such a cell cannot lead. The outer\n * cell costs what the inner search spent.\n *\n * The outer search keeps every rule of the kernel: its policy ranks\n * configurations on the selection problems, and with a test split it claims\n * once, on held-out problems, whether a configuration beats the root\n * configuration.\n */\n\nimport type {\n  RunSearchOptions,\n  SearchArtifactCodec,\n  SearchCellResult,\n  SearchCellWork,\n  SearchLane,\n  SearchRunResult,\n} from '../campaign/search-kernel'\nimport { runSearch } from '../campaign/search-kernel'\nimport type { SearchRecorder } from '../campaign/search-ledger-recording'\nimport type {\n  SearchAttemptAccounting,\n  SearchOpenedEvent,\n  SearchSplit,\n  SearchTaskOutcome,\n} from '../campaign/search-ledger-types'\nimport type { SearchStateView } from '../campaign/search-state'\nimport { hashCanonical } from '../ledger-core/canonical'\nimport { META_SEARCH_SCORE_SOURCE, metaSearchScore } from './lenses/meta-search'\n\n/** The outer cell attempt an inner search runs as. */\nexport type NestedSearchContainment = NonNullable<SearchOpenedEvent['containment']>\n\n/** One inner search to run: a configuration on one outer task. */\nexport interface NestedSearchRunInput<TConfig> {\n  config: TConfig\n  /** Record this as the inner search's `containment`. */\n  containment: NestedSearchContainment\n  /** The inner search's id, a digest of `containment`: rerunning the same\n   * attempt opens the same ledger, so an inner search resumes rather than\n   * starting again. */\n  searchId: string\n  task: { taskId: string; unitId: string; split: SearchSplit; rep: number }\n  signal: AbortSignal\n}\n\nexport interface RunNestedSearchOptions<TConfig>\n  extends Omit<RunSearchOptions<TConfig>, 'codec' | 'executor'> {\n  /** How configurations are stored as nodes. Default `searchConfigCodec()`,\n   * for plain JSON configurations. */\n  codec?: SearchArtifactCodec<TConfig>\n  /** How many inner searches run at once, and what one is expected to cost:\n   * `cellUsd` is the admission rule's prior for one inner search. */\n  lane: SearchLane\n  /** Run the inner search for one outer cell attempt to its close, recording\n   * `containment` in its header, and return its closed state. */\n  runInner(input: NestedSearchRunInput<TConfig>): Promise<SearchStateView>\n  /** The closed inner search of an attempt an earlier outer process started,\n   * or null to run it through `runInner`. Default null. */\n  adoptInner?(input: NestedSearchRunInput<TConfig>): Promise<SearchStateView | null>\n}\n\n/** The deterministic id of the inner search one outer cell attempt runs. */\nexport function nestedSearchId(containment: NestedSearchContainment): string {\n  const { searchId, cellId, attempt } = containment\n  return `nested_${hashCanonical({ searchId, cellId, attempt }).slice('sha256:'.length, 'sha256:'.length + 32)}`\n}\n\n/**\n * The codec for a plain JSON configuration: the node is the configuration's\n * canonical JSON, and the diff names each top-level key whose value changed.\n */\nexport function searchConfigCodec<TConfig>(): SearchArtifactCodec<TConfig> {\n  return {\n    node: (recorder, config) => {\n      const artifact = recorder.blob('search-config', config)\n      return {\n        artifactDigest: hashCanonical(config),\n        artifact,\n        surfaces: [{ surfaceId: 'search-config', kind: 'runtime-config', artifact }],\n      }\n    },\n    diff: (recorder, parent, child) => {\n      const before = asRecord(parent)\n      const after = asRecord(child)\n      const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort()\n      const changes = keys\n        .filter((key) => hashCanonical(before[key] ?? null) !== hashCanonical(after[key] ?? null))\n        .map((key) => ({ key, from: before[key] ?? null, to: after[key] ?? null }))\n      return recorder.blob('diff', { kind: 'search-config-diff', changes })\n    },\n    load: (recorder, node) => recorder.readBlob(node.artifact) as TConfig,\n  }\n}\n\n/**\n * Run an outer search over search configurations to its close, or continue\n * one from its ledger. The outer search must maximize (its score is lift per\n * dollar), its nodes must be `runtime-config` artifacts, and its judge must be\n * `META_SEARCH_SCORE_SOURCE`.\n */\nexport async function runNestedSearch<TConfig>(\n  options: RunNestedSearchOptions<TConfig>,\n): Promise<SearchRunResult> {\n  const { recorder, lane, runInner, adoptInner } = options\n  const header = (await recorder.state()).header\n  if (!header) throw new Error(`runNestedSearch: search ${recorder.searchId} has not been opened`)\n  if (header.objective.direction !== 'maximize') {\n    throw new Error(\n      'runNestedSearch: an outer search scores held-out lift per dollar, so its objective must maximize',\n    )\n  }\n  if (header.artifactKind !== 'runtime-config') {\n    throw new Error(\n      `runNestedSearch: an outer search's nodes are configurations (runtime-config), not ${header.artifactKind}`,\n    )\n  }\n  // The cells are scored by metaSearchScore, so the header must name it as the\n  // judge: a ledger that declared another judge would misstate its own scores.\n  const judge = header.objective.judge\n  if (\n    !('uri' in judge) ||\n    judge.uri !== META_SEARCH_SCORE_SOURCE.uri ||\n    judge.revision !== META_SEARCH_SCORE_SOURCE.revision\n  ) {\n    throw new Error(\n      `runNestedSearch: an outer search's judge must be META_SEARCH_SCORE_SOURCE (${META_SEARCH_SCORE_SOURCE.uri}@${META_SEARCH_SCORE_SOURCE.revision}), which scores its cells`,\n    )\n  }\n  const input = (work: SearchCellWork<TConfig>): NestedSearchRunInput<TConfig> => {\n    const containment = { searchId: work.searchId, cellId: work.cellId, attempt: work.attempt }\n    return {\n      config: work.artifact,\n      containment,\n      searchId: nestedSearchId(containment),\n      task: { taskId: work.taskId, unitId: work.unitId, split: work.split, rep: work.rep },\n      signal: work.signal,\n    }\n  }\n  return runSearch({\n    ...options,\n    codec: options.codec ?? searchConfigCodec<TConfig>(),\n    executor: {\n      lanes: () => [lane],\n      place: () => lane.name,\n      async adopt(work) {\n        if (!adoptInner) return null\n        const request = input(work)\n        const inner = await adoptInner(request)\n        return inner ? outerResult(recorder, request, inner, work.lane, null) : null\n      },\n      async run(work) {\n        const request = input(work)\n        const startedAt = Date.now()\n        const inner = await runInner(request)\n        return outerResult(recorder, request, inner, work.lane, Date.now() - startedAt)\n      },\n    },\n  })\n}\n\n/** The outer cell's result from its closed inner search. */\nfunction outerResult<TConfig>(\n  recorder: SearchRecorder,\n  request: NestedSearchRunInput<TConfig>,\n  inner: SearchStateView,\n  lane: string,\n  wallMs: number | null,\n): SearchCellResult {\n  const header = inner.header\n  const expected = request.containment\n  const recorded = header?.containment ?? null\n  if (\n    !header ||\n    recorded === null ||\n    recorded.searchId !== expected.searchId ||\n    recorded.cellId !== expected.cellId ||\n    recorded.attempt !== expected.attempt\n  ) {\n    throw new Error(\n      `runNestedSearch: inner search ${inner.searchId} does not record outer cell ${expected.cellId} attempt ${expected.attempt} of ${expected.searchId} as its containment`,\n    )\n  }\n  if (!inner.closed) {\n    throw new Error(\n      `runNestedSearch: inner search ${inner.searchId} is open; runInner must return it closed`,\n    )\n  }\n  const score = metaSearchScore(inner)\n  const { spend, tokens } = inner.audit\n  const metrics: Record<string, number> = {\n    knownUsd: spend.knownUsd,\n    floorUsd: spend.floorUsd,\n    nodes: inner.audit.nodes,\n    cells: inner.audit.cells.settled,\n  }\n  if (score.status === 'scored') {\n    metrics.lift = score.lift\n    metrics.testUnits = score.estimate.pairs\n  }\n  const perUsd = score.status === 'scored' ? score.liftPerUsd : null\n  const outcome: SearchTaskOutcome =\n    perUsd?.status === 'known'\n      ? { status: 'passed', score: perUsd.value, metrics }\n      : {\n          status: 'errored',\n          metrics,\n          error: {\n            ...(score.status === 'unscored'\n              ? { code: `inner-${score.reason}`, message: score.detail }\n              : { code: `inner-cost-${perUsd!.status}`, message: perUsd!.reason }),\n            retryable: false,\n          },\n        }\n  const unknownCost = spend.unknownCostCells + spend.unknownCostOperations\n  const accounting: SearchAttemptAccounting = {\n    tokens:\n      tokens.unknownTokenAttempts > 0\n        ? {\n            status: 'unknown',\n            reason: `${tokens.unknownTokenAttempts} attempt(s) of inner search ${inner.searchId} recorded no token usage`,\n          }\n        : {\n            status: 'known',\n            inputTokens: tokens.inputTokens,\n            outputTokens: tokens.outputTokens,\n            cachedTokens: tokens.cachedTokens,\n          },\n    // The sum of the inner search's recorded costs, each already priced by the\n    // inner ledger's own accounting.\n    cost:\n      unknownCost > 0\n        ? {\n            status: 'unknown',\n            knownLowerBoundUsd: spend.committedUsd,\n            reason: `${unknownCost} cost(s) of inner search ${inner.searchId} are known only as a floor`,\n          }\n        : { status: 'known', usd: spend.knownUsd, source: 'pricing-table' },\n  }\n  const nested = recorder.blob('nested-search', {\n    kind: 'nested-search',\n    searchId: inner.searchId,\n    containment: expected,\n    head: inner.head,\n    score,\n  })\n  return {\n    outcome,\n    accounting,\n    identity: header.identity,\n    wallMs,\n    placement: { lane, boxId: null },\n    traceRef: {\n      unknown: `the cell ran inner search ${inner.searchId}; its ledger records the execution`,\n    },\n    artifacts: [nested],\n  }\n}\n\nfunction asRecord(value: unknown): Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : { value }\n}\n"],"mappings":"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"}