@burdenoff/fe-libs 2026.1009.2 → 2026.1010.2

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 };

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

@@ -0,0 +1,21 @@
+/**
+ * ★ BOFF-8867 (multilingual commands): the closed case forms of a page name.
+ *
+ * Tamil glues its case to the noun ("வானிலைக்கு போ", "பயிர்களை திற") and Hindi
+ * puts the feminine plural into the oblique before a postposition ("फसलों को
+ * खोलो"). The page is still found by EXACT equality: the engine adds these
+ * forms of each label the app shows to the same index entry, and a name that is
+ * not the label or one of these forms is not a page. Nothing here guesses a
+ * stem from the sentence; the stem is always the app's own label.
+ *
+ * The list is closed on purpose. A label whose last letters match no rule has
+ * no extra form (it is matched bare, as before), and a collision with another
+ * page's own label makes the sentence a clarification, never a pick.
+ */
+/**
+ * Accusative (-ஐ), dative (-க்கு / -உக்கு) and locative (-இல்) forms of a
+ * Tamil label, plus each with the doubled consonant of the next word.
+ */
+export declare function tamilNameForms(label: string): readonly string[];
+/** The oblique plural of a Hindi feminine-plural label (फसलें → फसलों, सब्जियाँ → सब्जियों), for "फसलों को खोलो". */
+export declare function hindiNameForms(label: string): readonly string[];

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

@@ -0,0 +1,44 @@
+//#region src/shared/assistant/localeCommands/nameForms.ts
+var e = "்", t = [
+	"",
+	"க்",
+	"ச்",
+	"த்",
+	"ப்"
+], n = new Set([
+	"ள",
+	"ல",
+	"ர",
+	"ன",
+	"ண",
+	"ஸ",
+	"ட",
+	"ழ"
+]);
+function r(r) {
+	let i = r.normalize("NFKC").trim();
+	if (!i || /\s/.test(i.slice(-1))) return [];
+	let a = [...i].slice(-2), o = [], s = a[a.length - 1] ?? "", c = a.length === 2 ? a[0] : "";
+	if (s === e && c && n.has(c)) {
+		let e = i.slice(0, -1);
+		o.push(`${e}ை`, `${e}ுக்கு`, `${e}ில்`);
+	} else if (s === e && c === "ம") {
+		let e = i.slice(0, -2);
+		o.push(`${e}த்தை`, `${e}த்துக்கு`, `${e}த்தில்`);
+	} else if (s === "ை") o.push(`${i}யை`, `${i}க்கு`, `${i}யில்`);
+	else if (s === "ு") {
+		let e = i.slice(0, -1);
+		o.push(`${e}ை`, `${i}க்கு`, `${e}ில்`);
+	} else s === "ி" && o.push(`${i}யை`, `${i}க்கு`, `${i}யில்`);
+	return o.flatMap((e) => t.map((t) => `${e}${t}`));
+}
+function i(e) {
+	let t = e.normalize("NFKC").trim();
+	if (!t) return [];
+	let n = [], r = (e, r) => {
+		e.test(t) && n.push(t.replace(e, r));
+	};
+	return r(/ें$/u, "ों"), r(/ेँ$/u, "ों"), r(/ियाँ$/u, "ियों"), r(/ियां$/u, "ियों"), r(/ाएँ$/u, "ाओं"), r(/ाएं$/u, "ाओं"), n;
+}
+//#endregion
+export { i as hindiNameForms, r as tamilNameForms };

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

@@ -0,0 +1,49 @@
+import { CommandLocale } from './types';
+export type FoldLocale = CommandLocale | "en";
+/** The normalisation words a table (or the English additions) brings. */
+export interface PrepSource {
+    maxLength: number;
+    courtesy: {
+        prefix: readonly string[];
+        suffix: readonly string[];
+    };
+    fillers: readonly string[];
+    compound: readonly string[];
+    polite?: PoliteSource | undefined;
+}
+/**
+ * A question is a command only as a polite request. A request opens with one of
+ * `prefix` ("can you…") or ends with one of `suffix` ("…can you?"); either is
+ * enough. `particle` words ("吗") are dropped after one of those, never alone.
+ */
+export interface PoliteSource {
+    prefix: readonly string[];
+    suffix: readonly string[];
+    particle?: readonly string[];
+}
+/** `PrepSource` folded and ready: longest phrase first, so the longest courtesy wins. */
+export interface PrepData {
+    fold: FoldLocale;
+    zh: boolean;
+    maxLength: number;
+    prefix: string[];
+    suffix: string[];
+    fillers: Set<string>;
+    compound: string[];
+    /** null: this table has no polite request, and every question is the model's. */
+    polite: {
+        prefix: string[];
+        suffix: string[];
+        particle: string[];
+    } | null;
+}
+export declare function foldedList(list: readonly string[], fold: FoldLocale): string[];
+export declare function buildPrep(source: PrepSource, fold: FoldLocale): PrepData;
+export declare function removeFillers(value: string, prep: PrepData): string;
+/** A whole utterance said twice in a row ("go to X go to X") is said once. */
+export declare function collapseRepeat(value: string, zh: boolean): string;
+export declare function stripEdges(value: string, prefixes: readonly string[], suffixes: readonly string[], zh: boolean, mustStrip?: boolean): string | null;
+/** The folded utterance a run reads: fillers, a repeat and courtesy removed; null when it cannot be a command. */
+export declare function normaliseSaid(said: string, prep: PrepData, question: boolean): string | null;
+/** A question mark at the end, or an opening `¿`. */
+export declare function isQuestionText(said: string): boolean;

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

@@ -0,0 +1,87 @@
+import { foldText as e } from "./fold.js";
+//#region src/shared/assistant/localeCommands/normalise.ts
+function t(t, n) {
+	return t.map((t) => e(t, n)).filter(Boolean).sort((e, t) => t.length - e.length);
+}
+function n(e, n) {
+	return {
+		fold: n,
+		zh: n === "zh",
+		maxLength: e.maxLength,
+		prefix: t(e.courtesy.prefix, n),
+		suffix: t(e.courtesy.suffix, n),
+		fillers: new Set(t(e.fillers, n)),
+		compound: t(e.compound, n),
+		polite: e.polite ? {
+			prefix: t(e.polite.prefix, n),
+			suffix: t(e.polite.suffix, n),
+			particle: t(e.polite.particle ?? [], n)
+		} : null
+	};
+}
+function r(e, t) {
+	let { fillers: n } = t;
+	if (n.size === 0) return e;
+	if (t.zh) {
+		let t = e;
+		for (;;) {
+			let e = [...n].reduce((e, t) => e.length > t.length && (e.startsWith(t) || e.endsWith(t)) ? e.startsWith(t) ? e.slice(t.length) : e.slice(0, e.length - t.length) : e, t);
+			if (e === t) return t;
+			t = e;
+		}
+	}
+	return e.split(" ").filter((e) => !n.has(e)).join(" ");
+}
+function i(e, t) {
+	if (t) {
+		let t = e.length / 2;
+		return e.length >= 4 && Number.isInteger(t) && e.slice(0, t) === e.slice(t) ? e.slice(0, t) : e;
+	}
+	let n = e.split(" "), r = n.length / 2;
+	if (n.length >= 2 && Number.isInteger(r)) {
+		let e = n.slice(0, r).join(" ");
+		if (e === n.slice(r).join(" ")) return e;
+	}
+	return e;
+}
+function a(e, t, n, r, i = !1) {
+	let a = (e) => {
+		for (let n of t) {
+			let t = r ? e.startsWith(n) ? e.slice(n.length) : null : e.startsWith(`${n} `) ? e.slice(n.length + 1) : null;
+			if (t !== null && t.length > 0) return t;
+		}
+		return null;
+	}, o = (e) => {
+		for (let t of n) {
+			let n = r ? e.endsWith(t) ? e.slice(0, e.length - t.length) : null : e.endsWith(` ${t}`) ? e.slice(0, e.length - t.length - 1) : null;
+			if (n !== null && n.length > 0) return n;
+		}
+		return null;
+	}, s = e, c = !1;
+	for (;;) {
+		let e = a(s) ?? o(s);
+		if (e === null) break;
+		s = e, c = !0;
+	}
+	return i && !c ? null : s;
+}
+function o(t, n, o) {
+	let s = e(t, n.fold);
+	if (!s) return null;
+	if (o) {
+		let { polite: e } = n;
+		if (e === null) return null;
+		let t = a(s, e.prefix, [], n.zh, !0), r = a(t ?? s, [], e.suffix, n.zh, !0);
+		if (t === null && r === null) return null;
+		let i = r ?? t ?? s;
+		s = a(i, [], e.particle, n.zh) ?? i;
+	}
+	s = r(s, n), s = i(s, n.zh);
+	let c = a(s, n.prefix, n.suffix, n.zh);
+	return c === null || !c || c.length > n.maxLength ? null : c;
+}
+function s(e) {
+	return /[?¿؟？][^\p{L}\p{N}]*$/u.test(e) || /^\s*¿/u.test(e);
+}
+//#endregion
+export { n as buildPrep, i as collapseRepeat, t as foldedList, s as isQuestionText, o as normaliseSaid, r as removeFillers, a as stripEdges };

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

@@ -0,0 +1,8 @@
+/**
+ * ★ BOFF-8867: an emoji or symbol can carry the meaning — "🚫 dark mode", "dark
+ * mode 👎", "हाँ 🙄" — and the grammar cannot read it, so it must not strip it and
+ * act; nor can an ASCII emoticon ("dark mode :(", ">:(", "xD", "-_-"). Whitespace
+ * before the eyes, so "http://" and "10:30" are not faces. Shared by the
+ * English matcher, the per-language engine and the offer "yes".
+ */
+export declare function carriesSymbolOrEmoticon(said: string): boolean;

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

@@ -0,0 +1,6 @@
+//#region src/shared/assistant/localeCommands/symbols.ts
+function e(e) {
+	return /[\p{Extended_Pictographic}\p{So}]/u.test(e) ? !0 : /(?:^|\s)>?[:;=][-'^]?[()[\]/\\|pPdDoO3*@$]+(?=\s|$)/.test(e) || /(?:^|\s)(?:xD|XD|-_-|T_T|<\/?3)(?=\s|$)/.test(e);
+}
+//#endregion
+export { e as carriesSymbolOrEmoticon };

package/dist/shared/assistant/localeCommands/tables/ar.d.ts

@@ -0,0 +1,10 @@
+import { LocaleTable } from '../types';
+/**
+ * Arabic (Modern Standard with the common colloquial imperatives). Arabic stays
+ * left-to-right in layout (operator decision 2026-10-07); matching is on the
+ * logical string. AI-written, no native review; every phrase is a seed the
+ * blind set measures. The fold removes tashkeel and unifies the alef, ya, ta
+ * marbuta and hamza forms on both sides, and a leading definite article is
+ * optional on the name (`lookup`, design §2.3).
+ */
+export declare const ARABIC_COMMANDS: LocaleTable;