@mnmal-ai/substrate-nl 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/{bootstrap-BDi2fdbS.js → bootstrap-CLYwjrrl.js}

@@ -1,4 +1,4 @@
-import { defineBootstrap, error400, jsonResponse, parseJsonBody, trimTrailingSlashes } from "@mnmal-ai/substrate/sdk";
+import { METADATA_AUTHOR_FIELDS, METADATA_FILTER_FIELDS, ROW_POLICY_BLOCKS_WALK, WALKS_NEED_PARTITIONED, WALKS_UNSUPPORTED_STORE, defineBootstrap, error400, jsonResponse, parseJsonBody, trimTrailingSlashes } from "@mnmal-ai/substrate/sdk";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 
@@ -28,6 +28,168 @@ function uniqueSorted(xs) {
 	return [...new Set(xs)].sort();
 }
 
+//#endregion
+//#region src/rulings/schema.ts
+/**
+* Rulings arrive from two places: declared by the namespace owner in
+* `defineNamespace(..., { annotations: { nl } })`, and overridden by the
+* operator in `substrate-nl.config.json`. Both are validated here. Bad declared
+* rulings are dropped with a warning rather than failing the boot: one
+* namespace's typo must not take NL down for every namespace, and must not
+* pass silently either.
+*/
+const ValueAliasSchema = z.object({
+	type: z.string().min(1),
+	field: z.string().min(1),
+	in: z.array(z.string()).optional(),
+	eq: z.string().optional(),
+	startsWith: z.string().optional(),
+	contains: z.string().optional()
+}).strict().refine((v) => [
+	v.in,
+	v.eq,
+	v.startsWith,
+	v.contains
+].filter((x) => x !== void 0).length === 1, { message: "a value alias names exactly one of in, eq, startsWith, contains" });
+const norm = (p) => p.trim().replace(/\s+/g, " ").toLowerCase();
+const FieldPhraseSchema = z.object({
+	field: z.string().min(1).optional(),
+	value: z.unknown().optional(),
+	exclude: z.record(z.string(), z.unknown()).optional(),
+	derive: z.union([z.object({ diff: z.tuple([z.string(), z.string()]) }).strict(), z.object({ ratio: z.tuple([z.string(), z.string()]) }).strict()]).optional(),
+	pick: z.enum([
+		"latest",
+		"max",
+		"min"
+	]).optional()
+}).strict().refine((v) => v.field !== void 0 || v.value === void 0 && v.exclude === void 0, { message: "value and exclude require field" }).refine((v) => v.field !== void 0 || v.derive !== void 0 || v.pick !== void 0, { message: "an entry needs at least one of field, derive, pick" });
+const FieldPhrasesSchema = z.record(z.string(), FieldPhraseSchema).transform((rec, ctx) => {
+	const out = {};
+	for (const [phrase, entry] of Object.entries(rec)) {
+		const key = norm(phrase);
+		if (Object.hasOwn(out, key)) {
+			ctx.addIssue({
+				code: "custom",
+				message: `two phrases normalise to '${key}'`
+			});
+			return z.NEVER;
+		}
+		out[key] = entry;
+	}
+	return out;
+});
+const record = z.record(z.string(), z.string());
+const NamespaceRulingsSchema = z.object({
+	fieldPhrases: FieldPhrasesSchema.optional(),
+	unscopedTypes: z.array(z.string()).optional(),
+	typeAliases: record.optional(),
+	fieldAliases: record.optional(),
+	liveStatus: record.optional(),
+	timeField: record.optional(),
+	typeNotes: record.optional(),
+	valueAliases: z.record(z.string(), z.array(ValueAliasSchema)).optional(),
+	typeExcludes: z.record(z.string(), z.record(z.string(), z.unknown())).optional()
+}).strict();
+/** Per top-level key: records merge entry-by-entry (override wins), arrays replace. */
+function mergeRulings(declared, override) {
+	if (override === void 0) return declared;
+	const out = { ...declared };
+	for (const [key, value] of Object.entries(override)) {
+		const prior = out[key];
+		out[key] = Array.isArray(value) || prior === void 0 || Array.isArray(prior) ? value : {
+			...prior,
+			...value
+		};
+	}
+	return out;
+}
+const COMBINATORS = [
+	"AND",
+	"OR",
+	"NOT"
+];
+/** Field names an `exclude` clause names, walked through AND/OR/NOT. Structural only: operator spellings are the engine's to refuse at query time. */
+function whereFields(w, out) {
+	if (Array.isArray(w)) for (const x of w) whereFields(x, out);
+	else if (typeof w === "object" && w !== null) for (const [k, v] of Object.entries(w)) if (COMBINATORS.includes(k)) whereFields(v, out);
+	else out.push(k);
+}
+/** Why a `fieldPhrases` entry does not fit the schema, or undefined. */
+function phraseProblem(schema, e) {
+	const types = /* @__PURE__ */ new Set();
+	const refs = [...e.field !== void 0 ? [e.field] : [], ...e.derive ? Object.values(e.derive)[0] ?? [] : []];
+	for (const r of refs) {
+		const dot = r.indexOf(".");
+		const type = dot < 0 ? r : r.slice(0, dot);
+		const field = dot < 0 ? "" : r.slice(dot + 1);
+		const t = Object.hasOwn(schema.types, type) ? schema.types[type] : void 0;
+		if (t === void 0) return `unknown type '${type}'`;
+		if (!Object.hasOwn(t.fields, field)) return `unknown field '${type}.${field}'`;
+		types.add(type);
+	}
+	if (types.size > 1) return `refers to more than one type (${[...types].join(", ")})`;
+	const [type] = types;
+	if (e.exclude !== void 0 && type !== void 0) return excludeProblem(schema, type, e.exclude);
+}
+/** Why an exclude clause does not fit `type`, or undefined. */
+function excludeProblem(schema, type, exclude) {
+	const names = [];
+	whereFields(exclude, names);
+	const fields = schema.types[type]?.fields ?? {};
+	const bad = names.find((n) => !n.startsWith("_") && !Object.hasOwn(fields, n) && !Object.hasOwn(METADATA_FILTER_FIELDS, n) && !Object.hasOwn(METADATA_AUTHOR_FIELDS, n));
+	return bad !== void 0 ? `exclude names unknown field '${type}.${bad}'` : void 0;
+}
+/** The effective rulings for one namespace's schema, plus anything that was dropped. */
+function readRulings(schema, override) {
+	const warnings = [];
+	let declared = {};
+	const raw = schema.annotations?.nl;
+	if (raw !== void 0) {
+		const parsed = NamespaceRulingsSchema.safeParse(raw);
+		if (parsed.success) declared = parsed.data;
+		else {
+			const where = parsed.error.issues.map((i) => i.path.join(".") || "(root)").join(", ");
+			warnings.push(`declared rulings are invalid and were ignored (${where})`);
+		}
+	}
+	let normOverride = override;
+	if (override?.fieldPhrases !== void 0) {
+		const p = FieldPhrasesSchema.safeParse(override.fieldPhrases);
+		const { fieldPhrases: _drop, ...rest } = override;
+		if (p.success) normOverride = {
+			...rest,
+			fieldPhrases: p.data
+		};
+		else {
+			normOverride = rest;
+			warnings.push(`override fieldPhrases are invalid and were ignored (${p.error.issues.map((i) => i.message).join("; ")})`);
+		}
+	}
+	const rulings = mergeRulings(declared, normOverride);
+	if (rulings.fieldPhrases !== void 0) {
+		const kept = {};
+		for (const [phrase, entry] of Object.entries(rulings.fieldPhrases)) {
+			const problem = phraseProblem(schema, entry);
+			if (problem === void 0) kept[phrase] = entry;
+			else warnings.push(`fieldPhrases '${phrase}' was ignored: ${problem}`);
+		}
+		rulings.fieldPhrases = kept;
+	}
+	if (rulings.typeExcludes !== void 0) {
+		const kept = {};
+		for (const [type, where] of Object.entries(rulings.typeExcludes)) {
+			const problem = Object.hasOwn(schema.types, type) ? excludeProblem(schema, type, where) : `unknown type '${type}'`;
+			if (problem === void 0) kept[type] = where;
+			else warnings.push(`typeExcludes '${type}' was ignored: ${problem}`);
+		}
+		rulings.typeExcludes = kept;
+	}
+	return {
+		rulings,
+		warnings
+	};
+}
+
 //#endregion
 //#region src/parse/time.ts
 const WEEKDAYS = [
@@ -109,10 +271,732 @@ function rangeFor(phrase, asOf) {
 	return null;
 }
 
+//#endregion
+//#region src/parse/compare.ts
+const NUMBER = /^\$?(\d+(?:\.\d+)?)$/;
+/** The comparison phrase starting at `words[0]`, or null. */
+function parseComparison(words) {
+	const [a = "", b = "", c = ""] = words;
+	const pct = /^(\d+(?:\.\d+)?)%$/.exec(a);
+	if (pct !== null) {
+		const n = Number(pct[1]);
+		const up = (100 + n) / 100;
+		if (b === "over" || b === "above") return {
+			op: "gte",
+			times: up,
+			length: 2
+		};
+		if (b === "more" && c === "than") return {
+			op: "gte",
+			times: up,
+			length: 3
+		};
+		const length = c === "than" ? 3 : 2;
+		if (b === "slower") return {
+			op: "gte",
+			times: up,
+			length
+		};
+		if (b === "faster") return n < 100 ? {
+			op: "lte",
+			times: (100 - n) / 100,
+			length
+		} : {
+			op: "lte",
+			length,
+			invalid: `${n}% faster leaves no time to compare against`
+		};
+		return null;
+	}
+	const lead = a === "at" && b === "least" ? 2 : 0;
+	const w = words[lead] ?? "";
+	const mult = /^(\d+(?:\.\d+)?)(?:x|×)$/.exec(w);
+	if (mult !== null) return {
+		op: "gte",
+		times: Number(mult[1]),
+		length: lead + 1
+	};
+	const next = words[lead + 1];
+	if (/^\d+(?:\.\d+)?$/.test(w) && (next === "times" || next === "x" || next === "×")) return {
+		op: "gte",
+		times: Number(w),
+		length: lead + 2
+	};
+	if (lead > 0) return null;
+	const amount = /^\$(\d+(?:\.\d+)?)$/.exec(a);
+	if (amount !== null) {
+		const plus = Number(amount[1]);
+		if (b === "over") return {
+			op: "gte",
+			plus,
+			length: 2
+		};
+		if (b === "more" && c === "than") return {
+			op: "gte",
+			plus,
+			length: 3
+		};
+		return null;
+	}
+	const head = a === "over" ? ["gt", 1] : a === "under" ? ["lt", 1] : a === "more" && b === "than" ? ["gt", 2] : a === "less" && b === "than" ? ["lt", 2] : null;
+	if (head === null) return null;
+	const [op, length] = head;
+	const lit = NUMBER.exec(words[length] ?? "");
+	return lit !== null ? {
+		op,
+		value: Number(lit[1]),
+		length: length + 1
+	} : {
+		op,
+		length
+	};
+}
+
+//#endregion
+//#region src/parse/walks.ts
+/** The plan note for a type's default exclusion that yielded to the question's own filter on `field`. */
+function defaultYield(type, field, path = ["where"]) {
+	return {
+		path: [...path, `ruling:${type} default exclude (yields to the question's ${field} filter)`],
+		kind: "filter",
+		served: false
+	};
+}
+/** Every crossRef hop out of `type`, both directions, inside the pack's namespace. */
+function hopsFrom(pack, type) {
+	const out = [];
+	for (const [owner, t] of Object.entries(pack.types)) for (const [field, f] of Object.entries(t.fields)) {
+		const target = f.kind === "crossRef" ? f.target : void 0;
+		if (target === void 0 || target.namespace !== pack.namespace) continue;
+		if (own(pack.types, target.type) === void 0) continue;
+		if (owner === type) out.push({
+			dir: "out",
+			from: type,
+			owner,
+			field,
+			to: target.type
+		});
+		if (target.type === type) out.push({
+			dir: "in",
+			from: type,
+			owner,
+			field,
+			to: owner
+		});
+	}
+	return out;
+}
+/** All shortest crossRef paths from `from` to `to` (BFS, both directions, no type revisited). */
+function findPaths(pack, from, to, maxHops = 3) {
+	if (from === to) return [[]];
+	let frontier = [[]];
+	for (let depth = 1; depth <= maxHops; depth++) {
+		const next = [];
+		for (const p of frontier) {
+			const at = p[p.length - 1]?.to ?? from;
+			for (const h of hopsFrom(pack, at)) {
+				if (h.to === from || p.some((x) => x.to === h.to)) continue;
+				next.push([...p, h]);
+			}
+		}
+		const done = next.filter((p) => p[p.length - 1]?.to === to);
+		if (done.length > 0) return done;
+		frontier = next;
+	}
+	return [];
+}
+function pathLabel(ns, p) {
+	return p.map((h) => h.dir === "in" ? `in ${ns}/${h.owner}.${h.field}` : `out ${h.field}`).join(" > ");
+}
+const PICKED = {
+	latest: "latest",
+	max: "highest",
+	min: "lowest"
+};
+const PICK_WORDS = {
+	latest: "latest",
+	current: "latest",
+	"most recent": "latest",
+	highest: "max",
+	best: "max",
+	lowest: "min",
+	cheapest: "min"
+};
+const DERIVE_WORDS = /* @__PURE__ */ new Set([
+	"margin",
+	"spread",
+	"gap"
+]);
+/** A comparative the lexicon does not cover. */
+const COMPARATIVE = /%$|^\d+(?:\.\d+)?(?:x|×)$|^(?:than|twice|double|half|triple)$/;
+const text = (tokens, [s, e]) => tokens.slice(s, e + 1).map((t) => t.text).join(" ");
+const range = ([s, e]) => Array.from({ length: e - s + 1 }, (_, k) => s + k);
+const take = (tokens, [s, e]) => {
+	for (let i = s; i <= e; i++) tokens[i].used = true;
+};
+/**
+* Claims field phrases, pick words, "by <derive>" and comparisons. Only a
+* namespace that declares `fieldPhrases` composes walks, so nothing changes
+* for one that does not.
+*/
+function claimWalkParts(tokens, rulings, glue) {
+	const claims = {
+		phrases: [],
+		compares: [],
+		picks: [],
+		derives: [],
+		dropped: []
+	};
+	const table = rulings.fieldPhrases;
+	if (table === void 0 || Object.keys(table).length === 0) return claims;
+	for (let n = 6; n >= 1; n--) for (let i = 0; i + n <= tokens.length; i++) {
+		const at = [i, i + n - 1];
+		if (tokens.slice(i, i + n).some((t) => t.used)) continue;
+		const entry = own(table, text(tokens, at));
+		if (entry === void 0) continue;
+		take(tokens, at);
+		const dot = entry.field?.indexOf(".") ?? -1;
+		claims.phrases.push({
+			span: text(tokens, at),
+			at,
+			entry,
+			...entry.field !== void 0 && dot > 0 ? {
+				type: entry.field.slice(0, dot),
+				field: entry.field.slice(dot + 1)
+			} : {}
+		});
+	}
+	claims.phrases.sort((x, y) => x.at[0] - y.at[0]);
+	for (const p of claims.phrases) {
+		const s = p.at[0];
+		for (const [word, kind] of Object.entries(PICK_WORDS)) {
+			const at = [s - word.split(" ").length, s - 1];
+			if (at[0] < 0 || tokens.slice(at[0], s).some((t) => t.used)) continue;
+			if (text(tokens, at) !== word) continue;
+			take(tokens, at);
+			claims.picks.push({
+				span: word,
+				at,
+				phrase: p,
+				kind
+			});
+			break;
+		}
+	}
+	for (const p of claims.phrases) {
+		if (p.entry.derive === void 0) continue;
+		const by = tokens[p.at[0] - 1];
+		if (by?.text === "by" && !by.used) {
+			by.used = true;
+			claims.derives.push(p);
+		} else claims.dropped.push({
+			span: p.span,
+			reason: `"${p.span}" is a derived value; it orders a list only as "by ${p.span}"`,
+			kind: "filter"
+		});
+	}
+	tokens.forEach((t, i) => {
+		const next = tokens[i + 1];
+		if (t.text !== "by" || t.used || next === void 0 || next.used) return;
+		if (!DERIVE_WORDS.has(next.text)) return;
+		t.used = true;
+		next.used = true;
+		claims.dropped.push({
+			span: `by ${next.text}`,
+			reason: `no derived value "${next.text}" is declared for this namespace`,
+			kind: "order"
+		});
+	});
+	const phraseAt = (i) => claims.phrases.find((p) => p.at[0] === i);
+	for (let i = 0; i < tokens.length; i++) {
+		if (tokens[i]?.used === true) continue;
+		const cmp = parseComparison(tokens.slice(i).map((t) => t.text));
+		if (cmp === null) continue;
+		const at = [i, i + cmp.length - 1];
+		const usedAt = range(at).filter((k) => tokens[k]?.used === true);
+		const wordPhrase = usedAt.length === 1 ? phraseAt(usedAt[0]) : void 0;
+		if (usedAt.length > 0 && (wordPhrase === void 0 || wordPhrase.at[1] !== usedAt[0] || !/^(?:slower|faster)$/.test(wordPhrase.span))) continue;
+		let object;
+		if (cmp.value === void 0) {
+			const pickAt = new Set(claims.picks.flatMap((k) => range(k.at)));
+			let j = at[1] + 1;
+			while (j < tokens.length && phraseAt(j) === void 0) {
+				const t = tokens[j];
+				if (!(glue.has(t.text) && !t.used) && !pickAt.has(j)) break;
+				j++;
+			}
+			object = phraseAt(j);
+			if (object === void 0) continue;
+		}
+		const before = [...claims.phrases].reverse().find((p) => p.at[1] < i);
+		const adjacent = before !== void 0 && tokens.slice(before.at[1] + 1, i).every((t) => !t.used && glue.has(t.text)) && before.field !== void 0 && before.entry.value === void 0;
+		const subject = wordPhrase ?? (adjacent ? before : void 0);
+		for (let k = i; k <= at[1]; k++) tokens[k].used = true;
+		const span = text(tokens, at);
+		claims.compares.push({
+			span,
+			at,
+			cmp,
+			...subject !== void 0 ? { subject } : {},
+			...object !== void 0 ? { object } : {}
+		});
+		i = at[1];
+	}
+	return claims;
+}
+/** Comparatives the lexicon did not claim: dropped, never approximated. */
+function dropComparatives(tokens, dropped) {
+	tokens.forEach((t, i) => {
+		if (t.used || !COMPARATIVE.test(t.text)) return;
+		const prev = tokens[i - 1];
+		const words = prev !== void 0 && !prev.used && t.text === "than" ? [prev, t] : [t];
+		for (const w of words) w.used = true;
+		dropped.push({
+			span: words.map((w) => w.text).join(" "),
+			reason: "this comparison is not in the comparison lexicon",
+			kind: "filter"
+		});
+	});
+}
+const filter = (clause, path, label) => ({
+	clause,
+	plan: [{
+		path: [...path, label],
+		kind: "filter",
+		served: false
+	}]
+});
+/** Clauses as one where: the clause itself, or an AND with plan paths re-rooted. */
+function andOf(parts) {
+	if (parts.length === 0) return null;
+	if (parts.length === 1) return {
+		where: parts[0].clause,
+		plan: parts[0].plan
+	};
+	return {
+		where: { AND: parts.map((p) => p.clause) },
+		plan: parts.flatMap((p, i) => p.plan.map((c) => ({
+			...c,
+			path: [
+				"AND",
+				String(i),
+				...c.path
+			]
+		})))
+	};
+}
+/** Binding names: the type name's capitals ("Listing" -> L, "CiRun" -> CR). */
+function aliasFor(type, taken) {
+	const base = type.replace(/[^A-Z]/g, "") || type.slice(0, 1).toUpperCase();
+	let name = base;
+	for (let n = 2; taken.has(name); n++) name = `${base}${n}`;
+	taken.add(name);
+	return name;
+}
+function compose(input) {
+	const { pack, rulings, seed, claims } = input;
+	const ns = pack.namespace;
+	const dropped = [...claims.dropped];
+	const seedParts = [];
+	const walks = /* @__PURE__ */ new Map();
+	const dead = /* @__PURE__ */ new Set();
+	let clarify = null;
+	const timeField = (type) => own(rulings.timeField, type) ?? "createdAt";
+	const typeExclude = (type) => {
+		const where = own(rulings.typeExcludes, type);
+		return where === void 0 ? null : filter({ NOT: where }, ["NOT"], `ruling:${type} default exclude`);
+	};
+	const walkTo = (type, span) => {
+		const known = walks.get(type);
+		if (known !== void 0) return known;
+		if (dead.has(type)) return null;
+		const paths = findPaths(pack, seed, type);
+		if (paths.length === 0) {
+			dead.add(type);
+			dropped.push({
+				span,
+				reason: `no crossRef path from ${seed} to ${type} within 3 hops`,
+				kind: "filter"
+			});
+			return null;
+		}
+		if (paths.length > 1) {
+			clarify ??= `several equally short paths from ${seed} to ${type}: ${paths.map((p) => pathLabel(ns, p)).join("; ")}`;
+			dead.add(type);
+			return null;
+		}
+		const w = {
+			type,
+			path: paths[0],
+			filters: [],
+			window: [],
+			excludes: [typeExclude(type)].filter((x) => x !== null),
+			notes: [],
+			applied: /* @__PURE__ */ new Set()
+		};
+		walks.set(type, w);
+		return w;
+	};
+	/** Where a phrase's own clauses go: the seed, a walk, or nowhere (dropped). */
+	const home = (p) => {
+		if (p.type === void 0) return null;
+		if (p.type === seed) return { seed: true };
+		return walkTo(p.type, p.span);
+	};
+	const isWalk = (h) => !("seed" in h);
+	for (const p of claims.phrases) {
+		if (p.field === void 0 || p.type === void 0) continue;
+		const h = home(p);
+		if (h === null) continue;
+		if (isWalk(h) && h.applied.has(p.span)) continue;
+		const parts = [];
+		if (p.entry.value !== void 0) parts.push(filter({ [p.field]: { eq: p.entry.value } }, [p.field], `ruling:${p.span}`));
+		const excl = p.entry.exclude;
+		if (excl !== void 0) {
+			const part = filter({ NOT: excl }, ["NOT"], `ruling:${p.span}`);
+			if (isWalk(h)) h.excludes.push(part);
+			else seedParts.push(part);
+		}
+		if (isWalk(h)) {
+			h.filters.push(...parts);
+			h.applied.add(p.span);
+		} else seedParts.push(...parts);
+	}
+	const picked = /* @__PURE__ */ new Map();
+	for (const k of claims.picks) picked.set(k.phrase, k.kind);
+	for (const p of claims.phrases) {
+		if (p.type === void 0 || p.type === seed || p.field === void 0) continue;
+		const w = walks.get(p.type);
+		if (w === void 0) continue;
+		const kind = picked.get(p) ?? p.entry.pick;
+		if (kind === void 0) continue;
+		const source = picked.has(p) ? `"${claims.picks.find((k) => k.phrase === p)?.span}"` : "ruling";
+		const span = claims.picks.find((k) => k.phrase === p)?.span ?? p.span;
+		const pick = {
+			kind,
+			by: kind === "latest" ? timeField(p.type) : p.field,
+			source,
+			span
+		};
+		if (w.pick !== void 0 && (w.pick.kind !== pick.kind || w.pick.by !== pick.by)) {
+			clarify ??= `${w.pick.source} and ${pick.source} pick different ${p.type} rows`;
+			continue;
+		}
+		w.pick = pick;
+	}
+	let seedLatest;
+	for (const k of claims.picks) if (k.phrase.type === seed && k.kind === "latest") seedLatest = k.span;
+	else if (k.phrase.type === seed) dropped.push({
+		span: `${k.span} ${k.phrase.span}`,
+		reason: `"${k.span}" picks one neighbour, and ${seed} is the type being asked about`,
+		kind: "order"
+	});
+	const mentionOf = /* @__PURE__ */ new Map();
+	const mention = (w, p, text) => {
+		const known = mentionOf.get(w);
+		if (known === void 0) mentionOf.set(w, {
+			at: p.at[0],
+			text
+		});
+		else if (known.at !== p.at[0]) clarify ??= `"${known.text}" and "${text}": one ${w.type} meeting both, or two different ${w.type} rows?`;
+	};
+	for (const c of claims.compares) {
+		if (c.cmp.invalid !== void 0) {
+			dropped.push({
+				span: c.span,
+				reason: c.cmp.invalid,
+				kind: "filter"
+			});
+			continue;
+		}
+		const s = c.subject;
+		if (s?.type === void 0 || s.field === void 0) {
+			dropped.push({
+				span: c.span,
+				reason: "no field phrase directly before it to compare",
+				kind: "filter"
+			});
+			continue;
+		}
+		const sh = home(s);
+		if (sh === null) {
+			dropped.push({
+				span: c.span,
+				reason: `its field "${s.span}" was dropped`,
+				kind: "filter"
+			});
+			continue;
+		}
+		let operand;
+		let kind = "filter";
+		if (c.cmp.value !== void 0) operand = c.cmp.value;
+		else {
+			const o = c.object;
+			if (o?.type === void 0 || o.field === void 0) {
+				dropped.push({
+					span: c.span,
+					reason: "nothing to compare against",
+					kind: "filter"
+				});
+				continue;
+			}
+			let ref;
+			if (o.type === seed) ref = `$.${o.field}`;
+			else {
+				if (o.type === s.type) {
+					dropped.push({
+						span: `${c.span} ${o.span}`,
+						reason: `comparing two fields of one ${o.type} is not expressible`,
+						kind: "filter"
+					});
+					continue;
+				}
+				const ow = walkTo(o.type, o.span);
+				if (ow === null) {
+					dropped.push({
+						span: c.span,
+						reason: `its operand "${o.span}" was dropped`,
+						kind: "filter"
+					});
+					continue;
+				}
+				mention(ow, o, `${c.span} ${o.span}`);
+				if (ow.path.length > 1 || ow.pick !== void 0) {
+					dropped.push({
+						span: `${c.span} ${o.span}`,
+						reason: ow.pick !== void 0 ? `a picked ${o.type} cannot be referenced` : `a comparison against a ${ow.path.length}-hop walk is not expressible`,
+						kind: "filter"
+					});
+					continue;
+				}
+				ref = `${o.type}\u0000${o.field}`;
+			}
+			operand = {
+				$ref: ref,
+				...c.cmp.times !== void 0 ? { times: c.cmp.times } : {},
+				...c.cmp.plus !== void 0 ? { plus: c.cmp.plus } : {}
+			};
+			kind = "ref";
+		}
+		const part = {
+			clause: { [s.field]: { [c.cmp.op]: operand } },
+			plan: [{
+				path: [
+					s.field,
+					c.cmp.op,
+					...kind === "ref" ? [] : [`compare:${c.span}`]
+				],
+				kind,
+				served: kind === "ref"
+			}]
+		};
+		if (isWalk(sh)) {
+			mention(sh, s, `${s.span} ${c.span}`);
+			sh.filters.push(part);
+		} else seedParts.push(part);
+	}
+	let timeOnSeed = input.time !== null;
+	if (input.time !== null) {
+		const t = input.time.at;
+		const dist = ([s, e]) => s > t[1] ? s - t[1] : e < t[0] ? t[0] - e : 0;
+		const near = /* @__PURE__ */ new Map();
+		const note = (type, at) => {
+			if (type === void 0) return;
+			near.set(type, Math.min(near.get(type) ?? Number.POSITIVE_INFINITY, dist(at)));
+		};
+		for (const p of claims.phrases) note(p.type, p.at);
+		for (const m of input.mentions) note(m.type, m.at);
+		const best = Math.min(...near.values());
+		const nearest = [...near].filter(([, d]) => d === best).map(([type]) => type);
+		if (nearest.length > 1) clarify ??= `"${input.time.span}" could window ${nearest.sort().join(" or ")}`;
+		else if (nearest.length === 1 && nearest[0] !== seed) {
+			const type = nearest[0];
+			const w = walkTo(type, input.time.span);
+			timeOnSeed = false;
+			if (w === null) dropped.push({
+				span: input.time.span,
+				reason: `it windows ${type}, which no walk from ${seed} reaches`,
+				kind: "filter"
+			});
+			else {
+				const field = timeField(type);
+				const ruled = own(rulings.timeField, type) !== void 0;
+				w.window.push(filter({ [field]: {
+					gte: input.time.range.gte,
+					lt: input.time.range.lt
+				} }, [field], `window:${input.time.span}${ruled ? "" : ` on ${field} (default)`}`));
+			}
+		}
+	}
+	const params = {};
+	const plan = [];
+	for (const d of claims.derives) {
+		const spec = d.entry.derive;
+		if (spec === void 0) continue;
+		const [op, operands] = Object.entries(spec)[0];
+		if (!operands.every((o) => o.startsWith(`${seed}.`))) {
+			dropped.push({
+				span: `by ${d.span}`,
+				reason: `"${d.span}" derives from fields of another type than ${seed}`,
+				kind: "order"
+			});
+			continue;
+		}
+		const name = d.span.replace(/[^a-z0-9]+(.)?/g, (_, ch) => (ch ?? "").toUpperCase());
+		params.derive = {
+			...params.derive ?? {},
+			[name]: { [op]: operands.map((o) => `$.${o.slice(seed.length + 1)}`) }
+		};
+		params.orderBy = [{ [`$${name}`]: "desc" }];
+		plan.push({
+			path: [
+				"derive",
+				name,
+				`ruling:${d.span}`
+			],
+			kind: "derive",
+			served: false
+		}, {
+			path: [
+				"orderBy",
+				"0",
+				`$${name}`,
+				"desc (default)"
+			],
+			kind: "order",
+			served: false
+		});
+	}
+	if (clarify !== null) return { clarify };
+	for (const w of walks.values()) {
+		const def = typeExclude(w.type);
+		const tested = [];
+		if (def !== null) whereFields(own(rulings.typeExcludes, w.type), tested);
+		const named = [];
+		for (const f of w.filters) whereFields(f.clause, named);
+		const yieldTo = tested.find((f) => named.includes(f));
+		if (yieldTo === void 0) continue;
+		w.excludes = w.excludes.filter((x) => !isDefault(x, w.type));
+		w.notes.push(defaultYield(w.type, yieldTo, []));
+	}
+	let pickDropped = false;
+	for (const w of walks.values()) {
+		if (w.pick === void 0 || w.excludes.length === 0) continue;
+		const names = w.excludes.flatMap((x) => x.plan.map((c) => `'${String(c.path.at(-1)).replace(/^ruling:/, "")}'`)).join(", ");
+		dropped.push({
+			span: w.pick.span,
+			reason: `cannot pick the ${PICKED[w.pick.kind]} ${w.type} while the ${names} exclusion applies`,
+			kind: "filter"
+		});
+		delete w.pick;
+		pickDropped = true;
+	}
+	const taken = /* @__PURE__ */ new Set();
+	const ordered = [...walks.values()].sort((x, y) => hopKey(ns, x.path[0]).localeCompare(hopKey(ns, y.path[0])));
+	for (const w of ordered) if (w.path.length === 1 && w.pick === void 0) w.alias = aliasFor(w.type, taken);
+	const aliasOf = new Map(ordered.map((w) => [w.type, w.alias]));
+	const resolveRefs = (v) => {
+		if (Array.isArray(v)) return v.map(resolveRefs);
+		if (typeof v !== "object" || v === null) return v;
+		const out = {};
+		for (const [k, x] of Object.entries(v)) if (k === "$ref" && typeof x === "string" && x.includes("\0")) {
+			const [type, field] = x.split("\0");
+			out[k] = `${aliasOf.get(type)}.${field}`;
+		} else out[k] = resolveRefs(x);
+		return out;
+	};
+	const parts = [...seedParts];
+	for (const w of ordered) parts.push(walkPart(ns, w, typeExclude));
+	const composed = parts.map((p) => ({
+		...p,
+		clause: resolveRefs(p.clause)
+	}));
+	return {
+		parts: composed,
+		params,
+		plan,
+		dropped,
+		timeOnSeed,
+		...seedLatest !== void 0 ? { seedLatest } : {},
+		walked: walks.size > 0 || seedParts.some((p) => p.plan.some((c) => c.kind === "ref")) || plan.length > 0,
+		strict: pickDropped || ordered.some((w) => w.pick !== void 0) || composed.some((p) => p.plan.some((c) => c.kind === "ref"))
+	};
+}
+const isDefault = (x, type) => x.plan.some((c) => c.path.at(-1) === `ruling:${type} default exclude`);
+function hopKey(ns, h) {
+	return h.dir === "in" ? `${ns}/${h.owner}.${h.field}` : h.field;
+}
+/** One walk as a (possibly nested) `_walk` clause. */
+function walkPart(ns, w, exclude) {
+	const inner = andOf([
+		...w.filters,
+		...w.window,
+		...w.excludes
+	]);
+	const label = w.pick === void 0 ? "any" : `pick:${w.pick.kind}(${w.pick.by}) from ${w.pick.source}`;
+	let node = {
+		...w.alias !== void 0 ? { as: w.alias } : {},
+		...edge(ns, w.path[w.path.length - 1]),
+		...inner !== null ? { where: inner.where } : {},
+		...w.pick !== void 0 ? { pick: { [w.pick.kind]: w.pick.by } } : {}
+	};
+	let plan = [{
+		path: [
+			"_walk",
+			hopKey(ns, w.path[w.path.length - 1]),
+			label
+		],
+		kind: "hop",
+		served: true
+	}, ...[...inner?.plan ?? [], ...w.notes].map((c) => ({
+		...c,
+		path: [
+			"_walk",
+			"where",
+			...c.path
+		]
+	}))];
+	for (let i = w.path.length - 2; i >= 0; i--) {
+		const h = w.path[i];
+		const ex = exclude(h.to);
+		const where = andOf([{
+			clause: { _walk: node },
+			plan
+		}, ...ex !== null ? [ex] : []]);
+		node = {
+			...edge(ns, h),
+			where: where?.where
+		};
+		plan = [{
+			path: [
+				"_walk",
+				hopKey(ns, h),
+				"any"
+			],
+			kind: "hop",
+			served: true
+		}, ...(where?.plan ?? []).map((c) => ({
+			...c,
+			path: [
+				"_walk",
+				"where",
+				...c.path
+			]
+		}))];
+	}
+	return {
+		clause: { _walk: node },
+		plan
+	};
+}
+function edge(ns, h) {
+	return h.dir === "in" ? { in: `${ns}/${h.owner}.${h.field}` } : { out: h.field };
+}
+
 //#endregion
 //#region src/parse/parse.ts
 /** Words that carry no query meaning on their own. */
-const GLUE = new Set("a about again all am an and any anything are as at be been by can could current did do does for from get give go got have hey i i'm in is it it's let let's lets list me more my need needs next now of ok on or our please raised see show so some still talk tell that the their them there these this those to us want was we we've we'd what what's whats when where which who whose why will with would you your yo up thought handled judgement judgment make nice there's anymore stuff things few runs run lives wrote write written created made filed logged".split(/\s+/));
+const GLUE = new Set("a about again all am an and any anything are as at be been by can could current did do does for from get give go got have hey i i'm in is it it's let let's lets list me more my need needs next now of ok on or our please raised see show so some still talk tell that the their them there these this those to us want was we we've we'd what what's whats when where which who whose why will with would you your yo up thought handled judgement judgment make nice there's anymore stuff things few runs run ran lives wrote write written created made filed logged".split(/\s+/));
 /** First word of an imperative edit, which substrate-nl refuses: it only reads. */
 const MUTATIONS = new Set("close delete remove archive merge approve approved create add update set mark rename reopen assign ack deploy cut land".split(" "));
 const LEADING_FILLER = new Set("please can could would you go ahead let let's lets hey ok yo so and then".split(" "));
@@ -137,6 +1021,13 @@ const CLOSED = [
 	"resolved"
 ];
 const HISTORY_WORDS = new Set("archived archive history historical ever previously past trend trends over-time all-time total".split(" "));
+/** Connectives a composed reading cannot honour; dropped while composing walks. */
+const CONNECTIVES = /* @__PURE__ */ new Set([
+	"or",
+	"not",
+	"no",
+	"every"
+]);
 const LATEST = new Set("latest newest recent last".split(" "));
 const OLDEST = new Set("oldest earliest first".split(" "));
 const AUTHOR_VERBS = new Set("raised created written filed authored opened made sent logged".split(" "));
@@ -201,7 +1092,7 @@ function parseQuestion(question, pack, ctx) {
 	const tokens = (question.replace(CLAUSE, (span, _q, field, raw) => {
 		clauses.push(parseClause(span, field, raw));
 		return " ";
-	}).toLowerCase().replace(/[‘’]/g, "'").match(/#\d+|[a-z0-9@[][a-z0-9@._'\]-]*/g) ?? []).map((t) => t.replace(/[.'-]+$/, "").replace(/'s$/, "")).filter((t) => t.length > 0).map((text) => ({
+	}).toLowerCase().replace(/[‘’]/g, "'").match(/\$\d+(?:\.\d+)?|\d+(?:\.\d+)?[%×]|#\d+|[a-z0-9@[][a-z0-9@._'\]-]*/g) ?? []).map((t) => t.replace(/[.'-]+$/, "").replace(/'s$/, "")).filter((t) => t.length > 0).map((text) => ({
 		text,
 		used: false
 	}));
@@ -226,6 +1117,7 @@ function parseQuestion(question, pack, ctx) {
 		});
 		return true;
 	});
+	const walkClaims = claimWalkParts(tokens, rulings, GLUE);
 	const mentioned = /* @__PURE__ */ new Map();
 	for (const entry of buildTypeIndex(pack, rulings)) {
 		const n = entry.phrase.split(" ").length;
@@ -235,7 +1127,8 @@ function parseQuestion(question, pack, ctx) {
 			for (const t of slice) t.used = true;
 			for (const type of entry.types) mentioned.set(type, {
 				span: entry.phrase,
-				plural: entry.plural
+				plural: entry.plural,
+				at: mentioned.get(type)?.at ?? [i, i + n - 1]
 			});
 		}
 	}
@@ -352,6 +1245,19 @@ function parseQuestion(question, pack, ctx) {
 		role: "author",
 		detail: `createdById startsWith ${author}`
 	});
+	const composing = walkClaims.phrases.length + walkClaims.compares.length + walkClaims.dropped.length > 0;
+	if (composing) {
+		dropComparatives(tokens, walkClaims.dropped);
+		for (const t of tokens) {
+			if (t.used || !CONNECTIVES.has(t.text)) continue;
+			t.used = true;
+			walkClaims.dropped.push({
+				span: t.text,
+				reason: `"${t.text}" is not composed: walk clauses are read as all applying together`,
+				kind: "filter"
+			});
+		}
+	}
 	const fieldAliases = {
 		...BUILTIN_FIELD_ALIASES,
 		...rulings.fieldAliases ?? {}
@@ -411,6 +1317,12 @@ function parseQuestion(question, pack, ctx) {
 			detail: ctx.forceType
 		});
 	}
+	if (composing && ctx.forceType === void 0 && mentioned.size > 0) {
+		const reached = new Set(walkClaims.phrases.map((p) => p.type));
+		const byPosition = [...mentioned].sort(([, x], [, y]) => x.at[0] - y.at[0]).map(([t]) => t);
+		const seeds = byPosition.filter((t) => !reached.has(t));
+		types = (seeds.length > 0 ? seeds : byPosition.slice(0, 1)).sort();
+	}
 	if (types.length === 0 && ids.length > 0 && ctx.defaultIdType !== void 0) types = [ctx.defaultIdType];
 	if (types.length === 0 && values.length > 0) {
 		types = typesCovering(pack, values);
@@ -442,7 +1354,30 @@ function parseQuestion(question, pack, ctx) {
 	const candidates = [];
 	const ruledOut = [];
 	for (const type of types) {
+		let composed;
+		if (composing) {
+			const r = compose({
+				pack,
+				rulings,
+				seed: type,
+				claims: walkClaims,
+				mentions: [...mentioned].map(([t, m]) => ({
+					type: t,
+					span: m.span,
+					at: m.at
+				})),
+				time
+			});
+			if ("clarify" in r) return {
+				status: "clarify",
+				candidates: [],
+				residual: [],
+				reason: r.clarify
+			};
+			composed = r;
+		}
 		const c = assemble(type, {
+			composed,
 			pack,
 			ctx,
 			tokens: tokens.map((t) => ({ ...t })),
@@ -450,7 +1385,7 @@ function parseQuestion(question, pack, ctx) {
 			ids,
 			values,
 			clauses,
-			time,
+			time: composed === void 0 || composed.timeOnSeed ? time : null,
 			order,
 			count,
 			allProjects,
@@ -481,6 +1416,12 @@ function parseQuestion(question, pack, ctx) {
 		reason: `${candidates.length} readings`
 	};
 	const only = candidates[0];
+	if (only.dropped.length > 0) return {
+		status: "partial",
+		candidates,
+		residual: only.residual,
+		reason: `dropped: ${only.dropped.map((d) => `"${d.span}" (${d.reason})`).join("; ")}`
+	};
 	if (only.residual.length > 0 && ids.length === 0) return {
 		status: "partial",
 		candidates,
@@ -499,8 +1440,25 @@ function assemble(type, a) {
 	const rulings = ctx.rulings ?? {};
 	const fields = own(pack.types, type)?.fields ?? {};
 	const words = tokens.map((t) => t.text);
-	const ev = [...a.evidence];
+	const seedLatest = a.composed?.seedLatest;
+	const evidence = a.order === null && seedLatest !== void 0 ? [...a.evidence, {
+		span: seedLatest,
+		role: "order",
+		detail: "desc, limit 1"
+	}] : a.evidence;
+	const recency = a.order ?? (seedLatest !== void 0 ? "desc" : null);
+	const conflict = a.composed?.params.orderBy !== void 0 && recency !== null;
+	const order = conflict ? null : recency;
+	const orderSpan = evidence.find((e) => e.role === "order")?.span ?? "";
+	const ev = conflict ? evidence.filter((e) => e.role !== "order") : [...evidence];
+	const dropped = [...a.composed?.dropped ?? [], ...conflict ? [{
+		span: orderSpan,
+		reason: "it conflicts with the derived ordering, which is kept",
+		kind: "order"
+	}] : []];
 	const where = [];
+	const wherePlan = /* @__PURE__ */ new Map();
+	const yields = [];
 	if (a.ids.length > 0) where.push({ shortId: a.ids.length === 1 ? { eq: a.ids[0] } : { in: a.ids } });
 	const byField = /* @__PURE__ */ new Map();
 	const usedFields = /* @__PURE__ */ new Set();
@@ -575,19 +1533,46 @@ function assemble(type, a) {
 	}
 	const historical = a.historyWord || a.time !== null || a.closeVerb || terminal;
 	if (a.time !== null) {
-		const dateField = Object.entries(fields).find(([, f]) => f.valueType === "date" && f.kind !== "metadata" && creditFieldWords(tokens, f))?.[0] ?? (a.closeVerb || a.updateVerb ? "updatedAt" : own(rulings.timeField, type) ?? "createdAt");
-		where.push({ [dateField]: {
+		const named = Object.entries(fields).find(([, f]) => f.valueType === "date" && f.kind !== "metadata" && creditFieldWords(tokens, f));
+		const dateField = named?.[0] ?? (a.closeVerb || a.updateVerb ? "updatedAt" : own(rulings.timeField, type) ?? "createdAt");
+		const clause = { [dateField]: {
 			gte: a.time.range.gte,
 			lt: a.time.range.lt
-		} });
+		} };
+		where.push(clause);
+		if (a.composed !== void 0) {
+			const ruled = named !== void 0 || a.closeVerb || a.updateVerb || own(rulings.timeField, type) !== void 0;
+			wherePlan.set(clause, [{
+				path: [dateField, `window:${a.time.span}${ruled ? "" : ` on ${dateField} (default)`}`],
+				kind: "filter",
+				served: false
+			}]);
+		}
 	}
 	if (a.ids.length === 0) {
+		const excluded = own(rulings.typeExcludes, type);
+		if (excluded !== void 0) {
+			const tested = [];
+			whereFields(excluded, tested);
+			const named = [...usedFields];
+			for (const p of a.composed?.parts ?? []) whereFields(p.clause, named);
+			const yieldTo = tested.find((f) => named.includes(f));
+			if (yieldTo === void 0) {
+				const clause = { NOT: excluded };
+				where.push(clause);
+				wherePlan.set(clause, [{
+					path: ["NOT", `ruling:${type} default exclude`],
+					kind: "filter",
+					served: false
+				}]);
+			} else yields.push(defaultYield(type, yieldTo));
+		}
 		const statusField = fields.status;
 		const live = own(rulings.liveStatus, type);
 		if (a.closeVerb && statusField?.enum !== void 0 && !byField.has("status")) {
 			const closed = statusField.enum.filter((s) => CLOSED.includes(s));
 			if (closed.length > 0) where.push({ status: { in: closed } });
-		} else if (!historical && live !== void 0 && statusField?.enum?.includes(live) === true && !usedFields.has("status") && a.order === null) where.push({ status: { eq: live } });
+		} else if (!historical && live !== void 0 && statusField?.enum?.includes(live) === true && !usedFields.has("status") && order === null) where.push({ status: { eq: live } });
 		if (!historical && fields.archived !== void 0) where.push({ archived: { eq: false } });
 		else if (historical) ev.push({
 			span: "(history)",
@@ -607,19 +1592,36 @@ function assemble(type, a) {
 		}
 	}
 	const params = {};
-	if (where.length === 1) params.where = where[0];
-	else if (where.length > 1) params.where = { AND: where };
-	if (a.order !== null) {
-		params.orderBy = [{ createdAt: a.order }];
+	const parts = [...where.map((clause) => ({
+		clause,
+		plan: wherePlan.get(clause) ?? []
+	})), ...a.composed?.parts ?? []];
+	const all = andOf(parts);
+	if (all !== null) params.where = all.where;
+	const plan = [
+		...(all?.plan ?? []).map((c) => ({
+			...c,
+			path: ["where", ...c.path]
+		})),
+		...yields,
+		...a.composed?.plan ?? []
+	];
+	if (order !== null) {
+		params.orderBy = [{ [own(rulings.timeField, type) ?? "createdAt"]: order }];
 		params.limit = 1;
 	}
-	const answer = a.askField !== null ? a.askField.group ? `group:${a.askField.field}` : `field:${a.askField.field}` : a.count ? "count" : a.order !== null || a.ids.length === 1 ? "single" : "rows";
+	Object.assign(params, a.composed?.params ?? {});
+	if (a.count && a.composed?.walked === true) params.count = true;
+	const answer = a.askField !== null ? a.askField.group ? `group:${a.askField.field}` : `field:${a.askField.field}` : a.count ? "count" : order !== null || a.ids.length === 1 ? "single" : "rows";
 	return {
 		type,
 		frame: { [`${pack.namespace}/${type}`]: { params } },
 		answer,
 		evidence: ev,
-		residual: contentWords(tokens)
+		residual: contentWords(tokens),
+		plan,
+		dropped,
+		strict: a.count || order !== null || a.ids.length === 1 || a.composed?.strict === true
 	};
 }
 /** A clause's field name: the field itself, case-insensitively, then the rulings' and built-in aliases. */
@@ -666,7 +1668,16 @@ function creditFieldWords(tokens, field) {
 	return hit;
 }
 function contentWords(tokens) {
-	return tokens.filter((t) => !t.used && !GLUE.has(t.text) && !/^\d+$/.test(t.text)).map((t) => t.text);
+	const free = (t) => t !== void 0 && !t.used && !GLUE.has(t.text);
+	const num = (t) => free(t) && /^\d+$/.test(t.text);
+	const out = [];
+	tokens.forEach((t, i) => {
+		if (!free(t) || num(t)) return;
+		const before = num(tokens[i - 1]) ? `${tokens[i - 1]?.text} ` : "";
+		const after = num(tokens[i + 1]) && !(free(tokens[i + 2]) && !num(tokens[i + 2])) ? ` ${tokens[i + 1]?.text}` : "";
+		out.push(`${before}${t.text}${after}`);
+	});
+	return out;
 }
 /** Claims the longest n-grams (up to `max` words) for which `accept` returns true. */
 function claimNgrams(tokens, max, accept) {
@@ -739,13 +1750,14 @@ function pickField(candidates, fields, words) {
 }
 function claimTime(tokens, asOf) {
 	let found = null;
-	claimNgrams(tokens, 3, (key) => {
+	claimNgrams(tokens, 3, (key, at) => {
 		if (found !== null) return false;
 		const range = rangeFor(key, asOf);
 		if (range === null) return false;
 		found = {
 			span: key,
-			range
+			range,
+			at: [at[0], at[at.length - 1]]
 		};
 		return true;
 	});
@@ -930,18 +1942,50 @@ async function parseWithJudge(question, pack, ctx, judge, opts = {}) {
 		} };
 		trail.push(step);
 		const prompt = buildJudgePrompt(question, result, pack, context.rulings, rejected);
-		const checked = checkChoice(await judge.decide(prompt, opts.signal), prompt);
+		const reply = await judge.decide(prompt, opts.signal);
+		const checked = checkChoice(reply, prompt);
 		if (typeof checked === "string") {
 			step.rejected = checked;
 			break;
 		}
 		step.choice = checked;
+		const extra = Object.keys(reply).filter((k) => !Object.hasOwn(checked, k));
+		if (extra.length > 0) step.ignored = extra.sort();
 		switch (checked.action) {
-			case "pick": return {
-				status: "resolved",
-				candidate: result.candidates[checked.candidate],
-				trail
-			};
+			case "pick": {
+				const chosen = result.candidates[checked.candidate];
+				if (chosen.dropped.length > 0) {
+					const reason = `dropped: ${chosen.dropped.map((d) => `"${d.span}" (${d.reason})`).join("; ")}`;
+					return {
+						status: "escalated",
+						result: {
+							status: "partial",
+							candidates: [chosen],
+							residual: chosen.residual,
+							reason
+						},
+						trail
+					};
+				}
+				if (chosen.strict && chosen.residual.length > 0) {
+					const reason = `unexplained under a strict reading: ${chosen.residual.join(", ")}`;
+					return {
+						status: "escalated",
+						result: {
+							status: "partial",
+							candidates: [chosen],
+							residual: chosen.residual,
+							reason
+						},
+						trail
+					};
+				}
+				return {
+					status: "resolved",
+					candidate: chosen,
+					trail
+				};
+			}
 			case "recall": return {
 				status: "recall",
 				query: question,
@@ -997,28 +2041,92 @@ async function parseWithJudge(question, pack, ctx, judge, opts = {}) {
 //#endregion
 //#region src/ask/run.ts
 const RECALL_K = 10;
-/** The frame a candidate needs to run: its params plus every projectable field of its type. */
-function executable(c, pack) {
+/**
+* The frame a candidate needs to run. A count is the server's `count: true`
+* over the reading's where; `paged` is the rows frame with every projectable
+* field, which a count falls back to when the server cannot count.
+*/
+function executable(c, pack, paged = c.answer !== "count") {
 	const [key, value] = Object.entries(c.frame)[0];
+	const { count: _count, ...params } = value.params;
+	if (!paged) {
+		const { orderBy: _o, limit: _l, derive: _d, ...counted } = params;
+		return { [key]: {
+			params: {
+				...counted,
+				count: true
+			},
+			fields: { id: true }
+		} };
+	}
 	const fields = { id: true };
 	for (const [name, f] of Object.entries(own(pack.types, c.type)?.fields ?? {})) if (f.kind !== "metadata") fields[name] = true;
 	return { [key]: {
-		params: value.params,
+		params,
 		fields
 	} };
 }
-async function rows(c, source, http, deps, handoff) {
-	const frame = executable(c, deps.pack);
+/**
+* The engine refused `count: true`: the seed is under a row policy, or the
+* store (memory, legacy-layout pg) answers no walk grammar. A plain paged read
+* works in every case.
+*/
+const COUNT_REFUSED = /* @__PURE__ */ new Set([
+	ROW_POLICY_BLOCKS_WALK,
+	WALKS_UNSUPPORTED_STORE,
+	WALKS_NEED_PARTITIONED
+]);
+/**
+* The parser's plan with the engine's `served`/`recommend` where the engine
+* planned the same clause (matched by path: the engine's path is a prefix of
+* the parser's labelled one, or, for a NOT, extends it). Parser-only clauses
+* keep their entries; engine-only clauses are appended.
+*/
+function mergePlan(parsed, engine) {
+	if (engine === void 0) return parsed;
+	const kindOf = (c) => c.kind === "derive" && c.path[0] === "orderBy" ? "order" : c.kind;
+	const prefix = (a, b) => a.length <= b.length && a.every((x, i) => x === b[i]);
+	const used = /* @__PURE__ */ new Set();
+	return [...parsed.map((p) => {
+		const same = engine.filter((e) => kindOf(e) === kindOf(p));
+		const under = same.filter((e) => prefix(e.path, p.path)).sort((x, y) => y.path.length - x.path.length);
+		const matches = under.length > 0 ? [under[0]] : same.filter((e) => prefix(p.path.slice(0, -1), e.path));
+		if (matches.length === 0) return p;
+		for (const m of matches) used.add(m);
+		const { recommend: _r, ...rest } = p;
+		const recommend = matches.find((m) => !m.served)?.recommend;
+		return {
+			...rest,
+			served: matches.every((m) => m.served),
+			...recommend !== void 0 ? { recommend } : {}
+		};
+	}), ...engine.filter((e) => !used.has(e))];
+}
+async function rows(c, source, question, http, deps, handoff, leftovers = []) {
+	const dropped = [...c.dropped, ...leftovers];
+	if (c.strict && dropped.some((d) => d.kind === "filter")) return {
+		kind: "unknown",
+		question,
+		dropped,
+		plan: c.plan
+	};
+	let frame = executable(c, deps.pack);
 	const key = Object.keys(frame)[0];
-	const env = await deps.engine.query(frame, http);
+	let env = await deps.engine.query(frame, http);
+	const refused = (env.errors ?? []).some((e) => COUNT_REFUSED.has(e.code ?? ""));
+	const paging = c.answer === "count" && !(key in (env.data ?? {})) && refused;
+	if (paging) {
+		frame = executable(c, deps.pack, true);
+		env = await deps.engine.query(frame, http);
+	}
 	const data = env.data !== void 0 && key in env.data ? env.data?.[key] : void 0;
 	const errors = [...env.errors ?? []];
 	let count;
-	if (c.answer === "count" && Array.isArray(data)) {
+	if (paging && Array.isArray(data)) {
 		const counted = await countRest(frame, key, data.length, env, http, deps);
 		if (typeof counted === "number") count = counted;
 		else errors.push(counted);
-	}
+	} else if (c.answer === "count" && typeof data?.count === "number") count = data.count;
 	return {
 		kind: "rows",
 		frame,
@@ -1027,7 +2135,9 @@ async function rows(c, source, http, deps, handoff) {
 		...count !== void 0 ? { count } : {},
 		...errors.length > 0 ? { errors } : {},
 		source,
-		...handoff !== void 0 ? { handoff } : {}
+		...handoff !== void 0 ? { handoff } : {},
+		dropped,
+		plan: mergePlan(c.plan, env._diagnostics?.[key]?.plan)
 	};
 }
 const MAX_COUNT_PAGES = 1e3;
@@ -1122,14 +2232,28 @@ async function* runAsk(req, http, deps) {
 		...first.reason !== void 0 ? { reason: first.reason } : {}
 	};
 	if (isAborted(http)) return yield { event: "done" };
+	/**
+	* No judge decided: the parser's reading runs as it stands. Its unexplained
+	* words are dropped, so a strict reading with any is `unknown`, never a number.
+	*/
+	const handoff = async (reason, parsed = first) => {
+		const best = parsed.candidates[0];
+		if (best === void 0) return clarify(req.question, reason, parsed.candidates, deps.pack);
+		const leftovers = best.residual.map((w) => ({
+			span: w,
+			reason: `not understood (${reason})`,
+			kind: "filter"
+		}));
+		return rows(best, "handoff", req.question, http, deps, reason, leftovers);
+	};
 	let outcome;
-	if (first.status === "resolved" && best !== void 0) outcome = await rows(best, "parser", http, deps);
+	if (first.status === "resolved" && best !== void 0) outcome = await rows(best, "parser", req.question, http, deps);
 	else if (first.status === "refuse") outcome = {
 		kind: "refuse",
 		reason: first.reason ?? "refused"
 	};
 	else if (first.status === "clarify") outcome = clarify(req.question, first.reason ?? "which did you mean?", first.candidates, deps.pack);
-	else if (deps.judge === void 0) outcome = best !== void 0 ? await rows(best, "handoff", http, deps, "judge not configured") : clarify(req.question, "judge not configured", first.candidates, deps.pack);
+	else if (deps.judge === void 0) outcome = await handoff("judge not configured");
 	else {
 		yield {
 			event: "judging",
@@ -1171,7 +2295,7 @@ async function* runAsk(req, http, deps) {
 			http.signal?.removeEventListener("abort", onAbort);
 		}
 		if (isAborted(http)) return yield { event: "done" };
-		if (judged === void 0) outcome = best !== void 0 ? await rows(best, "handoff", http, deps, "judge unavailable") : clarify(req.question, "judge unavailable", first.candidates, deps.pack);
+		if (judged === void 0) outcome = await handoff("judge unavailable");
 		else {
 			yield {
 				event: "judged",
@@ -1179,9 +2303,15 @@ async function* runAsk(req, http, deps) {
 				trail: judged.trail
 			};
 			switch (judged.status) {
-				case "resolved":
-					outcome = await rows(judged.candidate, "judge", http, deps);
+				case "resolved": {
+					const noise = judged.candidate.residual.map((w) => ({
+						span: w,
+						reason: "judge: noise",
+						kind: "filter"
+					}));
+					outcome = await rows(judged.candidate, "judge", req.question, http, deps, void 0, noise);
 					break;
+				}
 				case "recall":
 					outcome = await recall(judged.query, deps.pack.namespace, ctx.forceType ?? judged.type, http, deps);
 					break;
@@ -1194,7 +2324,7 @@ async function* runAsk(req, http, deps) {
 				case "clarify":
 					outcome = clarify(req.question, judged.reason, first.candidates, deps.pack);
 					break;
-				case "escalated": outcome = best !== void 0 ? await rows(best, "handoff", http, deps, "judge could not decide") : clarify(req.question, "judge could not decide", first.candidates, deps.pack);
+				case "escalated": outcome = await handoff("judge could not decide", judged.result.candidates.length > 0 ? judged.result : first);
 			}
 		}
 	}
@@ -1252,63 +2382,6 @@ var OllamaJudge = class {
 	}
 };
 
-//#endregion
-//#region src/rulings/schema.ts
-const ValueAliasSchema = z.object({
-	type: z.string().min(1),
-	field: z.string().min(1),
-	in: z.array(z.string()).optional(),
-	eq: z.string().optional(),
-	startsWith: z.string().optional(),
-	contains: z.string().optional()
-}).strict().refine((v) => [
-	v.in,
-	v.eq,
-	v.startsWith,
-	v.contains
-].filter((x) => x !== void 0).length === 1, { message: "a value alias names exactly one of in, eq, startsWith, contains" });
-const record = z.record(z.string(), z.string());
-const NamespaceRulingsSchema = z.object({
-	unscopedTypes: z.array(z.string()).optional(),
-	typeAliases: record.optional(),
-	fieldAliases: record.optional(),
-	liveStatus: record.optional(),
-	timeField: record.optional(),
-	typeNotes: record.optional(),
-	valueAliases: z.record(z.string(), z.array(ValueAliasSchema)).optional()
-}).strict();
-/** Per top-level key: records merge entry-by-entry (override wins), arrays replace. */
-function mergeRulings(declared, override) {
-	if (override === void 0) return declared;
-	const out = { ...declared };
-	for (const [key, value] of Object.entries(override)) {
-		const prior = out[key];
-		out[key] = Array.isArray(value) || prior === void 0 || Array.isArray(prior) ? value : {
-			...prior,
-			...value
-		};
-	}
-	return out;
-}
-/** The effective rulings for one namespace's schema, plus anything that was dropped. */
-function readRulings(schema, override) {
-	const warnings = [];
-	let declared = {};
-	const raw = schema.annotations?.nl;
-	if (raw !== void 0) {
-		const parsed = NamespaceRulingsSchema.safeParse(raw);
-		if (parsed.success) declared = parsed.data;
-		else {
-			const where = parsed.error.issues.map((i) => i.path.join(".") || "(root)").join(", ");
-			warnings.push(`declared rulings are invalid and were ignored (${where})`);
-		}
-	}
-	return {
-		rulings: mergeRulings(declared, override),
-		warnings
-	};
-}
-
 //#endregion
 //#region src/pack/build.ts
 /** Longest value worth matching as a whole phrase. */
@@ -1422,8 +2495,11 @@ function packField(name, def, operators) {
 		case "crossRef": return {
 			name,
 			kind: "crossRef",
-			target: def.type,
-			indexed: def.indexed === true,
+			target: {
+				namespace: def.ns,
+				type: def.type
+			},
+			indexed: def.indexed !== false,
 			operators: [...operators.crossRef ?? []],
 			phrases
 		};
@@ -1859,4 +2935,4 @@ const bootstrap = defineBootstrap.kernel({
 });
 
 //#endregion
-export { askHandler as a, profileNamespace as c, mergeRulings as d, readRulings as f, parseQuestion as g, parseWithJudge as h, createNlPlugin as i, buildNamespacePack as l, runAsk as m, bootstrap as n, packHandler as o, OllamaJudge as p, CONTRACT_VERSION as r, PackService as s, NlBootstrapConfigSchema as t, NamespaceRulingsSchema as u };
+export { askHandler as a, profileNamespace as c, runAsk as d, parseWithJudge as f, readRulings as g, mergeRulings as h, createNlPlugin as i, buildNamespacePack as l, NamespaceRulingsSchema as m, bootstrap as n, packHandler as o, parseQuestion as p, CONTRACT_VERSION as r, PackService as s, NlBootstrapConfigSchema as t, OllamaJudge as u };