@tangle-network/agent-eval 0.197.0 → 0.198.0

package/dist/tree-DHHWsH-X.js

@@ -0,0 +1,4045 @@
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-BsZVgBhW.js";
+import { s as zQuantile } from "./internal-BMFSR8Ns.js";
+import { t as mulberry32 } from "./random-Dn5fPWkt.js";
+import { r as holm } from "./multiplicity-D9cjmStq.js";
+import { a as pairedSignTest, n as DECISION_PAIRED_DELTA_STATISTIC } from "./paired-tests-C8iCsioC.js";
+import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest } from "./paired-promotion-decision-D5B1Cxc2.js";
+import { C as searchPosterior, E as paretoFrontier, _ as rankingSplit, a as searchPolicyView, b as estimateNode, g as INSUFFICIENT_FROM, u as verifySearchClaim, v as summarizeSamples, w as seedFromDigest } from "./search-kernel-D8_kxChy.js";
+import { f as searchUnitScores } from "./search-ledger-BnUytR8X.js";
+import { defineInlineResource } from "@tangle-network/agent-interface";
+//#region src/search/lenses/edit-credit.ts
+/**
+* `editCredit`: the edits of a search as genes, followed down its lineage.
+*
+* Every lineage edge is a parent-to-child change of an artifact. The lens
+* diffs the two artifacts line by line (whitespace-normalized) and cuts each
+* changed run into paragraphs: an added paragraph is an `insert` gene, a
+* removed paragraph a `delete` gene. A gene's id hashes its kind, its location
+* in the artifact and its normalized lines, so the same edit has the same id
+* wherever and whenever a proposer makes it. A node carries an insert gene
+* when the paragraph is present at that location, and a delete gene when it is
+* absent. Carrying is read from each node's content, so it follows merges,
+* re-proposals and reverts without any bookkeeping in the record.
+*
+* A step is one lineage parent and its child. A gene flips on a step when the
+* parent and the child disagree on carrying it. The gene's credit pairs, per
+* step, the side that carries it against the side that lacks it on the units
+* both scored, and averages those contrasts across its steps inside each unit.
+* Only clean steps count: steps on which nothing flips except edits introduced
+* together with the gene. A merge that also brings in the other parent's edits
+* is therefore not evidence for any one of them, and genes that always move
+* together are reported as linked, because their credits are one number.
+*
+* Interactions compare a gene's step contrasts where another gene is present
+* against where it is absent, in both directions, and are flagged after a Holm
+* correction for a factorial test rather than claimed.
+*
+* The lens reads node artifacts through `readArtifact`, which the caller backs
+* with verified blob bytes. An artifact the caller cannot read, and a code
+* surface whose patch bytes are not in the ledger, leave the node's content
+* unknown: its steps yield no genes and no contrasts.
+*/
+const CONFIDENCE = .95;
+const RESAMPLES = 2e3;
+const DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(CONFIDENCE);
+const INTERACTION_ALPHA = .05;
+const DEFAULT_INTERACTION_GENES = 24;
+/** Signal name a policy reads. */
+const EDIT_CREDIT_SIGNAL = "reusableHunks";
+/** The estimator every gene credit names. */
+const EDIT_CREDIT_ESTIMATOR = {
+	uri: "npm:@tangle-network/agent-eval/search#editCredit",
+	revision: hashCanonical({
+		name: "tangle.edit-credit.2026-09",
+		gene: "a paragraph of whitespace-normalized lines added (insert) or removed (delete) at one artifact location",
+		step: "one lineage parent and its child, both with known content and neither invalid",
+		clean: "the gene flips on the step and every gene that flips was introduced on one edge that introduced it",
+		unit: "mean of a node’s scored cells in the unit; per unit, carrier-side and lacking-side means averaged over the clean steps where both sides scored it",
+		statistic: DECISION_PAIRED_DELTA_STATISTIC,
+		interval: "percentile paired bootstrap",
+		confidence: CONFIDENCE,
+		resamples: RESAMPLES,
+		rng: "mulberry32",
+		seed: "the first 32 bits of cellSetDigest",
+		signTest: "exact, one-sided toward improvement in the objective direction",
+		methods: {
+			none: "below 2 units",
+			insufficient: `below ${DESCRIPTIVE_FROM} units`,
+			descriptive: `below 20 units`,
+			bootstrap: `from 20 units`
+		}
+	})
+};
+/**
+* The edit-credit lens. Pure: the result depends only on `state` and what
+* `readArtifact` returns for its references.
+*/
+function editCredit(state, options) {
+	const header = state.header;
+	if (!header) throw new Error(`editCredit: search ${state.searchId} has not been opened`);
+	const split = options.split ?? rankingSplit(state);
+	const direction = header.objective.direction;
+	const sign = direction === "maximize" ? 1 : -1;
+	const interactionGenes = options.interactionGenes ?? DEFAULT_INTERACTION_GENES;
+	if (!Number.isSafeInteger(interactionGenes) || interactionGenes < 0) throw new Error(`editCredit: interactionGenes must be a non-negative integer`);
+	const nodes = state.nodes();
+	const byId = new Map(nodes.map((node) => [node.nodeId, node]));
+	const contents = /* @__PURE__ */ new Map();
+	for (const node of nodes) contents.set(node.nodeId, nodeContent(options, node.artifact));
+	const known = (nodeId) => contents.get(nodeId);
+	const invalid = new Set(nodes.filter((node) => node.status === "invalid").map((n) => n.nodeId));
+	const genes = /* @__PURE__ */ new Map();
+	const byLocus = /* @__PURE__ */ new Map();
+	const introducedOn = /* @__PURE__ */ new Map();
+	const unknownEdges = {};
+	const stepList = [];
+	const stepKeys = /* @__PURE__ */ new Set();
+	let lineageEdges = 0;
+	let readEdges = 0;
+	let edgeOrdinal = 0;
+	for (const edge of state.edges()) {
+		edgeOrdinal += 1;
+		const child = byId.get(edge.childNodeId);
+		const parents = lineageParents(state, edge, child, byId);
+		if (parents.length === 0) continue;
+		lineageEdges += 1;
+		const missing = [child.nodeId, ...parents].map((nodeId) => contents.get(nodeId)).find((content) => !content.known);
+		if (missing && !missing.known) {
+			unknownEdges[missing.reason] = (unknownEdges[missing.reason] ?? 0) + 1;
+			continue;
+		}
+		readEdges += 1;
+		const childContent = known(child.nodeId);
+		const reproposal = child.edgeIds[0] !== edge.edgeId;
+		const wholeLineage = edge.parents.every((parent) => parent.searchId === state.searchId && parents.includes(parent.nodeId));
+		const cuts = /* @__PURE__ */ new Map();
+		for (const parentId of parents) {
+			const key = `${parentId}>${child.nodeId}`;
+			if (!stepKeys.has(key)) {
+				stepKeys.add(key);
+				stepList.push({
+					key,
+					parentId,
+					childId: child.nodeId,
+					flips: /* @__PURE__ */ new Set()
+				});
+			}
+			for (const cut of edgeCuts(known(parentId), childContent)) {
+				const locus = locusOf(cut);
+				if (!cuts.has(locus)) cuts.set(locus, cut);
+			}
+		}
+		if (!wholeLineage) continue;
+		const introducedHere = [];
+		for (const [locus, cut] of cuts) {
+			const existing = byLocus.get(locus);
+			const gene = existing ?? cut;
+			const childCarries = carries(childContent, gene);
+			const parentCarries = parents.filter((parentId) => carries(known(parentId), gene));
+			if (existing && !childCarries && parentCarries.length > 0) {
+				existing.dropped += 1;
+				continue;
+			}
+			if (!childCarries || parentCarries.length > 0) continue;
+			let record = existing;
+			if (!record) {
+				const geneId = `gene_${hashCanonical({
+					kind: cut.kind,
+					path: cut.path,
+					lines: cut.lines
+				}).slice(7).slice(0, 24)}`;
+				record = {
+					...cut,
+					geneId,
+					locus,
+					introduced: [],
+					dropped: 0,
+					order: [edgeOrdinal, cut.position]
+				};
+				genes.set(geneId, record);
+				byLocus.set(locus, record);
+			}
+			record.introduced.push({
+				nodeId: child.nodeId,
+				edgeId: edge.edgeId,
+				operator: edge.operator,
+				parents,
+				reproposal
+			});
+			introducedHere.push(record.geneId);
+		}
+		introducedOn.set(edge.edgeId, introducedHere);
+	}
+	const carriersOf = /* @__PURE__ */ new Map();
+	const carried = /* @__PURE__ */ new Map();
+	for (const record of genes.values()) {
+		const set = /* @__PURE__ */ new Set();
+		for (const node of nodes) {
+			const content = contents.get(node.nodeId);
+			if (content.known && carries(content, record)) {
+				set.add(node.nodeId);
+				appendTo(carried, node.nodeId, record.geneId);
+			}
+		}
+		carriersOf.set(record.geneId, set);
+	}
+	for (const step of stepList) for (const [geneId, set] of carriersOf) if (set.has(step.parentId) !== set.has(step.childId)) step.flips.add(geneId);
+	const measurable = stepList.filter((step) => !invalid.has(step.parentId) && !invalid.has(step.childId));
+	const editsOf = /* @__PURE__ */ new Map();
+	for (const record of genes.values()) editsOf.set(record.geneId, record.introduced.map((introduction) => new Set(introducedOn.get(introduction.edgeId))));
+	const unitMeansOf = memo((nodeId) => {
+		const means = /* @__PURE__ */ new Map();
+		for (const unit of state.unitScores(nodeId, split)) means.set(unit.unitId, unit.mean);
+		return means;
+	});
+	const cellsDigestOf = memo((nodeId) => state.scoredCells(nodeId, split).map((cell) => [
+		cell.cellId,
+		cell.unitId,
+		cell.attempt,
+		cell.score
+	]).sort((left, right) => compareCodeUnits(left[0], right[0])));
+	const cleanOf = /* @__PURE__ */ new Map();
+	const flipCount = /* @__PURE__ */ new Map();
+	for (const step of measurable) for (const geneId of step.flips) {
+		flipCount.set(geneId, (flipCount.get(geneId) ?? 0) + 1);
+		if (!editsOf.get(geneId).some((edit) => [...step.flips].every((other) => edit.has(other)))) continue;
+		const childCarries = carriersOf.get(geneId).has(step.childId);
+		appendTo(cleanOf, geneId, {
+			step,
+			carrierId: childCarries ? step.childId : step.parentId,
+			lackingId: childCarries ? step.parentId : step.childId
+		});
+	}
+	const credits = /* @__PURE__ */ new Map();
+	for (const record of genes.values()) {
+		const steps = cleanOf.get(record.geneId) ?? [];
+		const perUnit = /* @__PURE__ */ new Map();
+		for (const { carrierId, lackingId } of steps) {
+			const lacking = unitMeansOf(lackingId);
+			for (const [unitId, carrierMean] of unitMeansOf(carrierId)) {
+				const lackingMean = lacking.get(unitId);
+				if (lackingMean === void 0) continue;
+				const entry = perUnit.get(unitId) ?? {
+					carrier: 0,
+					lacking: 0,
+					count: 0
+				};
+				entry.carrier += carrierMean;
+				entry.lacking += lackingMean;
+				entry.count += 1;
+				perUnit.set(unitId, entry);
+			}
+		}
+		const unitIds = [...perUnit.keys()].sort(compareCodeUnits);
+		const cellSetDigest = hashCanonical({
+			split,
+			steps: steps.map(({ carrierId, lackingId }) => [
+				carrierId,
+				lackingId,
+				cellsDigestOf(carrierId),
+				cellsDigestOf(lackingId)
+			]).sort((left, right) => compareCodeUnits(canonicalString(left), canonicalString(right)))
+		});
+		const carrierUnits = /* @__PURE__ */ new Set();
+		for (const { carrierId } of steps) for (const unitId of unitMeansOf(carrierId).keys()) carrierUnits.add(unitId);
+		credits.set(record.geneId, pairedEstimate({
+			against: `${record.geneId}:lacking`,
+			split,
+			direction,
+			units: carrierUnits.size,
+			lacking: unitIds.map((unitId) => perUnit.get(unitId).lacking / perUnit.get(unitId).count),
+			carrier: unitIds.map((unitId) => perUnit.get(unitId).carrier / perUnit.get(unitId).count),
+			cellSetDigest
+		}));
+	}
+	const linkageKey = (geneId) => canonicalString((cleanOf.get(geneId) ?? []).map(({ step, carrierId }) => `${step.key}:${carrierId === step.childId ? "+" : "-"}`).sort(compareCodeUnits));
+	const linkGroups = /* @__PURE__ */ new Map();
+	for (const record of [...genes.values()].sort((a, b) => compareOrder(a.order, b.order))) {
+		if (!cleanOf.has(record.geneId)) continue;
+		appendTo(linkGroups, linkageKey(record.geneId), record.geneId);
+	}
+	const geneList = [...genes.values()].map((record) => {
+		const clean = cleanOf.get(record.geneId) ?? [];
+		const group = clean.length > 0 ? linkGroups.get(linkageKey(record.geneId)) : [];
+		const carriers = carriersOf.get(record.geneId);
+		const { credit, verdict } = credits.get(record.geneId);
+		return {
+			geneId: record.geneId,
+			kind: record.kind,
+			path: record.path,
+			lines: record.lines,
+			text: record.text,
+			introduced: record.introduced,
+			dropped: record.dropped,
+			edit: [...editsOf.get(record.geneId)[0]].sort((a, b) => compareOrder(genes.get(a).order, genes.get(b).order)),
+			carriers: [...carriers].filter((nodeId) => !invalid.has(nodeId)).length,
+			invalidCarriers: [...carriers].filter((nodeId) => invalid.has(nodeId)).length,
+			steps: {
+				flips: flipCount.get(record.geneId) ?? 0,
+				clean: clean.length,
+				gained: clean.filter(({ step, carrierId }) => carrierId === step.childId).length,
+				lost: clean.filter(({ step, carrierId }) => carrierId === step.parentId).length
+			},
+			credit,
+			verdict,
+			linkage: group.length > 1 ? group[0] : null
+		};
+	});
+	const verdictRank = {
+		reusable: 0,
+		harmful: 1,
+		unresolved: 2,
+		insufficient: 3
+	};
+	geneList.sort((a, b) => verdictRank[a.verdict] - verdictRank[b.verdict] || improvementLow(b.credit, sign) - improvementLow(a.credit, sign) || gain(b.credit, sign) - gain(a.credit, sign) || compareOrder(genes.get(a.geneId).order, genes.get(b.geneId).order));
+	const counts = emptyCounts();
+	const editCounts = emptyCounts();
+	for (const gene of geneList) {
+		counts[gene.verdict] += 1;
+		if ((gene.linkage ?? (gene.steps.clean === 0 ? gene.edit[0] : gene.geneId)) === gene.geneId) editCounts[gene.verdict] += 1;
+	}
+	const interactions = interactionPairs({
+		genes: geneList,
+		cleanOf,
+		carriersOf,
+		unitMeansOf,
+		limit: interactionGenes,
+		sign
+	});
+	const skillCandidates = skills(geneList, genes, header.subject, split);
+	const lineage = lineageRows(state, nodes, byId, contents, carried);
+	const isMeasured = (gene) => gene.credit.method === "descriptive" || gene.credit.method === "bootstrap";
+	const measured = geneList.filter(isMeasured).length;
+	const measuredLeads = geneList.filter((gene) => isMeasured(gene) && (gene.linkage ?? gene.geneId) === gene.geneId);
+	const expectedReusable = plain(Math.round(measuredLeads.reduce((sum, gene) => sum + chanceReusable(gene.credit.pairs), 0) * 1e6) / 1e6);
+	const top = geneList.filter((gene) => gene.verdict === "reusable" && (gene.linkage ?? gene.geneId) === gene.geneId).map((gene) => gene.geneId);
+	return {
+		signal: measured === 0 ? {
+			name: EDIT_CREDIT_SIGNAL,
+			value: null,
+			basis: `insufficient: no gene has ${DESCRIPTIVE_FROM} ${split} units on clean steps (${geneList.length} genes, ${measurable.length} measurable steps)`,
+			top: []
+		} : {
+			name: EDIT_CREDIT_SIGNAL,
+			value: editCounts.reusable,
+			basis: `independent edits pairedDeltaTest finds improve the objective on the ${split} split (${counts.reusable} genes), of ${measuredLeads.length} edits (${measured} genes) measured on ${DESCRIPTIVE_FROM} or more units; about ${expectedReusable.toFixed(2)} would be called reusable by chance with no true effect (unadjusted)`,
+			top
+		},
+		data: {
+			split,
+			direction,
+			edges: {
+				lineage: lineageEdges,
+				read: readEdges,
+				unknown: unknownEdges
+			},
+			steps: {
+				total: stepList.length,
+				invalidEnd: stepList.length - measurable.length
+			},
+			nodes: {
+				total: nodes.length,
+				contentUnknown: [...contents.values()].filter((content) => !content.known).length,
+				invalid: invalid.size
+			},
+			genes: geneList,
+			counts,
+			editCounts,
+			interactions,
+			skillCandidates,
+			chance: {
+				measuredEdits: measuredLeads.length,
+				expectedReusable,
+				method: `per measured edit, the chance with no true effect that its verdict is reusable: the exact one-sided sign test's attained size at its unit count below 20 units (at most ${(1 - CONFIDENCE) / 2}; the point-estimate condition only lowers it), the nominal ${(1 - CONFIDENCE) / 2} of the percentile bootstrap from 20; summed, so it is the expected number of false reusable edits if every edit had no effect`
+			},
+			lineage,
+			method: {
+				estimator: EDIT_CREDIT_ESTIMATOR,
+				credit: `per clean step (a parent and its child on which every change belongs to one edit that introduced the gene), the carrying side against the lacking side on each unit both scored; per unit, both sides averaged over those steps; ${DECISION_PAIRED_DELTA_STATISTIC} paired delta with a ${Math.round(CONFIDENCE * 100)}% percentile bootstrap (${RESAMPLES} resamples, seeded from cellSetDigest): none below 2 units, insufficient below ${DESCRIPTIVE_FROM}, a descriptive interval and exact one-sided sign p below 20, a decision-grade interval from 20; unscored cells are absent, never zero`,
+				verdict: `pairedDeltaTest's own decision in each direction: reusable when it finds an improvement (below 20 units an exact one-sided sign test at ${(1 - CONFIDENCE) / 2} with the point estimate on the better side; from 20 the bootstrap interval above zero), harmful when it finds one in the other direction, unresolved otherwise, insufficient below ${DESCRIPTIVE_FROM} units`,
+				interaction: `per unit, a gene's clean-step contrast where both ends carry the other gene minus where neither does, averaged over both directions; ${Math.round(CONFIDENCE * 100)}% percentile bootstrap (${RESAMPLES} resamples) for spread; exact two-sided sign test, Holm-adjusted over the pairs tested, flagged at ${INTERACTION_ALPHA}`,
+				multiplicity: "credit is not adjusted for the number of genes: it steers which edits to reuse and test next, as selection estimates steer spend, and claims nothing; interaction flags are Holm-adjusted because pairs grow with the square of the genes",
+				selectionBias: "a policy chooses a parent for its scores, so a parent is high by chance on the units it was chosen on: on a step where the child gained a gene the lacking side is that parent, and credit is biased toward harmful; where the child lost it, toward reusable. Only the sealed test split is free of this, so a reusable edit still needs a held-out test before it ships"
+			}
+		}
+	};
+}
+function nodeContent(options, ref) {
+	const body = options.readArtifact(ref);
+	if (body === void 0) return {
+		known: false,
+		reason: `artifact ${ref.role} unreadable`
+	};
+	const paths = /* @__PURE__ */ new Map();
+	const record = body;
+	if (record && typeof record === "object" && record.kind === "mutable-surface") {
+		const surface = record.surface;
+		if (typeof surface === "string") addText(paths, "prompt", surface);
+		else if (surface?.kind === "components") for (const name of Object.keys(surface.components).sort(compareCodeUnits)) addText(paths, `component:${name}`, surface.components[name]);
+		else return {
+			known: false,
+			reason: "code surface: its patch bytes are not in the ledger"
+		};
+	} else flatten(body, "", paths);
+	const haystacks = /* @__PURE__ */ new Map();
+	for (const [path, text] of paths) haystacks.set(path, `\n${text.norm.filter((line) => line.length > 0).join("\n")}\n`);
+	return {
+		known: true,
+		paths,
+		haystacks
+	};
+}
+/** JSON as text per location: a string's lines at its path, an array's
+* elements as lines at the array's path, any other value as one canonical
+* line. Array elements share a path, so an insertion does not renumber the
+* rest. */
+function flatten(value, path, paths) {
+	const at = path === "" ? "/" : path;
+	if (typeof value === "string") addText(paths, at, value);
+	else if (Array.isArray(value)) for (const element of value) addText(paths, at, typeof element === "string" ? element : canonicalString(element));
+	else if (value !== null && typeof value === "object") for (const key of Object.keys(value).sort(compareCodeUnits)) {
+		const escaped = key.replaceAll("~", "~0").replaceAll("/", "~1");
+		flatten(value[key], `${path}/${escaped}`, paths);
+	}
+	else addText(paths, at, canonicalString(value));
+}
+function addText(paths, path, text) {
+	const entry = paths.get(path) ?? {
+		raw: [],
+		norm: []
+	};
+	for (const line of text.split(/\r?\n/)) {
+		entry.raw.push(line);
+		entry.norm.push(line.replace(/\s+/g, " ").trim());
+	}
+	paths.set(path, entry);
+}
+function carries(content, gene) {
+	const present = content.haystacks.get(gene.path)?.includes(gene.needle) ?? false;
+	return gene.kind === "insert" ? present : !present;
+}
+function locusOf(cut) {
+	return canonicalString([cut.path, cut.lines]);
+}
+function edgeCuts(parent, child) {
+	const cuts = [];
+	const paths = /* @__PURE__ */ new Set([...parent.paths.keys(), ...child.paths.keys()]);
+	let position = 0;
+	for (const path of [...paths].sort(compareCodeUnits)) {
+		const before = parent.paths.get(path) ?? {
+			raw: [],
+			norm: []
+		};
+		const after = child.paths.get(path) ?? {
+			raw: [],
+			norm: []
+		};
+		for (const run of changeRuns(before.norm, after.norm)) for (const [kind, side, start, end] of [[
+			"delete",
+			before,
+			run.aStart,
+			run.aEnd
+		], [
+			"insert",
+			after,
+			run.bStart,
+			run.bEnd
+		]]) for (const [from, to] of paragraphs(side.norm, start, end)) {
+			const lines = side.norm.slice(from, to).filter((line) => line.length > 0);
+			if (lines.length === 0) continue;
+			cuts.push({
+				kind,
+				path,
+				lines,
+				needle: `\n${lines.join("\n")}\n`,
+				text: side.raw.slice(from, to).join("\n").trim(),
+				position: position++
+			});
+		}
+	}
+	return cuts;
+}
+/** Paragraph ranges of `lines[start, end)`, split at blank lines. */
+function paragraphs(lines, start, end) {
+	const ranges = [];
+	let from = -1;
+	for (let index = start; index < end; index++) if (lines[index].length === 0) {
+		if (from >= 0) ranges.push([from, index]);
+		from = -1;
+	} else if (from < 0) from = index;
+	if (from >= 0) ranges.push([from, end]);
+	return ranges;
+}
+/** Maximal runs where `a[aStart, aEnd)` became `b[bStart, bEnd)`, from a
+* shortest edit script (Myers, 1986). */
+function changeRuns(a, b) {
+	let prefix = 0;
+	while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) prefix += 1;
+	let suffix = 0;
+	while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix += 1;
+	const innerA = a.slice(prefix, a.length - suffix);
+	const innerB = b.slice(prefix, b.length - suffix);
+	const runs = [];
+	let i = 0;
+	let j = 0;
+	const flush = (toI, toJ) => {
+		if (toI > i || toJ > j) runs.push({
+			aStart: prefix + i,
+			aEnd: prefix + toI,
+			bStart: prefix + j,
+			bEnd: prefix + toJ
+		});
+	};
+	for (const [mi, mj] of matches(innerA, innerB)) {
+		flush(mi, mj);
+		i = mi + 1;
+		j = mj + 1;
+	}
+	flush(innerA.length, innerB.length);
+	return runs;
+}
+/** Matched index pairs of a shortest edit script, in increasing order. */
+function matches(a, b) {
+	const n = a.length;
+	const m = b.length;
+	if (n === 0 || m === 0) return [];
+	const offset = n + m;
+	const v = new Int32Array(2 * offset + 2);
+	const trace = [];
+	let done = false;
+	for (let d = 0; d <= n + m && !done; d++) {
+		trace.push(v.slice());
+		for (let k = -d; k <= d; k += 2) {
+			let x = k === -d || k !== d && v[k - 1 + offset] < v[k + 1 + offset] ? v[k + 1 + offset] : v[k - 1 + offset] + 1;
+			let y = x - k;
+			while (x < n && y < m && a[x] === b[y]) {
+				x += 1;
+				y += 1;
+			}
+			v[k + offset] = x;
+			if (x >= n && y >= m) {
+				done = true;
+				break;
+			}
+		}
+	}
+	const pairs = [];
+	let x = n;
+	let y = m;
+	for (let d = trace.length - 1; d >= 0; d--) {
+		const before = trace[d];
+		const k = x - y;
+		const prevK = k === -d || k !== d && before[k - 1 + offset] < before[k + 1 + offset] ? k + 1 : k - 1;
+		const prevX = before[prevK + offset];
+		const prevY = prevX - prevK;
+		while (x > prevX && y > prevY) {
+			x -= 1;
+			y -= 1;
+			pairs.push([x, y]);
+		}
+		if (d > 0) {
+			x = prevX;
+			y = prevY;
+		}
+	}
+	return pairs.reverse();
+}
+/** Parents of an edge that precede its child in this search: the edge's
+* lineage. A re-proposal from the child itself or a later node adds none. */
+function lineageParents(state, edge, child, byId) {
+	const parents = [];
+	for (const parent of edge.parents) {
+		if (parent.searchId !== state.searchId) continue;
+		const node = byId.get(parent.nodeId);
+		if (node && node.ordinal < child.ordinal && !parents.includes(node.nodeId)) parents.push(node.nodeId);
+	}
+	return parents;
+}
+function lineageRows(state, nodes, byId, contents, carried) {
+	const rows = [];
+	const placed = /* @__PURE__ */ new Set();
+	const visit = (root) => {
+		const stack = [root];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (placed.has(node.nodeId)) continue;
+			placed.add(node.nodeId);
+			const firstEdge = node.edgeIds[0] ? state.edge(node.edgeIds[0]) : void 0;
+			rows.push({
+				nodeId: node.nodeId,
+				ordinal: node.ordinal,
+				depth: node.depth,
+				primaryParentId: node.primaryParentId,
+				parents: node.parents.filter((parent) => parent.searchId === state.searchId).map((parent) => parent.nodeId),
+				operator: firstEdge?.operator ?? null,
+				status: node.status,
+				carries: [...carried.get(node.nodeId) ?? []].sort(compareCodeUnits),
+				contentKnown: contents.get(node.nodeId).known
+			});
+			const children = node.children.map((id) => byId.get(id)).filter((child) => child.primaryParentId === node.nodeId).sort((a, b) => b.ordinal - a.ordinal);
+			stack.push(...children);
+		}
+	};
+	for (const node of nodes) if (node.primaryParentId === null) visit(node);
+	for (const node of nodes) visit(node);
+	return rows;
+}
+/**
+* The paired contrast of per-unit carrier means against per-unit lacking
+* means, staged and oriented exactly as `estimateNodeFromCells` stages and
+* orients a node against another, with the verdict `pairedDeltaTest` itself
+* would reach in each direction: below 20 units the exact one-sided sign test
+* at α = 0.025 and a point estimate on the same side, from 20 the bootstrap
+* interval clear of zero.
+*/
+function pairedEstimate(input) {
+	const pairs = input.carrier.length;
+	const method = methodFor(pairs);
+	const base = {
+		against: input.against,
+		split: input.split,
+		units: input.units,
+		pairs,
+		method,
+		cellSetDigest: input.cellSetDigest,
+		estimator: EDIT_CREDIT_ESTIMATOR
+	};
+	if (method === "none") return {
+		credit: {
+			...base,
+			delta: null,
+			interval: null,
+			exactSignP: null,
+			indeterminate: false
+		},
+		verdict: "insufficient"
+	};
+	const maximize = input.direction === "maximize";
+	const before = maximize ? input.lacking : input.carrier;
+	const after = maximize ? input.carrier : input.lacking;
+	const options = {
+		statistic: DECISION_PAIRED_DELTA_STATISTIC,
+		confidence: CONFIDENCE,
+		resamples: RESAMPLES,
+		seed: seedFromDigest(input.cellSetDigest)
+	};
+	const better = pairedDeltaTest(before, after, options);
+	const worse = pairedDeltaTest(after, before, options);
+	const { mean, low, high } = better.bootstrap;
+	const indeterminate = better.indeterminate;
+	const spread = (method === "descriptive" || method === "bootstrap") && !indeterminate;
+	return {
+		credit: {
+			...base,
+			delta: plain(maximize ? mean : -mean),
+			interval: spread ? maximize ? [plain(low), plain(high)] : [plain(-high), plain(-low)] : null,
+			exactSignP: method === "descriptive" && !indeterminate ? better.pValue : null,
+			indeterminate
+		},
+		verdict: method === "insufficient" ? "insufficient" : better.significant ? "reusable" : worse.significant ? "harmful" : "unresolved"
+	};
+}
+/** The chance, with no true effect, that the verdict on `pairs` units is
+* reusable: the exact sign test's attained size (the upper tail at the
+* smallest positive count that clears α) below the bootstrap gate, the
+* percentile bootstrap's nominal one-sided α from it. */
+const chanceReusable = (() => {
+	const alpha = (1 - CONFIDENCE) / 2;
+	const cache = /* @__PURE__ */ new Map();
+	return (pairs) => {
+		if (pairs < DESCRIPTIVE_FROM) return 0;
+		if (pairs >= 20) return alpha;
+		const cached = cache.get(pairs);
+		if (cached !== void 0) return cached;
+		let size = 0;
+		for (let positive = 0; positive <= pairs; positive++) {
+			const p = pairedSignTest(Array.from({ length: pairs }, (_, index) => index < positive ? 1 : -1), "greater").pValue;
+			if (p <= alpha) {
+				size = p;
+				break;
+			}
+		}
+		cache.set(pairs, size);
+		return size;
+	};
+})();
+function methodFor(units) {
+	if (units < 2) return "none";
+	if (units < DESCRIPTIVE_FROM) return "insufficient";
+	if (units < 20) return "descriptive";
+	return "bootstrap";
+}
+/** The worse end of the interval, as an improvement; -Infinity without one. */
+function improvementLow(credit, sign) {
+	if (credit.interval === null) return Number.NEGATIVE_INFINITY;
+	return sign > 0 ? credit.interval[0] : -credit.interval[1];
+}
+function gain(credit, sign) {
+	return credit.delta === null ? Number.NEGATIVE_INFINITY : sign * credit.delta;
+}
+function interactionPairs(input) {
+	const seenGroups = /* @__PURE__ */ new Set();
+	const considered = [...input.genes].filter((gene) => {
+		const group = gene.linkage ?? gene.geneId;
+		if (seenGroups.has(group)) return false;
+		seenGroups.add(group);
+		return gene.credit.pairs >= DESCRIPTIVE_FROM;
+	}).sort((a, b) => b.credit.pairs - a.credit.pairs || compareCodeUnits(a.geneId, b.geneId)).slice(0, input.limit);
+	/** Per unit, the mean clean-step contrast of `geneId` over `steps`. */
+	const contrasts = (steps) => {
+		const sums = /* @__PURE__ */ new Map();
+		for (const { carrierId, lackingId } of steps) {
+			const lacking = input.unitMeansOf(lackingId);
+			for (const [unitId, carrierMean] of input.unitMeansOf(carrierId)) {
+				const lackingMean = lacking.get(unitId);
+				if (lackingMean === void 0) continue;
+				const entry = sums.get(unitId) ?? {
+					sum: 0,
+					count: 0
+				};
+				entry.sum += carrierMean - lackingMean;
+				entry.count += 1;
+				sums.set(unitId, entry);
+			}
+		}
+		return new Map([...sums].map(([unitId, entry]) => [unitId, entry.sum / entry.count]));
+	};
+	/** `geneId`'s clean steps split by whether both ends carry `other`. */
+	const split = (geneId, other) => {
+		const carriers = input.carriersOf.get(other);
+		const steps = input.cleanOf.get(geneId) ?? [];
+		return {
+			withOther: steps.filter(({ step }) => carriers.has(step.parentId) && carriers.has(step.childId)),
+			withoutOther: steps.filter(({ step }) => !carriers.has(step.parentId) && !carriers.has(step.childId))
+		};
+	};
+	const pairs = [];
+	for (let i = 0; i < considered.length; i++) for (let j = i + 1; j < considered.length; j++) {
+		const first = considered[i];
+		const second = considered[j];
+		if (first.edit.includes(second.geneId) || second.edit.includes(first.geneId)) continue;
+		const firstSplit = split(first.geneId, second.geneId);
+		const secondSplit = split(second.geneId, first.geneId);
+		const steps = {
+			firstWithSecond: firstSplit.withOther.length,
+			firstWithoutSecond: firstSplit.withoutOther.length,
+			secondWithFirst: secondSplit.withOther.length,
+			secondWithoutFirst: secondSplit.withoutOther.length
+		};
+		const directions = [firstSplit, secondSplit].filter((direction) => direction.withOther.length > 0 && direction.withoutOther.length > 0);
+		if (directions.length === 0) continue;
+		const perUnit = /* @__PURE__ */ new Map();
+		for (const direction of directions) {
+			const withMeans = contrasts(direction.withOther);
+			const withoutMeans = contrasts(direction.withoutOther);
+			for (const [unitId, withMean] of withMeans) {
+				const withoutMean = withoutMeans.get(unitId);
+				if (withoutMean === void 0) continue;
+				const entry = perUnit.get(unitId) ?? {
+					sum: 0,
+					count: 0
+				};
+				entry.sum += withMean - withoutMean;
+				entry.count += 1;
+				perUnit.set(unitId, entry);
+			}
+		}
+		const values = [...perUnit.keys()].sort(compareCodeUnits).map((unitId) => perUnit.get(unitId).sum / perUnit.get(unitId).count);
+		pairs.push(interactionEstimate([first.geneId, second.geneId], steps, values, input.sign));
+	}
+	const tested = pairs.filter((pair) => pair.signP !== null);
+	const adjusted = holm(tested.map((pair) => pair.signP), INTERACTION_ALPHA);
+	tested.forEach((pair, index) => {
+		pair.adjustedP = adjusted.adjusted[index];
+		pair.interacting = adjusted.significant[index];
+	});
+	pairs.sort((a, b) => Number(b.interacting) - Number(a.interacting) || (a.adjustedP ?? 2) - (b.adjustedP ?? 2) || b.units - a.units || compareCodeUnits(a.genes.join(), b.genes.join()));
+	return {
+		genesConsidered: considered.length,
+		pairsWithContexts: pairs.length,
+		pairsTested: tested.length,
+		alpha: INTERACTION_ALPHA,
+		correction: "holm",
+		pairs
+	};
+}
+function interactionEstimate(genes, steps, values, sign) {
+	const units = values.length;
+	const method = methodFor(units);
+	const base = {
+		genes,
+		steps,
+		units,
+		method,
+		adjustedP: null,
+		interacting: false
+	};
+	if (method === "none") return {
+		...base,
+		interaction: null,
+		interval: null,
+		indeterminate: false,
+		signP: null,
+		synergy: null
+	};
+	const interaction = plain(values.reduce((sum, value) => sum + value, 0) / units);
+	if (method === "insufficient") return {
+		...base,
+		interaction,
+		interval: null,
+		indeterminate: false,
+		signP: null,
+		synergy: sign * interaction > 0
+	};
+	const test = pairedDeltaTest(values.map(() => 0), values, {
+		statistic: DECISION_PAIRED_DELTA_STATISTIC,
+		confidence: CONFIDENCE,
+		resamples: RESAMPLES,
+		seed: seedFromDigest(hashCanonical({
+			genes,
+			values
+		}))
+	});
+	const indeterminate = test.indeterminate;
+	const greater = pairedSignTest(values, "greater").pValue;
+	const less = pairedSignTest(values, "less").pValue;
+	return {
+		...base,
+		interaction,
+		interval: indeterminate ? null : [plain(test.bootstrap.low), plain(test.bootstrap.high)],
+		indeterminate,
+		signP: indeterminate ? null : Math.min(1, 2 * Math.min(greater, less)),
+		synergy: sign * interaction > 0
+	};
+}
+function skills(genes, records, subject, split) {
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const gene of genes) {
+		if (gene.verdict !== "reusable" || gene.kind !== "insert") continue;
+		appendTo(byGroup, gene.linkage ?? gene.geneId, gene);
+	}
+	const candidates = [];
+	for (const members of byGroup.values()) {
+		members.sort((a, b) => compareOrder(records.get(a.geneId).order, records.get(b.geneId).order));
+		const lead = members[0];
+		const name = `edit-${lead.geneId.slice(5, 17)}`;
+		const content = [
+			"---",
+			`name: ${name}`,
+			`description: ${JSON.stringify(`Instructions a ${subject} search kept: the edit to ${lead.path} whose carriers scored better than the nodes without it on the ${split} split.`)}`,
+			"---",
+			"",
+			members.map((gene) => gene.text).join("\n\n"),
+			""
+		].join("\n");
+		candidates.push({
+			resource: defineInlineResource(name, content),
+			improveOptions: {
+				surface: "skills",
+				skills: { resourceName: name }
+			},
+			genes: members.map((gene) => gene.geneId),
+			path: lead.path,
+			credit: lead.credit
+		});
+	}
+	return candidates;
+}
+/** The lens as compact text: what `agent-eval search show --edit-credit`
+* prints and a proposer can read. */
+function editCreditText(result, options = {}) {
+	const limit = options.limit ?? 10;
+	const { data, signal } = result;
+	const unknown = Object.entries(data.edges.unknown).map(([reason, count]) => `${count} ${reason}`).join(", ");
+	const lines = [
+		`edit credit — ${data.genes.length} genes from ${data.edges.read} of ${data.edges.lineage} lineage edges, ${data.steps.total - data.steps.invalidEnd} measurable steps (${data.split} split, ${data.direction})`,
+		`  genes: reusable ${data.counts.reusable} · harmful ${data.counts.harmful} · unresolved ${data.counts.unresolved} · insufficient ${data.counts.insufficient}`,
+		`  edits: reusable ${data.editCounts.reusable} · harmful ${data.editCounts.harmful} · unresolved ${data.editCounts.unresolved} · insufficient ${data.editCounts.insufficient}`,
+		`  signal ${signal.name} = ${signal.value ?? "null"} (${signal.basis})${signal.top.length > 0 ? `; top: ${signal.top.slice(0, 5).join(", ")}` : ""}`
+	];
+	if (unknown.length > 0) lines.push(`  edges without content: ${unknown}`);
+	if (data.nodes.invalid > 0) lines.push(`  ${data.nodes.invalid} invalid node(s): ${data.steps.invalidEnd} step(s) excluded from every contrast`);
+	lines.push("", "Genes (carrying vs lacking side of each clean lineage step):");
+	if (data.genes.length === 0) lines.push("  none");
+	for (const gene of data.genes.slice(0, limit)) {
+		const reproposed = gene.introduced.length > 1 ? ` · introduced ${gene.introduced.length}×` : "";
+		const dropped = gene.dropped > 0 ? ` · dropped ${gene.dropped}×` : "";
+		const linked = gene.linkage && gene.linkage !== gene.geneId ? ` · linked to ${gene.linkage}` : "";
+		const invalid = gene.invalidCarriers > 0 ? ` · ${gene.invalidCarriers} invalid carrier(s)` : "";
+		lines.push(`  ${gene.geneId} ${gene.verdict} ${gene.kind} ${gene.path} "${excerpt(gene.lines)}"`, `    ${gene.steps.clean} clean of ${gene.steps.flips} step(s) (+${gene.steps.gained}/−${gene.steps.lost}) · ${formatEstimate(gene.credit)}${reproposed}${dropped}${linked}${invalid}`);
+	}
+	if (data.genes.length > limit) lines.push(`  … ${data.genes.length - limit} more`);
+	const { interactions } = data;
+	lines.push("", `Interactions: ${interactions.pairsTested} pair(s) tested of ${interactions.pairsWithContexts} with both contexts, among ${interactions.genesConsidered} genes (Holm, α=${interactions.alpha}):`);
+	const shown = interactions.pairs.filter((pair) => pair.signP !== null).slice(0, limit);
+	if (shown.length === 0) lines.push("  none testable");
+	for (const pair of shown) {
+		const interval = pair.interval ? ` [${pair.interval[0].toFixed(4)}, ${pair.interval[1].toFixed(4)}]` : "";
+		lines.push(`  ${pair.genes[0]} × ${pair.genes[1]}: ${pair.interacting ? "INTERACTING" : "no flag"} ${signed$1(pair.interaction)}${interval} on ${pair.units} units, sign p=${pair.signP.toPrecision(3)}, Holm p=${pair.adjustedP.toPrecision(3)}`);
+	}
+	lines.push("", `Skill candidates (agent-runtime improve surface 'skills'):`);
+	if (data.skillCandidates.length === 0) lines.push("  none");
+	for (const candidate of data.skillCandidates.slice(0, limit)) lines.push(`  ${candidate.resource.name}: ${candidate.genes.length} gene(s) at ${candidate.path} · ${formatEstimate(candidate.credit)}`);
+	return lines.join("\n");
+}
+function excerpt(lines) {
+	const text = lines.join(" ⏎ ");
+	return text.length <= 72 ? text : `${text.slice(0, 71)}…`;
+}
+function signed$1(value) {
+	if (value === null) return "null";
+	return `${value >= 0 ? "+" : ""}${value.toFixed(4)}`;
+}
+function formatEstimate(estimate) {
+	const units = `${estimate.pairs} unit${estimate.pairs === 1 ? "" : "s"}`;
+	if (estimate.method === "none") return `unknown (${units})`;
+	if (estimate.indeterminate) return `no measurable difference (indeterminate, ${units})`;
+	const delta = `Δ=${signed$1(estimate.delta)}`;
+	if (estimate.method === "insufficient") return `${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`;
+	const interval = estimate.interval ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]` : "";
+	if (estimate.method === "descriptive") return `${delta}${interval} descriptive, sign p=${estimate.exactSignP === null ? "null" : estimate.exactSignP.toPrecision(3)} (${units})`;
+	return `${delta}${interval} bootstrap (${units})`;
+}
+function emptyCounts() {
+	return {
+		reusable: 0,
+		harmful: 0,
+		unresolved: 0,
+		insufficient: 0
+	};
+}
+function appendTo(map, key, value) {
+	const list = map.get(key);
+	if (list) list.push(value);
+	else map.set(key, [value]);
+}
+function memo(compute) {
+	const cache = /* @__PURE__ */ new Map();
+	return (key) => {
+		let value = cache.get(key);
+		if (value === void 0) {
+			value = compute(key);
+			cache.set(key, value);
+		}
+		return value;
+	};
+}
+function compareOrder(left, right) {
+	return left[0] - right[0] || left[1] - right[1];
+}
+/** Canonical JSON has one zero; never hand it a negative one. */
+function plain(value) {
+	return value === 0 ? 0 : value;
+}
+//#endregion
+//#region src/search/lenses/front.ts
+function front(state, options = {}) {
+	const split = options.split ?? rankingSplit(state);
+	const direction = state.header?.objective.direction ?? "maximize";
+	const extraAxes = options.axes ?? [];
+	const rows = state.nodes().map((node) => {
+		const units = state.unitScores(node.nodeId, split);
+		const score = units.length > 0 ? units.reduce((sum, u) => sum + u.mean, 0) / units.length : null;
+		return {
+			nodeId: node.nodeId,
+			score,
+			knownCostUsd: node.spend.knownUsd,
+			costKnown: node.spend.unknownCostCells === 0,
+			extra: extraAxes.map((axis) => axis.value(state, node.nodeId))
+		};
+	});
+	const eligible = rows.filter((row) => row.score !== null && row.costKnown && row.extra.every((value) => Number.isFinite(value)));
+	const objectives = [
+		{
+			name: "score",
+			direction,
+			value: (row) => row.score
+		},
+		{
+			name: "knownCostUsd",
+			direction: "minimize",
+			value: (row) => row.knownCostUsd
+		},
+		...extraAxes.map((axis, index) => ({
+			name: axis.name,
+			direction: axis.direction,
+			value: (row) => row.extra[index]
+		}))
+	];
+	const frontierIds = eligible.length > 0 ? new Set(paretoFrontier(eligible, objectives).frontier.map((r) => r.nodeId)) : /* @__PURE__ */ new Set();
+	const outRows = rows.map((row) => ({
+		nodeId: row.nodeId,
+		score: row.score,
+		knownCostUsd: row.knownCostUsd,
+		costKnown: row.costKnown,
+		onFront: frontierIds.has(row.nodeId)
+	}));
+	const signalValue = {};
+	for (const row of outRows) signalValue[row.nodeId] = row.onFront ? 1 : 0;
+	return {
+		data: {
+			split,
+			axes: objectives.map((o) => o.name),
+			rows: outRows,
+			frontierSize: frontierIds.size,
+			excludedCount: rows.length - eligible.length
+		},
+		signal: {
+			name: "front.membership",
+			value: signalValue
+		}
+	};
+}
+/** The method `estimateNode` reports for a paired sample of `pairs` units. */
+function estimateMethodFor(pairs) {
+	if (pairs < 2) return "none";
+	if (pairs < INSUFFICIENT_FROM) return "insufficient";
+	if (pairs < 20) return "descriptive";
+	return "bootstrap";
+}
+/**
+* Nodes whose screen finished, in registration order, root first: the
+* ledger's reading of the kernel's `screened` list. A node counts once it is
+* not decided invalid, has an edge, and every cell it was allocated outside a
+* rung or the claim can no longer run (scored, final, cancelled, or errored
+* with no attempt left). Cells a rung opened later do not un-screen it.
+*/
+function screenedNodes(state, options = {}) {
+	const maxAttempts = options.maxAttempts ?? 3;
+	const screened = [];
+	for (const node of state.nodes()) {
+		if (node.status === "invalid" || node.edgeIds.length === 0) continue;
+		let allocated = 0;
+		let open = false;
+		for (const cell of state.cells({ nodeId: node.nodeId })) {
+			if (cell.stage === "rung" || cell.stage === "claim") continue;
+			allocated += 1;
+			if (!(cell.final || cell.cancelled !== null || cell.outcome === "errored" && cell.attempts >= maxAttempts)) {
+				open = true;
+				break;
+			}
+		}
+		if (allocated > 0 && !open) screened.push(node.nodeId);
+	}
+	return screened;
+}
+/** The head's sequence, or -1 before the first entry. */
+function headSequence(state) {
+	return state.head?.sequence ?? -1;
+}
+/** Rounded for JSON a person reads; 9 decimals keep the bits a renderer
+* needs and drop float noise. */
+function round9(value) {
+	const rounded = Math.round(value * 1e9) / 1e9;
+	return rounded === 0 ? 0 : rounded;
+}
+function median(values) {
+	if (values.length === 0) return null;
+	const sorted = [...values].sort((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+/** At most `cap` items, evenly spaced by position: a deterministic sample
+* that keeps a quadratic step bounded on a large search. */
+function evenSample(items, cap) {
+	if (items.length <= cap) return [...items];
+	return Array.from({ length: cap }, (_, index) => items[Math.floor(index * items.length / cap)]);
+}
+function positiveInteger(owner, name, value) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${owner}: ${name} must be a positive integer, got ${String(value)}`);
+	return value;
+}
+function plural$1(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+//#endregion
+//#region src/math/cholesky.ts
+/**
+* Cholesky factorization and solves for small symmetric positive-definite
+* systems (Golub and Van Loan, Matrix Computations, 4th ed., §4.2), the
+* ridge normal equations the skill-manifold lens solves once per row and
+* column of each alternating least-squares sweep.
+*/
+/** The lower-triangular L with `matrix = L Lᵀ`, or null when the matrix is
+* not numerically positive definite. */
+function cholesky(matrix) {
+	const n = matrix.length;
+	const lower = Array.from({ length: n }, () => new Array(n).fill(0));
+	for (let j = 0; j < n; j++) {
+		let diagonal = matrix[j][j];
+		for (let k = 0; k < j; k++) diagonal -= lower[j][k] ** 2;
+		if (!(diagonal > 0) || !Number.isFinite(diagonal)) return null;
+		const pivot = Math.sqrt(diagonal);
+		lower[j][j] = pivot;
+		for (let i = j + 1; i < n; i++) {
+			let value = matrix[i][j];
+			for (let k = 0; k < j; k++) value -= lower[i][k] * lower[j][k];
+			lower[i][j] = value / pivot;
+		}
+	}
+	return lower;
+}
+/** Solves `L Lᵀ x = b` for x given the Cholesky factor L. */
+function choleskySolve(lower, b) {
+	const n = lower.length;
+	const y = new Array(n).fill(0);
+	for (let i = 0; i < n; i++) {
+		let value = b[i];
+		for (let k = 0; k < i; k++) value -= lower[i][k] * y[k];
+		y[i] = value / lower[i][i];
+	}
+	const x = new Array(n).fill(0);
+	for (let i = n - 1; i >= 0; i--) {
+		let value = y[i];
+		for (let k = i + 1; k < n; k++) value -= lower[k][i] * x[k];
+		x[i] = value / lower[i][i];
+	}
+	return x;
+}
+/** The inverse of a symmetric positive-definite matrix from its factor. */
+function choleskyInverse(lower) {
+	const n = lower.length;
+	const columns = Array.from({ length: n }, (_, j) => choleskySolve(lower, Array.from({ length: n }, (_, i) => i === j ? 1 : 0)));
+	return Array.from({ length: n }, (_, i) => columns.map((column) => column[i]));
+}
+//#endregion
+//#region src/math/symmetric-eigen.ts
+const MAX_SWEEPS = 100;
+/** Eigenvalues and eigenvectors of a symmetric matrix, largest value first. */
+function symmetricEigen(matrix) {
+	const n = matrix.length;
+	const a = matrix.map((row, index) => {
+		if (row.length !== n) throw new RangeError(`symmetricEigen: row ${index} has ${row.length} entries, expected ${n}`);
+		return row.map((value) => {
+			if (!Number.isFinite(value)) throw new RangeError("symmetricEigen: entries must be finite");
+			return value;
+		});
+	});
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const scale = Math.max(1, Math.abs(a[i][j]), Math.abs(a[j][i]));
+		if (Math.abs(a[i][j] - a[j][i]) > 1e-9 * scale) throw new RangeError(`symmetricEigen: the matrix is not symmetric at (${i}, ${j})`);
+	}
+	const v = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => i === j ? 1 : 0));
+	let total = 0;
+	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) total += a[i][j] ** 2;
+	const tolerance = 1e-24 * Math.max(total, Number.MIN_VALUE);
+	for (let sweep = 0; sweep < MAX_SWEEPS; sweep++) {
+		let off = 0;
+		for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) off += a[i][j] ** 2;
+		if (off <= tolerance) break;
+		for (let p = 0; p < n; p++) for (let q = p + 1; q < n; q++) {
+			const apq = a[p][q];
+			if (apq === 0) continue;
+			const theta = (a[q][q] - a[p][p]) / (2 * apq);
+			const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+			const c = 1 / Math.sqrt(t * t + 1);
+			const s = t * c;
+			for (let k = 0; k < n; k++) {
+				const akp = a[k][p];
+				const akq = a[k][q];
+				a[k][p] = c * akp - s * akq;
+				a[k][q] = s * akp + c * akq;
+			}
+			for (let k = 0; k < n; k++) {
+				const apk = a[p][k];
+				const aqk = a[q][k];
+				a[p][k] = c * apk - s * aqk;
+				a[q][k] = s * apk + c * aqk;
+			}
+			for (let k = 0; k < n; k++) {
+				const vkp = v[k][p];
+				const vkq = v[k][q];
+				v[k][p] = c * vkp - s * vkq;
+				v[k][q] = s * vkp + c * vkq;
+			}
+		}
+	}
+	const order = Array.from({ length: n }, (_, index) => index).sort((left, right) => a[right][right] - a[left][left] || left - right);
+	return {
+		values: order.map((index) => a[index][index]),
+		vectors: order.map((index) => orient$1(v.map((row) => row[index])))
+	};
+}
+function orient$1(vector) {
+	let pivot = 0;
+	for (let index = 1; index < vector.length; index++) if (Math.abs(vector[index]) > Math.abs(vector[pivot]) + 1e-12) pivot = index;
+	return (vector[pivot] ?? 0) < 0 ? vector.map((value) => value === 0 ? 0 : -value) : vector;
+}
+//#endregion
+//#region src/search/lenses/plateau.ts
+const PLATEAU_METHOD = `rise of the best improvement over the root across the last \`window\` accepted nodes (screened, no dodged unit, ${INSUFFICIENT_FROM} or more units shared with the root), divided by the best node's standard error sqrt(pooled variance / its shared units); an improvement is the mean per-unit gain over the root on shared units in the objective's direction, and the variance is the between-unit variance of those gains pooled over screened nodes with 2 or more shared units`;
+/**
+* The plateau score of a search. Nodes are taken in the view's screened
+* order, which is registration order. Insufficient with fewer than `window`
+* accepted nodes, or without a pooled variance above zero.
+*/
+function searchPlateau(view, options = {}) {
+	const window = options.window ?? 6;
+	if (!Number.isSafeInteger(window) || window < 1) throw new TypeError(`searchPlateau: window must be a positive integer, got ${String(window)}`);
+	const sign = view.direction === "maximize" ? 1 : -1;
+	const root = new Map(view.unitScores(view.rootNodeId).map((unit) => [unit.unitId, unit.mean]));
+	const accepted = [];
+	let squares = 0;
+	let degreesOfFreedom = 0;
+	for (const nodeId of view.screened) {
+		if (nodeId === view.rootNodeId || !view.complete(nodeId)) continue;
+		const deltas = [];
+		for (const unit of view.unitScores(nodeId)) {
+			const base = root.get(unit.unitId);
+			if (base !== void 0) deltas.push(sign * (unit.mean - base));
+		}
+		if (deltas.length < 2) continue;
+		let total = 0;
+		for (const delta of deltas) total += delta;
+		const mean = total / deltas.length;
+		for (const delta of deltas) squares += (delta - mean) ** 2;
+		degreesOfFreedom += deltas.length - 1;
+		if (deltas.length >= INSUFFICIENT_FROM) accepted.push({
+			nodeId,
+			gain: mean,
+			pairs: deltas.length
+		});
+	}
+	const pooledVariance = degreesOfFreedom > 0 ? squares / degreesOfFreedom : null;
+	const start = Math.max(0, accepted.length - window);
+	let before = null;
+	for (const entry of accepted.slice(0, start)) if (before === null || entry.gain > before.gain) before = entry;
+	let best = before;
+	for (const entry of accepted.slice(start)) if (best === null || entry.gain > best.gain) best = entry;
+	const base = {
+		window,
+		accepted: accepted.length,
+		windowNodes: accepted.slice(start).map((entry) => entry.nodeId),
+		best: best === null ? null : {
+			...best,
+			gain: round9(best.gain)
+		},
+		pooledVariance: pooledVariance === null ? null : round9(pooledVariance),
+		degreesOfFreedom,
+		method: PLATEAU_METHOD
+	};
+	const insufficient = (reason) => ({
+		...base,
+		value: null,
+		rise: null,
+		noise: null,
+		insufficient: reason
+	});
+	if (accepted.length < window) return insufficient(`${accepted.length} of ${window} accepted nodes (screened, no dodged unit, ${INSUFFICIENT_FROM} or more units shared with the root)`);
+	if (pooledVariance === null || pooledVariance === 0) return insufficient(pooledVariance === null ? "no pooled between-unit variance" : "every per-unit gain equals its node’s mean, so the noise is unmeasured");
+	const leader = best;
+	const rise = Math.max(0, leader.gain) - Math.max(0, before?.gain ?? 0);
+	const noise = Math.sqrt(pooledVariance / leader.pairs);
+	return {
+		...base,
+		value: round9(rise / noise),
+		rise: round9(rise),
+		noise: round9(noise),
+		insufficient: null
+	};
+}
+/**
+* `base`, except that on a plateau it drafts: it proposes a fresh artifact
+* (operator `draft`, anchored on the root) instead of refining one. The
+* plateau is the `landscape` lens's signal (`searchPlateau` on this view):
+* how many standard errors the best improvement over the root rose across the
+* last `window` accepted nodes. A draft needs a measured plateau (at least
+* `window` accepted nodes and a pooled variance) and an expansion count that
+* is a multiple of `window`, so `base` expands at least `window − 1` times
+* between drafts and each draft's lineage gets a chance to lift the plateau.
+* Nodes still screening do not hold a draft back: the kernel expands while
+* its screening backlog is below twice the lane capacity, so under a full
+* pipeline some node is always screening, and the plateau reads only nodes
+* whose screen finished. The leader and patience are `base`'s.
+*
+* This is AIDE's draft trigger driven by measured progress instead of a fixed
+* count; `draftOnPlateau(aide(...))` adds it to `aide`'s own drafts. A draft
+* pays off only when `base` then expands drafts that trail the leader:
+* `incumbent` expands only its leader, so a draft that starts below it is
+* never refined.
+*/
+function draftOnPlateau(base, options = {}) {
+	const window = options.window ?? 6;
+	const below = options.below ?? 1;
+	if (!Number.isSafeInteger(window) || window < 1) throw new TypeError(`draftOnPlateau: window must be a positive integer, got ${String(window)}`);
+	if (!(below > 0) || !Number.isFinite(below)) throw new TypeError(`draftOnPlateau: below must be a positive number, got ${String(below)}`);
+	const name = `draft-on-plateau(${base.name},window=${window},below=${below})`;
+	return {
+		name,
+		...base.patience === void 0 ? {} : { patience: base.patience },
+		leader: (view) => base.leader(view),
+		expand(view) {
+			if (view.expansions % window !== 0) return base.expand(view);
+			const plateau = searchPlateau(view, { window });
+			if (plateau.value === null || plateau.value >= below) return base.expand(view);
+			return {
+				parents: [view.rootNodeId],
+				operator: "draft",
+				selection: {
+					rule: name,
+					evidence: {
+						plateau: plateau.value,
+						rise: plateau.rise,
+						noise: plateau.noise,
+						window,
+						accepted: plateau.accepted,
+						expansions: view.expansions
+					}
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/search/lenses/landscape.ts
+/**
+* The landscape lens: where each node sits in edit space, and how the score
+* varies over it.
+*
+* Nodes are placed in two dimensions by landmark classical multidimensional
+* scaling (de Silva and Tenenbaum, 2004) of a pluggable distance between
+* their profiles. The default distance counts the edits the ledger recorded
+* between two profiles along their lineage; a caller that can read the
+* surface blobs passes `surfaceTextEdits`, and a caller with a model
+* embedding passes `vectorEmbedding`. Every node's score is its improvement
+* over the root on the units both scored, in the objective's direction, with
+* the standard error its shared units give it. Kriging (Gaussian-process
+* regression with each node's own noise) interpolates the scores over a grid
+* and leaves a cell unknown where the nodes do not constrain it. Basins are
+* the peaks of the node scores on the nearest-neighbour graph that stand
+* above their saddle by more than the noise, Bonferroni-bounded over the
+* graph's local maxima (0-dimensional persistence of the superlevel sets,
+* ToMATo).
+*
+* The signal is `plateau`: how far the best improvement over the root rose
+* across the last `window` screened nodes, in units of that node's standard
+* error. Below 1 the search is on a plateau; a policy that drafts afresh when
+* it is (`draftOnPlateau`) reads the same function on its own view.
+*/
+/** The default: edits recorded between two profiles along the lineage. */
+function lineageEdits() {
+	return {
+		kind: "lineage",
+		name: "lineage-edits",
+		method: "edits between the two profiles along the recorded lineage: the fewest improve, debug or merge edges joining them (a re-proposal edge counts; a draft is written afresh, so its edge is no edit of its anchor)"
+	};
+}
+/** Surfaces whose content digests differ: the edit distance between two
+* profiles at the granularity of their declared surfaces. */
+function surfaceDigestEdits() {
+	return {
+		kind: "distance",
+		name: "surface-digest-edits",
+		method: "declared surfaces whose content digests differ (a surface only one node has counts)",
+		distance(a, b) {
+			const left = new Map(a.surfaces.map((surface) => [surface.surfaceId, surface.artifact.sha256]));
+			let count = 0;
+			const seen = /* @__PURE__ */ new Set();
+			for (const surface of b.surfaces) {
+				seen.add(surface.surfaceId);
+				if (left.get(surface.surfaceId) !== surface.artifact.sha256) count += 1;
+			}
+			for (const surfaceId of left.keys()) if (!seen.has(surfaceId)) count += 1;
+			return count;
+		}
+	};
+}
+/**
+* Line edits between the surfaces' texts: for each declared surface, the
+* fewest line insertions and deletions that turn one text into the other
+* (Myers, 1986), summed over surfaces. `read` returns a surface's content:
+* a string, parsed JSON (flattened with `profileTextLines`), or null when it
+* cannot be read, which leaves every distance of that node unknown. The lens
+* stays pure; the caller owns the I/O and its verification.
+*/
+function surfaceTextEdits(read) {
+	const lines = /* @__PURE__ */ new Map();
+	const linesOf = (surface) => {
+		const key = surface.artifact.sha256;
+		if (!lines.has(key)) {
+			const content = read(surface);
+			lines.set(key, content === null || content === void 0 ? null : typeof content === "string" ? content.split("\n") : profileTextLines(content));
+		}
+		return lines.get(key);
+	};
+	return {
+		kind: "distance",
+		name: "surface-text-edits",
+		method: "line insertions plus deletions between the surface texts (Myers diff), summed over declared surfaces; JSON is flattened to one line per leaf and per line of a string",
+		distance(a, b) {
+			const right = new Map(b.surfaces.map((surface) => [surface.surfaceId, surface]));
+			let total = 0;
+			const seen = /* @__PURE__ */ new Set();
+			for (const surface of a.surfaces) {
+				seen.add(surface.surfaceId);
+				const own = linesOf(surface);
+				if (own === null) return null;
+				const other = right.get(surface.surfaceId);
+				if (!other) {
+					total += own.length;
+					continue;
+				}
+				if (other.artifact.sha256 === surface.artifact.sha256) continue;
+				const theirs = linesOf(other);
+				if (theirs === null) return null;
+				total += lineEditDistance(own, theirs);
+			}
+			for (const surface of b.surfaces) {
+				if (seen.has(surface.surfaceId)) continue;
+				const theirs = linesOf(surface);
+				if (theirs === null) return null;
+				total += theirs.length;
+			}
+			return total;
+		}
+	};
+}
+/** A caller's vector per node, for example a model embedding of its profile. */
+function vectorEmbedding(name, vector) {
+	return {
+		kind: "vector",
+		name,
+		method: `Euclidean distance between ${name} vectors`,
+		vector
+	};
+}
+/**
+* JSON as lines a diff can count: one line per scalar leaf, `path=value`, and
+* one line per line of a string, so an edit inside a long prompt counts the
+* lines it changed rather than the whole prompt. Object keys are visited in
+* code-unit order.
+*/
+function profileTextLines(value, path = "$") {
+	if (typeof value === "string") {
+		const parts = value.split("\n");
+		return parts.length === 1 ? [`${path}=${canonicalString(value)}`] : parts.map((line, index) => `${path}[${index}]=${canonicalString(line)}`);
+	}
+	if (Array.isArray(value)) {
+		if (value.length === 0) return [`${path}=[]`];
+		return value.flatMap((entry, index) => profileTextLines(entry, `${path}[${index}]`));
+	}
+	if (value !== null && typeof value === "object") {
+		const keys = Object.keys(value).sort(compareCodeUnits);
+		if (keys.length === 0) return [`${path}={}`];
+		return keys.flatMap((key) => profileTextLines(value[key], `${path}.${key}`));
+	}
+	return [`${path}=${canonicalString(value ?? null)}`];
+}
+/** Fewest line insertions plus deletions turning `a` into `b` (Myers' O(ND)
+* greedy algorithm, which is fast when the texts are close). */
+function lineEditDistance(a, b) {
+	const n = a.length;
+	const m = b.length;
+	const max = n + m;
+	if (max === 0) return 0;
+	const offset = max;
+	const v = new Int32Array(2 * max + 2);
+	for (let d = 0; d <= max; d++) for (let k = -d; k <= d; k += 2) {
+		let x = k === -d || k !== d && v[offset + k - 1] < v[offset + k + 1] ? v[offset + k + 1] : v[offset + k - 1] + 1;
+		let y = x - k;
+		while (x < n && y < m && a[x] === b[y]) {
+			x += 1;
+			y += 1;
+		}
+		v[offset + k] = x;
+		if (x >= n && y >= m) return d;
+	}
+	return max;
+}
+const GRID_METHOD = "Gaussian-process regression (ordinary kriging) of node scores: a constant mean (generalized least squares), a squared-exponential covariance whose prior variance is the between-node variance of the scores minus their mean noise and whose length scale maximizes the marginal likelihood over 0.5, 1, 2 and 4 times the median nearest-neighbour distance, and each node's own noise variance (the pooled between-unit variance over its units shared with the root; the root is the reference at exactly 0); nodes with fewer than 2 shared units are left out; a cell is null where the posterior variance exceeds half the prior variance, so the surface never extends past the nodes that support it; no surface is drawn unless the length scale raises the log-likelihood by 1 or more over independent node scores";
+/** Scored nodes a surface or a basin count needs: the library's minimum
+* sample for anything descriptive, as for units. */
+const SURFACE_MIN_NODES = INSUFFICIENT_FROM;
+const BASIN_METHOD = "0-dimensional persistence of node scores on the symmetric k-nearest-neighbour graph of placed nodes, read on the leading MDS axes that hold 80% of the positive eigenvalue mass (2 to 8), joined into one component by the shortest edge between components (ToMATo, Chazal et al. 2013): nodes enter from the highest score down, and where two components meet, the lower peak merges into the higher unless it stands above that saddle node by z standard errors of their difference, sqrt(pooled variance / shared units) per node, where z is the standard-normal quantile at 1 − 0.05 / (local maxima − 1), a Bonferroni bound over every peak that could survive, so a flat landscape of noisy nodes counts one basin at least 95% of the time; at most 2000 nodes, evenly spaced by registration plus the 100 best";
+/** Nodes the basin graph holds: evenly spaced by registration, plus the best. */
+const BASIN_NODES = 2e3;
+const BASIN_TOP = 100;
+/**
+* The landscape of a search: every node placed by `embed`, the interpolated
+* score over the placement, the basins of that surface, and the plateau
+* signal. Pure: it reads the state and calls `embed`.
+*/
+function landscape(state, embed = lineageEdits(), options = {}) {
+	const landmarkCap = positiveInteger("landscape", "landmarks", options.landmarks ?? 32);
+	const columns = positiveInteger("landscape", "grid", options.grid ?? 24);
+	const surfaceNodes = positiveInteger("landscape", "surfaceNodes", options.surfaceNodes ?? 400);
+	const window = options.window ?? 6;
+	const header = state.header;
+	const split = options.split ?? rankingSplit(state);
+	const direction = header?.objective.direction ?? "maximize";
+	const plateauEmpty = (reason) => ({
+		value: null,
+		window,
+		accepted: 0,
+		windowNodes: [],
+		rise: null,
+		noise: null,
+		best: null,
+		pooledVariance: null,
+		degreesOfFreedom: 0,
+		method: PLATEAU_METHOD,
+		insufficient: reason
+	});
+	const rootNodeId = header ? state.rootNodeId : null;
+	if (!header || rootNodeId === null) {
+		const reason = header ? "the search has no root node yet" : "the search has not been opened";
+		return result$1(state, emptyData(split, direction, embed, reason, plateauEmpty(reason)));
+	}
+	const nodes = state.nodes();
+	const index = new Map(nodes.map((node, position) => [node.nodeId, position]));
+	const posterior = searchPosterior(state, { split });
+	const scoreOf = new Map(posterior.nodes.map((entry) => [entry.nodeId, entry]));
+	const placement = placeNodes(nodes, index, rootNodeId, embed, landmarkCap, () => lineageAdjacency(state, index));
+	const records = nodes.map((node, position) => {
+		const entry = scoreOf.get(node.nodeId);
+		const firstEdge = node.edgeIds[0] ? state.edge(node.edgeIds[0]) : void 0;
+		const at = placement.coordinates[position];
+		return {
+			nodeId: node.nodeId,
+			ordinal: node.ordinal,
+			depth: node.depth,
+			status: node.status,
+			operator: firstEdge?.operator ?? null,
+			x: at ? round9(at[0]) : null,
+			y: at ? round9(at[1]) : null,
+			unplaced: at ? null : placement.unplaced.get(position) ?? "not placed",
+			score: entry.mean === null || entry.pairs < 2 && node.nodeId !== rootNodeId ? null : round9(entry.mean),
+			standardError: entry.variance === null ? null : round9(Math.sqrt(entry.variance)),
+			pairs: entry.pairs,
+			method: estimateMethodFor(entry.pairs),
+			basin: null
+		};
+	});
+	const lineage = [];
+	for (const node of nodes) {
+		const operator = node.edgeIds[0] ? state.edge(node.edgeIds[0])?.operator ?? "unknown" : "none";
+		for (const parent of node.parents) {
+			if (parent.searchId !== state.searchId) continue;
+			lineage.push({
+				parent: parent.nodeId,
+				child: node.nodeId,
+				operator
+			});
+		}
+	}
+	const scored = records.filter((record) => record.x !== null && record.score !== null && record.pairs >= 2);
+	const gridResult = krige(records, scored, new Map(posterior.nodes.map((entry) => [entry.nodeId, entry.variance])), columns, surfaceNodes);
+	const fullOf = /* @__PURE__ */ new Map();
+	nodes.forEach((node, position) => {
+		const point = placement.full[position];
+		if (point) fullOf.set(node.nodeId, point);
+	});
+	const basins = graphBasins(records, scored, fullOf, {
+		axes: placement.fullAxes,
+		explained: placement.fullExplained
+	}, posterior.pooledVariance, posterior.degreesOfFreedom);
+	const plateau = searchPlateau(searchPolicyView(state, {
+		screened: screenedNodes(state, { maxAttempts: options.maxAttempts }),
+		screening: 0,
+		expansions: 0,
+		...options.maxAttempts === void 0 ? {} : { maxAttempts: options.maxAttempts }
+	}), { window });
+	return result$1(state, {
+		split,
+		direction,
+		embedding: {
+			name: embed.name,
+			method: embed.method,
+			landmarks: placement.landmarks,
+			landmarkDistance: placement.landmarkDistance,
+			eigenvalues: placement.eigenvalues.map(round9),
+			explained: placement.explained === null ? null : round9(placement.explained),
+			negativeMass: placement.negativeMass === null ? null : round9(placement.negativeMass),
+			placed: records.filter((record) => record.x !== null).length,
+			unplaced: records.filter((record) => record.x === null).length
+		},
+		nodes: records,
+		lineage,
+		grid: gridResult.grid,
+		gridInsufficient: gridResult.insufficient,
+		basins,
+		plateau
+	});
+}
+function result$1(state, data) {
+	const { plateau } = data;
+	const signal = {
+		name: "plateau",
+		value: plateau.value,
+		subject: plateau.best?.nodeId ?? null,
+		method: plateau.method,
+		n: plateau.accepted,
+		insufficient: plateau.insufficient
+	};
+	return {
+		lens: "landscape",
+		searchId: state.searchId,
+		sequence: headSequence(state),
+		data,
+		signal
+	};
+}
+function emptyData(split, direction, embed, reason, plateau) {
+	return {
+		split,
+		direction,
+		embedding: {
+			name: embed.name,
+			method: embed.method,
+			landmarks: 0,
+			landmarkDistance: null,
+			eigenvalues: [],
+			explained: null,
+			negativeMass: null,
+			placed: 0,
+			unplaced: 0
+		},
+		nodes: [],
+		lineage: [],
+		grid: null,
+		gridInsufficient: reason,
+		basins: {
+			count: null,
+			neighbours: 0,
+			localMaxima: 0,
+			z: null,
+			graphNodes: 0,
+			graphAxes: 0,
+			graphExplained: null,
+			method: BASIN_METHOD,
+			insufficient: reason,
+			peaks: []
+		},
+		plateau
+	};
+}
+function placeNodes(nodes, index, rootNodeId, embed, landmarkCap, adjacency) {
+	const n = nodes.length;
+	const distancesFrom = distanceRows(nodes, embed, adjacency);
+	const unplaced = /* @__PURE__ */ new Map();
+	const coordinates = new Array(n).fill(void 0);
+	const first = index.get(rootNodeId) ?? 0;
+	const rows = [];
+	const chosen = [];
+	const nearest = new Array(n).fill(Number.POSITIVE_INFINITY);
+	let pick = first;
+	while (pick !== null && chosen.length < landmarkCap) {
+		const row = distancesFrom(pick);
+		rows.push(row);
+		chosen.push(pick);
+		for (let j = 0; j < n; j++) {
+			const d = row[j];
+			if (unplaced.has(j)) continue;
+			if (d === null || d === void 0 || !Number.isFinite(d) || d < 0) {
+				unplaced.set(j, chosen.length === 1 ? `no ${embed.name} distance to the root` : `no ${embed.name} distance to landmark ${nodes[pick].nodeId}`);
+				continue;
+			}
+			nearest[j] = Math.min(nearest[j], d);
+		}
+		if (unplaced.has(first)) break;
+		let next = null;
+		for (let j = 0; j < n; j++) {
+			if (unplaced.has(j) || chosen.includes(j) || nearest[j] <= 0) continue;
+			if (next === null || nearest[j] > nearest[next]) next = j;
+		}
+		pick = next;
+	}
+	const landmarks = chosen.map((node, position) => ({
+		node,
+		row: rows[position]
+	})).filter(({ node }) => !unplaced.has(node));
+	if (landmarks.length === 0) {
+		for (let j = 0; j < n; j++) if (!unplaced.has(j)) unplaced.set(j, `the root has no ${embed.name} placement`);
+		return {
+			coordinates,
+			full: new Array(n).fill(void 0),
+			fullAxes: 0,
+			fullExplained: null,
+			unplaced,
+			landmarks: 0,
+			landmarkDistance: null,
+			eigenvalues: [],
+			explained: null,
+			negativeMass: null
+		};
+	}
+	const L = landmarks.length;
+	const squared = landmarks.map(({ row: rowA, node: a }) => landmarks.map(({ row: rowB, node: b }) => {
+		const d = ((rowA[b] ?? 0) + (rowB[a] ?? 0)) / 2;
+		return d * d;
+	}));
+	const columnMean = squared[0].map((_, j) => squared.reduce((sum, row) => sum + row[j], 0) / L);
+	const grand = columnMean.reduce((sum, value) => sum + value, 0) / L;
+	const b = squared.map((row, i) => row.map((value, j) => -.5 * (value - columnMean[i] - columnMean[j] + grand)));
+	const between = [];
+	for (let i = 0; i < L; i++) for (let j = i + 1; j < L; j++) between.push(Math.sqrt(squared[i][j]));
+	const { values, vectors } = symmetricEigen(b);
+	const positiveMass = values.filter((value) => value > 1e-12).reduce((sum, value) => sum + value, 0);
+	const negativeMass = values.filter((value) => value < -1e-12).reduce((sum, value) => sum - value, 0);
+	let fullAxes = 2;
+	let held = values.slice(0, 2).reduce((sum, value) => sum + Math.max(value, 0), 0);
+	while (fullAxes < FULL_AXES_MAX && positiveMass > 0 && held / positiveMass < FULL_AXES_MASS && (values[fullAxes] ?? 0) > 1e-12) {
+		held += values[fullAxes];
+		fullAxes += 1;
+	}
+	const allAxes = Array.from({ length: fullAxes }, (_, k) => (values[k] ?? 0) > 1e-12 ? {
+		value: values[k],
+		vector: vectors[k]
+	} : null);
+	const axes = allAxes.slice(0, 2);
+	const full = new Array(n).fill(void 0);
+	for (let j = 0; j < n; j++) {
+		if (unplaced.has(j)) continue;
+		const coordinate = allAxes.map((axis) => {
+			if (axis === null) return 0;
+			let sum = 0;
+			for (let l = 0; l < L; l++) {
+				const d = landmarks[l].row[j];
+				sum += (d * d - columnMean[l]) * axis.vector[l];
+			}
+			return -.5 * sum / Math.sqrt(axis.value);
+		});
+		coordinates[j] = [coordinate[0], coordinate[1]];
+		full[j] = coordinate;
+	}
+	return {
+		coordinates,
+		full,
+		fullAxes,
+		fullExplained: positiveMass > 0 ? Math.min(1, held / positiveMass) : null,
+		unplaced,
+		landmarks: L,
+		landmarkDistance: between.length === 0 ? null : {
+			median: round9(median(between)),
+			max: round9(Math.max(...between))
+		},
+		eigenvalues: values,
+		explained: positiveMass > 0 ? axes.reduce((sum, axis) => sum + (axis?.value ?? 0), 0) / positiveMass : null,
+		negativeMass: positiveMass + negativeMass > 0 ? negativeMass / (positiveMass + negativeMass) : null
+	};
+}
+/**
+* The undirected lineage graph by node index: an edge joins a child to each
+* parent in this search when its operator edits a parent (improve, debug,
+* merge). Every recorded edge counts, re-proposals into an existing node
+* included, since each says the child is one edit from that parent.
+*/
+function lineageAdjacency(state, index) {
+	const neighbours = Array.from({ length: index.size }, () => /* @__PURE__ */ new Set());
+	for (const edge of state.edges()) {
+		if (edge.operator !== "improve" && edge.operator !== "debug" && edge.operator !== "merge") continue;
+		const child = index.get(edge.childNodeId);
+		if (child === void 0) continue;
+		for (const parent of edge.parents) {
+			if (parent.searchId !== state.searchId) continue;
+			const at = index.get(parent.nodeId);
+			if (at === void 0 || at === child) continue;
+			neighbours[child].add(at);
+			neighbours[at].add(child);
+		}
+	}
+	return neighbours.map((set) => [...set].sort((left, right) => left - right));
+}
+/** Distances from one node to every node, by the embedding's kind. */
+function distanceRows(nodes, embed, adjacency) {
+	const n = nodes.length;
+	if (embed.kind === "lineage") {
+		const neighbours = adjacency();
+		return (from) => {
+			const hops = new Array(n).fill(null);
+			hops[from] = 0;
+			const queue = [from];
+			for (let head = 0; head < queue.length; head++) {
+				const at = queue[head];
+				for (const next of neighbours[at]) {
+					if (hops[next] !== null) continue;
+					hops[next] = hops[at] + 1;
+					queue.push(next);
+				}
+			}
+			return hops;
+		};
+	}
+	if (embed.kind === "vector") {
+		const vectors = nodes.map((node) => embed.vector(node));
+		const size = vectors.find((vector) => vector !== null)?.length ?? 0;
+		return (from) => vectors.map((vector) => {
+			const own = vectors[from];
+			if (!own || !vector || own.length !== size || vector.length !== size) return null;
+			let sum = 0;
+			for (let d = 0; d < size; d++) sum += (own[d] - vector[d]) ** 2;
+			return Math.sqrt(sum);
+		});
+	}
+	return (from) => nodes.map((node, j) => j === from ? 0 : embed.distance(nodes[from], node));
+}
+/**
+* The score surface by ordinary kriging. Each scored node is a noisy
+* observation of the surface at its placement, with its own noise variance
+* (the root, the reference, is exact). The prior variance is the scores'
+* between-node variance minus their mean noise; when that is not positive the
+* nodes do not differ beyond noise and there is no surface to draw. The length
+* scale maximizes the marginal likelihood over a few multiples of the median
+* nearest-neighbour distance, never below one grid cell.
+*/
+function krige(records, scored, variances, columns, surfaceNodes) {
+	if (scored.length < SURFACE_MIN_NODES) return {
+		grid: null,
+		insufficient: `${plural$1(scored.length, "placed node")} share 2 or more units with the root; a surface needs ${SURFACE_MIN_NODES}`
+	};
+	const noiseOf = (node) => variances.get(node.nodeId) ?? null;
+	if (scored.some((node) => noiseOf(node) === null)) return {
+		grid: null,
+		insufficient: "no pooled between-unit variance, so the noise of a node’s score is unknown"
+	};
+	let [x0, x1, y0, y1] = [
+		Number.POSITIVE_INFINITY,
+		Number.NEGATIVE_INFINITY,
+		Number.POSITIVE_INFINITY,
+		Number.NEGATIVE_INFINITY
+	];
+	for (const record of records) {
+		if (record.x === null || record.y === null) continue;
+		x0 = Math.min(x0, record.x);
+		x1 = Math.max(x1, record.x);
+		y0 = Math.min(y0, record.y);
+		y1 = Math.max(y1, record.y);
+	}
+	const span = Math.max(x1 - x0, y1 - y0);
+	if (span <= 0) return {
+		grid: null,
+		insufficient: "every placed node sits at one point"
+	};
+	const pad = span * .05;
+	x0 -= pad;
+	x1 += pad;
+	y0 -= pad;
+	y1 += pad;
+	const byScore = [...scored].sort((left, right) => right.score - left.score || left.ordinal - right.ordinal);
+	const keep = new Set(evenSample(scored, surfaceNodes));
+	const rootNode = scored.find((node) => noiseOf(node) === 0);
+	for (const must of [rootNode, byScore[0]]) {
+		if (!must || keep.has(must)) continue;
+		const drop = [...keep].reverse().find((node) => node !== rootNode && node !== byScore[0]);
+		if (drop) keep.delete(drop);
+		keep.add(must);
+	}
+	const fit = scored.filter((node) => keep.has(node));
+	const n = fit.length;
+	const y = fit.map((node) => node.score);
+	const noise = fit.map((node) => noiseOf(node));
+	const meanScore = y.reduce((sum, value) => sum + value, 0) / n;
+	const spread = y.reduce((sum, value) => sum + (value - meanScore) ** 2, 0) / (n - 1);
+	const meanNoise = noise.reduce((sum, value) => sum + value, 0) / n;
+	const priorVariance = spread - meanNoise;
+	if (!(priorVariance > 0)) return {
+		grid: null,
+		insufficient: `the nodes' scores vary no more than their noise (between-node variance ${fixed(spread)}, mean noise variance ${fixed(meanNoise)}), so there is no surface beyond a flat one`
+	};
+	const cell = Math.max(x1 - x0, y1 - y0) / columns;
+	const nearest = evenSample(fit, 2e3).map((a, _, sample) => {
+		let best = Number.POSITIVE_INFINITY;
+		for (const b of sample) {
+			if (a === b) continue;
+			const d = Math.hypot(a.x - b.x, a.y - b.y);
+			if (d > 0 && d < best) best = d;
+		}
+		return best;
+	});
+	const typical = Math.max(median(nearest.filter(Number.isFinite)) ?? cell, cell);
+	const d2 = fit.map((a) => fit.map((b) => (a.x - b.x) ** 2 + (a.y - b.y) ** 2));
+	const jitter = priorVariance * 1e-9;
+	let best = null;
+	for (const multiple of [
+		.5,
+		1,
+		2,
+		4
+	]) {
+		const lengthScale = Math.max(typical * multiple, cell);
+		const lower = cholesky(d2.map((row, i) => row.map((value, j) => priorVariance * Math.exp(-value / (2 * lengthScale * lengthScale)) + (i === j ? noise[i] + jitter : 0))));
+		if (lower === null) continue;
+		const ones = forward(lower, new Array(n).fill(1));
+		const whiteY = forward(lower, y);
+		let numerator = 0;
+		let denominator = 0;
+		for (let i = 0; i < n; i++) {
+			numerator += ones[i] * whiteY[i];
+			denominator += ones[i] * ones[i];
+		}
+		const mean = numerator / denominator;
+		const residual = forward(lower, y.map((value) => value - mean));
+		let quadratic = 0;
+		let logDeterminant = 0;
+		for (let i = 0; i < n; i++) {
+			quadratic += residual[i] ** 2;
+			logDeterminant += 2 * Math.log(lower[i][i]);
+		}
+		const logLikelihood = -.5 * (quadratic + logDeterminant + n * Math.log(2 * Math.PI));
+		if (best === null || logLikelihood > best.logLikelihood) best = {
+			lengthScale,
+			lower,
+			alpha: backward(lower, residual),
+			mean,
+			logLikelihood
+		};
+	}
+	if (best === null) return {
+		grid: null,
+		insufficient: "the kriging covariance is not positive definite"
+	};
+	const independent = independentLogLikelihood(y, noise, priorVariance);
+	if (best.logLikelihood - independent < 1) return {
+		grid: null,
+		insufficient: `node scores do not correlate with distance in this embedding (log-likelihood ${fixed(best.logLikelihood)} with a length scale against ${fixed(independent)} without one), so a surface would only interpolate noise`
+	};
+	const { lengthScale, lower, alpha, mean } = best;
+	const rows = columns;
+	const values = [];
+	const sd = [];
+	let supported = 0;
+	for (let r = 0; r < rows; r++) {
+		const row = [];
+		const sdRow = [];
+		const gy = y0 + (r + .5) * (y1 - y0) / rows;
+		for (let c = 0; c < columns; c++) {
+			const gx = x0 + (c + .5) * (x1 - x0) / columns;
+			const k = fit.map((node) => priorVariance * Math.exp(-((node.x - gx) ** 2 + (node.y - gy) ** 2) / (2 * lengthScale * lengthScale)));
+			let value = mean;
+			for (let i = 0; i < n; i++) value += k[i] * alpha[i];
+			const white = forward(lower, k);
+			let explained = 0;
+			for (const entry of white) explained += entry * entry;
+			const variance = Math.max(0, priorVariance - explained);
+			sdRow.push(round9(Math.sqrt(variance)));
+			if (variance <= priorVariance / 2) {
+				row.push(round9(value));
+				supported += 1;
+			} else row.push(null);
+		}
+		values.push(row);
+		sd.push(sdRow);
+	}
+	return {
+		grid: {
+			columns,
+			rows,
+			x: [round9(x0), round9(x1)],
+			y: [round9(y0), round9(y1)],
+			values,
+			sd,
+			supportedCells: supported,
+			model: {
+				mean: round9(mean),
+				priorVariance: round9(priorVariance),
+				lengthScale: round9(lengthScale),
+				logLikelihood: round9(best.logLikelihood),
+				independentLogLikelihood: round9(independent),
+				fitNodes: n
+			},
+			method: GRID_METHOD
+		},
+		insufficient: null
+	};
+}
+/** Log likelihood of scores drawn independently around a generalized
+* least-squares mean, each with the prior variance plus its own noise. */
+function independentLogLikelihood(y, noise, priorVariance) {
+	let numerator = 0;
+	let denominator = 0;
+	for (let i = 0; i < y.length; i++) {
+		const variance = priorVariance + noise[i];
+		numerator += y[i] / variance;
+		denominator += 1 / variance;
+	}
+	const mean = numerator / denominator;
+	let total = 0;
+	for (let i = 0; i < y.length; i++) {
+		const variance = priorVariance + noise[i];
+		total += -.5 * ((y[i] - mean) ** 2 / variance + Math.log(2 * Math.PI * variance));
+	}
+	return total;
+}
+/** Solves L z = b for lower-triangular L. */
+function forward(lower, b) {
+	const n = lower.length;
+	const z = new Array(n).fill(0);
+	for (let i = 0; i < n; i++) {
+		const row = lower[i];
+		let value = b[i];
+		for (let k = 0; k < i; k++) value -= row[k] * z[k];
+		z[i] = value / row[i];
+	}
+	return z;
+}
+/** Solves Lᵀ x = z for lower-triangular L. */
+function backward(lower, z) {
+	const n = lower.length;
+	const x = new Array(n).fill(0);
+	for (let i = n - 1; i >= 0; i--) {
+		let value = z[i];
+		for (let k = i + 1; k < n; k++) value -= lower[k][i] * x[k];
+		x[i] = value / lower[i][i];
+	}
+	return x;
+}
+function cellOf(grid, x, y) {
+	const c = Math.min(grid.columns - 1, Math.max(0, Math.floor((x - grid.x[0]) / (grid.x[1] - grid.x[0]) * grid.columns)));
+	const r = Math.min(grid.rows - 1, Math.max(0, Math.floor((y - grid.y[0]) / (grid.y[1] - grid.y[0]) * grid.rows)));
+	return grid.values[r][c] === null ? null : r * grid.columns + c;
+}
+/**
+* Basins on the k-nearest-neighbour graph of the scored, placed nodes, by
+* ToMATo's sweep. Nodes enter from the highest score down (earlier
+* registration first on a tie). A node with no entered neighbour starts a
+* component, of which it is the peak; otherwise it joins its highest entered
+* neighbour's component. Where it touches another component, the one with
+* the lower peak merges into the higher unless its peak stands above this
+* node, the saddle, by two standard errors of their difference; a component
+* that survives its first saddle keeps that persistence. Every component left
+* at the end is a basin, labelled by its peak.
+*/
+function graphBasins(records, scoredNodes, fullOf, space, pooledVariance, degreesOfFreedom) {
+	const empty = (reason) => ({
+		count: null,
+		neighbours: 0,
+		localMaxima: 0,
+		z: null,
+		graphNodes: 0,
+		graphAxes: 0,
+		graphExplained: null,
+		method: BASIN_METHOD,
+		insufficient: reason,
+		peaks: []
+	});
+	let scored = scoredNodes;
+	if (scored.length < SURFACE_MIN_NODES) return empty(`${plural$1(scored.length, "placed node")} share 2 or more units with the root; basins need ${SURFACE_MIN_NODES}`);
+	if (pooledVariance === null || pooledVariance <= 0) return empty("no pooled between-unit variance, so the noise a peak must clear is unknown");
+	const sample = new Set(evenSample(scored, BASIN_NODES));
+	for (const node of [...scored].sort((left, right) => right.score - left.score || left.ordinal - right.ordinal).slice(0, BASIN_TOP)) sample.add(node);
+	scored = scoredNodes.filter((node) => sample.has(node));
+	const k = Math.min(BASIN_NEIGHBOURS, scored.length - 1);
+	const points = scored.map((node) => fullOf.get(node.nodeId) ?? [node.x, node.y]);
+	const adjacency = connectComponents(points, nearestNeighbours(points, k));
+	const variance = (index) => pooledVariance / scored[index].pairs;
+	const order = scored.map((_, index) => index).sort((left, right) => scored[right].score - scored[left].score || scored[left].ordinal - scored[right].ordinal);
+	const rank = new Int32Array(scored.length);
+	order.forEach((index, position) => {
+		rank[index] = position;
+	});
+	const parent = new Int32Array(scored.length).fill(-1);
+	const find = (index) => {
+		let root = index;
+		while (parent[root] !== root) root = parent[root];
+		let at = index;
+		while (parent[at] !== root) {
+			const next = parent[at];
+			parent[at] = root;
+			at = next;
+		}
+		return root;
+	};
+	let maxima = 0;
+	for (let index = 0; index < scored.length; index++) if (adjacency[index].every((neighbour) => rank[neighbour] > rank[index])) maxima += 1;
+	const z = zQuantile(1 - BASIN_ALPHA / Math.max(1, maxima - 1));
+	const survived = /* @__PURE__ */ new Map();
+	for (const index of order) {
+		let highest = -1;
+		for (const neighbour of adjacency[index]) {
+			if (parent[neighbour] === -1) continue;
+			if (highest === -1 || rank[neighbour] < rank[highest]) highest = neighbour;
+		}
+		if (highest === -1) {
+			parent[index] = index;
+			continue;
+		}
+		parent[index] = find(highest);
+		for (const neighbour of adjacency[index]) {
+			if (parent[neighbour] === -1) continue;
+			const mine = find(index);
+			const theirs = find(neighbour);
+			if (mine === theirs) continue;
+			const [high, low] = rank[mine] < rank[theirs] ? [mine, theirs] : [theirs, mine];
+			const persistence = scored[low].score - scored[index].score;
+			const threshold = z * Math.sqrt(variance(low) + variance(index));
+			if (persistence < threshold) parent[low] = high;
+			else if (!survived.has(low)) survived.set(low, {
+				saddle: index,
+				persistence,
+				threshold
+			});
+		}
+	}
+	const peaks = [...new Set(order.map(find))].sort((left, right) => rank[left] - rank[right]);
+	const basinOf = new Map(peaks.map((peak, basin) => [peak, basin]));
+	const members = new Array(peaks.length).fill(0);
+	const byNode = /* @__PURE__ */ new Map();
+	scored.forEach((node, index) => {
+		const basin = basinOf.get(find(index));
+		byNode.set(node.nodeId, basin);
+		members[basin] += 1;
+	});
+	for (const record of records) record.basin = byNode.get(record.nodeId) ?? null;
+	return {
+		count: peaks.length,
+		neighbours: k,
+		localMaxima: maxima,
+		z: round9(z),
+		graphNodes: scored.length,
+		graphAxes: space.axes,
+		graphExplained: space.explained === null ? null : round9(space.explained),
+		method: `${BASIN_METHOD}; pooled over ${degreesOfFreedom} degrees of freedom`,
+		insufficient: null,
+		peaks: peaks.map((peak, basin) => {
+			const node = scored[peak];
+			const own = survived.get(peak) ?? null;
+			return {
+				peak: {
+					nodeId: node.nodeId,
+					x: node.x,
+					y: node.y,
+					score: node.score,
+					pairs: node.pairs
+				},
+				persistence: own === null ? null : round9(own.persistence),
+				threshold: own === null ? null : round9(own.threshold),
+				saddle: own === null ? null : scored[own.saddle].nodeId,
+				nodes: members[basin]
+			};
+		})
+	};
+}
+const BASIN_NEIGHBOURS = 6;
+/** The basin graph's space: leading MDS axes up to this share of the positive
+* eigenvalue mass, and at most this many. */
+const FULL_AXES_MASS = .8;
+const FULL_AXES_MAX = 8;
+/** Family-wise rate of a spurious basin on a flat landscape. */
+const BASIN_ALPHA = .05;
+/**
+* Joins a graph's components into one (Borůvka): each round links every
+* component to its nearest point in another component by one edge, until
+* one component remains. Without it, two regions the k-nearest-neighbour
+* graph leaves apart would each count as a basin with no saddle to test.
+*/
+function connectComponents(points, adjacency) {
+	const n = points.length;
+	const parent = Int32Array.from({ length: n }, (_, index) => index);
+	const find = (index) => {
+		let root = index;
+		while (parent[root] !== root) root = parent[root];
+		while (parent[index] !== root) {
+			const next = parent[index];
+			parent[index] = root;
+			index = next;
+		}
+		return root;
+	};
+	for (let a = 0; a < n; a++) for (const b of adjacency[a]) parent[find(a)] = find(b);
+	const edges = adjacency.map((list) => new Set(list));
+	for (;;) {
+		const component = Int32Array.from({ length: n }, (_, index) => find(index));
+		const best = /* @__PURE__ */ new Map();
+		for (let a = 0; a < n; a++) {
+			const own = component[a];
+			for (let b = 0; b < n; b++) {
+				if (component[b] === own) continue;
+				const distance = euclidean(points[a], points[b]);
+				const known = best.get(own);
+				if (!known || distance < known.distance) best.set(own, {
+					a,
+					b,
+					distance
+				});
+			}
+		}
+		if (best.size === 0) break;
+		for (const { a, b } of best.values()) {
+			edges[a].add(b);
+			edges[b].add(a);
+			parent[find(a)] = find(b);
+		}
+	}
+	return edges.map((set) => [...set].sort((left, right) => left - right));
+}
+/**
+* The symmetric k-nearest-neighbour graph of points in any dimension: each
+* point joins its k nearest (ties by index) and every edge is kept in both
+* directions. Brute force, so callers keep n in the low thousands.
+*/
+function nearestNeighbours(points, k) {
+	const n = points.length;
+	const adjacency = Array.from({ length: n }, () => /* @__PURE__ */ new Set());
+	if (n < 2 || k < 1) return adjacency.map(() => []);
+	for (let index = 0; index < n; index++) {
+		const best = [];
+		for (let other = 0; other < n; other++) {
+			if (other === index) continue;
+			const distance = euclidean(points[index], points[other]);
+			if (best.length === k && distance >= best[k - 1].distance) continue;
+			best.push({
+				index: other,
+				distance
+			});
+			best.sort((left, right) => left.distance - right.distance || left.index - right.index);
+			if (best.length > k) best.length = k;
+		}
+		for (const { index: other } of best) {
+			adjacency[index].add(other);
+			adjacency[other].add(index);
+		}
+	}
+	return adjacency.map((set) => [...set].sort((left, right) => left - right));
+}
+function euclidean(left, right) {
+	let sum = 0;
+	for (let d = 0; d < left.length; d++) sum += (left[d] - (right[d] ?? 0)) ** 2;
+	return Math.sqrt(sum);
+}
+const SHADES = " .:-=+*#%@";
+/** The landscape as text for a terminal or a proposer's context: the same
+* numbers the view draws, with a coarse shaded map. */
+function formatLandscape(lens) {
+	const { data } = lens;
+	const lines = [];
+	const { embedding } = data;
+	lines.push(`Landscape (${data.split} split, larger is better; ${embedding.name}: ${embedding.method})`);
+	lines.push(`  placed ${embedding.placed} of ${embedding.placed + embedding.unplaced} nodes by landmark MDS on ${plural$1(embedding.landmarks, "landmark")}${embedding.landmarkDistance ? ` (landmarks lie a median ${fixed(embedding.landmarkDistance.median)} and at most ${fixed(embedding.landmarkDistance.max)} apart)` : ""}; two axes hold ${percent(embedding.explained)} of the positive eigenvalue mass (negative mass ${percent(embedding.negativeMass)})`);
+	const reasons = /* @__PURE__ */ new Map();
+	for (const node of data.nodes) if (node.unplaced) reasons.set(node.unplaced, (reasons.get(node.unplaced) ?? 0) + 1);
+	for (const [reason, count] of reasons) lines.push(`  unplaced ${count}: ${reason}`);
+	const methods = /* @__PURE__ */ new Map();
+	for (const node of data.nodes) methods.set(node.method, (methods.get(node.method) ?? 0) + 1);
+	lines.push(`  scores (improvement over the root on shared units): ${[
+		"bootstrap",
+		"descriptive",
+		"insufficient",
+		"none"
+	].map((method) => `${methods.get(method) ?? 0} ${method}`).join(", ")}`);
+	if (data.grid === null) lines.push(`  surface: insufficient: ${data.gridInsufficient}`);
+	else {
+		const { grid } = data;
+		lines.push(`  surface: ${grid.columns}×${grid.rows} grid kriged from ${plural$1(grid.model.fitNodes, "node")} (mean ${signed(grid.model.mean)}, prior sd ${fixed(Math.sqrt(grid.model.priorVariance))}, length scale ${fixed(grid.model.lengthScale)}); ${grid.supportedCells} of ${grid.columns * grid.rows} cells supported (posterior variance at most half the prior)`);
+	}
+	const { basins } = data;
+	if (basins.count === null) lines.push(`  basins: insufficient: ${basins.insufficient}`);
+	else {
+		lines.push(`  basins: ${basins.count} on the ${basins.neighbours}-nearest-neighbour graph of ${plural$1(basins.graphNodes, "node")} in ${basins.graphAxes} MDS axes holding ${percent(basins.graphExplained)} of the distance structure (a lower peak counts when it stands ${fixed(basins.z)} standard errors of the difference above its saddle, Bonferroni over ${basins.localMaxima} local ${basins.localMaxima === 1 ? "maximum" : "maxima"} at 5%)`);
+		basins.peaks.forEach((basin, index) => {
+			const standing = basin.persistence === null ? index === 0 ? "the highest" : "a separate region of the graph" : `persistence ${fixed(basin.persistence)} ≥ ${fixed(basin.threshold)} over saddle ${basin.saddle}`;
+			lines.push(`    ${index + 1}. ${basin.peak.nodeId} ${signed(basin.peak.score)} on ${basin.peak.pairs} units at (${fixed(basin.peak.x)}, ${fixed(basin.peak.y)}), ${standing}; ${plural$1(basin.nodes, "node")}`);
+		});
+	}
+	const { plateau } = data;
+	if (plateau.value === null) lines.push(`  plateau: insufficient: ${plateau.insufficient}`);
+	else {
+		const verdict = plateau.value < 1 ? "on a plateau" : "still climbing";
+		lines.push(`  plateau: ${fixed(plateau.value)}: the best improvement over the root rose ${signed(plateau.rise)} across the last ${plateau.window} of ${plateau.accepted} accepted nodes, one standard error ${fixed(plateau.noise)} (best ${plateau.best.nodeId} on ${plateau.best.pairs} units, ${plateau.degreesOfFreedom} pooled df): ${verdict}`);
+	}
+	if (data.grid !== null) {
+		const { grid } = data;
+		const present = grid.values.flat().filter((value) => value !== null);
+		const low = Math.min(...present);
+		const high = Math.max(...present);
+		const marks = /* @__PURE__ */ new Map();
+		basins.peaks.forEach((basin, index) => {
+			const cell = cellOf(grid, basin.peak.x, basin.peak.y);
+			if (cell !== null) marks.set(cell, String((index + 1) % 10));
+		});
+		lines.push(`  map (top row is the highest y; shade ${JSON.stringify(SHADES)} runs from ${signed(low)} to ${signed(high)}; digits mark each basin's peak node):`);
+		for (let r = grid.rows - 1; r >= 0; r--) {
+			let row = "";
+			for (let c = 0; c < grid.columns; c++) {
+				const mark = marks.get(r * grid.columns + c);
+				const value = grid.values[r][c];
+				if (mark) row += mark;
+				else if (value === null || value === void 0) row += " ";
+				else {
+					const level = high > low ? (value - low) / (high - low) : .5;
+					row += SHADES[Math.min(9, Math.floor(level * 10))];
+				}
+			}
+			lines.push(`    |${row}|`);
+		}
+	}
+	return lines.join("\n");
+}
+function percent(value) {
+	return value === null ? "unknown" : `${Math.round(value * 1e3) / 10}%`;
+}
+function fixed(value) {
+	return value.toFixed(3);
+}
+function signed(value) {
+	return `${value >= 0 ? "+" : ""}${value.toFixed(3)}`;
+}
+//#endregion
+//#region src/search/lenses/meta-search.ts
+/**
+* `metaSearch(searches)`: a search of searches (search-tree-design §12).
+*
+* Every search is one node. Its genome is the configuration that ran it: the
+* expansion policy and allocator its header declares (their names carry
+* their parameters, such as patience, operator weights and rung sizes), its
+* budget, and the proposer its edges and candidate-generation operations
+* name, with the proposer's model. Its score is the held-out lift its claim
+* measured, per known dollar of the whole search.
+*
+* The held-out lift is `estimateNode` of one node against the root on the
+* sealed test split, from the test cells themselves: the shipped node on
+* `ship`; on `hold`, the first finalist not decided invalid, in the claim's
+* order, which the claim fixed from selection data before any test cell ran.
+* A hold's measured lift counts rather than being dropped: keeping only the
+* searches whose test was significant would inflate a configuration's mean.
+* A search whose claim is open, missing, `test-cannot-resolve`, contradicted
+* by its own ledger (`verifySearchClaim`), held with no finalist tested, or
+* whose lift pairs fewer than 2 test units is unscored with its reason, never
+* 0, and every configuration reports how many of its searches were scored.
+*
+* Dollars are the search's committed spend: every cell and operation, the
+* claim's test cells included. An unknown-cost cell or operation leaves only a
+* floor, so that search's lift per dollar is a bound, not a value, and stays
+* out of every estimate. A search that recorded no spend has none either.
+*
+* Searches arrange into a forest by derivation (`derivedFrom`: a search that
+* started from a node of another) and containment (`containment`: a search
+* that ran inside a cell of another). A search contained in an outer search's
+* cell belongs to that cell's node: the outer node is its configuration, and
+* the outer node's lineage is the configuration's lineage.
+*
+* Configurations group searches with one genome and one objective (subject,
+* metric, direction). A configuration's lift per dollar summarizes its scored
+* searches as independent units with `summarizeSamples` (a percentile
+* bootstrap of the mean); a configuration with one scored search carries that
+* search's own paired interval, whose units are its test units. The signal
+* names the configuration with the largest estimate within one objective.
+*/
+/** The signal's name, as a policy or a view reads it. */
+const META_SEARCH_SIGNAL = "metaSearch.bestPolicyConfiguration";
+const DEFAULT_GLYPH_NODES = 64;
+/** The per-search score `metaSearchScore` computes. An outer search names it
+* as its objective's judge. */
+const META_SEARCH_SCORE_SOURCE = {
+	uri: "npm:@tangle-network/agent-eval#metaSearchScore",
+	revision: hashCanonical({
+		name: "tangle.meta-search-score.2026-09",
+		node: "the claim selection on ship; on hold, the first finalist in claim order not decided invalid",
+		lift: "estimateNode(node, against root, split test), oriented so a gain is positive",
+		unscored: [
+			"open",
+			"no claim",
+			"claim the ledger contradicts (verifySearchClaim mismatch)",
+			"test-cannot-resolve",
+			"hold with no finalist tested",
+			"fewer than 2 shared test units"
+		],
+		dollars: "committed spend of every cell and operation, claim cells included",
+		unknownCost: "a floor only: the lift per dollar is a bound and enters no estimate"
+	})
+};
+/**
+* The genome of a search: the configuration its ledger records. Declared
+* parts come from the header; the proposer comes from what the edges and
+* candidate-generation operations name, because the header declares none.
+*/
+function searchPolicyGenome(state) {
+	const header = state.header;
+	if (!header) throw new Error(`search ${state.searchId} has not been opened`);
+	const { maxUsd, maxCells, maxNodes, maxConcurrency, reservedClaimUsd } = header.budget;
+	const proposers = /* @__PURE__ */ new Map();
+	const operations = /* @__PURE__ */ new Set();
+	for (const edge of state.edges()) {
+		if (!edge.proposer) continue;
+		const { kind, name, source, operationId } = edge.proposer;
+		const proposer = {
+			kind,
+			name,
+			source
+		};
+		proposers.set(hashCanonical(proposer), proposer);
+		if (operationId !== null) operations.add(operationId);
+	}
+	const executions = /* @__PURE__ */ new Map();
+	for (const operationId of operations) {
+		const execution = state.operation(operationId)?.execution;
+		if (!execution) continue;
+		const entry = execution.kind === "model" ? {
+			kind: "model",
+			model: execution.model
+		} : {
+			kind: "deterministic",
+			source: execution.source
+		};
+		executions.set(hashCanonical(entry), entry);
+	}
+	return {
+		expansion: withoutSearchSeed(header.policy.expansion, header.policy.seed),
+		allocation: withoutSearchSeed(header.policy.allocation, header.policy.seed),
+		budget: {
+			maxUsd,
+			maxCells,
+			maxNodes,
+			maxConcurrency,
+			reservedClaimUsd
+		},
+		proposers: proposers.size > 0 ? sortedValues(proposers) : { unknown: "the search recorded no proposal, so its proposer is not in the ledger" },
+		proposerExecution: executions.size > 0 ? sortedValues(executions) : { unknown: "no recorded candidate-generation operation names what ran the proposer" }
+	};
+}
+/**
+* A search's held-out lift per known dollar, from its claim and its test
+* cells. Pure; it reads the test split, so a policy view (which holds no test
+* cells) cannot call it; an outer search reads it from a closed inner search.
+*/
+function metaSearchScore(state) {
+	return scoreSearch(state, state.closed?.claim ? verifySearchClaim(state) : null);
+}
+function scoreSearch(state, verification) {
+	const header = state.header;
+	if (!header) throw new Error(`search ${state.searchId} has not been opened`);
+	const { spend: audit } = state.audit;
+	const spend = {
+		knownUsd: audit.knownUsd,
+		floorUsd: audit.floorUsd,
+		unknownCost: audit.unknownCostCells + audit.unknownCostOperations
+	};
+	const unscored = (reason, detail, decision = null) => ({
+		status: "unscored",
+		decision,
+		reason,
+		detail,
+		spend
+	});
+	const closed = state.closed;
+	if (!closed) return unscored("open", "the search is open; its claim is made when it closes");
+	const claim = closed.claim;
+	if (!claim) return unscored("no-claim", `the search closed (${closed.reason}) without a claim on a test split`);
+	if (verification?.status === "mismatch") return unscored("claim-mismatch", `the claim differs from what its ledger supports: ${verification.differences.join("; ")}`, claim.decision);
+	if (claim.decision === "test-cannot-resolve") return unscored("test-cannot-resolve", claim.reason, claim.decision);
+	const root = state.rootNodeId;
+	const nodeId = claim.decision === "ship" ? claim.selected : claim.finalists.find((finalist) => state.node(finalist.nodeId)?.status !== "invalid")?.nodeId ?? null;
+	if (nodeId === null || nodeId === root) return unscored("no-valid-finalist", claim.finalists.length === 0 ? `hold: no finalist went to test (${claim.reason})` : `hold: every finalist was decided invalid (${claim.finalists.length})`, claim.decision);
+	const estimate = estimateNode(state, nodeId, {
+		against: root,
+		split: "test"
+	});
+	if (estimate.delta === null) return unscored("insufficient", `${nodeId} and the root share ${estimate.pairs} scored test unit${estimate.pairs === 1 ? "" : "s"}; a lift needs 2`, claim.decision);
+	const maximize = header.objective.direction === "maximize";
+	const lift = orient(estimate.delta, maximize);
+	const liftInterval = estimate.interval ? orientInterval(estimate.interval, maximize) : null;
+	return {
+		status: "scored",
+		decision: claim.decision,
+		nodeId,
+		estimate,
+		lift,
+		liftInterval,
+		spend,
+		liftPerUsd: liftPerUsd(lift, liftInterval, spend)
+	};
+}
+/** The lens: every search as a node of a search of searches. */
+function metaSearch(searches, options = {}) {
+	const glyphNodes = options.glyphNodes ?? DEFAULT_GLYPH_NODES;
+	if (!Number.isSafeInteger(glyphNodes) || glyphNodes < 0) throw new TypeError(`metaSearch: glyphNodes must be a non-negative integer, got ${glyphNodes}`);
+	const byId = /* @__PURE__ */ new Map();
+	for (const state of searches) {
+		if (!state.header) throw new Error(`metaSearch: search ${state.searchId} has not been opened`);
+		if (byId.has(state.searchId)) throw new Error(`metaSearch: search ${state.searchId} was given twice`);
+		byId.set(state.searchId, state);
+	}
+	const entries = searches.map((state) => entry(state, byId, glyphNodes));
+	const entryById = new Map(entries.map((item) => [item.searchId, item]));
+	for (const item of entries) if (item.parent?.present) entryById.get(item.parent.searchId).children.push(item.searchId);
+	const roots = entries.filter((item) => !item.parent?.present).map((item) => item.searchId);
+	const assignDepth = (searchId, depth, seen) => {
+		if (seen.has(searchId)) return;
+		seen.add(searchId);
+		const item = entryById.get(searchId);
+		item.depth = depth;
+		for (const child of item.children) assignDepth(child, depth + 1, seen);
+	};
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of roots) assignDepth(root, 0, seen);
+	const configurations = configure(entries, byId);
+	const objectives = [...new Set(entries.map((item) => item.objectiveKey))].sort(compareCodeUnits);
+	const { objective, value } = best(configurations, objectives, options.objective);
+	return {
+		data: {
+			searches: entries,
+			roots,
+			configurations,
+			objectives,
+			signalObjective: objective
+		},
+		signal: {
+			name: META_SEARCH_SIGNAL,
+			value
+		}
+	};
+}
+function entry(state, byId, glyphNodes) {
+	const header = state.header;
+	const genome = searchPolicyGenome(state);
+	const closed = state.closed;
+	let claim = null;
+	const verification = closed?.claim ? verifySearchClaim(state) : null;
+	if (closed?.claim) claim = {
+		decision: closed.claim.decision,
+		selected: closed.claim.selected,
+		verification: verification?.status ?? "unknown",
+		reason: closed.claim.reason
+	};
+	const nodes = state.nodes();
+	const cells = state.cells();
+	return {
+		searchId: state.searchId,
+		subject: header.subject,
+		objective: {
+			metric: header.objective.metric,
+			direction: header.objective.direction
+		},
+		objectiveKey: objectiveKey(header),
+		status: closed ? "closed" : "open",
+		closeReason: closed?.reason ?? null,
+		genome,
+		genomeDigest: hashCanonical(genome),
+		seed: header.policy.seed,
+		rootArtifactDigest: nodes[0]?.artifactDigest ?? null,
+		nodes: nodes.length,
+		cells: {
+			settled: state.audit.cells.settled,
+			test: cells.filter((cell) => cell.split === "test").length
+		},
+		claim,
+		score: scoreSearch(state, verification),
+		parent: parentOf(state, byId),
+		children: [],
+		depth: 0,
+		glyph: {
+			nodes: nodes.slice(0, glyphNodes).map((node) => [
+				node.nodeId,
+				node.primaryParentId,
+				node.status
+			]),
+			omitted: Math.max(0, nodes.length - glyphNodes)
+		}
+	};
+}
+/** `subject · metric (direction)`: the key searches are compared within. */
+function objectiveKey(header) {
+	return `${header.subject} · ${header.objective.metric} (${header.objective.direction})`;
+}
+function parentOf(state, byId) {
+	const header = state.header;
+	if (header.containment) {
+		const { searchId, cellId, attempt } = header.containment;
+		const outer = byId.get(searchId);
+		return {
+			relation: "contained",
+			searchId,
+			cellId,
+			attempt,
+			nodeId: outer?.cell(cellId)?.nodeId ?? null,
+			present: outer !== void 0
+		};
+	}
+	if (header.derivedFrom) {
+		const { searchId, nodeId } = header.derivedFrom;
+		return {
+			relation: "derived",
+			searchId,
+			nodeId,
+			present: byId.has(searchId)
+		};
+	}
+	return null;
+}
+function configure(entries, byId) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of entries) {
+		const key = configurationKey(item.objectiveKey, item.genomeDigest);
+		const group = groups.get(key);
+		if (group) group.push(item);
+		else groups.set(key, [item]);
+	}
+	const genomeOfOuterNode = /* @__PURE__ */ new Map();
+	for (const item of entries) if (item.parent?.relation === "contained" && item.parent.nodeId !== null) genomeOfOuterNode.set(`${item.parent.searchId}\u0000${item.parent.nodeId}`, item.genomeDigest);
+	return [...groups.values()].map((group) => {
+		const first = group[0];
+		const decisions = {
+			ship: 0,
+			hold: 0,
+			"test-cannot-resolve": 0,
+			none: 0
+		};
+		const unscored = {};
+		const values = [];
+		let single = null;
+		let bounded = 0;
+		for (const item of group) {
+			decisions[item.claim?.decision ?? "none"] += 1;
+			const score = item.score;
+			if (score.status === "unscored") {
+				unscored[score.reason] = (unscored[score.reason] ?? 0) + 1;
+				continue;
+			}
+			if (score.liftPerUsd.status === "bound") bounded += 1;
+			if (score.liftPerUsd.status !== "known") continue;
+			values.push(score.liftPerUsd.value);
+			single = {
+				basis: "test-units",
+				n: score.estimate.pairs,
+				value: score.liftPerUsd.value,
+				method: score.estimate.method,
+				interval: score.liftPerUsd.interval,
+				intervalMethod: score.liftPerUsd.interval ? "paired-delta-test-over-usd" : null
+			};
+		}
+		const estimate = values.length === 1 && single ? single : fromSummary(summarizeSamples(values, seedFromDigest(first.genomeDigest)));
+		const outerNodes = /* @__PURE__ */ new Map();
+		for (const item of group) {
+			const parent = item.parent;
+			if (parent?.relation !== "contained" || parent.nodeId === null) continue;
+			const key = `${parent.searchId}\u0000${parent.nodeId}`;
+			if (outerNodes.has(key)) continue;
+			const outer = byId.get(parent.searchId);
+			const parentNodeId = outer.node(parent.nodeId).primaryParentId;
+			outerNodes.set(key, {
+				searchId: parent.searchId,
+				nodeId: parent.nodeId,
+				parentNodeId,
+				parentGenomeDigest: parentNodeId === null ? null : genomeOfOuterNode.get(`${parent.searchId}\u0000${parentNodeId}`) ?? null,
+				againstParent: parentNodeId === null ? null : estimateNode(outer, parent.nodeId, {
+					against: parentNodeId,
+					split: rankingSplit(outer)
+				})
+			});
+		}
+		return {
+			genomeDigest: first.genomeDigest,
+			objectiveKey: first.objectiveKey,
+			genome: first.genome,
+			searches: group.map((item) => item.searchId),
+			decisions,
+			scored: values.length,
+			bounded,
+			unscored,
+			estimate,
+			outerNodes: [...outerNodes.values()]
+		};
+	}).sort((left, right) => rankValue(right.estimate.value) - rankValue(left.estimate.value) || right.scored - left.scored || compareCodeUnits(left.objectiveKey, right.objectiveKey) || compareCodeUnits(left.genomeDigest, right.genomeDigest));
+}
+function best(configurations, objectives, requested) {
+	const empty = (objective, reason) => ({
+		objective,
+		value: {
+			liftPerUsd: null,
+			objectiveKey: objective,
+			genomeDigest: null,
+			genome: null,
+			interval: null,
+			method: null,
+			intervalMethod: null,
+			basis: null,
+			n: 0,
+			searches: 0,
+			scored: 0,
+			outerNode: null,
+			reason
+		}
+	});
+	if (configurations.length === 0) return empty(null, "no search was given");
+	const measured = [...new Set(configurations.filter((item) => item.estimate.value !== null).map((item) => item.objectiveKey))].sort(compareCodeUnits);
+	let objective;
+	if (requested !== void 0) {
+		if (!objectives.includes(requested)) return empty(requested, `no search given has objective ${requested}; the searches have ${objectives.join("; ")}`);
+		objective = requested;
+	} else if (measured.length > 1) return empty(null, `searches with a known lift per dollar span ${measured.length} objectives (${measured.join("; ")}); a lift in one metric does not compare with another, so name one`);
+	else {
+		objective = measured[0] ?? (objectives.length === 1 ? objectives[0] : "");
+		if (objective === "") return empty(null, `no configuration has a known lift per dollar, across ${objectives.length} objectives`);
+	}
+	const within = configurations.filter((item) => item.objectiveKey === objective);
+	const withValue = within.filter((item) => item.estimate.value !== null);
+	const top = withValue[0];
+	if (!top) {
+		const unscored = within.reduce((total, item) => total + Object.values(item.unscored).reduce((sum, count) => sum + (count ?? 0), 0), 0);
+		const bounded = within.reduce((total, item) => total + item.bounded, 0);
+		return empty(objective, `no configuration of ${objective} has a known lift per dollar: ${unscored} unscored search${unscored === 1 ? "" : "es"} and ${bounded} with only a spend floor`);
+	}
+	const { estimate } = top;
+	const runnerUp = withValue[1];
+	const coverage = `${top.scored} of ${top.searches.length} of its searches scored`;
+	return {
+		objective,
+		value: {
+			liftPerUsd: estimate.value,
+			objectiveKey: objective,
+			genomeDigest: top.genomeDigest,
+			genome: top.genome,
+			interval: estimate.interval,
+			method: estimate.method,
+			intervalMethod: estimate.intervalMethod,
+			basis: estimate.basis,
+			n: estimate.n,
+			searches: top.searches.length,
+			scored: top.scored,
+			outerNode: top.outerNodes[0] ? {
+				searchId: top.outerNodes[0].searchId,
+				nodeId: top.outerNodes[0].nodeId
+			} : null,
+			reason: runnerUp === void 0 ? `the only configuration with a known lift per dollar (${estimate.method}, ${estimate.basis} n=${estimate.n}; ${coverage})` : `the largest of ${withValue.length} configurations by estimated lift per dollar (${estimate.method}, ${estimate.basis} n=${estimate.n}; ${coverage}); a point ranking, not a test`
+		}
+	};
+}
+function liftPerUsd(lift, interval, spend) {
+	const committed = spend.knownUsd + spend.floorUsd;
+	if (spend.unknownCost > 0) {
+		if (committed <= 0) return {
+			status: "unknown",
+			reason: `${spend.unknownCost} cost${spend.unknownCost === 1 ? " is" : "s are"} unknown with no proven floor`
+		};
+		return {
+			status: "bound",
+			value: lift / committed,
+			bound: lift >= 0 ? "at-most" : "at-least",
+			reason: `${spend.unknownCost} cost${spend.unknownCost === 1 ? " is" : "s are"} known only as a floor; $${round(committed)} is the least the search spent`
+		};
+	}
+	if (spend.knownUsd <= 0) return {
+		status: "unknown",
+		reason: "the search recorded no spend, so a lift per dollar is undefined"
+	};
+	return {
+		status: "known",
+		value: lift / spend.knownUsd,
+		interval: interval ? [interval[0] / spend.knownUsd, interval[1] / spend.knownUsd] : null
+	};
+}
+function fromSummary(summary) {
+	return {
+		basis: "searches",
+		n: summary.n,
+		value: summary.mean,
+		method: summary.n < 2 ? "none" : summary.method,
+		interval: summary.interval,
+		intervalMethod: summary.interval ? "percentile-bootstrap-of-mean" : null
+	};
+}
+/**
+* The lens as text, for an agent: the signal, every configuration best first
+* with its coverage and interval, and the forest of searches with contained
+* searches grouped under the outer node that ran them. `agent-eval search show
+* --meta` prints it.
+*/
+function renderMetaSearchText(result, options = {}) {
+	const perGroup = options.searchesPerGroup ?? 5;
+	const { data, signal } = result;
+	const lines = [];
+	const contained = data.searches.filter((item) => item.parent?.relation === "contained").length;
+	const derived = data.searches.filter((item) => item.parent?.relation === "derived").length;
+	lines.push(`meta-search: ${plural(data.searches.length, "search", "searches")} (${contained} contained, ${derived} derived) in ${plural(data.objectives.length, "objective")}, ${plural(data.configurations.length, "configuration")}`);
+	const value = signal.value;
+	lines.push(value.liftPerUsd === null ? `${signal.name}: unknown — ${value.reason}` : `${signal.name}: ${value.genomeDigest.slice(0, 19)} lift per known $ ${formatNumber(value.liftPerUsd)} ${formatInterval(value.interval, value.intervalMethod)} (${value.method}, ${value.basis} n=${value.n}); ${value.reason}`);
+	const index = new Map(data.configurations.map((item, position) => [configurationKey(item.objectiveKey, item.genomeDigest), position]));
+	for (const objective of data.objectives) {
+		lines.push("", `configurations of ${objective}, best first:`);
+		for (const configuration of data.configurations) {
+			if (configuration.objectiveKey !== objective) continue;
+			lines.push(...configurationLines(configuration, index));
+		}
+	}
+	lines.push("", "searches, by derivation and containment:");
+	const byId = new Map(data.searches.map((item) => [item.searchId, item]));
+	const walk = (searchId, depth) => {
+		const item = byId.get(searchId);
+		const pad = "  ".repeat(depth + 1);
+		lines.push(`${pad}${searchLine(item, index)}`);
+		const derivedChildren = item.children.filter((child) => byId.get(child).parent?.relation === "derived");
+		for (const child of derivedChildren) walk(child, depth + 1);
+		const groups = /* @__PURE__ */ new Map();
+		for (const child of item.children) {
+			const childItem = byId.get(child);
+			if (childItem.parent?.relation !== "contained") continue;
+			const key = childItem.parent.nodeId ?? "(unknown node)";
+			const group = groups.get(key);
+			if (group) group.push(childItem);
+			else groups.set(key, [childItem]);
+		}
+		for (const [nodeId, group] of groups) {
+			const shown = group.slice(0, perGroup);
+			const tally = decisionTally(group);
+			lines.push(`${pad}  node ${nodeId}: ${plural(group.length, "contained search", "contained searches")} (${tally})`);
+			for (const child of shown) walk(child.searchId, depth + 2);
+			if (group.length > shown.length) lines.push(`${"  ".repeat(depth + 3)}… ${group.length - shown.length} more`);
+		}
+	};
+	for (const root of data.roots) walk(root, 0);
+	return lines.join("\n");
+}
+function configurationLines(configuration, index) {
+	const { estimate, genome } = configuration;
+	const decisions = Object.entries(configuration.decisions).filter(([, count]) => count > 0).map(([decision, count]) => `${decision} ${count}`).join(", ");
+	const unscored = Object.entries(configuration.unscored).map(([reason, count]) => `${reason} ${count}`).join(", ");
+	const value = estimate.value === null ? "lift per known $: unknown" : `lift per known $ ${formatNumber(estimate.value)} ${formatInterval(estimate.interval, estimate.intervalMethod)} (${estimate.method}, ${estimate.basis} n=${estimate.n})`;
+	const lines = [`  #${index.get(configurationKey(configuration.objectiveKey, configuration.genomeDigest)) + 1} ${configuration.genomeDigest.slice(0, 19)} ${genomeLine(genome)}`, `     ${plural(configuration.searches.length, "search", "searches")}: ${decisions}; scored ${configuration.scored}${configuration.bounded > 0 ? `, spend floor only ${configuration.bounded}` : ""}${unscored ? `, unscored: ${unscored}` : ""}; ${value}`];
+	for (const outer of configuration.outerNodes) {
+		const against = outer.againstParent;
+		const parentIndex = outer.parentGenomeDigest === null ? void 0 : index.get(configurationKey(configuration.objectiveKey, outer.parentGenomeDigest));
+		lines.push(against === null ? `     outer node ${outer.nodeId} in ${outer.searchId}: the outer root` : `     outer node ${outer.nodeId} in ${outer.searchId}, from ${parentIndex === void 0 ? outer.parentNodeId : `#${parentIndex + 1}`}: ${estimateText(against)}`);
+	}
+	return lines;
+}
+function searchLine(item, index) {
+	const claim = item.claim ? `claim ${item.claim.decision} (${item.claim.verification})` : "no claim";
+	const configuration = index.get(configurationKey(item.objectiveKey, item.genomeDigest));
+	const score = item.score;
+	const scoreText = score.status === "unscored" ? `unscored: ${score.reason} — ${score.detail}` : `lift ${formatNumber(score.lift)} ${formatInterval(score.liftInterval, score.liftInterval ? "paired-delta-test" : null)} on ${score.estimate.pairs} test units (${score.estimate.method}); ${liftPerUsdText(score.liftPerUsd)}`;
+	const relation = item.parent === null ? "" : item.parent.relation === "derived" ? ` derived from ${item.parent.searchId}/${item.parent.nodeId}${item.parent.present ? "" : " (not given)"};` : item.parent.present ? "" : ` contained in ${item.parent.searchId} cell ${item.parent.cellId} (not given);`;
+	return `${item.searchId} [${item.status}${item.closeReason ? `: ${item.closeReason}` : ""}; ${claim}; config #${configuration === void 0 ? "?" : configuration + 1}; ${item.nodes} nodes, ${item.cells.settled} cells, $${round(item.score.spend.knownUsd)} known${item.score.spend.unknownCost > 0 ? ` + $${round(item.score.spend.floorUsd)} floor over ${item.score.spend.unknownCost} unknown` : ""}]${relation} ${scoreText}`;
+}
+function genomeLine(genome) {
+	const budget = Object.entries(genome.budget).filter(([, value]) => value !== null && value !== 0).map(([key, value]) => `${key}=${value}`).join(" ");
+	const proposers = Array.isArray(genome.proposers) ? genome.proposers.map((proposer) => `${proposer.kind}:${proposer.name}`).join(", ") : "unknown";
+	const execution = Array.isArray(genome.proposerExecution) ? genome.proposerExecution.map((item) => item.kind === "model" ? `model ${item.model.provider}/${"snapshot" in item.model ? item.model.snapshot : `${item.model.alias} (snapshot unknown)`}` : "deterministic").join(", ") : "unknown";
+	return `expansion=${genome.expansion} allocation=${genome.allocation}${budget ? ` ${budget}` : ""} proposer=${proposers} (${execution})`;
+}
+function decisionTally(group) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const item of group) {
+		const key = item.score.status === "scored" ? `${item.score.decision} scored` : `${item.claim?.decision ?? "no claim"} unscored`;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	return [...counts.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([key, count]) => `${key} ${count}`).join(", ");
+}
+function estimateText(estimate) {
+	if (estimate.delta === null) return `unknown (${plural(estimate.pairs, "shared unit")})`;
+	if (estimate.method === "insufficient") return `${formatSigned(estimate.delta)} (insufficient: ${estimate.pairs} of ${INSUFFICIENT_FROM} units)`;
+	return `${formatSigned(estimate.delta)} ${formatInterval(estimate.interval, estimate.interval ? "paired-delta-test" : null)} (${estimate.method}, ${estimate.pairs} ${estimate.split} units)`;
+}
+function liftPerUsdText(value) {
+	if (value.status === "unknown") return `per $: unknown (${value.reason})`;
+	if (value.status === "bound") return `per $: ${value.bound} ${formatNumber(value.value)} (${value.reason})`;
+	return `per $: ${formatNumber(value.value)}`;
+}
+function formatInterval(interval, method) {
+	if (interval === null) return "[no interval]";
+	return `[${formatNumber(interval[0])}, ${formatNumber(interval[1])}]${method ? ` ${method}` : ""}`;
+}
+function formatNumber(value) {
+	if (value === 0) return "0";
+	return Math.abs(value) >= .01 ? value.toFixed(4) : value.toPrecision(3);
+}
+function formatSigned(value) {
+	return value > 0 ? `+${formatNumber(value)}` : formatNumber(value);
+}
+function plural(count, one, many = `${one}s`) {
+	return `${count} ${count === 1 ? one : many}`;
+}
+/** A policy or allocator name carries `seed=<n>` when it is seeded from the
+* search's own seed; the genome names it `seed=<search>` so searches of one
+* configuration on different seeds share a genome. */
+function withoutSearchSeed(name, seed) {
+	return name.replace(new RegExp(`\\bseed=${seed}(?![\\d.])`, "g"), "seed=<search>");
+}
+function orient(delta, maximize) {
+	return maximize ? delta : delta === 0 ? 0 : -delta;
+}
+function orientInterval(interval, maximize) {
+	return maximize ? interval : [orient(interval[1], false), orient(interval[0], false)];
+}
+function sortedValues(map) {
+	return [...map.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([, value]) => value);
+}
+function configurationKey(objective, genomeDigest) {
+	return `${objective}\u0000${genomeDigest}`;
+}
+function rankValue(value) {
+	return value === null ? Number.NEGATIVE_INFINITY : value;
+}
+function round(usd) {
+	return Math.round(usd * 1e6) / 1e6;
+}
+//#endregion
+//#region src/search/lenses/skill-manifold.ts
+const METHODS = {
+	identity: {
+		model: "masked matrix factorization: each observed per-unit mean is b_u + P_i·Q_u on standardized scores, fitted by alternating ridge least squares over observed cells only; missing cells are masked, never filled",
+		intrinsic: "k-fold cross-validation over observed cells (folds by a hash of node and unit), mean squared error of held-out cells by rank; the intrinsic dimension is the smallest rank within one standard error (across folds) of the best",
+		nextUnit: "expected share of the variance of each leader pair’s contrast on the whole split that one more cell on the unit, run on both leaders, removes; each leader’s coordinates have the linear-Gaussian ridge posterior with loadings held fixed and noise equal to the cross-validated cell error; averaged over leader pairs",
+		explained: "in-sample R² of each rank over the rank-0 model (unit means only), on the fitted rows; it always grows with rank, which is why the intrinsic dimension is cross-validated"
+	},
+	logit: {
+		model: "multidimensional two-parameter item-response model: a node passes a unit with probability logistic(b_u + P_i·Q_u), its passes on the unit binomial over its cells; fitted by alternating Newton steps on the likelihood with standard-normal priors on P and Q (ridge) and a N(0, 10²) prior on b; missing cells are masked, never filled",
+		intrinsic: "k-fold cross-validation over observed node-unit pass counts (folds by a hash of node and unit), binomial log loss per held-out cell by rank; the intrinsic dimension is the smallest rank within one standard error (across folds) of the best",
+		nextUnit: "expected share of the variance of each leader pair’s contrast (predicted pass rate on the whole split) that one more cell on the unit, run on both leaders, removes; each leader’s coordinates have the Laplace posterior of the item-response model with loadings held fixed, and a cell’s information is its binomial variance at the leader’s predicted pass rate; averaged over leader pairs",
+		explained: "in-sample McFadden pseudo-R² of each rank over the rank-0 model (unit easiness only), on the fitted rows; it always grows with rank, which is why the intrinsic dimension is cross-validated"
+	}
+};
+/** The prior precision on a unit's log-odds intercept: N(0, 10²), weak
+* enough to leave any observed pass rate alone and strong enough to keep a
+* unit every node passed (or failed) finite. */
+const LOGIT_BIAS_PRECISION = .01;
+/** The largest move one Newton step makes in any coordinate, in log-odds. */
+const NEWTON_STEP_CAP = 4;
+const MAX_ITERATIONS = 300;
+/** Relative change of the objective that ends a fit. */
+const TOLERANCE = 1e-7;
+/**
+* The skill manifold of a search at rank `k` (`auto`: the cross-validated
+* intrinsic dimension, at least 1, and 1 when too few nodes cross-validate).
+* Pure: it reads the state, and `calibration` when given.
+*/
+function skillManifold(state, k = "auto", options = {}) {
+	const maxRank = positiveInteger("skillManifold", "maxRank", options.maxRank ?? 4);
+	const folds = positiveInteger("skillManifold", "folds", options.folds ?? 5);
+	if (folds < 2) throw new TypeError(`skillManifold: folds must be at least 2, got ${folds}`);
+	const leaderCount = positiveInteger("skillManifold", "leaders", options.leaders ?? 3);
+	const ridge = options.ridge ?? 1;
+	if (!(ridge > 0) || !Number.isFinite(ridge)) throw new TypeError(`skillManifold: ridge must be a positive number, got ${String(ridge)}`);
+	const sampleRows = positiveInteger("skillManifold", "sampleRows", options.sampleRows ?? 1e3);
+	if (k !== "auto") positiveInteger("skillManifold", "k", k);
+	const requested = options.model ?? "auto";
+	if (requested !== "auto" && requested !== "linear" && requested !== "logistic") throw new TypeError(`skillManifold: model must be auto, linear or logistic, got ${String(requested)}`);
+	const header = state.header;
+	const split = options.split ?? rankingSplit(state);
+	const direction = header?.objective.direction ?? "maximize";
+	const sign = direction === "maximize" ? 1 : -1;
+	const calibration = options.calibration ?? null;
+	const source = calibration?.source ?? `${state.searchId}@${headSequence(state)}`;
+	let link = calibration?.link ?? (requested === "logistic" ? "logit" : "identity");
+	const empty = (reason, matrix) => result(state, link, {
+		split,
+		direction,
+		mode: calibration ? "calibrated" : "fitted",
+		source,
+		matrix: matrix ?? {
+			rows: 0,
+			units: 0,
+			observed: 0,
+			density: null,
+			excludedNodes: 0,
+			excludedUnits: 0,
+			fitRows: 0
+		},
+		model: null,
+		explained: null,
+		intrinsicDimension: {
+			value: null,
+			method: METHODS[link].intrinsic,
+			n: 0,
+			folds,
+			curve: [],
+			insufficient: reason
+		},
+		axes: axesNote(direction),
+		noiseVariance: null,
+		nodes: [],
+		units: [],
+		leaders: [],
+		nextUnits: [],
+		batch: null,
+		insufficient: reason
+	});
+	if (!header || state.rootNodeId === null) return empty(header ? "the search has no root node yet" : "the search has not been opened");
+	const matrix = scoreMatrix(state, split, options.asOfSequence, calibration);
+	const shape = {
+		rows: matrix.rows.length,
+		units: matrix.unitIds.length,
+		observed: matrix.observed,
+		density: matrix.rows.length * matrix.unitIds.length > 0 ? round9(matrix.observed / (matrix.rows.length * matrix.unitIds.length)) : null,
+		excludedNodes: matrix.excludedNodes,
+		excludedUnits: matrix.excludedUnits,
+		fitRows: 0
+	};
+	if (!calibration) {
+		if (requested === "logistic" && !matrix.binary) throw new TypeError("skillManifold: model logistic needs every modelled cell to score 0 or 1; use auto or linear");
+		link = requested === "linear" || !matrix.binary ? "identity" : "logit";
+	} else if (link === "logit" && !matrix.binary) return empty(`the calibration from ${calibration.source} is an item-response model, and this search has cells that score other than 0 or 1`, shape);
+	let center;
+	let scale;
+	let fit;
+	let rank;
+	let noiseVariance;
+	let intrinsic;
+	let explained = null;
+	let iterations = 0;
+	let converged = true;
+	if (calibration) {
+		if (matrix.rows.length === 0 || matrix.unitIds.length === 0) return empty("no node scored a calibrated unit", shape);
+		center = calibration.center;
+		scale = calibration.scale;
+		rank = calibration.rank;
+		const byUnit = new Map(calibration.units.map((unit) => [unit.unitId, unit]));
+		fit = {
+			rank,
+			bias: matrix.unitIds.map((unitId) => byUnit.get(unitId).bias),
+			loadings: matrix.unitIds.map((unitId) => [...byUnit.get(unitId).loading]),
+			byRow: /* @__PURE__ */ new Map(),
+			coordinates: [],
+			iterations: 0,
+			converged: true
+		};
+		placeRows(matrix, fit, center, scale, calibration.ridge, link);
+		noiseVariance = calibration.noiseVariance;
+		intrinsic = {
+			value: null,
+			method: METHODS[link].intrinsic,
+			n: 0,
+			folds,
+			curve: [],
+			insufficient: `loadings come from ${calibration.source}; its fit decided the rank (${rank})`
+		};
+	} else {
+		if (matrix.rows.length < 3 || matrix.unitIds.length < INSUFFICIENT_FROM) return empty(`${plural$1(matrix.rows.length, "node")} and ${plural$1(matrix.unitIds.length, "unit")} qualify (a unit counts when 2 or more nodes scored it, a node when it scored 2 or more such units); a manifold needs 3 nodes and ${INSUFFICIENT_FROM} units`, shape);
+		const standard = standardization(matrix);
+		if (standard === null) return empty("every node scores the same on every unit, so there is no variation to factor", shape);
+		({center, scale} = link === "logit" ? {
+			center: 0,
+			scale: 1
+		} : standard);
+		const fitRows = evenSample(matrix.rows.map((_, index) => index), sampleRows);
+		shape.fitRows = fitRows.length;
+		const cells = observedCells(matrix, fitRows, center, scale);
+		const rankCap = Math.min(maxRank, matrix.unitIds.length - 1, fitRows.length - 1);
+		intrinsic = crossValidate(matrix, cells, rankCap, folds, ridge, link);
+		rank = k === "auto" ? Math.max(1, intrinsic.value ?? 1) : Math.min(k, Math.max(1, rankCap));
+		const fits = [];
+		for (let r = 0; r <= Math.max(rank, rankCap); r++) fits.push(factor(matrix.unitIds.length, cells, r, ridge, link));
+		const base = loss(fits[0], cells, link);
+		explained = {
+			byRank: fits.slice(1).map((entry) => ({
+				rank: entry.rank,
+				r2: round9(base > 0 ? 1 - loss(entry, cells, link) / base : 0)
+			})),
+			axisShare: [],
+			method: METHODS[link].explained
+		};
+		fit = fits[rank];
+		iterations = fit.iterations;
+		converged = fit.converged;
+		const cv = intrinsic.curve.find((point) => point.rank === rank);
+		noiseVariance = link === "identity" && cv && Number.isFinite(cv.error) ? cv.error : null;
+		const shares = principalAxes(fit, fitRows);
+		explained.axisShare = shares.map(round9);
+		fit.coordinates = [];
+		placeRows(matrix, fit, center, scale, ridge, link);
+	}
+	orientAxes(fit, sign);
+	const unitCount = matrix.unitIds.length;
+	const meanLoading = new Array(rank).fill(0);
+	for (const loading of fit.loadings) for (let d = 0; d < rank; d++) meanLoading[d] += loading[d] / unitCount;
+	const meanBias = fit.bias.reduce((sum, value) => sum + value, 0) / unitCount;
+	const predicted = (coordinates) => {
+		if (link === "identity") return center + scale * (meanBias + dot(coordinates, meanLoading));
+		let total = 0;
+		for (let u = 0; u < unitCount; u++) total += logistic(fit.bias[u] + dot(coordinates, fit.loadings[u]));
+		return total / unitCount;
+	};
+	const leaderFloor = Math.min(INSUFFICIENT_FROM, unitCount);
+	let leaderRows;
+	if (options.candidates) {
+		const wanted = new Set(options.candidates);
+		leaderRows = matrix.rows.flatMap((row, index) => wanted.has(row.nodeId) ? [index] : []);
+	} else leaderRows = matrix.rows.map((row, index) => ({
+		row,
+		index
+	})).filter(({ row }) => row.observed.size >= leaderFloor).sort((left, right) => sign * (predicted(fit.coordinates[right.index]) - predicted(fit.coordinates[left.index])) || left.row.ordinal - right.row.ordinal).slice(0, leaderCount).map(({ index }) => index);
+	const leaderSet = new Set(leaderRows);
+	const next = intrinsic.value === 0 ? {
+		ranked: [],
+		batch: null,
+		insufficient: "held-out cells fit no better with any skill axis than with unit means alone (intrinsic dimension 0): the nodes do not differ beyond noise, so no unit separates them"
+	} : !calibration && intrinsic.value === null ? {
+		ranked: [],
+		batch: null,
+		insufficient: "the skill axes are not cross-validated (see the intrinsic dimension), so no unit’s information is known"
+	} : nextUnits(matrix, fit, leaderRows, noiseVariance, calibration?.ridge ?? ridge, options.batch ?? null, link);
+	const nodes = matrix.rows.map((row, index) => ({
+		nodeId: row.nodeId,
+		ordinal: row.ordinal,
+		status: row.status,
+		observed: row.observed.size,
+		coordinates: fit.coordinates[index].map(round9),
+		predictedMean: round9(predicted(fit.coordinates[index])),
+		leader: leaderSet.has(index)
+	}));
+	const units = matrix.unitIds.map((unitId, u) => ({
+		unitId,
+		observedBy: matrix.observedBy[u],
+		bias: round9(link === "identity" ? center + scale * fit.bias[u] : logistic(fit.bias[u])),
+		intercept: round9(fit.bias[u]),
+		loading: fit.loadings[u].map(round9),
+		strength: round9(Math.hypot(...fit.loadings[u]))
+	}));
+	return result(state, link, {
+		split,
+		direction,
+		mode: calibration ? "calibrated" : "fitted",
+		source,
+		matrix: shape,
+		model: {
+			method: METHODS[link].model,
+			link,
+			rank,
+			ridge: calibration?.ridge ?? ridge,
+			center: round9(center),
+			scale: round9(scale),
+			iterations,
+			converged
+		},
+		explained,
+		intrinsicDimension: intrinsic,
+		axes: axesNote(direction),
+		noiseVariance: noiseVariance === null ? null : round9(noiseVariance),
+		nodes,
+		units,
+		leaders: leaderRows.map((index) => ({
+			nodeId: matrix.rows[index].nodeId,
+			predictedMean: round9(predicted(fit.coordinates[index])),
+			observed: matrix.rows[index].observed.size
+		})),
+		nextUnits: next.ranked,
+		batch: options.batch ? next.batch : null,
+		insufficient: next.insufficient
+	});
+}
+/** The loadings of a fitted manifold, for a later search over the same units
+* to place its nodes on. Null unless cross-validation found at least one skill
+* axis (intrinsic dimension 1 or more), and, for the linear model, measured
+* the cell noise: loadings of an axis the held-out cells do not support would
+* steer allocation by noise. */
+function skillCalibration(lens) {
+	const { data } = lens;
+	const { model } = data;
+	if (data.mode !== "fitted" || model === null || model.center === null || model.scale === null || model.link === "identity" && data.noiseVariance === null || data.intrinsicDimension.value === null || data.intrinsicDimension.value < 1) return null;
+	return {
+		source: data.source,
+		link: model.link,
+		center: model.center,
+		scale: model.scale,
+		rank: model.rank,
+		ridge: model.ridge,
+		noiseVariance: data.noiseVariance,
+		units: data.units.map((unit) => ({
+			unitId: unit.unitId,
+			bias: unit.intercept,
+			loading: [...unit.loading]
+		}))
+	};
+}
+function result(state, link, data) {
+	const best = data.nextUnits.filter((unit) => unit.measuredBy < data.leaders.length)[0] ?? data.nextUnits[0] ?? null;
+	const signal = {
+		name: "nextUnit",
+		value: best === null ? null : best.share,
+		subject: best?.unitId ?? null,
+		method: METHODS[link].nextUnit,
+		n: data.leaders.reduce((sum, leader) => sum + leader.observed, 0),
+		insufficient: best === null ? data.insufficient ?? "no unit to rank" : null
+	};
+	return {
+		lens: "skillManifold",
+		searchId: state.searchId,
+		sequence: headSequence(state),
+		data,
+		signal
+	};
+}
+function axesNote(direction) {
+	return direction === "maximize" ? "axes are principal (largest share first) and oriented so the mean unit loads positively: a larger coordinate predicts a higher score" : "axes are principal (largest share first) and oriented so the mean unit loads negatively: a larger coordinate predicts a lower (better) score";
+}
+/**
+* Per-unit means of every node on `split`. Without a calibration, a unit is
+* modelled when 2 or more nodes scored it and a node when it scored 2 or more
+* modelled units, repeated until both hold. With one, the modelled units are
+* the calibration's, and a node needs one of them.
+*/
+function scoreMatrix(state, split, asOf, calibration) {
+	const raw = [];
+	const allUnits = /* @__PURE__ */ new Set();
+	for (const node of state.nodes()) {
+		const cells = asOf === void 0 ? state.scoredCells(node.nodeId, split) : scoredAsOf(state, node.nodeId, split, asOf);
+		const scores = searchUnitScores(cells);
+		const units = new Map(scores.map((unit) => [unit.unitId, unit.mean]));
+		const counts = new Map(scores.map((unit) => [unit.unitId, {
+			sum: unit.sum,
+			count: unit.count
+		}]));
+		for (const unitId of units.keys()) allUnits.add(unitId);
+		raw.push({
+			nodeId: node.nodeId,
+			ordinal: node.ordinal,
+			status: node.status,
+			units,
+			counts,
+			binary: cells.every((cell) => cell.score === 0 || cell.score === 1)
+		});
+	}
+	let unitIds;
+	let keep;
+	if (calibration) {
+		const calibrated = new Set(calibration.units.map((unit) => unit.unitId));
+		unitIds = calibration.units.map((unit) => unit.unitId);
+		keep = raw.filter((row) => [...row.units.keys()].some((unitId) => calibrated.has(unitId)));
+	} else {
+		let units = new Set(allUnits);
+		keep = raw;
+		for (;;) {
+			const counts = /* @__PURE__ */ new Map();
+			for (const row of keep) for (const unitId of row.units.keys()) if (units.has(unitId)) counts.set(unitId, (counts.get(unitId) ?? 0) + 1);
+			const nextUnits = new Set([...units].filter((unitId) => (counts.get(unitId) ?? 0) >= 2));
+			const nextKeep = keep.filter((row) => [...row.units.keys()].filter((unitId) => nextUnits.has(unitId)).length >= 2);
+			const stable = nextUnits.size === units.size && nextKeep.length === keep.length;
+			units = nextUnits;
+			keep = nextKeep;
+			if (stable) break;
+		}
+		unitIds = [...units].sort(compareCodeUnits);
+	}
+	const unitIndex = new Map(unitIds.map((unitId, index) => [unitId, index]));
+	const observedBy = new Array(unitIds.length).fill(0);
+	let observed = 0;
+	const rows = keep.map((row) => {
+		const map = /* @__PURE__ */ new Map();
+		const counts = /* @__PURE__ */ new Map();
+		for (const [unitId, mean] of row.units) {
+			const index = unitIndex.get(unitId);
+			if (index === void 0) continue;
+			map.set(index, mean);
+			counts.set(index, row.counts.get(unitId));
+			observedBy[index] += 1;
+			observed += 1;
+		}
+		return {
+			nodeId: row.nodeId,
+			ordinal: row.ordinal,
+			status: row.status,
+			observed: map,
+			counts
+		};
+	});
+	return {
+		rows,
+		unitIds,
+		observedBy,
+		observed,
+		binary: keep.length > 0 && keep.every((row) => row.binary),
+		excludedNodes: raw.length - rows.length,
+		excludedUnits: calibration ? [...allUnits].filter((unitId) => !unitIndex.has(unitId)).length : allUnits.size - unitIds.length
+	};
+}
+/** A node's scored cells on `split` whose score the ledger held at `asOf`:
+* a cell's last update is its scoring settle, so a later retry is excluded. */
+function scoredAsOf(state, nodeId, split, asOf) {
+	const cells = [];
+	for (const cell of state.cells({ nodeId })) {
+		if (cell.split !== split || cell.score === null || cell.updatedSequence > asOf) continue;
+		cells.push({
+			cellId: cell.cellId,
+			unitId: cell.unitId,
+			attempt: cell.attempts,
+			score: cell.score
+		});
+	}
+	return cells;
+}
+function standardization(matrix) {
+	let total = 0;
+	const columnSum = new Array(matrix.unitIds.length).fill(0);
+	for (const row of matrix.rows) for (const [u, value] of row.observed) {
+		total += value;
+		columnSum[u] += value;
+	}
+	const center = total / matrix.observed;
+	let squares = 0;
+	for (const row of matrix.rows) for (const [u, value] of row.observed) squares += (value - columnSum[u] / matrix.observedBy[u]) ** 2;
+	const scale = Math.sqrt(squares / matrix.observed);
+	return scale > 1e-12 ? {
+		center,
+		scale
+	} : null;
+}
+function observedCells(matrix, rows, center, scale) {
+	const cells = [];
+	for (const row of rows) {
+		const { nodeId, observed, counts } = matrix.rows[row];
+		for (const [unit, value] of [...observed].sort(([left], [right]) => left - right)) {
+			const { sum, count } = counts.get(unit);
+			cells.push({
+				row,
+				unit,
+				z: (value - center) / scale,
+				k: sum,
+				n: count,
+				fold: fnv1a(`${nodeId}\u0000${matrix.unitIds[unit]}`)
+			});
+		}
+	}
+	return cells;
+}
+/** 32-bit FNV-1a: a deterministic fold assignment that depends on the cell's
+* coordinates alone, not on the order cells were read. */
+function fnv1a(text) {
+	let hash = 2166136261;
+	for (let index = 0; index < text.length; index++) {
+		hash ^= text.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+/** The fit of `rank` axes under `link`. */
+function factor(units, cells, rank, ridge, link) {
+	return link === "identity" ? factorLinear(units, cells, rank, ridge) : factorLogistic(units, cells, rank, ridge);
+}
+function groupCells(units, cells) {
+	const byUnit = Array.from({ length: units }, () => []);
+	const byRow = /* @__PURE__ */ new Map();
+	for (const cell of cells) {
+		byUnit[cell.unit].push(cell);
+		const list = byRow.get(cell.row);
+		if (list) list.push(cell);
+		else byRow.set(cell.row, [cell]);
+	}
+	return {
+		byUnit,
+		byRow
+	};
+}
+/** Loadings start from a fixed seeded draw, so a fit is deterministic. */
+function seededLoadings(units, rank) {
+	const random = mulberry32(24301 + rank);
+	return Array.from({ length: units }, () => Array.from({ length: rank }, () => (random() - .5) * .2));
+}
+/**
+* Alternating ridge least squares over `cells`: rows' coordinates given the
+* loadings, then each unit's loading and (unpenalized) bias given the
+* coordinates, until the objective moves by less than 1e-7 of itself.
+*/
+function factorLinear(units, cells, rank, ridge) {
+	const { byUnit, byRow: rowIds } = groupCells(units, cells);
+	const bias = byUnit.map((list) => list.length === 0 ? 0 : list.reduce((sum, cell) => sum + cell.z, 0) / list.length);
+	const loadings = seededLoadings(units, rank);
+	const coordinates = /* @__PURE__ */ new Map();
+	for (const row of rowIds.keys()) coordinates.set(row, new Array(rank).fill(0));
+	if (rank === 0) return {
+		rank,
+		bias,
+		loadings,
+		byRow: coordinates,
+		coordinates: [],
+		iterations: 0,
+		converged: true
+	};
+	let previous = Number.POSITIVE_INFINITY;
+	let iterations = 0;
+	let converged = false;
+	for (; iterations < MAX_ITERATIONS; iterations++) {
+		for (const [row, list] of rowIds) coordinates.set(row, solveRow(list, loadings, bias, rank, ridge, "identity"));
+		for (let u = 0; u < units; u++) {
+			const list = byUnit[u];
+			if (list.length === 0) continue;
+			const size = rank + 1;
+			const system = Array.from({ length: size }, (_, i) => Array.from({ length: size }, (_, j) => i === j && i < rank ? ridge : 0));
+			const rhs = new Array(size).fill(0);
+			for (const cell of list) {
+				const point = coordinates.get(cell.row);
+				for (let i = 0; i < size; i++) {
+					const xi = i < rank ? point[i] : 1;
+					rhs[i] += xi * cell.z;
+					const line = system[i];
+					for (let j = 0; j < size; j++) line[j] += xi * (j < rank ? point[j] : 1);
+				}
+			}
+			const lower = cholesky(system);
+			if (lower === null) continue;
+			const solution = choleskySolve(lower, rhs);
+			loadings[u] = solution.slice(0, rank);
+			bias[u] = solution[rank];
+		}
+		let objective = 0;
+		for (const cell of cells) objective += (cell.z - bias[cell.unit] - dot(coordinates.get(cell.row), loadings[cell.unit])) ** 2;
+		for (const point of coordinates.values()) objective += ridge * dot(point, point);
+		for (const loading of loadings) objective += ridge * dot(loading, loading);
+		if (Math.abs(previous - objective) <= TOLERANCE * Math.max(objective, 1e-12)) {
+			converged = true;
+			iterations += 1;
+			break;
+		}
+		previous = objective;
+	}
+	return {
+		rank,
+		bias,
+		loadings,
+		byRow: coordinates,
+		coordinates: [],
+		iterations,
+		converged
+	};
+}
+/**
+* The item-response fit: alternating Newton steps on the penalized binomial
+* likelihood, each row's coordinates given the loadings, then each unit's
+* loading and intercept given the coordinates, until the objective moves by
+* less than 1e-7 of itself. Priors: standard normal on coordinates and
+* loadings (scaled by `ridge`), N(0, 10²) on each intercept, which keeps a
+* unit every node passed finite. A step moves no parameter by more than 4.
+*/
+function factorLogistic(units, cells, rank, ridge) {
+	const { byUnit, byRow: rowIds } = groupCells(units, cells);
+	const bias = byUnit.map((list) => {
+		let k = 0;
+		let n = 0;
+		for (const cell of list) {
+			k += cell.k;
+			n += cell.n;
+		}
+		return Math.log((k + .5) / (n - k + .5));
+	});
+	const loadings = seededLoadings(units, rank);
+	const coordinates = /* @__PURE__ */ new Map();
+	for (const row of rowIds.keys()) coordinates.set(row, new Array(rank).fill(0));
+	const objectiveOf = () => {
+		let total = 0;
+		for (const cell of cells) total += binomialLoss(cell, bias[cell.unit] + dot(coordinates.get(cell.row), loadings[cell.unit]));
+		for (const point of coordinates.values()) total += ridge / 2 * dot(point, point);
+		for (const loading of loadings) total += ridge / 2 * dot(loading, loading);
+		for (const value of bias) total += LOGIT_BIAS_PRECISION / 2 * value * value;
+		return total;
+	};
+	let previous = Number.POSITIVE_INFINITY;
+	let iterations = 0;
+	let converged = false;
+	for (; iterations < MAX_ITERATIONS; iterations++) {
+		if (rank > 0) for (const [row, list] of rowIds) {
+			const point = coordinates.get(row);
+			coordinates.set(row, newtonStep(point, list, loadings, bias, ridge));
+		}
+		for (let u = 0; u < units; u++) {
+			const list = byUnit[u];
+			if (list.length === 0) continue;
+			const size = rank + 1;
+			const theta = [...loadings[u], bias[u]];
+			const precision = (i) => i < rank ? ridge : LOGIT_BIAS_PRECISION;
+			const hessian = Array.from({ length: size }, (_, i) => Array.from({ length: size }, (_, j) => i === j ? precision(i) : 0));
+			const gradient = theta.map((value, i) => -precision(i) * value);
+			for (const cell of list) {
+				const point = coordinates.get(cell.row);
+				const p = logistic(theta[rank] + dot(point, theta));
+				const weight = cell.n * p * (1 - p);
+				for (let i = 0; i < size; i++) {
+					const xi = i < rank ? point[i] : 1;
+					gradient[i] += (cell.k - cell.n * p) * xi;
+					const line = hessian[i];
+					for (let j = 0; j < size; j++) line[j] += weight * xi * (j < rank ? point[j] : 1);
+				}
+			}
+			const lower = cholesky(hessian);
+			if (lower === null) continue;
+			const step = capped(choleskySolve(lower, gradient));
+			loadings[u] = theta.slice(0, rank).map((value, i) => value + step[i]);
+			bias[u] = theta[rank] + step[rank];
+		}
+		const objective = objectiveOf();
+		if (Math.abs(previous - objective) <= TOLERANCE * Math.max(objective, 1e-12)) {
+			converged = true;
+			iterations += 1;
+			break;
+		}
+		previous = objective;
+	}
+	return {
+		rank,
+		bias,
+		loadings,
+		byRow: coordinates,
+		coordinates: [],
+		iterations,
+		converged
+	};
+}
+/** One Newton step on a row's coordinates under the item-response model. */
+function newtonStep(point, list, loadings, bias, ridge) {
+	const rank = point.length;
+	const hessian = Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => i === j ? ridge : 0));
+	const gradient = point.map((value) => -ridge * value);
+	for (const cell of list) {
+		const q = loadings[cell.unit];
+		const p = logistic(bias[cell.unit] + dot(point, q));
+		const weight = cell.n * p * (1 - p);
+		for (let i = 0; i < rank; i++) {
+			gradient[i] += (cell.k - cell.n * p) * q[i];
+			for (let j = 0; j < rank; j++) hessian[i][j] += weight * q[i] * q[j];
+		}
+	}
+	const step = capped(choleskySolve(cholesky(hessian), gradient));
+	return point.map((value, i) => value + step[i]);
+}
+function capped(step) {
+	const largest = Math.max(0, ...step.map(Math.abs));
+	return largest > NEWTON_STEP_CAP ? step.map((value) => value * NEWTON_STEP_CAP / largest) : [...step];
+}
+/** −log of the binomial likelihood of `k` passes in `n` at log-odds `eta`,
+* without the binomial coefficient: n·log(1 + e^η) − k·η, computed stably. */
+function binomialLoss(cell, eta) {
+	const softplus = Math.max(eta, 0) + Math.log1p(Math.exp(-Math.abs(eta)));
+	return cell.n * softplus - cell.k * eta;
+}
+function logistic(eta) {
+	if (eta >= 0) return 1 / (1 + Math.exp(-eta));
+	const e = Math.exp(eta);
+	return e / (1 + e);
+}
+/** A row's coordinates given the loadings: one ridge solve (identity), or
+* Newton steps to convergence (logit). */
+function solveRow(list, loadings, bias, rank, ridge, link) {
+	if (link === "logit") {
+		let point = new Array(rank).fill(0);
+		for (let iteration = 0; iteration < 50; iteration++) {
+			const next = newtonStep(point, list, loadings, bias, ridge);
+			const moved = Math.max(0, ...next.map((value, i) => Math.abs(value - point[i])));
+			point = next;
+			if (moved < 1e-10) break;
+		}
+		return point;
+	}
+	const system = Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => i === j ? ridge : 0));
+	const rhs = new Array(rank).fill(0);
+	for (const cell of list) {
+		const q = loadings[cell.unit];
+		const residual = cell.z - bias[cell.unit];
+		for (let i = 0; i < rank; i++) {
+			rhs[i] += q[i] * residual;
+			for (let j = 0; j < rank; j++) system[i][j] += q[i] * q[j];
+		}
+	}
+	return choleskySolve(cholesky(system), rhs);
+}
+/** The model's linear predictor: standardized mean (identity) or log-odds (logit). */
+function predict(fit, point, unit) {
+	return fit.bias[unit] + (point ? dot(point, fit.loadings[unit]) : 0);
+}
+/** Squared error (identity) or binomial log loss (logit) of the fit on `cells`. */
+function loss(fit, cells, link) {
+	let total = 0;
+	for (const cell of cells) total += cellLoss(cell, predict(fit, fit.byRow.get(cell.row), cell.unit), link);
+	return total;
+}
+function cellLoss(cell, eta, link) {
+	return link === "identity" ? (cell.z - eta) ** 2 : binomialLoss(cell, eta);
+}
+/** Every matrix row placed on the fitted loadings. */
+function placeRows(matrix, fit, center, scale, ridge, link) {
+	fit.coordinates = matrix.rows.map((row) => {
+		if (fit.rank === 0) return [];
+		return solveRow([...row.observed].map(([unit, value]) => ({
+			unit,
+			z: (value - center) / scale,
+			k: row.counts.get(unit).sum,
+			n: row.counts.get(unit).count
+		})), fit.loadings, fit.bias, fit.rank, ridge, link);
+	});
+}
+/**
+* Rotates the fitted rows and loadings to principal axes: the singular
+* vectors of the fitted low-rank matrix, largest first, with the scale split
+* evenly between rows and loadings. The product the model predicts is
+* unchanged. Returns each axis's share of the squared singular values.
+*/
+function principalAxes(fit, fitRows) {
+	const rank = fit.rank;
+	const byRow = fit.byRow;
+	const rows = fitRows.map((row) => byRow.get(row) ?? new Array(rank).fill(0));
+	const gram = (vectors) => Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => vectors.reduce((sum, v) => sum + v[i] * v[j], 0)));
+	const lowerP = cholesky(gram(rows));
+	const lowerQ = cholesky(gram(fit.loadings));
+	if (lowerP === null || lowerQ === null) return [];
+	const c = Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => {
+		let sum = 0;
+		for (let m = 0; m < rank; m++) sum += lowerP[m][i] * lowerQ[m][j];
+		return sum;
+	}));
+	const { values, vectors } = symmetricEigen(Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => {
+		let sum = 0;
+		for (let m = 0; m < rank; m++) sum += c[m][i] * c[m][j];
+		return sum;
+	})));
+	const sigma = values.map((value) => Math.sqrt(Math.max(value, 0)));
+	if (sigma.some((value) => value <= 1e-12)) return [];
+	const b = Array.from({ length: rank }, (_, i) => vectors.map((vector) => vector[i]));
+	const a = Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => {
+		let sum = 0;
+		for (let m = 0; m < rank; m++) sum += c[i][m] * b[m][j];
+		return sum / sigma[j];
+	}));
+	const upperInverse = (lower) => transpose(lowerInverse(lower));
+	const transformP = multiply(multiply(upperInverse(lowerP), a), diagonal(sigma.map(Math.sqrt)));
+	const transformQ = multiply(multiply(upperInverse(lowerQ), b), diagonal(sigma.map(Math.sqrt)));
+	for (const [row, point] of byRow) byRow.set(row, applyRow(point, transformP));
+	fit.loadings = fit.loadings.map((loading) => applyRow(loading, transformQ));
+	const total = values.reduce((sum, value) => sum + Math.max(value, 0), 0);
+	return values.map((value) => Math.max(value, 0) / total);
+}
+/** Flips each axis so the mean loading points toward a better score. */
+function orientAxes(fit, sign) {
+	for (let d = 0; d < fit.rank; d++) {
+		let mean = 0;
+		for (const loading of fit.loadings) mean += loading[d];
+		if (sign * mean >= 0) continue;
+		for (const loading of fit.loadings) loading[d] = -loading[d] || 0;
+		for (const point of fit.coordinates) point[d] = -point[d] || 0;
+		for (const point of fit.byRow.values()) point[d] = -point[d] || 0;
+	}
+}
+function crossValidate(matrix, cells, rankCap, folds, ridge, link) {
+	const rows = new Set(cells.map((cell) => cell.row)).size;
+	if (rows < INSUFFICIENT_FROM || matrix.unitIds.length < INSUFFICIENT_FROM) return {
+		value: null,
+		method: METHODS[link].intrinsic,
+		n: 0,
+		folds,
+		curve: [],
+		insufficient: `cross-validation needs ${INSUFFICIENT_FROM} nodes and ${INSUFFICIENT_FROM} units; ${plural$1(rows, "node")} and ${plural$1(matrix.unitIds.length, "unit")} qualify`
+	};
+	const curve = [];
+	let held = 0;
+	for (let rank = 0; rank <= rankCap; rank++) {
+		const foldErrors = [];
+		let squares = 0;
+		let count = 0;
+		for (let fold = 0; fold < folds; fold++) {
+			const train = cells.filter((cell) => cell.fold % folds !== fold);
+			const test = cells.filter((cell) => cell.fold % folds === fold);
+			const fit = factor(matrix.unitIds.length, train, rank, ridge, link);
+			const trained = new Set(train.map((cell) => cell.unit));
+			let foldSquares = 0;
+			let foldCount = 0;
+			for (const cell of test) {
+				if (!trained.has(cell.unit)) continue;
+				foldSquares += cellLoss(cell, predict(fit, fit.byRow.get(cell.row), cell.unit), link);
+				foldCount += 1;
+			}
+			if (foldCount > 0) foldErrors.push(foldSquares / foldCount);
+			squares += foldSquares;
+			count += foldCount;
+		}
+		held = count;
+		const error = count > 0 ? squares / count : NaN;
+		const spread = foldErrors.length > 1 ? Math.sqrt(foldErrors.reduce((sum, value) => sum + (value - mean(foldErrors)) ** 2, 0) / (foldErrors.length - 1) / foldErrors.length) : NaN;
+		curve.push({
+			rank,
+			error: round9(error),
+			standardError: round9(spread)
+		});
+	}
+	const finite = curve.filter((point) => Number.isFinite(point.error));
+	if (finite.length === 0) return {
+		value: null,
+		method: METHODS[link].intrinsic,
+		n: held,
+		folds,
+		curve,
+		insufficient: "no held-out cell had a unit the rest of the data measured"
+	};
+	const best = finite.reduce((left, right) => right.error < left.error ? right : left);
+	const bar = best.error + (Number.isFinite(best.standardError) ? best.standardError : 0);
+	return {
+		value: finite.find((point) => point.error <= bar).rank,
+		method: METHODS[link].intrinsic,
+		n: held,
+		folds,
+		curve,
+		insufficient: null
+	};
+}
+function nextUnits(matrix, fit, leaderRows, noiseVariance, ridge, batch, link) {
+	if (leaderRows.length < 2) return {
+		ranked: [],
+		batch: null,
+		insufficient: `${plural$1(leaderRows.length, "leader")} qualify (${INSUFFICIENT_FROM} or more modelled units); separating leaders needs 2`
+	};
+	if (link === "identity" && (noiseVariance === null || !(noiseVariance > 0))) return {
+		ranked: [],
+		batch: null,
+		insufficient: "the cell noise is unmeasured, so no unit’s information is known"
+	};
+	if (fit.rank === 0) return {
+		ranked: [],
+		batch: null,
+		insufficient: "rank 0: the nodes do not differ beyond noise"
+	};
+	const rank = fit.rank;
+	const units = matrix.unitIds.length;
+	const meanLoading = new Array(rank).fill(0);
+	for (const loading of fit.loadings) for (let d = 0; d < rank; d++) meanLoading[d] += loading[d] / units;
+	const leaders = leaderRows.map((row) => {
+		const point = fit.coordinates[row];
+		const information = fit.loadings.map((q, u) => {
+			if (link === "identity") return 1 / noiseVariance;
+			const p = logistic(fit.bias[u] + dot(point, q));
+			return p * (1 - p);
+		});
+		const gradient = link === "identity" ? meanLoading : Array.from({ length: rank }, (_, d) => {
+			let total = 0;
+			for (let u = 0; u < units; u++) total += information[u] * fit.loadings[u][d] / units;
+			return total;
+		});
+		const prior = link === "identity" ? ridge / noiseVariance : ridge;
+		const system = Array.from({ length: rank }, (_, i) => Array.from({ length: rank }, (_, j) => i === j ? prior : 0));
+		const counts = matrix.rows[row].counts;
+		for (const unit of matrix.rows[row].observed.keys()) {
+			const q = fit.loadings[unit];
+			const weight = information[unit] * (link === "identity" ? 1 : counts.get(unit).count);
+			for (let i = 0; i < rank; i++) for (let j = 0; j < rank; j++) system[i][j] += weight * q[i] * q[j];
+		}
+		return {
+			information,
+			gradient,
+			covariance: choleskyInverse(cholesky(system))
+		};
+	});
+	const shares = (sigmas) => {
+		const toward = sigmas.map((sigma, index) => sigma.map((line) => dot(line, leaders[index].gradient)));
+		const contrast = toward.map((vector, index) => dot(leaders[index].gradient, vector));
+		return fit.loadings.map((q, u) => {
+			const reduction = sigmas.map((sigma, index) => {
+				const information = leaders[index].information[u];
+				if (!(information > 0)) return 0;
+				const spread = dot(q, sigma.map((line) => dot(line, q)));
+				return dot(toward[index], q) ** 2 / (1 / information + spread);
+			});
+			let share = 0;
+			let pairs = 0;
+			for (let i = 0; i < sigmas.length; i++) for (let j = i + 1; j < sigmas.length; j++) {
+				const variance = contrast[i] + contrast[j];
+				if (variance > 0) share += (reduction[i] + reduction[j]) / variance;
+				pairs += 1;
+			}
+			return share / pairs;
+		});
+	};
+	const byShare = (values) => (left, right) => values[right] - values[left] || compareCodeUnits(matrix.unitIds[left], matrix.unitIds[right]);
+	const covariance = leaders.map((leader) => leader.covariance);
+	const first = shares(covariance);
+	const ranked = matrix.unitIds.map((_, u) => u).sort(byShare(first)).map((u) => ({
+		unitId: matrix.unitIds[u],
+		share: round9(first[u]),
+		measuredBy: leaderRows.filter((row) => matrix.rows[row].observed.has(u)).length
+	}));
+	if (batch === null) return {
+		ranked,
+		batch: null,
+		insufficient: null
+	};
+	const among = new Set(batch.among ?? matrix.unitIds);
+	const open = new Set(matrix.unitIds.flatMap((unitId, u) => among.has(unitId) ? [u] : []));
+	const picked = [];
+	let sigmas = covariance;
+	while (picked.length < batch.count && open.size > 0) {
+		const values = shares(sigmas);
+		const best = [...open].sort(byShare(values))[0];
+		open.delete(best);
+		picked.push(matrix.unitIds[best]);
+		const q = fit.loadings[best];
+		sigmas = sigmas.map((sigma, index) => {
+			const information = leaders[index].information[best];
+			if (!(information > 0)) return sigma;
+			const toward = sigma.map((line) => dot(line, q));
+			const denominator = 1 / information + dot(q, toward);
+			return sigma.map((line, i) => line.map((value, j) => value - toward[i] * toward[j] / denominator));
+		});
+	}
+	return {
+		ranked,
+		batch: picked,
+		insufficient: null
+	};
+}
+/**
+* The `asha` extension that adds, at each rung, the units that best separate
+* the leaders: the greedy `nextUnit` batch from `calibration`'s loadings,
+* with this search's nodes placed on them from the cells the ledger held when
+* the rung opened. The leaders are the lens's (the top 3 by predicted mean on
+* every calibrated unit). Where the lens cannot rank (fewer than 2 leaders,
+* or no measured noise), `asha` fills the rung from its seeded order.
+*/
+function nextUnitExtension(calibration, options = {}) {
+	return {
+		name: `next-unit(${hashCanonical(calibration).slice(7, 19)})`,
+		choose({ state, asOfSequence, split, remaining, count }) {
+			return skillManifold(state, calibration.rank, {
+				split,
+				calibration,
+				asOfSequence,
+				...options.leaders === void 0 ? {} : { leaders: options.leaders },
+				batch: {
+					count,
+					among: remaining
+				}
+			}).data.batch ?? [];
+		}
+	};
+}
+function dot(left, right) {
+	let sum = 0;
+	for (let index = 0; index < left.length; index++) sum += left[index] * right[index];
+	return sum;
+}
+function mean(values) {
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function transpose(matrix) {
+	return matrix[0] ? matrix[0].map((_, j) => matrix.map((row) => row[j])) : [];
+}
+function multiply(left, right) {
+	return left.map((row) => right[0].map((_, j) => row.reduce((sum, value, m) => sum + value * right[m][j], 0)));
+}
+function diagonal(values) {
+	return values.map((value, i) => values.map((_, j) => i === j ? value : 0));
+}
+function applyRow(vector, transform) {
+	return transform[0].map((_, j) => vector.reduce((sum, value, m) => sum + value * transform[m][j], 0));
+}
+/** Inverse of a lower-triangular matrix by forward substitution. */
+function lowerInverse(lower) {
+	const n = lower.length;
+	const inverse = Array.from({ length: n }, () => new Array(n).fill(0));
+	for (let j = 0; j < n; j++) {
+		inverse[j][j] = 1 / lower[j][j];
+		for (let i = j + 1; i < n; i++) {
+			let sum = 0;
+			for (let m = j; m < i; m++) sum += lower[i][m] * inverse[m][j];
+			inverse[i][j] = -sum / lower[i][i];
+		}
+	}
+	return inverse;
+}
+/** The manifold as text for a terminal or a proposer's context. */
+function formatSkillManifold(lens) {
+	const { data, signal } = lens;
+	const lines = [];
+	const { matrix } = data;
+	lines.push(`Skill manifold (${data.split} split, ${data.mode === "calibrated" ? `loadings from ${data.source}` : "loadings fitted here"})`);
+	lines.push(`  matrix: ${plural$1(matrix.rows, "node")} × ${plural$1(matrix.units, "unit")}, ${matrix.observed} observed cells (density ${matrix.density === null ? "unknown" : `${Math.round(matrix.density * 1e3) / 10}%`}); left out ${plural$1(matrix.excludedNodes, "node")} and ${plural$1(matrix.excludedUnits, "unit")}${matrix.fitRows > 0 && matrix.fitRows < matrix.rows ? `; factors fitted on ${matrix.fitRows} evenly spaced rows` : ""}`);
+	const { intrinsicDimension: intrinsic } = data;
+	if (intrinsic.value === null) lines.push(`  intrinsic dimension: insufficient (${intrinsic.insufficient})`);
+	else {
+		const curve = intrinsic.curve.map((point) => `k=${point.rank} ${point.error.toFixed(3)}±${fixedOrDash(point.standardError)}`).join(", ");
+		lines.push(`  intrinsic dimension: ${intrinsic.value} (${intrinsic.folds}-fold held-out ${data.model?.link === "logit" ? "binomial log loss" : "squared error on the standardized scale"}, one-SE rule, ${intrinsic.n} held-out cells per rank: ${curve})`);
+	}
+	if (data.model === null) {
+		if (data.insufficient !== intrinsic.insufficient) lines.push(`  model: insufficient (${data.insufficient})`);
+		return lines.join("\n");
+	}
+	const { model } = data;
+	const explained = data.explained;
+	const r2 = explained?.byRank.find((entry) => entry.rank === model.rank)?.r2;
+	const logit = model.link === "logit";
+	lines.push(`  model: ${logit ? "item-response (two-parameter logistic, every cell 0 or 1)" : "linear on standardized means"}, rank ${model.rank}, ridge ${model.ridge}, ${model.iterations} ${logit ? "Newton" : "ALS"} sweeps${model.converged ? "" : " (not converged)"}${r2 === void 0 ? "" : `, in-sample ${logit ? "pseudo-R²" : "R²"} ${r2.toFixed(3)} over unit ${logit ? "easiness" : "means"}`}${explained && explained.axisShare.length > 0 ? `; axis shares ${explained.axisShare.map((share) => `${Math.round(share * 1e3) / 10}%`).join(", ")}` : ""}; ${logit ? "cell noise binomial" : `cell noise ${data.noiseVariance === null ? "unknown" : data.noiseVariance.toFixed(3)} (standardized)`}`);
+	const strongest = [...data.units].sort((left, right) => right.strength - left.strength).slice(0, 5);
+	lines.push(`  units that separate nodes most: ${strongest.map((unit) => `${unit.unitId} (${unit.strength.toFixed(2)}, axis ${dominantAxis(unit.loading) + 1})`).join(", ")}`);
+	if (data.leaders.length > 0) lines.push(`  leaders by predicted split mean: ${data.leaders.map((leader) => `${leader.nodeId} ${leader.predictedMean.toFixed(3)} on ${leader.observed} units`).join("; ")}`);
+	if (signal.value === null) lines.push(`  next unit: insufficient (${signal.insufficient})`);
+	else {
+		const top = data.nextUnits.slice(0, 5).map((unit) => `${unit.unitId} ${(unit.share * 100).toFixed(1)}% (${unit.measuredBy}/${data.leaders.length} measured)`).join(", ");
+		lines.push(`  next unit: ${signal.subject}, removing an expected ${(signal.value * 100).toFixed(1)}% of the leaders' contrast variance per cell; ranked: ${top}`);
+	}
+	return lines.join("\n");
+}
+function dominantAxis(loading) {
+	let best = 0;
+	for (let index = 1; index < loading.length; index++) if (Math.abs(loading[index]) > Math.abs(loading[best])) best = index;
+	return best;
+}
+function fixedOrDash(value) {
+	return Number.isFinite(value) ? value.toFixed(3) : "–";
+}
+//#endregion
+//#region src/search/lenses/task-matrix.ts
+function taskMatrix(state, options = {}) {
+	const split = options.split ?? rankingSplit(state);
+	const nodeIds = state.nodeIds();
+	const byNodeUnit = /* @__PURE__ */ new Map();
+	const unitSet = /* @__PURE__ */ new Set();
+	for (const nodeId of nodeIds) {
+		const units = /* @__PURE__ */ new Map();
+		for (const unit of state.unitScores(nodeId, split)) {
+			units.set(unit.unitId, unit.mean);
+			unitSet.add(unit.unitId);
+		}
+		byNodeUnit.set(nodeId, units);
+	}
+	const unitIds = [...unitSet].sort((a, b) => a.localeCompare(b));
+	const nodeClusters = clusterBy(nodeIds, (a, b) => nodeDistance(byNodeUnit, a, b));
+	const unitClusters = clusterBy(unitIds, (a, b) => unitDistance(byNodeUnit, nodeIds, a, b));
+	const orderedNodeIds = nodeClusters.flatMap((c) => c.members);
+	const orderedUnitIds = unitClusters.flatMap((c) => c.members);
+	const cells = [];
+	for (const nodeId of orderedNodeIds) {
+		const units = byNodeUnit.get(nodeId);
+		for (const unitId of orderedUnitIds) cells.push({
+			nodeId,
+			unitId,
+			mean: units.get(unitId) ?? null
+		});
+	}
+	const specialistGain = unitClusters.map((cluster) => {
+		const nodeMeans = [];
+		for (const nodeId of nodeIds) {
+			const units = byNodeUnit.get(nodeId);
+			const scored = cluster.members.map((unitId) => units.get(unitId)).filter((v) => v !== void 0);
+			if (scored.length > 0) nodeMeans.push(scored.reduce((a, b) => a + b, 0) / scored.length);
+		}
+		if (nodeMeans.length < 2) return {
+			clusterId: cluster.id,
+			unitIds: cluster.members,
+			gain: null,
+			nodesContributing: nodeMeans.length
+		};
+		const mean = nodeMeans.reduce((a, b) => a + b, 0) / nodeMeans.length;
+		const gain = Math.max(...nodeMeans) - mean;
+		return {
+			clusterId: cluster.id,
+			unitIds: cluster.members,
+			gain,
+			nodesContributing: nodeMeans.length
+		};
+	});
+	const signalValue = {};
+	for (const row of specialistGain) if (row.gain !== null) signalValue[row.clusterId] = row.gain;
+	return {
+		data: {
+			split,
+			nodeIds: orderedNodeIds,
+			unitIds: orderedUnitIds,
+			nodeClusters,
+			unitClusters,
+			cells,
+			specialistGain
+		},
+		signal: {
+			name: "taskMatrix.specialistGain",
+			value: signalValue
+		}
+	};
+}
+function nodeDistance(byNodeUnit, a, b) {
+	const unitsA = byNodeUnit.get(a);
+	const unitsB = byNodeUnit.get(b);
+	let sumSquares = 0;
+	let shared = 0;
+	for (const [unitId, valueA] of unitsA) {
+		const valueB = unitsB.get(unitId);
+		if (valueB === void 0) continue;
+		sumSquares += (valueA - valueB) ** 2;
+		shared += 1;
+	}
+	return shared === 0 ? Number.POSITIVE_INFINITY : Math.sqrt(sumSquares);
+}
+function unitDistance(byNodeUnit, nodeIds, a, b) {
+	let sumSquares = 0;
+	let shared = 0;
+	for (const nodeId of nodeIds) {
+		const units = byNodeUnit.get(nodeId);
+		const valueA = units.get(a);
+		const valueB = units.get(b);
+		if (valueA === void 0 || valueB === void 0) continue;
+		sumSquares += (valueA - valueB) ** 2;
+		shared += 1;
+	}
+	return shared === 0 ? Number.POSITIVE_INFINITY : Math.sqrt(sumSquares);
+}
+/**
+* Single-linkage agglomerative clustering. The cutoff is the median of the
+* finite pairwise distances measured before any merge — a threshold the data
+* itself sets, not a constant this lens chooses. Two items with no finite
+* distance (no shared observation) can never merge. Deterministic: ties in
+* the merge order break on the lexicographically smaller pair, and the
+* returned clusters and their members are both sorted.
+*/
+function clusterBy(ids, distance) {
+	let clusters = ids.map((id) => [id]);
+	if (clusters.length <= 1) return clusters.map(toCluster);
+	const finite = [];
+	for (let i = 0; i < ids.length; i++) for (let j = i + 1; j < ids.length; j++) {
+		const d = distance(ids[i], ids[j]);
+		if (Number.isFinite(d)) finite.push(d);
+	}
+	if (finite.length === 0) return clusters.map(toCluster);
+	finite.sort((a, b) => a - b);
+	const cutoff = finite[Math.floor(finite.length / 2)];
+	for (;;) {
+		let best = null;
+		for (let i = 0; i < clusters.length; i++) for (let j = i + 1; j < clusters.length; j++) {
+			let d = Number.POSITIVE_INFINITY;
+			for (const a of clusters[i]) for (const b of clusters[j]) d = Math.min(d, distance(a, b));
+			if (d > cutoff) continue;
+			if (best === null || d < best.d) best = {
+				i,
+				j,
+				d
+			};
+		}
+		if (!best) break;
+		const merged = [...clusters[best.i], ...clusters[best.j]];
+		clusters = clusters.filter((_, index) => index !== best.i && index !== best.j);
+		clusters.push(merged);
+	}
+	return clusters.map(toCluster).sort((a, b) => a.id.localeCompare(b.id));
+}
+function toCluster(members) {
+	const sorted = [...members].sort((a, b) => a.localeCompare(b));
+	return {
+		id: sorted[0],
+		members: sorted
+	};
+}
+//#endregion
+//#region src/search/lenses/tree.ts
+function tree(state) {
+	const nodes = state.nodes();
+	const byId = new Map(nodes.map((node) => [node.nodeId, node]));
+	const childrenOf = /* @__PURE__ */ new Map();
+	const topLevel = [];
+	for (const node of nodes) if (node.primaryParentId !== null && byId.has(node.primaryParentId)) {
+		const list = childrenOf.get(node.primaryParentId);
+		if (list) list.push(node.nodeId);
+		else childrenOf.set(node.primaryParentId, [node.nodeId]);
+	} else topLevel.push(node.nodeId);
+	const primaryOperator = /* @__PURE__ */ new Map();
+	for (const edge of state.edges()) {
+		const child = byId.get(edge.childNodeId);
+		if (!child) continue;
+		if ((edge.parents[0]?.nodeId ?? null) === child.primaryParentId && !primaryOperator.has(child.nodeId)) primaryOperator.set(child.nodeId, edge.operator);
+	}
+	const build = (nodeId) => {
+		const node = byId.get(nodeId);
+		return {
+			nodeId: node.nodeId,
+			status: node.status,
+			rung: node.rung,
+			depth: node.depth,
+			cellCount: node.cellCount,
+			knownCostUsd: node.spend.knownUsd,
+			operator: primaryOperator.get(node.nodeId) ?? null,
+			children: (childrenOf.get(nodeId) ?? []).map((childId) => build(childId))
+		};
+	};
+	return {
+		data: {
+			roots: topLevel.map(build),
+			nodeCount: nodes.length,
+			edgeCount: state.edges().length
+		},
+		signal: {
+			name: "tree.nodeCount",
+			value: nodes.length
+		}
+	};
+}
+//#endregion
+export { editCreditText as A, draftOnPlateau as C, EDIT_CREDIT_ESTIMATOR as D, front as E, EDIT_CREDIT_SIGNAL as O, vectorEmbedding as S, screenedNodes as T, lineageEdits as _, skillCalibration as a, surfaceDigestEdits as b, META_SEARCH_SIGNAL as c, objectiveKey as d, renderMetaSearchText as f, lineEditDistance as g, landscape as h, nextUnitExtension as i, editCredit as k, metaSearch as l, formatLandscape as m, taskMatrix as n, skillManifold as o, searchPolicyGenome as p, formatSkillManifold as r, META_SEARCH_SCORE_SOURCE as s, tree as t, metaSearchScore as u, nearestNeighbours as v, searchPlateau as w, surfaceTextEdits as x, profileTextLines as y };
+
+//# sourceMappingURL=tree-DHHWsH-X.js.map