@mnmal-ai/substrate-nl 0.0.0-stage → 1.0.0-alpha.0

package/dist/bootstrap.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { NlEngineAccess } from './access.js';
+export declare const NlBootstrapConfigSchema: z.ZodObject<{
+    judge: z.ZodOptional<z.ZodObject<{
+        baseUrl: z.ZodURL;
+        model: z.ZodString;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    rulings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@mnmal-ai/substrate/sdk").NlNamespaceRulings, unknown, z.core.$ZodTypeInternals<import("@mnmal-ai/substrate/sdk").NlNamespaceRulings, unknown>>>>;
+    packTtlMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type NlBootstrapConfig = z.infer<typeof NlBootstrapConfigSchema>;
+export interface NlHostDeps {
+    nlEngine: NlEngineAccess;
+}
+export declare const bootstrap: import("@mnmal-ai/substrate/sdk").KernelBootstrap<NlHostDeps>;
+export default bootstrap;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAalD,eAAO,MAAM,uBAAuB;;;;;;;;kBAMzB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,eAAO,MAAM,SAAS,+DAWpB,CAAC;eAGY,SAAS"}

package/dist/bootstrap.js

@@ -0,0 +1,3 @@
+import { n as bootstrap, t as NlBootstrapConfigSchema } from "./bootstrap-BpKUloR3.js";
+
+export { NlBootstrapConfigSchema, bootstrap, bootstrap as default };

package/dist/complete/complete.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Keystroke-speed completion over a served namespace pack. Pure, and imports
+ * types only, so the `@mnmal-ai/substrate-nl/complete` subpath runs in a browser
+ * or a TUI without pulling the plugin's server dependencies.
+ */
+import type { NamespaceRulings } from '../pack/rulings.js';
+import type { NamespacePack } from '../pack/types.js';
+export type CompletePack = NamespacePack & {
+    rulings?: NamespaceRulings;
+};
+export interface NlSuggestion {
+    replace: [start: number, end: number];
+    insert: string;
+    label: string;
+    detail?: string;
+    score: number;
+}
+export declare function complete(draft: string, cursor: number, pack: CompletePack): NlSuggestion[];
+//# sourceMappingURL=complete.d.ts.map

package/dist/complete/complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../src/complete/complete.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG;IAAE,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE1E,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AA2ED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,EAAE,CA2E1F"}

package/dist/complete.js

@@ -0,0 +1,157 @@
+//#region src/complete/complete.ts
+/** Own-key lookup: inherited names (`constructor`, `__proto__`) are not entries. Inlined so this module imports types only. */
+const own = (rec, key) => rec !== void 0 && Object.hasOwn(rec, key) ? rec[key] : void 0;
+const cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const DSL_OPERATORS = {
+	gte: ">=",
+	lte: "<=",
+	gt: ">",
+	lt: "<",
+	between: "..",
+	neq: "!",
+	contains: "~"
+};
+const OPERATOR_FORM = /^[<>!~.]/;
+const isHigh = (u) => u >= 55296 && u <= 56319;
+const isLow = (u) => u >= 56320 && u <= 57343;
+/** The token around `cursor`: [start, end). Whitespace-delimited; a trailing `field:` stays one token. */
+function tokenAt(draft, cursor) {
+	let c = Number.isFinite(cursor) ? Math.max(0, Math.min(Math.trunc(cursor), draft.length)) : 0;
+	if (c > 0 && c < draft.length && isHigh(draft.charCodeAt(c - 1)) && isLow(draft.charCodeAt(c))) c--;
+	let start = c;
+	while (start > 0 && !/\s/.test(draft[start - 1])) start--;
+	let end = c;
+	while (end < draft.length && !/\s/.test(draft[end])) end++;
+	return [start, end];
+}
+function typeIn(words, pack) {
+	const aliases = pack.rulings?.typeAliases ?? {};
+	for (const w of words) {
+		const lw = w.toLowerCase();
+		const aliased = own(aliases, lw);
+		if (aliased !== void 0) return aliased;
+		for (const t of Object.values(pack.types)) if (t.phrases.includes(lw)) return t.name;
+	}
+}
+function rank(prefix, pool, replace) {
+	const p = prefix.toLowerCase();
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const x of pool) {
+		const k = x.insert.toLowerCase();
+		if (seen.has(x.insert) || k === p) continue;
+		const score = k.startsWith(p) ? 2 : p.length > 0 && k.includes(p) ? 1 : 0;
+		if (score === 0) continue;
+		seen.add(x.insert);
+		out.push({
+			replace,
+			insert: x.insert,
+			label: x.label,
+			...x.detail !== void 0 ? { detail: x.detail } : {},
+			score
+		});
+	}
+	return out.sort((a, b) => b.score - a.score || a.insert.length - b.insert.length || cmp(a.insert, b.insert));
+}
+function complete(draft, cursor, pack) {
+	if (draft.trim() === "") return [];
+	const [start, end] = tokenAt(draft, cursor);
+	const token = draft.slice(start, end);
+	const type = typeIn(draft.slice(0, start).split(/\s+/).filter((w) => w !== ""), pack);
+	const colon = token.indexOf(":");
+	if (colon > 0 && type !== void 0) {
+		const typed = token.slice(0, colon);
+		const fieldName = own(pack.rulings?.fieldAliases, typed) ?? typed;
+		const f = own(own(pack.types, type)?.fields, fieldName);
+		if (f === void 0) return [];
+		const valueStart = start + colon + 1;
+		const pool = [
+			...(f.enum ?? []).map((v) => ({
+				insert: v,
+				label: v
+			})),
+			...Object.entries(f.aliases ?? {}).map(([alias, canon]) => ({
+				insert: alias,
+				label: `${alias} → ${canon}`
+			})),
+			...Object.entries(pack.values).filter(([, refs]) => refs.some((r) => r.type === type && r.field === fieldName)).map(([v, refs]) => ({
+				insert: refs.find((r) => r.type === type)?.value ?? v,
+				label: v
+			}))
+		];
+		const prefix = token.slice(colon + 1);
+		if (OPERATOR_FORM.test(prefix)) return [];
+		if (prefix === "") {
+			const replace = [valueStart, end];
+			const seen = /* @__PURE__ */ new Set();
+			const values = pool.filter((x) => !seen.has(x.insert) && seen.add(x.insert)).sort((a, b) => cmp(a.insert, b.insert)).map((x) => ({
+				replace,
+				insert: x.insert,
+				label: x.label,
+				score: 2
+			}));
+			const ops = f.operators.flatMap((op) => {
+				const form = own(DSL_OPERATORS, op);
+				return form === void 0 ? [] : [{
+					replace,
+					insert: form,
+					label: form,
+					detail: op,
+					score: 1
+				}];
+			});
+			return [...values, ...ops];
+		}
+		return rank(prefix, pool, [valueStart, end]);
+	}
+	if (token === "") return [];
+	const pool = [];
+	if (type === void 0) {
+		for (const t of Object.values(pack.types)) for (const ph of t.phrases) pool.push({
+			insert: ph,
+			label: ph,
+			detail: `${pack.namespace}/${t.name}`
+		});
+		for (const [alias, t] of Object.entries(pack.rulings?.typeAliases ?? {})) pool.push({
+			insert: alias,
+			label: alias,
+			detail: `${pack.namespace}/${t}`
+		});
+	} else {
+		for (const f of Object.values(own(pack.types, type)?.fields ?? {})) {
+			if (f.kind === "metadata") continue;
+			pool.push({
+				insert: `${f.name}:`,
+				label: f.name,
+				detail: f.operators.join(" ")
+			});
+			for (const ph of f.phrases) if (ph !== f.name) pool.push({
+				insert: `${f.name}:`,
+				label: ph,
+				detail: f.name
+			});
+		}
+		for (const [alias, canon] of Object.entries(pack.rulings?.fieldAliases ?? {})) pool.push({
+			insert: `${alias}:`,
+			label: `${alias} → ${canon}`,
+			detail: canon
+		});
+		for (const [word, preds] of Object.entries(pack.rulings?.valueAliases ?? {})) {
+			const p = preds[0];
+			if (!/\s/.test(word) && p !== void 0) pool.push({
+				insert: word,
+				label: word,
+				detail: `${p.type}.${p.field}`
+			});
+		}
+	}
+	for (const [v, refs] of Object.entries(pack.values)) if (refs.some((r) => r.field === "project")) pool.push({
+		insert: refs[0]?.value ?? v,
+		label: refs[0]?.value ?? v,
+		detail: "project"
+	});
+	return rank(token, pool, [start, end]);
+}
+
+//#endregion
+export { complete };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export type { NlEngineAccess, NlEnvelope } from './access.js';
+export type { AskRequest, NlEvent, NlOutcome } from './ask/events.js';
+export { runAsk } from './ask/run.js';
+export type { NlBootstrapConfig, NlHostDeps } from './bootstrap.js';
+export { bootstrap, NlBootstrapConfigSchema } from './bootstrap.js';
+export type { CompletePack, NlSuggestion } from './complete/complete.js';
+export { complete } from './complete/complete.js';
+export type { Judge } from './judge/judge.js';
+export { parseWithJudge } from './judge/judge.js';
+export { OllamaJudge } from './judge/ollama.js';
+export { buildNamespacePack } from './pack/build.js';
+export { profileNamespace } from './pack/profile.js';
+export type { NamespaceRulings } from './pack/rulings.js';
+export type { ServedPack } from './pack/service.js';
+export { PackService } from './pack/service.js';
+export type { NamespacePack } from './pack/types.js';
+export { parseQuestion } from './parse/parse.js';
+export type { NlPluginConfig } from './plugin.js';
+export { CONTRACT_VERSION, createNlPlugin } from './plugin.js';
+export type { NlRouteDeps } from './routes.js';
+export { askHandler, packHandler } from './routes.js';
+export { mergeRulings, NamespaceRulingsSchema, readRulings } from './rulings/schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9D,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,YAAY,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC/D,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+import { a as askHandler, c as profileNamespace, d as mergeRulings, f as readRulings, g as parseQuestion, h as parseWithJudge, i as createNlPlugin, l as buildNamespacePack, m as runAsk, n as bootstrap, o as packHandler, p as OllamaJudge, r as CONTRACT_VERSION, s as PackService, t as NlBootstrapConfigSchema, u as NamespaceRulingsSchema } from "./bootstrap-BpKUloR3.js";
+import { complete } from "./complete.js";
+
+export { CONTRACT_VERSION, NamespaceRulingsSchema, NlBootstrapConfigSchema, OllamaJudge, PackService, askHandler, bootstrap, buildNamespacePack, complete, createNlPlugin, mergeRulings, packHandler, parseQuestion, parseWithJudge, profileNamespace, readRulings, runAsk };

package/dist/judge/judge.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Tier 1b: a constrained judge for what the parser escalates. The model never
+ * writes a frame. It picks ONE choice from options generated for this
+ * question (a candidate, a type, a word-to-field binding, recall, clarify,
+ * refuse), its output constrained to those options by a JSON schema. The
+ * choice is then applied deterministically and the parser runs again, so
+ * every frame that comes out is still the parser's, tied to the words.
+ */
+import type { NlJudgeAction, NlJudgeChoice, NlJudgeStep } from '@mnmal-ai/substrate/sdk';
+import type { NamespaceRulings } from '../pack/rulings.js';
+import type { NamespacePack } from '../pack/types.js';
+import { type Candidate, type ParseContext, type ParseResult } from '../parse/parse.js';
+export type JudgeAction = NlJudgeAction;
+export type JudgeChoice = NlJudgeChoice;
+export interface JudgePrompt {
+    system: string;
+    user: string;
+    /** JSON schema the reply must satisfy; every enum is drawn from this question. */
+    schema: Record<string, unknown>;
+}
+/** Transport for one constrained decision. Returns the parsed JSON reply. */
+export interface Judge {
+    decide(prompt: JudgePrompt, signal?: AbortSignal): Promise<unknown>;
+}
+export type JudgeStep = NlJudgeStep;
+export type JudgedResult = {
+    status: 'resolved';
+    candidate: Candidate;
+    trail: JudgeStep[];
+} | {
+    status: 'recall';
+    query: string;
+    trail: JudgeStep[];
+} | {
+    status: 'clarify' | 'refuse';
+    reason: string;
+    trail: JudgeStep[];
+} | {
+    status: 'escalated';
+    result: ParseResult;
+    trail: JudgeStep[];
+};
+/** Build the options, the prompt and the schema for one escalated parse. */
+export declare function buildJudgePrompt(question: string, result: ParseResult, pack: NamespacePack, rulings?: NamespaceRulings, rejected?: string[]): JudgePrompt;
+/** Check a reply against the options it was offered. */
+export declare function checkChoice(reply: unknown, prompt: JudgePrompt): JudgeChoice | string;
+export interface JudgeOptions {
+    /** Judge rounds before giving up. Default 3. */
+    rounds?: number;
+    /**
+     * Does any row of `type` match `where`? A binding is applied only when its
+     * value occurs in the data: a bound value that matches nothing is the
+     * judge reading a word as data that is not data. Omitted, bindings are
+     * checked against the schema only.
+     */
+    exists?: (type: string, where: Record<string, unknown>) => Promise<boolean>;
+    /** Aborts the in-flight judge call. */
+    signal?: AbortSignal;
+}
+/**
+ * Parse; while the parse is not resolved, ask the judge and apply its choice.
+ * A refused, clarified or resolved parse never reaches the model.
+ */
+export declare function parseWithJudge(question: string, pack: NamespacePack, ctx: ParseContext, judge: Judge, opts?: JudgeOptions): Promise<JudgedResult>;
+//# sourceMappingURL=judge.d.ts.map

package/dist/judge/judge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge.d.ts","sourceRoot":"","sources":["../../src/judge/judge.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEzF,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,EAEjB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,WAAW,GAAG,aAAa,CAAC;AAExC,MAAM,MAAM,WAAW,GAAG,aAAa,CAAC;AAExC,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,6EAA6E;AAC7E,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACrE;AAED,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC;AAEpC,MAAM,MAAM,YAAY,GACpB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GAChE;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GACvD;IAAE,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GACpE;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;AAarE,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,gBAAqB,EAC9B,QAAQ,GAAE,MAAM,EAAO,GACtB,WAAW,CAqFb;AAED,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW,GAAG,MAAM,CAkBrF;AAkBD,MAAM,WAAW,YAAY;IAC3B,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5E,uCAAuC;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAmCD;;;GAGG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,KAAK,EACZ,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,YAAY,CAAC,CA+DvB"}

package/dist/judge/ollama.d.ts

@@ -0,0 +1,20 @@
+import type { Judge, JudgePrompt } from './judge.js';
+export interface OllamaJudgeConfig {
+    baseUrl: string;
+    model: string;
+    /** Abort a call after this long. Default 60s. */
+    timeoutMs?: number;
+}
+/**
+ * Ollama's native chat endpoint with `format` set to the question's schema,
+ * so decoding cannot leave the offered options. Thinking off, temperature 0
+ * and a fixed seed. Sends no `num_ctx` / `keep_alive`: Ollama shares one
+ * runner per model, and differing options force a reload for every client
+ * (see substrate-embedder's README).
+ */
+export declare class OllamaJudge implements Judge {
+    #private;
+    constructor(config: OllamaJudgeConfig);
+    decide(prompt: JudgePrompt, signal?: AbortSignal): Promise<unknown>;
+}
+//# sourceMappingURL=ollama.d.ts.map

package/dist/judge/ollama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../src/judge/ollama.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,qBAAa,WAAY,YAAW,KAAK;;IAGvC,YAAY,MAAM,EAAE,iBAAiB,EAEpC;IAEK,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAqBxE;CACF"}

package/dist/own.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A lookup into a plain-object record by a user-supplied key. Inherited
+ * names (`constructor`, `__proto__`, `toString`) are not entries.
+ */
+export declare function own<T>(rec: Record<string, T> | undefined, key: string): T | undefined;
+//# sourceMappingURL=own.d.ts.map

package/dist/own.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"own.d.ts","sourceRoot":"","sources":["../src/own.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAErF"}

package/dist/pack/build.d.ts

@@ -0,0 +1,17 @@
+import type { Schema } from '@mnmal-ai/substrate/sdk';
+import type { NamespacePack, NamespaceProfile } from './types.js';
+export interface BuildPackInput {
+    namespace: string;
+    schema: Schema;
+    /** The schema's operator table, keyed `scalar.<type>`, `crossRef`, `list`. */
+    operators: Record<string, readonly string[]>;
+    profile?: NamespaceProfile;
+    /** Safety cap: a profiled field with more distinct values is not used. Default 1000. */
+    maxDistinct?: number;
+}
+/**
+ * Builds the NL vocabulary for one namespace. Pure: the same schema, operator
+ * table and profile always give byte-identical output, with sorted keys.
+ */
+export declare function buildNamespacePack(input: BuildPackInput): NamespacePack;
+//# sourceMappingURL=build.d.ts.map

package/dist/pack/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/pack/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAC7C,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,wFAAwF;IACxF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAsBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,aAAa,CA8CvE"}

package/dist/pack/profile.d.ts

@@ -0,0 +1,27 @@
+import type { Schema } from '@mnmal-ai/substrate/sdk';
+import type { NamespaceProfile } from './types.js';
+/** One page of rows for `type`, projecting `fields`. */
+export type ReadPage = (type: string, fields: string[], cursor?: string) => Promise<{
+    rows: Record<string, unknown>[];
+    nextCursor: string | undefined;
+}>;
+export interface ProfileInput {
+    schema: Schema;
+    read: ReadPage;
+    /** Stop collecting a field past this many distinct values. Default 1000. */
+    maxDistinct?: number;
+    /**
+     * Rows read per type. Default 10 000. The pack is built on the request
+     * path, per caller, so an unbounded read would be a full scan of every type.
+     * A field's labels that appear only past the budget are left out of its
+     * vocabulary.
+     */
+    maxRows?: number;
+}
+/**
+ * Distinct values of every indexed string field (and indexed list-of-string
+ * field) in the namespace, reading up to `maxRows` rows per type. A field that
+ * passes `maxDistinct` is marked truncated and stops growing.
+ */
+export declare function profileNamespace(input: ProfileInput): Promise<NamespaceProfile>;
+//# sourceMappingURL=profile.d.ts.map

package/dist/pack/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/pack/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAgB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEjE,wDAAwD;AACxD,MAAM,MAAM,QAAQ,GAAG,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,CAAC,EAAE,MAAM,KACZ,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC,CAAC;AAElF,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA+CrF"}

package/dist/pack/rulings.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Operator rulings for one namespace, kept as data: what the schema cannot
+ * say about how people talk about it. The pack is generated; rulings are
+ * curated, and they win over the pack where they speak.
+ */
+import type { NlNamespaceRulings, NlValueAlias } from '@mnmal-ai/substrate/sdk';
+export type NamespaceRulings = NlNamespaceRulings;
+export type ValueAlias = NlValueAlias;
+//# sourceMappingURL=rulings.d.ts.map

package/dist/pack/rulings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulings.d.ts","sourceRoot":"","sources":["../../src/pack/rulings.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC"}

package/dist/pack/service.d.ts

@@ -0,0 +1,28 @@
+import type { NlServedPack, SubstrateRequest } from '@mnmal-ai/substrate/sdk';
+import type { NlEngineAccess } from '../access.js';
+import type { NamespaceRulings } from './rulings.js';
+export type ServedPack = NlServedPack;
+export interface PackServiceOptions {
+    engine: NlEngineAccess;
+    rulings?: Record<string, NamespaceRulings>;
+    ttlMs?: number;
+    /** Cache capacity; least-recently-used entries are evicted. Default 256. */
+    maxEntries?: number;
+    now?: () => number;
+    log?: (line: string) => void;
+}
+/**
+ * Packs are built under the CALLER's request: the profile reads distinct
+ * values through `engine.query(frame, req)`, so row policy applies and a
+ * pack can never disclose a value its caller could not read. Hence the
+ * principal is part of the cache key.
+ */
+export declare class PackService {
+    #private;
+    constructor(opts: PackServiceOptions);
+    get(ns: string, req: SubstrateRequest): Promise<{
+        pack: ServedPack;
+        etag: string;
+    } | undefined>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/pack/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/pack/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAU,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAKnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC;AAEtC,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAQD;;;;;GAKG;AACH,qBAAa,WAAW;;IAMtB,YAAY,IAAI,EAAE,kBAAkB,EAEnC;IAEK,GAAG,CACP,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC,CA4BzD;CAuCF"}

package/dist/pack/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The per-namespace vocabulary the NL parser works from: every type and field
+ * a question can name, the operators each field accepts, and which concrete
+ * values belong to which field. Built deterministically from `schema`
+ * plus a profile of the data, and keyed to `schemaVersion` so it can be
+ * rebuilt when the schema moves.
+ */
+import type { NlNamespacePack, NlPackField, NlPackType, NlPackValueRef } from '@mnmal-ai/substrate/sdk';
+export type NamespacePack = NlNamespacePack;
+export type PackType = NlPackType;
+export type PackField = NlPackField;
+export type PackValueRef = NlPackValueRef;
+/** Distinct values observed per (type, field). `truncated` once past the cap. */
+export interface NamespaceProfile {
+    types: Record<string, Record<string, FieldProfile>>;
+}
+export interface FieldProfile {
+    values: string[];
+    truncated: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/pack/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/pack/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,UAAU,EACV,cAAc,EACf,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC;AAClC,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC;AACpC,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC;AAE1C,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB"}

package/dist/pack/words.d.ts

@@ -0,0 +1,7 @@
+/** `AgentMessage` -> ['agent', 'message']; `shortId` -> ['short', 'id']. */
+export declare function splitWords(name: string): string[];
+/** English plural for a lower-case noun, by suffix rule. */
+export declare function pluralize(word: string): string;
+/** Sorted, de-duplicated. */
+export declare function uniqueSorted(xs: Iterable<string>): string[];
+//# sourceMappingURL=words.d.ts.map

package/dist/pack/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../../src/pack/words.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAOjD;AAED,4DAA4D;AAC5D,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED,6BAA6B;AAC7B,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAE3D"}

package/dist/parse/parse.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Deterministic NL -> frame parser. Recognisers claim spans of the question
+ * against a namespace pack and the namespace's rulings; assembly turns the
+ * claims into candidate frames. The same question, pack, rulings and context
+ * always give the same result, and every clause in a produced frame is tied
+ * to the words that caused it.
+ *
+ * `resolved` means one candidate and nothing left over that could change it.
+ * Anything else is for the next tier to judge: this parser never guesses.
+ */
+import type { NlEvidence, NlParseStatus } from '@mnmal-ai/substrate/sdk';
+import type { NamespaceRulings } from '../pack/rulings.js';
+import type { NamespacePack } from '../pack/types.js';
+export interface ParseContext {
+    /** The asking project: the default scope is this project or none. */
+    project?: string;
+    /** "now" for relative dates, ISO-8601 with offset. */
+    asOf: string;
+    /** Type a bare `#N` refers to. */
+    defaultIdType?: string;
+    rulings?: NamespaceRulings;
+    /** Read the question as this type only: a judge's choice, applied deterministically. */
+    forceType?: string;
+}
+export type Evidence = NlEvidence;
+export interface Candidate {
+    type: string;
+    frame: Record<string, {
+        params: Record<string, unknown>;
+    }>;
+    answer: string;
+    evidence: Evidence[];
+    /** Content words this reading leaves unexplained. */
+    residual: string[];
+}
+export type ParseStatus = NlParseStatus;
+export interface ParseResult {
+    status: ParseStatus;
+    candidates: Candidate[];
+    /** What an unparsed question was understood to say, for the judge. */
+    evidence?: Evidence[];
+    /** Content words the best reading leaves unexplained. */
+    residual: string[];
+    reason?: string;
+}
+export declare function parseQuestion(question: string, pack: NamespacePack, ctx: ParseContext): ParseResult;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,kBAAkB,CAAC;AAIjE,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,wFAAwF;IACxF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC;AAElC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,MAAM,WAAW,GAAG,aAAa,CAAC;AAExC,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;IACtB,yDAAyD;IACzD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+GD,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,YAAY,GAChB,WAAW,CAuSb"}

package/dist/parse/time.d.ts

@@ -0,0 +1,13 @@
+/** A half-open range of instants, ISO-8601 with the asking offset. */
+export interface DateRange {
+    gte: string;
+    lt: string;
+}
+/**
+ * The range a time phrase names, relative to `asOf` and in its offset:
+ * today, yesterday, this/last week (weeks start Monday), this/last month,
+ * rolling "past <unit>" and "last N <units>", "since <weekday>". Null when
+ * the phrase is not a time phrase.
+ */
+export declare function rangeFor(phrase: string, asOf: string): DateRange | null;
+//# sourceMappingURL=time.d.ts.map

package/dist/parse/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/parse/time.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ;AAID;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAgDvE"}

package/dist/plugin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@mnmal-ai/substrate-nl` as a substrate plugin: NL owns no namespace, only two
+ * kernel routes. Both are read-gated: row policy keeps the data safe, and the
+ * gate keeps an anonymous caller from spending the operator's judge GPU.
+ */
+import type { KernelPlugin } from '@mnmal-ai/substrate/sdk';
+import type { NlEngineAccess } from './access.js';
+import type { Judge } from './judge/judge.js';
+import type { NamespaceRulings } from './pack/rulings.js';
+export interface NlPluginConfig {
+    engine: NlEngineAccess;
+    judge?: Judge;
+    judgeTimeoutMs?: number;
+    rulings?: Record<string, NamespaceRulings>;
+    packTtlMs?: number;
+}
+/** The routes rely on `KernelRouteClaim.capability`, which every 1.x host honours. */
+export declare const CONTRACT_VERSION = ">=1.0.0-alpha.0 <2.0.0";
+export declare function createNlPlugin(cfg: NlPluginConfig): KernelPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAI1D,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,2BAA2B,CAAC;AAEzD,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,YAAY,CAoBhE"}

package/dist/routes.d.ts

@@ -0,0 +1,16 @@
+import type { HttpHandler } from '@mnmal-ai/substrate/sdk';
+import type { NlEngineAccess } from './access.js';
+import type { Judge } from './judge/judge.js';
+import type { PackService } from './pack/service.js';
+export interface NlRouteDeps {
+    engine: NlEngineAccess;
+    packs: PackService;
+    judge?: Judge;
+    judgeTimeoutMs?: number;
+    now?: () => Date;
+    /** Receives the real engine error; clients only ever see a fixed message. */
+    log?: (err: unknown) => void;
+}
+export declare function askHandler(deps: NlRouteDeps): HttpHandler;
+export declare function packHandler(deps: NlRouteDeps): HttpHandler;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,yBAAyB,CAAC;AAE9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,6EAA6E;IAC7E,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9B;AAkBD,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAqDzD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAwB1D"}

package/dist/rulings/schema.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+import type { Schema } from '@mnmal-ai/substrate/sdk';
+import { z } from 'zod';
+import type { NamespaceRulings } from '../pack/rulings.js';
+export declare const NamespaceRulingsSchema: z.ZodType<NamespaceRulings>;
+/** Per top-level key: records merge entry-by-entry (override wins), arrays replace. */
+export declare function mergeRulings(declared: NamespaceRulings, override: NamespaceRulings | undefined): NamespaceRulings;
+/** The effective rulings for one namespace's schema, plus anything that was dropped. */
+export declare function readRulings(schema: Schema, override?: NamespaceRulings): {
+    rulings: NamespaceRulings;
+    warnings: string[];
+};
+//# sourceMappingURL=schema.d.ts.map