@burdenoff/fe-libs 2026.1009.2 → 2026.1010.1

package/dist/shared/assistant/localeCommands/evaluate.js

@@ -0,0 +1,180 @@
+import { planWriteReply as e } from "../writeReplySend.js";
+import { COMMAND_FAMILIES as t } from "./types.js";
+import { allOnManifest as n } from "./gate.js";
+import { matchLocalUiCommand as r } from "../localUiCommands.js";
+import { offerAssentFor as i } from "./assent.js";
+import { EMPTY_CONTROL_SNAPSHOT as a } from "../appControls/snapshot.js";
+//#region src/shared/assistant/localeCommands/evaluate.ts
+var o = (e) => e.id;
+function s(e) {
+	if (!e) return;
+	let t = { ...a.registered };
+	for (let n of e.registered ?? []) t[n] = !0;
+	let n = e.page ? {
+		name: e.page.name ?? "Page",
+		tabs: e.page.tabs ?? [],
+		filters: e.page.filters ?? [],
+		sorts: e.page.sorts ?? [],
+		searchable: e.page.searchable ?? !1,
+		openers: e.page.openers ?? []
+	} : null;
+	return {
+		...a,
+		registered: t,
+		languages: e.languages ?? [],
+		sidebarEntries: e.sidebarEntries ?? [],
+		page: n
+	};
+}
+function c(e) {
+	if (!e) return null;
+	let t = e.links ?? [], n = e.list, r = new Set(e.offered ?? []);
+	return {
+		links: {
+			targets: [...t],
+			unresolved: e.unresolved ?? 0
+		},
+		pendingChoice: n ? {
+			candidates: n.map((e) => t.find((t) => t.id === e) ?? null),
+			candidateIds: [...n]
+		} : null,
+		...r.size > 0 ? { offers: t.filter((e) => r.has(e.id)).map((e) => ({
+			path: e.path,
+			offerId: `uo_${e.id.padEnd(32, "0").slice(0, 32)}`
+		})) } : {}
+	};
+}
+function l(e) {
+	if (!e) return { result: "model" };
+	switch (e.kind) {
+		case "navigate": return {
+			result: "command",
+			kind: "navigate",
+			destinationId: e.destination.id,
+			...e.via ? { via: e.via } : {},
+			...e.via === "offer" ? { trigger: e.trigger } : {}
+		};
+		case "choose-destination":
+		case "choose-linked": return {
+			result: "command",
+			kind: e.kind,
+			candidateIds: e.candidates.map(o)
+		};
+		case "theme": return {
+			result: "command",
+			kind: "theme",
+			family: e.request.kind === "family" ? e.request.family : e.request.theme
+		};
+		case "app-control": return {
+			result: "command",
+			kind: "app-control",
+			control: e.request.control,
+			request: e.request
+		};
+		case "pick-from-list": return {
+			result: "command",
+			kind: "pick-from-list"
+		};
+		default: return {
+			result: "command",
+			kind: e.kind
+		};
+	}
+}
+function u(t, n) {
+	let a = t.inputLocale ?? t.uiLocale, o = t.origin === "spoken", u = o ? a : t.uiLocale;
+	if (t.yes) {
+		let r = t.yes, s = e({
+			text: t.text,
+			locale: u,
+			origin: o ? "spoken" : "typed",
+			hasAttachments: r.attachments === !0,
+			live: {
+				count: r.pending ?? 0,
+				execution: "enabled"
+			},
+			matchesLocalCommand: () => !1,
+			offer: r.offer ?? "none",
+			offerAssent: i({
+				text: t.text,
+				uiLocale: t.uiLocale,
+				inputLocale: a,
+				manifest: n,
+				leaveGuard: r.leaveGuard === !0
+			})
+		});
+		return s.kind === "accept_offer" ? {
+			result: "command",
+			kind: "accept_offer"
+		} : s.kind === "local_reply" ? {
+			result: "model",
+			plannedAs: "local_reply"
+		} : { result: "model" };
+	}
+	let d = s(t.controls), f = c(t.navigation), p = {
+		...t.backRunnable === void 0 ? {} : { backRunnable: t.backRunnable },
+		...f ? { navigation: f } : {},
+		...d ? { controls: d } : {}
+	};
+	return l(r(t.text, t.sidebar ?? [], {
+		locale: u,
+		uiLocale: t.uiLocale,
+		inputLocale: a,
+		commandManifest: n,
+		...t.themeWords ? { themeWords: t.themeWords } : {}
+	}, p));
+}
+function d(e, t) {
+	return typeof t == "string" ? e.result === t : Object.entries(t).every(([t, n]) => {
+		let r = e[t];
+		return JSON.stringify(r) === JSON.stringify(n);
+	});
+}
+function f(e, t) {
+	return t === void 0 ? "unscored" : (typeof t == "string" ? t === "model" : t.result === "model") ? e.result === "model" ? "pass" : "false-match" : e.result === "model" ? "miss" : d(e, t) ? "pass" : "wrong";
+}
+function p(e, t = n()) {
+	let r = u(e, t);
+	return {
+		id: e.id,
+		locale: e.uiLocale.toLowerCase().split(/[-_]/)[0] ?? e.uiLocale,
+		family: e.family ?? "unlabelled",
+		actual: r,
+		...e.expected === void 0 ? {} : { expected: e.expected },
+		verdict: f(r, e.expected)
+	};
+}
+function m(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		if (n.verdict === "unscored") continue;
+		let e = `${n.locale}\u0000${n.family}`, r = t.get(e) ?? {
+			locale: n.locale,
+			family: n.family,
+			items: 0,
+			positives: 0,
+			negatives: 0,
+			truePositives: 0,
+			misses: 0,
+			wrong: 0,
+			falseMatches: 0,
+			precision: null,
+			recall: null
+		};
+		r.items += 1;
+		let i = typeof n.expected == "string" ? n.expected === "model" : n.expected?.result === "model";
+		i ? r.negatives += 1 : r.positives += 1, n.verdict === "pass" && !i && (r.truePositives += 1), n.verdict === "miss" && (r.misses += 1), n.verdict === "wrong" && (r.wrong += 1), n.verdict === "false-match" && (r.falseMatches += 1), t.set(e, r);
+	}
+	return [...t.values()].map((e) => {
+		let t = e.falseMatches + e.wrong, n = e.truePositives + t;
+		return {
+			...e,
+			falseMatches: t,
+			precision: n === 0 ? null : e.truePositives / n,
+			recall: e.positives === 0 ? null : e.truePositives / e.positives
+		};
+	}).sort((e, t) => `${e.locale}${e.family}`.localeCompare(`${t.locale}${t.family}`));
+}
+var h = [...t];
+//#endregion
+export { h as EVAL_FAMILIES, u as actualOf, l as describeCommand, p as evaluateCommandItem, m as scoreboard, f as verdictOf };

package/dist/shared/assistant/localeCommands/fold.d.ts

@@ -0,0 +1,17 @@
+import { CommandLocale } from './types';
+/**
+ * The fold: lower-case, punctuation-free, single-spaced — and, for `zh`, with no
+ * space at all. Idempotent.
+ */
+export declare function foldText(text: string, locale: CommandLocale | "en"): string;
+/** One word of a sentence, as said and as folded (a word may fold to several, or to none). */
+export interface FoldedWord {
+    said: string;
+    folded: string[];
+}
+/**
+ * The sentence split at its spaces, each word with its folded form(s), so a
+ * free-text slot can hand back the person's OWN words (case, inner
+ * punctuation) rather than the fold of them.
+ */
+export declare function foldWords(text: string, locale: CommandLocale | "en"): FoldedWord[];

package/dist/shared/assistant/localeCommands/fold.js

@@ -0,0 +1,66 @@
+//#region src/shared/assistant/localeCommands/fold.ts
+var e = /\p{Cf}/gu, t = [
+	1632,
+	1776,
+	2406,
+	3046
+];
+function n(e) {
+	return e.replace(/\p{Nd}/gu, (e) => {
+		let n = e.codePointAt(0) ?? 0;
+		for (let e of t) if (n >= e && n <= e + 9) return String(n - e);
+		return e;
+	});
+}
+var r = /़/g, i = /ँ/g, a = [
+	[/ङ्(?=[क-घ])/g, "ं"],
+	[/ञ्(?=[च-झ])/g, "ं"],
+	[/ण्(?=[ट-ढ])/g, "ं"],
+	[/न्(?=[त-ध])/g, "ं"],
+	[/म्(?=[प-भ])/g, "ं"]
+];
+function o(e) {
+	let t = e.replace(r, "").replace(i, "ं");
+	for (let [e, n] of a) t = t.replace(e, n);
+	return t;
+}
+var s = /[ً-ٰٟـ]/g, c = [
+	[/[أإآٱ]/g, "ا"],
+	[/ى/g, "ي"],
+	[/ة/g, "ه"],
+	[/ؤ/g, "و"],
+	[/ئ/g, "ي"],
+	[/ی/g, "ي"],
+	[/ک/g, "ك"]
+];
+function l(e) {
+	let t = e.replace(s, "");
+	for (let [e, n] of c) t = t.replace(e, n);
+	return t;
+}
+function u(e) {
+	return e.replace(/\p{Script=Latin}\p{M}*/gu, (e) => {
+		let t = e.normalize("NFC");
+		return t === "ñ" ? t : e.normalize("NFD").replace(/[̀-ͯ]/g, "");
+	});
+}
+var d = {
+	en: (e) => e,
+	hi: o,
+	ta: (e) => e,
+	ar: l,
+	es: u,
+	zh: (e) => e
+};
+function f(t, r) {
+	let i = n(t.normalize("NFKC").replace(e, "").toLowerCase().normalize("NFKC")), a = d[r](i).replace(/&/g, " and ").replace(/[^\p{L}\p{N}\p{M}\s]/gu, " ").replace(/\s+/g, " ").trim();
+	return r === "zh" ? a.replace(/\s+/g, "") : a;
+}
+function p(t, n) {
+	return t.normalize("NFKC").replace(e, "").split(/\s+/).filter(Boolean).map((e) => ({
+		said: e.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ""),
+		folded: f(e, n).split(" ").filter(Boolean)
+	}));
+}
+//#endregion
+export { f as foldText, p as foldWords };

package/dist/shared/assistant/localeCommands/frames.d.ts

@@ -0,0 +1,23 @@
+import { CommandLocale } from './types';
+/** The words a closed slot may be: a map from the FOLDED word to its value. */
+export type ClosedSlots = Readonly<Record<string, ReadonlyMap<string, string | number>>>;
+/** What a template captured: slot name → folded text. */
+export type Captures = Readonly<Record<string, string>>;
+export interface CompiledFrame {
+    readonly template: string;
+    /** Lazy then greedy; identical when the template has no open slot. */
+    readonly expressions: readonly RegExp[];
+    readonly slots: readonly string[];
+}
+/** Compile a template for `locale`. Throws on a malformed template (a table bug). */
+export declare function compileFrame(template: string, locale: CommandLocale | "en", closed?: ClosedSlots): CompiledFrame;
+/** Every distinct parse of the whole folded utterance by this frame. */
+export declare function matchFrame(frame: CompiledFrame, folded: string): Captures[];
+/** A map from folded word to value, for a closed slot. */
+export declare function closedSlot(entries: ReadonlyArray<readonly [readonly string[], string | number]>, locale: CommandLocale | "en"): ReadonlyMap<string, string | number>;
+/**
+ * Every sentence a template can say, with each slot filled from `slots` (a
+ * closed slot may be left out: its table words are used). For the tests and the
+ * evaluation harness — the engine never enumerates, it matches.
+ */
+export declare function expandTemplate(template: string, locale: CommandLocale | "en", slots: Readonly<Record<string, readonly string[]>>, closed?: ClosedSlots): string[];

package/dist/shared/assistant/localeCommands/frames.js

@@ -0,0 +1,150 @@
+import { foldText as e } from "./fold.js";
+//#region src/shared/assistant/localeCommands/frames.ts
+var t = new Set([
+	"x",
+	"q",
+	"lang"
+]), n = new Set([
+	"p",
+	"o",
+	"n",
+	"d"
+]), r = 6, i = 12, a = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function o(t, n) {
+	let r = 0, i = (a) => {
+		let o = [[]], s = "", c = () => {
+			if (!s) return;
+			let t = e(s, n);
+			if (s = "", !t) return;
+			let r = o[o.length - 1];
+			for (let e of t.split(" ")) r.push({
+				type: "lit",
+				text: e
+			});
+		};
+		for (; r < t.length;) {
+			let e = t.charAt(r);
+			if (a !== null && e === a) return c(), o;
+			let n = o[o.length - 1];
+			if (e === " ") c(), r += 1;
+			else if (e === "(") {
+				c(), r += 1;
+				let e = i(")");
+				if (r += 1, e.some((e) => e.length === 0)) throw Error(`empty alternative in template "${t}"`);
+				n.push({
+					type: "alt",
+					options: e
+				});
+			} else if (e === "[") {
+				c(), r += 1;
+				let e = i("]");
+				r += 1;
+				let [a, ...o] = e;
+				if (o.length > 0 || !a || a.length === 0) throw Error(`bad optional group in template "${t}"`);
+				n.push({
+					type: "opt",
+					seq: a
+				});
+			} else if (e === "{") {
+				c();
+				let e = t.indexOf("}", r);
+				if (e < 0) throw Error(`unclosed slot in template "${t}"`);
+				n.push({
+					type: "slot",
+					name: t.slice(r + 1, e)
+				}), r = e + 1;
+			} else if (e === "|" && a === ")") c(), r += 1, o.push([]);
+			else if (e === "|" && a === "]") throw Error(`alternatives inside [ ] in template "${t}": use [(a|b)]`);
+			else s += e, r += 1;
+		}
+		if (a !== null) throw Error(`unclosed group in template "${t}"`);
+		return c(), o;
+	}, [a] = i(null);
+	return a ?? [];
+}
+function s(e, o) {
+	if (o.slots.add(e), n.has(e)) {
+		let t = [...o.closed[e]?.keys() ?? []].sort((e, t) => t.length - e.length);
+		if (t.length === 0) throw Error(`no words for the closed slot {${e}}`);
+		return `(?<${e}>${t.map(a).join("|")})`;
+	}
+	if (!t.has(e)) throw Error(`unknown slot {${e}}`);
+	let s = o.lazy ? "?" : "";
+	return e === "q" ? `(?<q>.+${s})` : o.zh ? `(?<${e}>.{1,${i}}${s})` : `(?<${e}>\\S+(?: \\S+){0,${r - 1}}${s})`;
+}
+function c(e, t) {
+	let n = "", r = !1;
+	for (let i of e) {
+		if (i.type === "opt") {
+			let e = c(i.seq, t);
+			n += r ? `(?:${t.sep}${e})?` : `(?:${e}${t.sep})?`;
+			continue;
+		}
+		let e;
+		if (i.type === "lit") e = a(i.text);
+		else if (i.type === "slot") e = s(i.name, t);
+		else {
+			let n = i.options.map((e) => c(e, t));
+			n.sort((e, t) => t.length - e.length), e = `(?:${n.join("|")})`;
+		}
+		n += (r ? t.sep : "") + e, r = !0;
+	}
+	return n;
+}
+function l(e, n, r = {}) {
+	let i = o(e, n), a = n === "zh", s = /* @__PURE__ */ new Set(), l = (e) => RegExp(`^${c(i, {
+		sep: a ? "" : " ",
+		lazy: e,
+		closed: r,
+		zh: a,
+		slots: s
+	})}$`, "u"), u = l(!0), d = l(!1);
+	return {
+		template: e,
+		expressions: [...s].some((e) => t.has(e)) ? [u, d] : [u],
+		slots: [...s]
+	};
+}
+function u(e, t) {
+	let n = [], r = /* @__PURE__ */ new Set();
+	for (let i of e.expressions) {
+		let e = i.exec(t);
+		if (!e) continue;
+		let a = {};
+		for (let [t, n] of Object.entries(e.groups ?? {})) typeof n == "string" && (a[t] = n);
+		let o = JSON.stringify(a);
+		r.has(o) || (r.add(o), n.push(a));
+	}
+	return n;
+}
+function d(t, n) {
+	let r = /* @__PURE__ */ new Map();
+	for (let [i, a] of t) for (let t of i) {
+		let i = e(t, n);
+		i && r.set(i, a);
+	}
+	return r;
+}
+var f = 2e4;
+function p(e, t, n, r = {}) {
+	let i = o(e, t), a = t === "zh" ? "" : " ", s = (t) => {
+		let i = n[t];
+		if (i) return i;
+		let a = r[t];
+		if (a) return [...a.keys()];
+		throw Error(`no values for slot {${t}} in "${e}"`);
+	}, c = (t) => {
+		let n = [""];
+		for (let r of t) {
+			let t;
+			t = r.type === "lit" ? [r.text] : r.type === "slot" ? [...s(r.name)] : r.type === "alt" ? r.options.flatMap((e) => c(e)) : ["", ...c(r.seq)];
+			let i = [];
+			for (let r of n) for (let n of t) if (i.push(r === "" ? n : n === "" ? r : `${r}${a}${n}`), i.length > f) throw Error(`too many expansions of "${e}"`);
+			n = i;
+		}
+		return n;
+	};
+	return c(i);
+}
+//#endregion
+export { d as closedSlot, l as compileFrame, p as expandTemplate, u as matchFrame };

package/dist/shared/assistant/localeCommands/gate.d.ts

@@ -0,0 +1,37 @@
+import { CommandFamily, CommandManifest, ManifestLocale } from './types';
+/**
+ * What the shipped build turns on: only the cells that passed the round-3 blind
+ * gate (0 false matches, recall over the floor; evidence in `frozen/`, report
+ * `audit/platform/assistant/2026-10-09-multilingual-commands/eval/round3.md`).
+ */
+export declare const COMMAND_MANIFEST: CommandManifest;
+/** The families each manifest locale can carry. `en` carries only the English additions. */
+export declare const MANIFEST_FAMILIES: Readonly<Record<ManifestLocale, readonly (CommandFamily | "frames")[]>>;
+/** Design §3.2 G4: the recall an entry needs to be enabled for go-to, there and yes. */
+export declare const RECALL_FLOOR = 0.6;
+/**
+ * A manifest with every entry on. For the evaluation harness and the tests
+ * ONLY: it carries no evidence on purpose, so `validateManifest` rejects it —
+ * it can never be mistaken for a shippable one.
+ */
+export declare function allOnManifest(): CommandManifest;
+/** A manifest with only the listed `locale:family` pairs on (tests, evaluation of one family). */
+export declare function manifestWith(on: readonly string[]): CommandManifest;
+/**
+ * The manifest a matcher actually uses for a caller-supplied one. Absent: the
+ * shipped manifest. One the evaluation builders made (the harness, the tests):
+ * as given. Anything else: only the cells that are ON in BOTH it and the
+ * shipped manifest, with the shipped entry's evidence, so a product may narrow
+ * what shipped but never widen it past the evidence.
+ */
+export declare function effectiveManifest(supplied: CommandManifest | undefined, shipped?: CommandManifest): CommandManifest;
+/** Is `family` of `locale` on in this manifest? */
+export declare function isEnabled(manifest: CommandManifest, locale: ManifestLocale, family: CommandFamily | "frames"): boolean;
+/** Does this locale have any family on? (A table with nothing on is not active.) */
+export declare function localeHasAnyOn(manifest: CommandManifest, locale: ManifestLocale): boolean;
+/**
+ * The evidence rule, as a list of problems (empty: the manifest may ship).
+ * `corpusShaOf` reads the sha256 of the frozen blind file an entry names, or
+ * null when that file does not exist.
+ */
+export declare function validateManifest(manifest: CommandManifest, corpusShaOf: (locale: ManifestLocale, family: CommandFamily | "frames") => string | null): string[];

package/dist/shared/assistant/localeCommands/gate.js

@@ -0,0 +1,137 @@
+import { COMMAND_FAMILIES as e, COMMAND_LOCALES as t } from "./types.js";
+//#region src/shared/assistant/localeCommands/gate.ts
+function n(e) {
+	return Object.freeze({
+		enabled: !0,
+		...e
+	});
+}
+var r = Object.freeze({
+	en: Object.freeze({}),
+	hi: Object.freeze({ language: n({
+		corpusSha256: "c15bed2eabee0fece15456f96923bd12abf3e6f8884619a8a90d2e9a99c0acac",
+		positives: 8,
+		negatives: 195,
+		falseMatches: 0,
+		recall: 1
+	}) }),
+	ta: Object.freeze({}),
+	ar: Object.freeze({
+		goto: n({
+			corpusSha256: "9c39b609525a616bcba5992f6a30279af8023bd478d2c3f5692bba9b668893be",
+			positives: 26,
+			negatives: 188,
+			falseMatches: 0,
+			recall: .769
+		}),
+		language: n({
+			corpusSha256: "86a23a6e8920558576fd2f73cb3504a766103b8b58d0255ff4a4b27ccff46414",
+			positives: 8,
+			negatives: 188,
+			falseMatches: 0,
+			recall: .75
+		})
+	}),
+	es: Object.freeze({
+		goto: n({
+			corpusSha256: "5b67ba87a2a69dd6ec656c8f1d76c65a001043059fc7b0d4d971e641b52f9746",
+			positives: 26,
+			negatives: 188,
+			falseMatches: 0,
+			recall: .769
+		}),
+		language: n({
+			corpusSha256: "9bc791353a258d3e22bf28f505b9b34065d9b24c5c657a69fc8ce5625e846d7d",
+			positives: 8,
+			negatives: 188,
+			falseMatches: 0,
+			recall: .625
+		})
+	}),
+	zh: Object.freeze({
+		goto: n({
+			corpusSha256: "94f7b5b11bfd843695674cd86840cb6b59be291c7c9dcdaa83ec9b12d5bc0d16",
+			positives: 26,
+			negatives: 188,
+			falseMatches: 0,
+			recall: .769
+		}),
+		language: n({
+			corpusSha256: "edefba601427357299751db7a0cebd603d8945d981c61fb663b0e958f30e00bb",
+			positives: 8,
+			negatives: 188,
+			falseMatches: 0,
+			recall: .875
+		})
+	})
+}), i = Object.freeze({
+	en: [
+		"frames",
+		"goto",
+		"language"
+	],
+	hi: e,
+	ta: e,
+	ar: e,
+	es: e,
+	zh: e
+}), a = .6, o = "0".repeat(64);
+function s() {
+	let e = (e) => Object.fromEntries(e.map((e) => [e, { enabled: !0 }]));
+	return u({
+		en: e(i.en),
+		hi: e(i.hi),
+		ta: e(i.ta),
+		ar: e(i.ar),
+		es: e(i.es),
+		zh: e(i.zh)
+	});
+}
+function c(e) {
+	let t = new Set(e), n = (e) => Object.fromEntries(i[e].filter((n) => t.has(`${e}:${n}`)).map((e) => [e, { enabled: !0 }]));
+	return u({
+		en: n("en"),
+		hi: n("hi"),
+		ta: n("ta"),
+		ar: n("ar"),
+		es: n("es"),
+		zh: n("zh")
+	});
+}
+var l = /* @__PURE__ */ new WeakSet();
+function u(e) {
+	let t = Object.freeze(e);
+	return l.add(t), t;
+}
+function d(e, t = r) {
+	if (!e || e === t) return t;
+	if (l.has(e)) return e;
+	let n = (n) => Object.fromEntries(Object.entries(t[n]).filter(([t, r]) => r?.enabled === !0 && e[n]?.[t]?.enabled === !0));
+	return Object.freeze({
+		en: Object.freeze(n("en")),
+		hi: Object.freeze(n("hi")),
+		ta: Object.freeze(n("ta")),
+		ar: Object.freeze(n("ar")),
+		es: Object.freeze(n("es")),
+		zh: Object.freeze(n("zh"))
+	});
+}
+function f(e, t, n) {
+	return e[t][n]?.enabled === !0;
+}
+function p(e, t) {
+	return Object.values(e[t]).some((e) => e?.enabled === !0);
+}
+function m(e, n) {
+	let r = [];
+	for (let s of ["en", ...t]) for (let [t, c] of Object.entries(e[s])) {
+		if (!c?.enabled) continue;
+		let e = `${s}:${t}`;
+		i[s].includes(t) || r.push(`${e}: not a family of ${s}`), (!c.corpusSha256 || !/^[0-9a-f]{64}$/.test(c.corpusSha256)) && r.push(`${e}: enabled with no corpus sha256`), c.corpusSha256 === o && r.push(`${e}: placeholder sha256`), (c.falseMatches === void 0 || c.falseMatches !== 0) && r.push(`${e}: enabled without a recorded 0 false matches`), (c.negatives === void 0 || c.negatives <= 0) && r.push(`${e}: enabled without a negative count`), (t === "goto" || t === "there" || t === "yes") && (c.recall === void 0 || c.recall < .6) && r.push(`${e}: recall is under the ${a} floor`);
+		let l = n(s, t);
+		l === null ? r.push(`${e}: its corpus file is missing`) : c.corpusSha256 && l !== c.corpusSha256 && r.push(`${e}: its corpus file has a different hash`);
+	}
+	return r;
+}
+//#endregion
+export { r as COMMAND_MANIFEST, i as MANIFEST_FAMILIES, a as RECALL_FLOOR, s as allOnManifest, d as effectiveManifest, f as isEnabled, p as localeHasAnyOn, c as manifestWith, m as validateManifest };

package/dist/shared/assistant/localeCommands/languageNames.d.ts

@@ -0,0 +1,11 @@
+import { UiLanguage } from '../appControls/types';
+import { CommandLocale, LanguageCode, LocaleTable } from './types';
+/**
+ * Folded name → the one language it names. `fold` is the fold of the table the
+ * sentence is read with; the names of every `tables` locale are added.
+ */
+export declare function languageNameMap(input: {
+    tables: readonly LocaleTable[];
+    appLanguages: readonly UiLanguage[];
+    fold: CommandLocale | "en";
+}): ReadonlyMap<string, LanguageCode>;

package/dist/shared/assistant/localeCommands/languageNames.js

@@ -0,0 +1,53 @@
+import { uiLanguageWords as e } from "../appControls/languages.js";
+import { foldText as t } from "./fold.js";
+import { UI_LANGUAGE_CODES as n } from "../appControls/types.js";
+//#region src/shared/assistant/localeCommands/languageNames.ts
+var r = {
+	en: "en",
+	ar: "ar",
+	es: "es",
+	hi: "hi",
+	ta: "ta",
+	zh: "zh"
+}, i = /* @__PURE__ */ new Map();
+function a(e) {
+	let t = i.get(e);
+	if (t) return t;
+	let a = [];
+	try {
+		let t = new Intl.DisplayNames([e], { type: "language" });
+		for (let e of n) {
+			let n = t.of(r[e]);
+			n && a.push(`${e}\u0000${n}`);
+		}
+	} catch {}
+	return i.set(e, a), a;
+}
+var o = (e) => n.includes(e);
+function s(r) {
+	let i = /* @__PURE__ */ new Map(), s = (e, n) => {
+		let a = t(e, r.fold);
+		if (!a) return;
+		let o = i.get(a) ?? /* @__PURE__ */ new Set();
+		o.add(n), i.set(a, o);
+	};
+	for (let t of n) for (let n of e(t)) s(n, t);
+	for (let e of r.appLanguages) {
+		let t = e.code.toLowerCase().split(/[-_]/)[0] ?? "";
+		o(t) && s(e.label, t);
+	}
+	let c = ["en", ...r.tables.map((e) => e.locale)];
+	for (let e of c) for (let t of a(e)) {
+		let [e, n] = t.split("\0");
+		s(n, e);
+	}
+	for (let e of r.tables) for (let [t, n] of Object.entries(e.languageNames)) for (let e of n) s(e, t);
+	let l = /* @__PURE__ */ new Map();
+	for (let [e, t] of i) {
+		let [n] = [...t];
+		t.size === 1 && n && l.set(e, n);
+	}
+	return l;
+}
+//#endregion
+export { s as languageNameMap };