@orkestrel/interpret 0.0.2 → 0.0.3

package/dist/src/core/index.d.cts

@@ -1,2133 +0,0 @@
-import { Definition } from '@orkestrel/reason';
-import { EmitterErrorHandler } from '@orkestrel/emitter';
-import { EmitterHooks } from '@orkestrel/emitter';
-import { EmitterInterface } from '@orkestrel/emitter';
-import { FieldPath } from '@orkestrel/contract';
-import { ReasonResult } from '@orkestrel/reason';
-import { Subject } from '@orkestrel/reason';
-import { SymbolicExpression } from '@orkestrel/reason';
-
-/** An unresolved field surfaced as a human-readable question, never bare prose. */
-export declare interface Ambiguity {
-    readonly field: FieldPath;
-    readonly question: string;
-    readonly candidates: readonly string[];
-    readonly required: boolean;
-}
-
-/**
- * Replace every whole-word occurrence of a map's keys with their values.
- *
- * @remarks
- * Word-boundary safe (`in` never matches inside `information`) and
- * case-insensitive; each key is regex-escaped via the core-root
- * `escapeRegExp` before compiling, so a caller-supplied phrase containing
- * regex metacharacters is matched literally. Multiple keys apply in
- * `Object.entries` order — the `Normalizer` stage sequences its three maps
- * (contractions, abbreviations, corrections) with three separate calls.
- *
- * @param text - The text to substitute within
- * @param map - The `{ from: to }` substitution map
- * @returns `text` with every whole-word match replaced
- *
- * @example
- * ```ts
- * import { applyReplacements } from '@src/core'
- *
- * applyReplacements("can't stop", { "can't": 'cannot' }) // 'cannot stop'
- * applyReplacements('information', { in: 'IN' })          // 'information' — word-boundary safe
- * ```
- */
-export declare function applyReplacements(text: string, map: Readonly<Record<string, string>>): string;
-
-/**
- * Assign already-extracted numbers to a matched template's entity mappings.
- *
- * @remarks
- * Strategy, in order: (1) a SINGLE mapping collects every number (an array
- * when more than one, a scalar otherwise) at `CONFIDENCE_COLLECT`. Otherwise,
- * per mapping, the rightmost token in the text that equals the entity name
- * (`CONFIDENCE_EXACT`), an alias exactly (`CONFIDENCE_ALIAS`), or an alias
- * fuzzily (via `matchAlias`, confidence = its returned score) becomes a
- * keyword anchor; anchors sort left-to-right and each claims its nearest
- * unused number by text position. (3) Any mapping still unfilled claims the
- * next unused number positionally, at `CONFIDENCE_POSITIONAL`. Every entity
- * carries provenance `category: 'extracted'` with `detail` naming the
- * strategy that filled it (`'collect' | 'keyword' | 'alias' | 'positional'`).
- * Runs ONLY after a template has matched (an orchestrator-owned step, never
- * inside `Extractor`, which stays template-agnostic).
- *
- * @param numbers - The numbers already extracted from `text` via `extractNumbers`
- * @param mappings - The matched template's entity mappings
- * @param text - The same text `numbers` was extracted from (for keyword proximity)
- * @param similarity - The fuzzy alias-match score threshold (0..1)
- * @returns The assigned entities, one per filled mapping
- *
- * @example
- * ```ts
- * import { assignEntities } from '@src/core'
- *
- * const mappings = [
- * 	{ entity: 'age', aliases: ['years old'], field: 'age' },
- * 	{ entity: 'score', aliases: ['credit score'], field: 'score' },
- * ]
- * assignEntities([25, 720], mappings, '25 year old with score 720', 0.8)
- * // [{ name: 'age', value: 25, ... }, { name: 'score', value: 720, ... }]
- * ```
- */
-export declare function assignEntities(numbers: readonly number[], mappings: readonly EntityMapping[], text: string, similarity: number): readonly Entity[];
-
-/**
- * Render a value into a canonical, key-order-stable string — the pre-image
- * of `digestValue`.
- *
- * @remarks
- * Ported from the app's `raters` digest machinery (`app/core/raters/helpers.ts`)
- * — record keys sort before serialization so a re-ordered object canonicalizes
- * identically; arrays keep position order (position is meaningful).
- * Cycle-safe and total (AGENTS §14): `visited` tracks the object ancestors
- * along the CURRENT recursion path (not a global "seen" set, so the same
- * object reachable twice via non-cyclic sibling branches still canonicalizes
- * normally); revisiting an ancestor renders that node as the literal string
- * `'[cycle]'` instead of recursing — deterministic, never throws, never
- * overflows the call stack.
- *
- * @param value - The value to canonicalize
- * @param visited - The object ancestors along the current recursion path (internal; omit at the call site)
- * @returns The canonical string form
- *
- * @example
- * ```ts
- * import { canonicalize } from '@src/core'
- *
- * canonicalize({ b: 1, a: 2 }) === canonicalize({ a: 2, b: 1 }) // true
- * ```
- */
-export declare function canonicalize(value: unknown, visited?: ReadonlySet<object>): string;
-
-/**
- * The `Clarifier` stage: resolves same-domain carry-over, template defaults,
- * and declaratively computed fields against an already-assigned entity set,
- * surfacing an {@link Ambiguity} for every required mapping that stays
- * unresolved.
- *
- * @remarks
- * Resolution order: fresh (already-assigned) entities always win; carry-over
- * fills a mapping only from the SAME domain's most recent prior turn (a
- * domain change drops carry-over entirely) and never overwrites a fresh
- * value; template defaults fill any field still unresolved after carry-over;
- * computed fields resolve in dependency (topological) order via
- * `resolveExpression` — an unresolved input, a non-finite result, or a
- * dependency cycle leaves the field a gap, never landing an entity. `floor`
- * (from {@link ClarifierOptions}, never hardcoded — AGENTS-flagged scsr
- * defect 4) gates whether a resolved entity's confidence counts as
- * "resolved enough" when raising ambiguities — a field with a value below
- * `floor` still raises its ambiguity.
- *
- * @example
- * ```ts
- * import { Clarifier } from '@src/core'
- *
- * const clarifier = new Clarifier({ floor: 0.3 })
- * clarifier.clarify(
- * 	[],
- * 	{
- * 		id: 't1',
- * 		name: 'Arithmetic',
- * 		domain: 'arithmetic',
- * 		intents: ['calculate'],
- * 		mappings: [{ entity: 'value', aliases: [], field: 'value', required: true }],
- * 		defaults: [],
- * 		computations: [],
- * 		definition: { reasoning: 'symbolic', id: 't1', name: 'Arithmetic', equations: [], variables: {} },
- * 	},
- * 	undefined,
- * 	{ action: 'calculate', domain: 'arithmetic', confidence: 1 },
- * ) // { entities: [], ambiguities: [{ field: 'value', ... }], complete: false }
- * ```
- */
-export declare class Clarifier implements ClarifierInterface {
-    #private;
-    constructor(options?: ClarifierOptions);
-    clarify(entities: readonly Entity[], template: Template, context: InterpretContextInterface | undefined, intent: Intent): ClarifyResult;
-}
-
-/**
- * The `Clarifier` stage contract: resolve carry-over, defaults, and computed
- * fields against a set of already-assigned entities, surfacing ambiguities
- * for anything required that stays unresolved.
- */
-export declare interface ClarifierInterface {
-    clarify(entities: readonly Entity[], template: Template, context: InterpretContextInterface | undefined, intent: Intent): ClarifyResult;
-}
-
-/**
- * Options for `createClarifier` / the `Clarifier` constructor.
- *
- * @remarks
- * `floor` is the confidence axis honored when raising ambiguities — never
- * hardcoded (scsr hardcoded its confidence constant instead of honoring the
- * configured value).
- */
-export declare interface ClarifierOptions {
-    readonly floor?: number;
-}
-
-/** The `Clarifier` stage's output: resolved entities plus any remaining ambiguities. */
-export declare interface ClarifyResult {
-    readonly entities: readonly Entity[];
-    readonly ambiguities: readonly Ambiguity[];
-    readonly complete: boolean;
-}
-
-/**
- * Classify the action + domain intent of a text against caller-supplied
- * vocabularies.
- *
- * @remarks
- * `actions` maps a token to an action name — the first matching token in
- * `text` (left to right) wins, at `CONFIDENCE_EXACT`. `domains` maps a domain
- * name to its keyword list — the domain with the most matching tokens wins
- * (ties keep the earliest-declared domain), also at `CONFIDENCE_EXACT`.
- * Combined confidence (PINNED): both fire → their average; exactly one fires
- * → its value times `0.5`; neither → `0`. There is no built-in worldview and
- * no auto-classification from a registered template's own `domain` name — a
- * caller MUST list a template's domain among `domains` for it to classify.
- * No `floor` parameter: the confidence floor gate lives at the orchestrator's
- * `matchTemplate` step, never inside classification itself.
- *
- * @param text - The (normalized) text to classify
- * @param actions - The caller's token → action-name vocabulary
- * @param domains - The caller's domain-name → keyword-list vocabulary
- * @returns The classified intent
- *
- * @example
- * ```ts
- * import { classifyIntent } from '@src/core'
- *
- * classifyIntent('calculate my rate', { calculate: 'compute' }, { rating: ['rate'] })
- * // { action: 'compute', domain: 'rating', confidence: 1 }
- * classifyIntent('hello', {}, {}) // { action: '', domain: '', confidence: 0 }
- * ```
- */
-export declare function classifyIntent(text: string, actions: Readonly<Record<string, string>>, domains: Readonly<Record<string, readonly string[]>>): Intent;
-
-/**
- * Collapse every run of whitespace to a single space and trim the ends.
- *
- * @param text - The text to collapse
- * @returns The collapsed text
- *
- * @example
- * ```ts
- * import { collapseWhitespace } from '@src/core'
- *
- * collapseWhitespace('  a   b\t c ') // 'a b c'
- * ```
- */
-export declare function collapseWhitespace(text: string): string;
-
-/**
- * A declaratively computed field: evaluate `expression` against the entities
- * already resolved for this interpretation, and land the result on `field`.
- *
- * @remarks
- * Renamed from scsr's `InferenceRule` — the reasons engine already owns
- * `Inference` for fact derivation, a different concept. `expression` is a
- * reasons {@link SymbolicExpression} tree (pure JSON `Variable` / `Constant`
- * / `Operation`), evaluated by the pure `resolveExpression` helper rather
- * than a closure, so a `Template` stays JSON-serializable end to end.
- * Dependencies are derived from the tree (`variablesOf`) — scsr's explicit
- * `from: string[]` list is gone.
- */
-export declare interface ComputedField {
-    readonly field: FieldPath;
-    readonly expression: SymbolicExpression;
-}
-
-/** Confidence assigned to an exact alias-phrase entity match. */
-export declare const CONFIDENCE_ALIAS = 0.9;
-
-/** Confidence assigned to a same-domain carried-over field. */
-export declare const CONFIDENCE_CARRIED = 0.7;
-
-/** Confidence assigned when a single entity mapping collects every extracted number. */
-export declare const CONFIDENCE_COLLECT = 0.9;
-
-/** Confidence assigned to a successfully resolved computed field. */
-export declare const CONFIDENCE_COMPUTED = 0.9;
-
-/** Confidence assigned to a template default fill. */
-export declare const CONFIDENCE_DEFAULT = 1;
-
-/** Confidence assigned to an exact keyword-proximity entity match. */
-export declare const CONFIDENCE_EXACT = 1;
-
-/** Confidence assigned to a positional (order-based) entity match fallback. */
-export declare const CONFIDENCE_POSITIONAL = 0.7;
-
-/**
- * Create a clarifier — carry-over, defaults, and computed-field resolution
- * against an assigned entity set.
- *
- * @param options - Optional confidence `floor` for raised ambiguities
- * @returns A stateless {@link ClarifierInterface}
- *
- * @example
- * ```ts
- * import { createClarifier } from '@src/core'
- *
- * const clarifier = createClarifier({ floor: 0.5 })
- * ```
- */
-export declare function createClarifier(options?: ClarifierOptions): ClarifierInterface;
-
-/**
- * Create a definition registry.
- *
- * @param options - Optional initial seed collection
- * @returns A working {@link DefinitionManagerInterface}
- *
- * @example
- * ```ts
- * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
- * import { createDefinitionManager } from '@src/core'
- *
- * const definitions = createDefinitionManager({
- * 	definitions: [quantitativeDefinition('d1', 'D1', [factorGroup('total', 'sum', [fieldFactor('value', 'value')])])],
- * })
- * definitions.size // 1
- * ```
- */
-export declare function createDefinitionManager(options?: DefinitionManagerOptions): DefinitionManagerInterface;
-
-/**
- * Create a template-agnostic intent classifier and number extractor.
- *
- * @param options - Optional caller `actions` / `domains` vocabularies
- * @returns A stateless {@link ExtractorInterface}
- *
- * @example
- * ```ts
- * import { createExtractor } from '@src/core'
- *
- * const extractor = createExtractor({
- * 	actions: { calculate: 'calculate' },
- * 	domains: { arithmetic: ['arithmetic'] },
- * })
- * extractor.extract('calculate arithmetic 42').numbers // [42]
- * ```
- */
-export declare function createExtractor(options?: ExtractorOptions): ExtractorInterface;
-
-/**
- * Create a prompt formatter.
- *
- * @param options - Optional caller intent-verb phrasing map
- * @returns A stateless {@link FormatterInterface}
- *
- * @example
- * ```ts
- * import { createFormatter } from '@src/core'
- *
- * const formatter = createFormatter({ verbs: { calculate: 'Calculate' } })
- * ```
- */
-export declare function createFormatter(options?: FormatterOptions): FormatterInterface;
-
-/**
- * Create a subject/definition generator.
- *
- * @param options - Currently an empty extension seam
- * @returns A stateless {@link GeneratorInterface}
- *
- * @example
- * ```ts
- * import { createGenerator } from '@src/core'
- *
- * const generator = createGenerator()
- * ```
- */
-export declare function createGenerator(_options?: GeneratorOptions): GeneratorInterface;
-
-/**
- * Create an interpretation orchestrator.
- *
- * @remarks
- * `interpret()` is genuinely synchronous and runs the fixed five-stage
- * pipeline `[normalize, extract, clarify, format, generate]`. Every stage
- * slot (`normalizer` / `extractor` / `clarifier` / `formatter` / `generator`)
- * is bring-your-own — a supplied implementation is used as-is, else the
- * built-in stage is constructed from the matching per-stage options.
- *
- * @param options - Optional templates, context, stage implementations, the
- *   `similarity` / `floor` axes, and emitter hooks
- * @returns A working {@link InterpretInterface}
- *
- * @example
- * ```ts
- * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
- * import { createInterpret } from '@src/core'
- *
- * const interpret = createInterpret({
- * 	extractor: { extract: () => ({ intent: { action: 'calculate', domain: 'arithmetic', confidence: 1 }, numbers: [42], complete: true }) },
- * 	templates: [
- * 		{
- * 			id: 't1',
- * 			name: 'Arithmetic',
- * 			domain: 'arithmetic',
- * 			intents: ['calculate'],
- * 			mappings: [{ entity: 'value', aliases: [], field: 'value' }],
- * 			defaults: [],
- * 			computations: [],
- * 			definition: quantitativeDefinition('t1', 'Arithmetic', [
- * 				factorGroup('total', 'sum', [fieldFactor('value', 'value')]),
- * 			]),
- * 		},
- * 	],
- * })
- * interpret.interpret('calculate arithmetic 42').subject // { value: 42 }
- * ```
- */
-export declare function createInterpret(options?: InterpretOptions): InterpretInterface;
-
-/**
- * Create a cross-turn interpretation context.
- *
- * @param options - Optional `session` label and `history` ring-buffer cap
- * @returns A working {@link InterpretContextInterface}
- *
- * @example
- * ```ts
- * import { createInterpretContext } from '@src/core'
- *
- * const context = createInterpretContext({ session: 'turn-1', history: 4 })
- * context.previous() // []
- * ```
- */
-export declare function createInterpretContext(options?: InterpretContextOptions): InterpretContextInterface;
-
-/**
- * Create a lexicon-driven reverse-direction rendering engine.
- *
- * @remarks
- * Stateless — `phrase` / `label` / `line` / `value` are total lookups into a
- * caller `Lexicon` merged over `DEFAULT_LEXICON`, and `describe` / `narrate`
- * compose them over a reasons `Definition` / `ReasonResult`.
- *
- * @param options - Optional `lexicon` and `formatters` map
- * @returns A stateless {@link NarratorInterface}
- *
- * @example
- * ```ts
- * import { createNarrator } from '@src/core'
- *
- * const narrator = createNarrator({ lexicon: { templates: { 'subject.empty': 'nothing here' } } })
- * narrator.line('subject.empty', {}) // 'nothing here'
- * ```
- */
-export declare function createNarrator(options?: NarratorOptions): NarratorInterface;
-
-/**
- * Create a text normalizer.
- *
- * @param options - Optional contraction / abbreviation / correction maps,
- *   merged over the neutral built-in defaults
- * @returns A stateless {@link NormalizerInterface}
- *
- * @example
- * ```ts
- * import { createNormalizer } from '@src/core'
- *
- * createNormalizer().normalize("it's  cold") // { text: 'it is cold', changes: [{ from: "it's", to: 'it is' }] }
- * ```
- */
-export declare function createNormalizer(options?: NormalizerOptions): NormalizerInterface;
-
-/**
- * Create a subject registry.
- *
- * @remarks
- * Mints its own record ids on `add` when none is supplied — a `Subject`
- * carries no `id` field of its own.
- *
- * @param options - Optional initial seed collection
- * @returns A working {@link SubjectManagerInterface}
- *
- * @example
- * ```ts
- * import { createSubjectManager } from '@src/core'
- *
- * const subjects = createSubjectManager({ subjects: [{ value: 1 }] })
- * subjects.size // 1
- * ```
- */
-export declare function createSubjectManager(options?: SubjectManagerOptions): SubjectManagerInterface;
-
-/**
- * Build and validate one interpretation template from plain data.
- *
- * @remarks
- * The factory/coercer pair for template intake (AGENTS §4.6.1): this throws
- * on malformed data, while `parseTemplate` returns `undefined`. Data failing
- * {@link isTemplate} throws `InterpretError('INVALID_TEMPLATE', …)`.
- *
- * @param data - The candidate template data
- * @returns The same data, now known to satisfy {@link Template}
- * @throws {@link InterpretError} `INVALID_TEMPLATE` when `data` fails validation
-     *
-     * @example
-     * ```ts
-     * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
-     * import { createTemplate } from '@src/core'
-     *
-     * const template = createTemplate({
-     * 	id: 't1', name: 'Arithmetic', domain: 'arithmetic', intents: ['calculate'],
-     * 	mappings: [{ entity: 'value', aliases: [], field: 'value' }], defaults: [], computations: [],
-     * 	definition: quantitativeDefinition('t1', 'Arithmetic', [factorGroup('total', 'sum', [fieldFactor('value', 'value')])]),
-     * })
-     * template.id // 't1'
-     * ```
-     */
- export declare function createTemplate(data: Template): Template;
-
- /**
-  * Create a template registry.
-  *
-  * @param options - Optional initial seed collection
-  * @returns A working {@link TemplateManagerInterface}
-  *
-  * @example
-  * ```ts
-  * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
-  * import { createTemplate, createTemplateManager } from '@src/core'
-  *
-  * const template = createTemplate({
-  * 	id: 't1', name: 'Arithmetic', domain: 'arithmetic', intents: ['calculate'],
-  * 	mappings: [{ entity: 'value', aliases: [], field: 'value' }], defaults: [], computations: [],
-  * 	definition: quantitativeDefinition('t1', 'Arithmetic', [factorGroup('total', 'sum', [fieldFactor('value', 'value')])]),
-  * })
-  * const templates = createTemplateManager({ templates: [template] })
-  * templates.size // 1
-  * ```
-  */
- export declare function createTemplateManager(options?: TemplateManagerOptions): TemplateManagerInterface;
-
- /** Neutral built-in abbreviation expansions for `Normalizer` — empty by default. */
- export declare const DEFAULT_ABBREVIATIONS: Readonly<Record<string, string>>;
-
- /** Neutral built-in action-verb vocabulary for `Extractor#extract`'s intent classification — empty by default. */
- export declare const DEFAULT_ACTIONS: Readonly<Record<string, string>>;
-
- /**
-  * Neutral built-in contraction expansions for `Normalizer` — small on
-  * purpose; callers merge their own map over this one.
-  */
- export declare const DEFAULT_CONTRACTIONS: Readonly<Record<string, string>>;
-
- /** Neutral built-in misspelling corrections for `Normalizer` — empty by default. */
- export declare const DEFAULT_CORRECTIONS: Readonly<Record<string, string>>;
-
- /** Neutral built-in domain-keyword vocabulary for `Extractor#extract`'s intent classification — empty by default. */
- export declare const DEFAULT_DOMAINS: Readonly<Record<string, readonly string[]>>;
-
- /**
-  * Default `floor` for `createInterpret` / `matchTemplate` — the minimum
-  * intent confidence a template match (or the classified intent itself) must
-  * clear.
-  */
- export declare const DEFAULT_INTERPRET_FLOOR = 0.3;
-
- /** Default `history` cap for an `InterpretContext`'s `previous()` ring buffer. */
- export declare const DEFAULT_INTERPRET_HISTORY = 16;
-
- /**
-  * Default `similarity` for `createInterpret` / `matchAlias` — the fuzzy
-  * alias-match score threshold (0..1).
-  *
-  * @remarks
-  * Domain-qualified (not a bare `DEFAULT_SIMILARITY`) so the name stays free
-  * of collision on the shared `@src/core` barrel, mirroring the
-  * `DEFAULT_REASON_BAIL` precedent.
-  */
- export declare const DEFAULT_INTERPRET_SIMILARITY = 0.8;
-
- /**
-  * The neutral default `Lexicon` a `Narrator` merges caller data over.
-  *
-  * @remarks
-  * `phrases` and `labels` are empty — there is no built-in vocabulary or
-  * label overrides (AGENTS §21 mechanism-never-policy). `templates` carries
-  * the structural, display-neutral strings the reverse helpers formerly
-  * hardcoded, keyed by
-  * `{table}.{reasoning}` for the four reasons kinds, `result.quantitative.failed`
-  * for the quantitative-result failure suffix, and `subject.fields` /
-  * `subject.empty` for `describeSubject`. Every string is a plain
-  * `interpolateMessage` template — `{{name}}`-style placeholders resolved
-  * against the caller-supplied `values` record.
-  */
- export declare const DEFAULT_LEXICON: Lexicon;
-
- /** Neutral built-in intent-verb phrasing for `Formatter#format` — empty by default. */
- export declare const DEFAULT_VERBS: Readonly<Record<string, string>>;
-
- /**
-  * The definition registry — a self-owning, versioned and content-hashed
-  * record-holder for the reasons {@link Definition}s an interpretation produces.
-  *
-  * @remarks
-  * Mirrors {@link TemplateManager}: `add` defaults each record id to the
-  * definition's own `id`, derives `hash` from the definition CONTENT
-  * (id-independent), and bumps `version` ONLY when that hash changes at a reused
-  * id — an identical re-add keeps its version. The batch `remove(ids)` form is
-  * all-or-nothing; `destroy()` is idempotent and every method afterwards throws
-  * `InterpretError('DESTROYED', …)`.
-  *
-  * @example
-  * ```ts
-  * import { symbolicDefinition } from '@orkestrel/reason'
-  * import { DefinitionManager } from '@src/core'
-  *
-  * const manager = new DefinitionManager()
-  * const record = manager.add(symbolicDefinition('rate', 'Rate', []))
-  * record.id // 'rate'
-  * manager.add(symbolicDefinition('rate', 'Rate', [])).version // 1 — identical re-add, no bump
-  * ```
-  */
- export declare class DefinitionManager implements DefinitionManagerInterface {
-     #private;
-     constructor(options?: DefinitionManagerOptions);
-     get emitter(): EmitterInterface<DefinitionManagerEventMap>;
-     get size(): number;
-     has(id: string): boolean;
-     definition(id: string): DefinitionRecord | undefined;
-     definitions(): readonly DefinitionRecord[];
-     add(definition: Definition, options?: ManagerAddOptions): DefinitionRecord;
-     remove(ids: readonly string[]): boolean;
-     remove(id: string): boolean;
-     remove(): void;
-     destroy(): void;
- }
-
- /** The push observation surface of a {@link DefinitionManagerInterface} (AGENTS §13). */
- export declare type DefinitionManagerEventMap = {
-     /** A definition record was added — carries its record id. */
-     readonly add: readonly [id: string];
-     /** A definition record was removed — carries its record id. */
-     readonly remove: readonly [id: string];
-     /** The manager was destroyed. */
-     readonly destroy: readonly [];
- };
-
- /** The definition registry — a self-owning, versioned/hashed record-holder. */
- export declare interface DefinitionManagerInterface {
-     readonly emitter: EmitterInterface<DefinitionManagerEventMap>;
-     readonly size: number;
-     has(id: string): boolean;
-     definition(id: string): DefinitionRecord | undefined;
-     definitions(): readonly DefinitionRecord[];
-     add(definition: Definition, options?: ManagerAddOptions): DefinitionRecord;
-     remove(ids: readonly string[]): boolean;
-     remove(id: string): boolean;
-     remove(): void;
-     destroy(): void;
- }
-
- /** Options for `createDefinitionManager` / the `DefinitionManager` constructor — the initial seed collection. */
- export declare interface DefinitionManagerOptions {
-     readonly definitions?: readonly Definition[];
-     readonly on?: EmitterHooks<DefinitionManagerEventMap>;
-     readonly error?: EmitterErrorHandler;
- }
-
- /** A versioned, content-hashed {@link Definition} as held by a {@link DefinitionManagerInterface}. */
- export declare interface DefinitionRecord {
-     readonly id: string;
-     readonly definition: Definition;
-     readonly version: number;
-     readonly hash: string;
- }
-
- /**
-  * Copy-on-write write a value at a (possibly nested) field path on a subject.
-  *
-  * @remarks
-  * Never mutates `subject` — every level a `field` array descends through is
-  * freshly copied, so the input and every intermediate record stay untouched
-  * (AGENTS §11). Prototype-pollution-safe: a `field` containing `__proto__`,
-  * `prototype`, or `constructor` at ANY segment (checked against
-  * `UNSAFE_FIELD_SEGMENTS`) is refused as a no-op, returning `subject`
-  * unchanged. A non-record value already sitting at an intermediate segment is
-  * replaced by a fresh record rather than descended into.
-  *
-  * @param subject - The subject to derive from
-  * @param field - The (possibly nested) field path to write
-  * @param value - The value to write
-  * @returns A fresh subject with `value` written at `field`, or `subject`
-  * unchanged when `field` carries an unsafe segment
-  *
-  * @example
-  * ```ts
-  * import { setField } from '@src/core'
-  *
-  * setField({ age: 25 }, 'age', 30)               // { age: 30 }
-  * setField({}, ['address', 'city'], 'Reno')      // { address: { city: 'Reno' } }
-  * setField({}, ['__proto__', 'polluted'], true)  // {} — refused, unchanged
-  * ```
-  */
- /**
-  * Derive the sibling field path for a computed aggregate of `field` — the
-  * suffix is appended to `field`'s OWN last segment, so the aggregate nests
-  * beside the source field rather than flattening past it.
-  *
-  * @remarks
-  * For an array {@link FieldPath} (e.g. `['address', 'amounts']`) with suffix
-  * `'Sum'` the result is `['address', 'amountsSum']` — nested beside
-  * `address.amounts`. For a plain string field the result stays a flat string
-  * (`'amounts'` → `'amountsSum'`), matching the existing single-key behavior.
-  *
-  * @param field - The source field path
-  * @param suffix - The aggregate suffix (`'Sum'`, `'Count'`, `'Average'`, `'Minimum'`, `'Maximum'`)
-  * @returns The sibling field path for the aggregate
-  *
-  * @example
-  * ```ts
-  * import { deriveAggregateField } from '@src/core'
-  *
-  * deriveAggregateField(['address', 'amounts'], 'Sum') // ['address', 'amountsSum']
-  * deriveAggregateField('amounts', 'Sum')               // 'amountsSum'
-  * ```
-  */
- export declare function deriveAggregateField(field: FieldPath, suffix: string): FieldPath;
-
- /**
-  * Render a one-line, display-neutral description of a reasons `Subject`,
-  * through an injected `Narrator`.
-  *
-  * @remarks
-  * Complements — never duplicates — the raters `describe*` family (which
-  * describes RATERS artifacts); this describes REASONS artifacts. Every field
-  * renders via `narrator.label` + `narrator.value` (looked up under the
-  * `'units'` phrase table, falling back to `'plain'`) — the wording is fully
-  * lexicon-driven (AGENTS §21 mechanism-never-policy); `Definition` /
-  * `ReasonResult` narration lives on `Narrator#describe` / `Narrator#narrate`
-  * directly.
-  *
-  * @param subject - The subject to describe
-  * @param narrator - The lexicon-driven renderer to render field labels/values/lines through
-  * @returns A one-line description, the lexicon's `'subject.empty'` line when empty
-  *
-  * @example
-  * ```ts
-  * import { createNarrator, describeSubject } from '@src/core'
-  *
-  * describeSubject({ age: 25, income: 50000 }, createNarrator()) // 'with age: 25, income: 50000'
-  * ```
-  */
- export declare function describeSubject(subject: Subject, narrator: NarratorInterface): string;
-
- /**
-  * Compute a canonical structural digest of a pure-JSON value — a key-order-
-  * stable FNV-1a hash rendered as an 8-hex-digit string.
-  *
-  * @remarks
-  * Pure ECMAScript, no host crypto (AGENTS §17.7) — the same algorithm as the
-  * app's `digest`, ported into core so `Interpretation.digest` and the
-  * versioned managers can hash without leaving strict core.
-  *
-  * @param value - The value to digest
-  * @returns The 8-character hex digest
-  *
-  * @example
-  * ```ts
-  * import { digestValue } from '@src/core'
-  *
-  * digestValue({ a: 1 }) === digestValue({ a: 1 }) // true — deterministic
-  * ```
-  */
- export declare function digestValue(value: unknown): string;
-
- /** One value assigned to a template's entity mapping, with its provenance and confidence. */
- export declare interface Entity {
-     readonly name: string;
-     readonly value: unknown;
-     readonly provenance: Provenance;
-     readonly confidence: number;
- }
-
- /**
-  * One entity-extraction rule inside a {@link Template}: which literal alias
-  * phrases identify a value, and which subject field it lands on.
-  *
-  * @remarks
-  * `aliases` are literal phrases (no `RegExp` — templates stay JSON), matched
-  * exact-then-fuzzy against tokens surrounding an extracted number. `required`
-  * marks the field as needing an {@link Ambiguity} when it stays unresolved.
-  */
- export declare interface EntityMapping {
-     readonly entity: string;
-     readonly aliases: readonly string[];
-     readonly field: FieldPath;
-     readonly required?: boolean;
- }
-
- /**
-  * Escape every regex metacharacter in `text` so it matches literally when
-  * compiled into a `RegExp`.
-  *
-  * @param text - The literal text to escape
-  * @returns `text` with every regex metacharacter backslash-escaped
-  *
-  * @example
-  * ```ts
-  * import { escapeRegExp } from '@src/core'
-  *
-  * escapeRegExp('a.b*c') // 'a\\.b\\*c'
-  * new RegExp(escapeRegExp('a.b*c')).test('a.b*c') // true
-  * ```
-  */
- export declare function escapeRegExp(text: string): string;
-
- /**
-  * Mine every numeric literal from text — optional leading `$`, thousands
-  * commas, an optional decimal fraction, an optional trailing `%`.
-  *
-  * @remarks
-  * Numbers-only: this is the module's entire extraction contract (AGENTS
-  * §21 mechanism-never-policy) — no date, text-entity, or negation parsing.
-  *
-  * @param text - The text to scan
-  * @returns Every extracted number, in left-to-right order
-  *
-  * @example
-  * ```ts
-  * import { extractNumbers } from '@src/core'
-  *
-  * extractNumbers('income was $50,000, age 25') // [50000, 25]
-  * ```
-  */
- export declare function extractNumbers(text: string): readonly number[];
-
- /**
-  * The `Extractor` stage: template-agnostic intent classification plus raw
-  * numeric-entity mining.
-  *
-  * @remarks
-  * Deliberately never named `Parser` — the `contracts` module already owns
-  * `Parser<T>`, so a class of that name would collide in type space (AGENTS
-  * §21, design ledger 3). `extract` never sees a `Template`: numbers →
-  * entity ASSIGNMENT is a separate orchestrator-owned step that runs only
-  * after a template has matched (`assignEntities` in `helpers.ts`), not
-  * inside this stage (the defect-3 fix — scsr's parser mined template-shaped
-  * entities directly and only worked via an `instanceof` hack).
-  *
-  * @example
-  * ```ts
-  * import { Extractor } from '@src/core'
-  *
-  * const extractor = new Extractor({
-  * 	actions: { calculate: 'compute' },
-  * 	domains: { rating: ['rate'] },
-  * })
-  * extractor.extract('calculate my rate at 85')
-  * // { intent: { action: 'compute', domain: 'rating', confidence: 1 }, numbers: [85], complete: true }
-  * ```
-  */
- export declare class Extractor implements ExtractorInterface {
-     #private;
-     constructor(options?: ExtractorOptions);
-     extract(text: string): ExtractResult;
- }
-
- /** The `Extractor` stage contract: template-agnostic intent classification + raw number mining. */
- export declare interface ExtractorInterface {
-     extract(text: string): ExtractResult;
- }
-
- /**
-  * Options for `createExtractor` / the `Extractor` constructor.
-  *
-  * @remarks
-  * `actions` / `domains` are the caller's intent vocabulary — there is no
-  * built-in worldview (AGENTS-flagged scsr defect). Neither `floor` nor
-  * `similarity` lives here: the confidence floor gate is the orchestrator's
-  * `matchTemplate` step, never the classifier itself.
-  */
- export declare interface ExtractorOptions {
-     readonly actions?: Readonly<Record<string, string>>;
-     readonly domains?: Readonly<Record<string, readonly string[]>>;
- }
-
- /**
-  * The `Extractor` stage's output: intent classification plus raw numbers.
-  *
-  * @remarks
-  * Template-agnostic by design — extraction never sees a `Template`, only the
-  * text. `numbers`, not template-named entities; entity ASSIGNMENT is a
-  * separate orchestrator step run only after a template has matched (see
-  * `assignEntities` in `helpers.ts`).
-  */
- export declare interface ExtractResult {
-     readonly intent: Intent;
-     readonly numbers: readonly number[];
-     readonly complete: boolean;
- }
-
- /** A fallback value a {@link Template} fills onto a field left unresolved by extraction. */
- export declare interface FieldDefault {
-     readonly field: FieldPath;
-     readonly value: unknown;
- }
-
- /**
-  * One audited field of the built subject — its resolved value, provenance,
-  * and confidence.
-  *
-  * @remarks
-  * Emitted for EVERY field that lands in the generated subject, including
-  * defaults and computed fields (scsr silently omitted those from its audit
-  * trail; this closes that gap).
-  */
- export declare interface FieldMapping {
-     readonly field: FieldPath;
-     readonly entity?: string;
-     readonly value: unknown;
-     readonly provenance: Provenance;
-     readonly confidence: number;
- }
-
- /** The `Formatter` stage's output: the refined natural-language prompt. */
- export declare interface FormatResult {
-     readonly prompt: string;
- }
-
- /**
-  * The `Formatter` stage: renders the refined natural-language prompt for a
-  * matched template.
-  *
-  * @remarks
-  * Shape: `{verb} {template.name}` + ` with {label}: {value}, …` for every
-  * non-default entity (via the core-root `formatField`) + `
-  * (defaults: {label}: {value}, …)` for default-provenance entities + `
-  * needed: {question} …` for every ambiguity. `verbs` maps `intent.action` to
-  * its display verb; an action absent from the map falls back to the action
-  * string itself. Every parameter is read — no ignored `context` argument
-  * (AGENTS-flagged scsr defect 5).
-  *
-  * @example
-  * ```ts
-  * import { Formatter } from '@src/core'
-  *
-  * const formatter = new Formatter({ verbs: { calculate: 'Calculate' } })
-  * formatter.format(
-  * 	{ action: 'calculate', domain: 'arithmetic', confidence: 1 },
-  * 	{
-  * 		id: 't1',
-  * 		name: 'Arithmetic',
-  * 		domain: 'arithmetic',
-  * 		intents: ['calculate'],
-  * 		mappings: [],
-  * 		defaults: [],
-  * 		computations: [],
-  * 		definition: { reasoning: 'symbolic', id: 't1', name: 'Arithmetic', equations: [], variables: {} },
-  * 	},
-  * 	[],
-  * 	[],
-  * ) // { prompt: 'Calculate Arithmetic' }
-  * ```
-  */
- export declare class Formatter implements FormatterInterface {
-     #private;
-     constructor(options?: FormatterOptions);
-     format(intent: Intent, template: Template, entities: readonly Entity[], ambiguities: readonly Ambiguity[]): FormatResult;
- }
-
- /** The `Formatter` stage contract: render the refined natural-language prompt for a matched template. */
- export declare interface FormatterInterface {
-     format(intent: Intent, template: Template, entities: readonly Entity[], ambiguities: readonly Ambiguity[]): FormatResult;
- }
-
- /** Options for `createFormatter` / the `Formatter` constructor — caller-supplied intent-verb phrasing. */
- export declare interface FormatterOptions {
-     readonly verbs?: Readonly<Record<string, string>>;
- }
-
- /** The `Generator` stage's output: the built subject/definition pair plus its full field audit. */
- export declare interface GenerateResult {
-     readonly subject: Subject;
-     readonly definition: Definition;
-     readonly mappings: readonly FieldMapping[];
-     readonly confidence: number;
- }
-
- /**
-  * The `Generator` stage: builds the final `Subject` from a fully resolved
-  * entity set, plus its complete field audit.
-  *
-  * @remarks
-  * `entity → field` via `template.mappings` (an `EntityMapping.entity` name
-  * lookup); an entity whose name matches no mapping lands on the field named
-  * by its OWN `name` — the shape `Clarifier` uses for its synthesized
-  * default/computed entities, so one lookup rule serves both extraction-
-  * mapped and template-data-derived fields. A single-element array value
-  * unwraps to its scalar; a multi-element, ALL-numeric array value stays an
-  * array AND additionally emits five aggregate fields (`Sum` / `Count` /
-  * `Average` / `Minimum` / `Maximum`, provenance `computed`), each derived as
-  * a SIBLING path beside the source field via `deriveAggregateField` — for an
-  * array `FieldPath` (e.g. `['address', 'amounts']`) the aggregates nest
-  * (`['address', 'amountsSum']`, ...); for a plain string field they stay
-  * flat (`'amountsSum'`), matching the source field's own shape.
-  * `confidence` is the mean of the input entities' own confidences (`0` for
-  * an empty entity set). A `FieldMapping` is emitted for EVERY field that
-  * lands on the subject, including defaults, computed fields, and aggregates
-  * — scsr silently omitted defaults/computed from its audit trail; this
-  * closes that gap. `GeneratorOptions` is a reserved extension seam — the
-  * stage has no knobs yet, so construction takes no arguments until one
-  * exists.
-  *
-  * @example
-  * ```ts
-  * import { Generator } from '@src/core'
-  *
-  * const generator = new Generator()
-  * generator.generate(
-  * 	[
-  * 		{
-  * 			name: 'value',
-  * 			value: 42,
-  * 			provenance: { category: 'extracted', detail: 'collect' },
-  * 			confidence: 0.9,
-  * 		},
-  * 	],
-  * 	{
-  * 		id: 't1',
-  * 		name: 'Arithmetic',
-  * 		domain: 'arithmetic',
-  * 		intents: ['calculate'],
-  * 		mappings: [{ entity: 'value', aliases: [], field: 'value' }],
-  * 		defaults: [],
-  * 		computations: [],
-  * 		definition: { reasoning: 'symbolic', id: 't1', name: 'Arithmetic', equations: [], variables: {} },
-  * 	},
-  * ) // { subject: { value: 42 }, mappings: [...], confidence: 0.9, ... }
-  * ```
-  */
- declare class Generator_2 implements GeneratorInterface {
-     generate(entities: readonly Entity[], template: Template): GenerateResult;
- }
- export { Generator_2 as Generator }
-
- /** The `Generator` stage contract: build the final subject/definition pair plus its field audit. */
- export declare interface GeneratorInterface {
-     generate(entities: readonly Entity[], template: Template): GenerateResult;
- }
-
- /**
-  * Options for `createGenerator` / the `Generator` constructor.
-  *
-  * @remarks
-  * Currently an empty extension seam — the `Generator` stage takes no
-  * configuration today, but keeps its own options type so a future knob
-  * never has to change the `GeneratorInterface#generate` call signature.
-  */
- export declare interface GeneratorOptions {
- }
-
- /**
-  * The classified action + domain for one interpretation, with a combined
-  * confidence.
-  *
-  * @remarks
-  * Produced by `classifyIntent` against caller-supplied `actions` / `domains`
-  * vocabularies only — there is no built-in en-US worldview and no
-  * auto-classification from a registered template's own `domain` name.
-  */
- export declare interface Intent {
-     readonly action: string;
-     readonly domain: string;
-     readonly confidence: number;
- }
-
- /**
-  * Interpolate `{{dotted.path}}` tokens in a message template against a record.
-  *
-  * @remarks
-  * Each token is split on `.` into a {@link FieldPath} array and resolved with
-  * the contracts `resolveField` (a plain string field is ONE key, never
-  * dot-split — the split here is the token-to-path bridge). A finite number
-  * renders with `en-US` thousand grouping (`5010` → `5,010`); any other
-  * resolved value String-coerces. An UNRESOLVED path (the resolved value is
-  * `undefined`) renders as the empty string — the deterministic "nothing to
-  * show" rule.
-  *
-  * @param template - The message template carrying `{{dotted.path}}` tokens
-  * @param record - The record tokens resolve against
-  * @returns The template with every token replaced
-  *
-  * @example
-  * ```ts
-  * import { interpolateMessage } from '@src/core'
-  *
-  * interpolateMessage('Limit is {{limit}}', { limit: 5010 }) // 'Limit is 5,010'
-  * interpolateMessage('Missing {{gone}}', {})                // 'Missing '
-  * ```
-  */
- export declare function interpolateMessage(template: string, record: Readonly<Record<string, unknown>>): string;
-
- /**
-  * The interpretation orchestrator — the sole public entry point of the
-  * `interprets` module, mirroring the reasons `Reason` orchestrator shape.
-  *
-  * @remarks
-  * `interpret()` is genuinely SYNCHRONOUS (scsr's was fake-async with zero
-  * `await`s) and runs a fixed five-stage pipeline —
-  * `[normalize, extract, clarify, format, generate]` — each producing one
-  * {@link StageRecord}. Between `extract` and `clarify` the orchestrator matches
-  * the classified {@link Intent} against its registered {@link Template}s and,
-  * on a match, assigns the extracted numbers to that template's mappings
-  * (`assignEntities`) — a template-owned step, not a sixth stage. No match, or a
-  * matched template whose intent confidence falls below the configured `floor`,
-  * yields an explicit, auditable INCOMPLETE result (a `field: 'intent'`
-  * ambiguity, absent subject/definition) rather than scsr's arbitrary
-  * `templates[0]` fallback. A stage THROW is caught, marked on its record AND on
-  * `failures`, emitted as `error`, and still yields a visible incomplete result
-  * — never a silent fallback. Every result carries a `digest` over its original
-  * text plus the matched template id/version and the built subject/definition,
-  * so re-running the same text against the same template version reproduces the
-  * same digest (the replay contract). `describe` / `narrate` are the reverse
-  * direction (structure → prose). `destroy()` is idempotent, tears down the
-  * registry and context, then destroys the emitter LAST (AGENTS §13); every
-  * method afterwards except the {@link emitter} getter throws
-  * `InterpretError('DESTROYED', …)`.
-  *
-  * @example
-  * ```ts
-  * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
-  * import { Interpret, Extractor } from '@src/core'
-  *
-  * const interpret = new Interpret({
-  * 	extractor: new Extractor({ actions: { calculate: 'calculate' }, domains: { arithmetic: ['arithmetic'] } }),
-  * 	templates: [
-  * 		{
-  * 			id: 't1',
-  * 			name: 'Arithmetic',
-  * 			domain: 'arithmetic',
-  * 			intents: ['calculate'],
-  * 			mappings: [{ entity: 'value', aliases: [], field: 'value' }],
-  * 			defaults: [],
-  * 			computations: [],
-  * 			definition: quantitativeDefinition('t1', 'Arithmetic', [
-  * 				factorGroup('total', 'sum', [fieldFactor('value', 'value')]),
-  * 			]),
-  * 		},
-  * 	],
-  * })
-  * interpret.interpret('calculate arithmetic 42').subject // { value: 42 }
-  * ```
-  */
- export declare class Interpret implements InterpretInterface {
-     #private;
-     constructor(options?: InterpretOptions);
-     get emitter(): EmitterInterface<InterpretEventMap>;
-     interpret(text: string): Interpretation;
-     register(template: Template): void;
-     unregister(id: string): boolean;
-     template(id: string): Template | undefined;
-     templates(): readonly Template[];
-     describe(definition: Definition): string;
-     narrate(result: ReasonResult): string;
-     destroy(): void;
- }
-
- /** Default `id` for an `Interpret` orchestrator. */
- export declare const INTERPRET_ID = "interpret";
-
- /**
-  * The full, replayable outcome of one `interpret()` call.
-  *
-  * @remarks
-  * `subject` / `definition` are absent on an incomplete `NO_TEMPLATE` /
-  * `LOW_CONFIDENCE` result — there is never a fabricated fallback template
-  * (scsr's `templates[0]` double-fallback defect). `stages` always holds
-  * exactly five records, `[normalize, extract, clarify, format, generate]`,
-  * in order. `digest` is `digestValue` over `{text, templateId,
-  * templateVersion, subject, definition}` — re-running the same original text
-  * against the same template version reproduces the same digest (the replay
-  * contract).
-  */
- export declare interface Interpretation {
-     readonly text: string;
-     readonly normalized: string;
-     readonly intent: Intent;
-     readonly entities: readonly Entity[];
-     readonly subject?: Subject;
-     readonly definition?: Definition;
-     readonly mappings: readonly FieldMapping[];
-     readonly ambiguities: readonly Ambiguity[];
-     readonly prompt: string;
-     readonly stages: readonly StageRecord[];
-     readonly failures: readonly StageFailure[];
-     readonly complete: boolean;
-     readonly confidence: number;
-     readonly digest: string;
- }
-
- /**
-  * Cross-turn interpretation context — a capped, replayable history of
-  * completed {@link Interpretation}s plus the subject and definition registries
-  * carry-over reads from.
-  *
-  * @remarks
-  * `previous()` is a capped ring buffer (newest-last, oldest dropped once the
-  * `history` cap is reached — `DEFAULT_INTERPRET_HISTORY` by default, ≥ 3
-  * preserves the carry-over pin) rather than scsr's unbounded `previous` array.
-  * `entities()` flattens every entity across the buffered history, most recent
-  * last — the read a `Clarifier`'s same-domain carry-over consults. `add` pushes
-  * one result and trims to the cap; `clear` resets the history and both
-  * registries WITHOUT tearing the context down; `destroy()` is idempotent and
-  * every method afterwards throws `InterpretError('DESTROYED', …)`.
-  *
-  * @example
-  * ```ts
-  * import { InterpretContext } from '@src/core'
-  *
-  * const context = new InterpretContext({ session: 's1', history: 8 })
-  * context.session // 's1'
-  * context.previous() // []
-  * ```
-  */
- export declare class InterpretContext implements InterpretContextInterface {
-     #private;
-     constructor(options?: InterpretContextOptions);
-     get emitter(): EmitterInterface<InterpretContextEventMap>;
-     get session(): string | undefined;
-     get subjects(): SubjectManagerInterface;
-     get definitions(): DefinitionManagerInterface;
-     previous(): readonly Interpretation[];
-     entities(): readonly Entity[];
-     add(result: Interpretation): void;
-     clear(): void;
-     destroy(): void;
- }
-
- /**
-  * The push observation surface of an {@link InterpretContextInterface} (AGENTS
-  * §13).
-  *
-  * @remarks
-  * An {@link Interpretation} carries no `id` of its own — `add` carries the
-  * entry's `digest` instead, the closest content-derived identity it has.
-  */
- export declare type InterpretContextEventMap = {
-     /** A completed interpretation was added to the history — carries its digest. */
-     readonly add: readonly [digest: string];
-     /** The history and both registries were cleared. */
-     readonly clear: readonly [];
-     /** The context was destroyed. */
-     readonly destroy: readonly [];
- };
-
- /**
-  * Cross-turn interpretation context: a capped, replayable history plus the
-  * subject/definition registries carry-over reads from.
-  *
-  * @remarks
-  * `previous()` returns the ring buffer newest-last, capped at the
-  * configured `history` (default `DEFAULT_INTERPRET_HISTORY`). `entities()`
-  * flattens every entity recorded across the buffered history, most recent
-  * last — the read carry-over consults. `add` pushes one completed
-  * {@link Interpretation}, dropping the oldest entry once the cap is reached.
-  */
- export declare interface InterpretContextInterface {
-     readonly emitter: EmitterInterface<InterpretContextEventMap>;
-     readonly session?: string;
-     readonly subjects: SubjectManagerInterface;
-     readonly definitions: DefinitionManagerInterface;
-     previous(): readonly Interpretation[];
-     entities(): readonly Entity[];
-     add(result: Interpretation): void;
-     clear(): void;
-     destroy(): void;
- }
-
- /** Options for `createInterpretContext` / the `InterpretContext` constructor. */
- export declare interface InterpretContextOptions {
-     readonly session?: string;
-     readonly history?: number;
-     readonly on?: EmitterHooks<InterpretContextEventMap>;
-     readonly error?: EmitterErrorHandler;
- }
-
- /**
-  * An error thrown by the interprets layer.
-  *
-  * @remarks
-  * Thrown for: an injected stage implementation throwing during its phase
-  * (`NORMALIZE_FAILED` / `EXTRACT_FAILED` / `CLARIFY_FAILED` /
-  * `FORMAT_FAILED` / `GENERATE_FAILED`), `createTemplate` handed data that
-  * fails `isTemplate` (`INVALID_TEMPLATE`), and any use of a destroyed
-  * `Interpret` / manager / context (`DESTROYED`). `NO_TEMPLATE` and
-  * `LOW_CONFIDENCE` never throw — they surface as a visible incomplete
-  * {@link Interpretation} instead (never an arbitrary fallback template).
-  * `context`, when present, carries the offending stage / template id.
-  */
- export declare class InterpretError extends Error {
-     readonly code: InterpretErrorCode;
-     readonly context?: Readonly<Record<string, unknown>>;
-     constructor(code: InterpretErrorCode, message: string, context?: Readonly<Record<string, unknown>>);
- }
-
- /**
-  * Coded misuse / failure conditions thrown as an {@link InterpretError} or
-  * carried on a {@link StageFailure}.
-  *
-  * @remarks
-  * `NORMALIZE_FAILED` / `EXTRACT_FAILED` / `CLARIFY_FAILED` / `FORMAT_FAILED`
-  * / `GENERATE_FAILED` — an injected stage implementation threw during that
-  * phase. `NO_TEMPLATE` — no registered {@link Template} scored at or above
-  * the confidence floor (or the registry is empty). `LOW_CONFIDENCE` — a
-  * template matched but the classified {@link Intent}'s confidence fell below
-  * the floor. `INVALID_TEMPLATE` — `createTemplate` was handed data that
-  * fails `isTemplate`. `DESTROYED` — any use of a destroyed entity.
-  */
- export declare type InterpretErrorCode = 'NORMALIZE_FAILED' | 'EXTRACT_FAILED' | 'CLARIFY_FAILED' | 'FORMAT_FAILED' | 'GENERATE_FAILED' | 'NO_TEMPLATE' | 'LOW_CONFIDENCE' | 'INVALID_TEMPLATE' | 'DESTROYED';
-
- /**
-  * The push observation surface of an {@link InterpretInterface} (AGENTS §13).
-  *
-  * @remarks
-  * `interpret` fires once per completed `interpret()` call (complete OR
-  * incomplete — visibility is the point, unlike scsr's silent fallbacks).
-  * `register` fires when a template is registered, carrying its id. `error`
-  * fires with the raw thrown value when an injected stage implementation
-  * throws. `destroy` fires once on teardown. Listener isolation is the
-  * emitter's own (AGENTS §13) — never routed onto this map.
-  */
- export declare type InterpretEventMap = {
-     /** An `interpret()` call completed — carries the full result. */
-     readonly interpret: readonly [result: Interpretation];
-     /** A template was registered — carries its id. */
-     readonly register: readonly [templateId: string];
-     /** An injected stage implementation threw — carries the raw thrown value. */
-     readonly error: readonly [error: unknown];
-     /** The orchestrator was destroyed. */
-     readonly destroy: readonly [];
- };
-
- /**
-  * The interpretation orchestrator — the sole public entry point, mirroring
-  * `reasons`' `Reason` orchestrator shape.
-  *
-  * @remarks
-  * `interpret` is genuinely SYNCHRONOUS (scsr's `interpret()` was fake-async
-  * with zero `await`s). `register` / `unregister` / `template` / `templates`
-  * delegate to an internal {@link TemplateManagerInterface} but expose plain
-  * {@link Template} data, not the richer versioned record. `describe` /
-  * `narrate` are the reverse direction — structure-to-prose, complementing
-  * (never duplicating) raters' `describe*` family. After `destroy()` every
-  * method except the `emitter` getter and `destroy` itself throws
-  * `InterpretError('DESTROYED', …)`; `destroy()` is idempotent and tears the
-  * emitter down LAST.
-  */
- export declare interface InterpretInterface {
-     readonly emitter: EmitterInterface<InterpretEventMap>;
-     interpret(text: string): Interpretation;
-     register(template: Template): void;
-     unregister(id: string): boolean;
-     template(id: string): Template | undefined;
-     templates(): readonly Template[];
-     describe(definition: Definition): string;
-     narrate(result: ReasonResult): string;
-     destroy(): void;
- }
-
- /**
-  * Options for `createInterpret` / the `Interpret` constructor.
-  *
-  * @remarks
-  * `templates` seeds the registry. `context` supplies a shared
-  * {@link InterpretContextInterface} (a fresh one is constructed when
-  * omitted). Each stage slot is BRING-YOUR-OWN — a supplied implementation is
-  * used as-is, else the built-in stage is constructed from the matching
-  * per-stage options. `similarity` (fuzzy alias-match threshold, default
-  * `DEFAULT_INTERPRET_SIMILARITY`) and `floor` (intent confidence floor,
-  * default `DEFAULT_INTERPRET_FLOOR`) are two distinct, clearly named axes —
-  * both honored wherever they apply, never a single overloaded `threshold`
-  * (scsr's defect). `history` caps the context's `previous()` ring buffer.
-  * `on` — initial event listeners (AGENTS §8). `error` — the emitter's
-  * listener-error handler (AGENTS §13).
-  */
- export declare interface InterpretOptions {
-     readonly templates?: readonly Template[];
-     readonly context?: InterpretContextInterface;
-     readonly normalizer?: NormalizerInterface;
-     readonly extractor?: ExtractorInterface;
-     readonly clarifier?: ClarifierInterface;
-     readonly formatter?: FormatterInterface;
-     readonly generator?: GeneratorInterface;
-     readonly similarity?: number;
-     readonly floor?: number;
-     readonly history?: number;
-     readonly lexicon?: Lexicon;
-     readonly formatters?: Readonly<Record<string, NarratorFormatter>>;
-     readonly on?: EmitterHooks<InterpretEventMap>;
-     readonly error?: EmitterErrorHandler;
- }
-
- /**
-  * The five fixed pipeline phases an {@link InterpretInterface#interpret} run
-  * produces one {@link StageRecord} for, in order.
-  *
-  * @remarks
-  * Deliberately NOT named `Stage` — raters already owns that identifier for
-  * its worksheet derivation axis (`'factor' | 'group' | 'total'`); the two are
-  * unrelated concepts on the shared `@src/core` barrel.
-  */
- export declare type InterpretStage = 'normalize' | 'extract' | 'clarify' | 'format' | 'generate';
-
- /**
-  * Determine whether a value is a {@link ComputedField} — a declaratively
-  * computed field carrying a reasons {@link SymbolicExpression} tree.
-  *
-  * @param value - The value to test
-  * @returns `true` when `value` is a well-formed computed field
-  *
-  * @example
-  * ```ts
-  * import { constant, operation, variable } from '@orkestrel/reason'
-  * import { isComputedField } from '@src/core'
-  *
-  * isComputedField({
-  * 	field: 'monthly',
-  * 	expression: operation('divide', variable('deductible'), constant(12)),
-  * }) // true
-  * isComputedField({ field: 'monthly', expression: { form: 'variable' } }) // false — name missing
-  * ```
-  */
- export declare function isComputedField(value: unknown): value is ComputedField;
-
- /**
-  * Determine whether a value is an {@link EntityMapping} — a literal
-  * alias-phrase extraction rule pointing at a subject field.
-  *
-  * @param value - The value to test
-  * @returns `true` when `value` is a well-formed entity mapping
-  *
-  * @example
-  * ```ts
-  * import { isEntityMapping } from '@src/core'
-  *
-  * isEntityMapping({ entity: 'age', aliases: ['years old'], field: 'age' }) // true
-  * isEntityMapping({ entity: 'age', aliases: [/\d+/], field: 'age' })      // false — RegExp alias
-  * ```
-  */
- export declare function isEntityMapping(value: unknown): value is EntityMapping;
-
- /**
-  * Determine whether a value is a {@link FieldDefault} — a fallback value a
-  * {@link Template} fills onto an unresolved field.
-  *
-  * @remarks
-  * `value` is unconstrained (any value, including `null` or `undefined`) as
-  * long as the key is present — the trivially-true guard `notOf(unionOf())`
-  * mirrors the reasons `Check.value` precedent.
-  *
-  * @param value - The value to test
-  * @returns `true` when `value` is a well-formed field default
-  *
-  * @example
-  * ```ts
-  * import { isFieldDefault } from '@src/core'
-  *
-  * isFieldDefault({ field: 'term', value: 12 })   // true
-  * isFieldDefault({ field: 'term' })               // false — value missing
-  * ```
-  */
- export declare function isFieldDefault(value: unknown): value is FieldDefault;
-
- /**
-  * Narrow an unknown caught value to an {@link InterpretError}.
-  *
-  * @param value - The value to test (typically a `catch` binding)
-  * @returns `true` when `value` is an {@link InterpretError}
-  *
-  * @example
-  * ```ts
-  * import { isInterpretError } from '@src/core'
-  *
-  * try {
-  * 	interpret.template('missing')
-  * } catch (error) {
-  * 	if (isInterpretError(error) && error.code === 'DESTROYED') return
-  * }
-  * ```
-  */
- export declare function isInterpretError(value: unknown): value is InterpretError;
-
- /**
-  * Determine whether a value is a {@link Template} — a named, versionable
-  * interpretation template.
-  *
-  * @remarks
-  * `definition` is validated with reasons' `isDefinition` — a `Template`'s
-  * definition is already expressed in terrain reasons vocabulary, so no
-  * parallel interprets-owned definition guard exists.
-  *
-  * @param value - The value to test
-  * @returns `true` when `value` is a well-formed template
-  *
-  * @example
-  * ```ts
-  * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
-  * import { isTemplate } from '@src/core'
-  *
-  * isTemplate({
-  * 	id: 't1',
-  * 	name: 'Arithmetic',
-  * 	domain: 'arithmetic',
-  * 	intents: ['calculate'],
-  * 	mappings: [],
-  * 	defaults: [],
-  * 	computations: [],
-  * 	definition: quantitativeDefinition('t1', 'Arithmetic', [
-  * 		factorGroup('total', 'sum', [fieldFactor('value', 'value')]),
-  * 	]),
-  * }) // true
-  * isTemplate({ id: 't1' }) // false — most fields missing
-  * ```
-  */
- export declare function isTemplate(value: unknown): value is Template;
-
- /**
-  * Caller-injected wording data for the reverse direction — mechanism, never
-  * policy (AGENTS §21). Every phrase, label, and template string a `Narrator`
-  * renders is DATA supplied here, never a core literal.
-  *
-  * @remarks
-  * `phrases` is a two-level lookup (`table` → `key` → phrase) for domain
-  * vocabulary swaps (e.g. `comparison.equals` → `'is'`). `labels` maps a
-  * dotted `FieldPath` string to its display label, falling back to
-  * `formatField` when absent. `templates` maps a template id (e.g.
-  * `'definition.quantitative'`, `'result.symbolic'`, `'subject.fields'`) to an
-  * `interpolateMessage` template string — see `DEFAULT_LEXICON` for the
-  * pinned neutral key set.
-  */
- export declare interface Lexicon {
-     readonly phrases?: Readonly<Record<string, Readonly<Record<string, string>>>>;
-     readonly labels?: Readonly<Record<string, string>>;
-     readonly templates?: Readonly<Record<string, string>>;
- }
-
- /**
-  * Per-call options shared by every manager's `add` method.
-  *
-  * @remarks
-  * `id` overrides the minted record id. `TemplateManagerInterface#add` /
-  * `DefinitionManagerInterface#add` default to the added value's own `id`
-  * field when omitted; `SubjectManagerInterface#add` mints a fresh id when
-  * omitted, since a `Subject` carries no `id` field of its own.
-  */
- export declare interface ManagerAddOptions {
-     readonly id?: string;
- }
-
- /**
-  * The best `scoreSimilarity` a token achieves against a list of aliases,
-  * gated by a threshold.
-  *
-  * @param token - The token to score
-  * @param aliases - The alias phrases to score against
-  * @param threshold - The minimum score to report (an explicit no-match below it)
-  * @returns The best score when it meets `threshold`, else `0`
-  *
-  * @example
-  * ```ts
-  * import { matchAlias } from '@src/core'
-  *
-  * matchAlias('valu', ['value', 'amount'], 0.6) // ~0.86 — fuzzy hit on 'value'
-  * matchAlias('xyz', ['value', 'amount'], 0.6)  // 0 — no alias clears the threshold
-  * ```
-  */
- export declare function matchAlias(token: string, aliases: readonly string[], threshold: number): number;
-
- /**
-  * Find the best-scoring registered template for a classified intent, gated
-  * by a confidence floor.
-  *
-  * @remarks
-  * Explicit no-match (AGENTS-flagged scsr defect 2 — never an arbitrary
-  * `templates[0]` fallback): an empty registry, or a best score strictly below
-  * `floor`, both return `undefined`.
-  *
-  * @param intent - The classified intent
-  * @param templates - The registered templates to score
-  * @param floor - The minimum score a match must clear
-  * @returns The best-scoring template, or `undefined` on no qualifying match
-  *
-  * @example
-  * ```ts
-  * import { matchTemplate } from '@src/core'
-  *
-  * matchTemplate({ action: '', domain: '', confidence: 0 }, [], 0.3) // undefined — empty registry
-  * ```
-  */
- export declare function matchTemplate(intent: Intent, templates: readonly Template[], floor: number): Template | undefined;
-
- /**
-  * A stateless, TOTAL, lexicon-driven rendering engine for the reverse
-  * direction — the reverse-direction mirror of the forward `Formatter`'s
-  * `verbs` seam (AGENTS §21 mechanism-never-policy).
-  *
-  * @remarks
-  * Every wording decision is DATA — a caller-supplied `Lexicon` merged, per
-  * sub-record (`phrases` / `labels` / `templates`), OVER `DEFAULT_LEXICON`.
-  * Stateless and holds no resources: no emitter, no `destroy()` (deliberate —
-  * there is nothing to release). Every method is total (never throws); a
-  * lexicon or formatter miss degrades to its documented fallback rather than
-  * a thrown error, and every lookup guards with `Object.hasOwn` so an
-  * adversarial key (`toString`, `constructor`, `__proto__`) misses cleanly
-  * instead of reading an inherited prototype member.
-  *
-  * @example
-  * ```ts
-  * import { Narrator } from '@src/core'
-  *
-  * const narrator = new Narrator({
-  * 	lexicon: { phrases: { comparison: { equals: 'is' } } },
-  * 	formatters: { money: (value) => `$${String(value)}` },
-  * })
-  * narrator.phrase('comparison', 'equals', 'equals') // 'is'
-  * narrator.phrase('comparison', 'missing', 'equals') // 'equals' — fallback
-  * narrator.value('money', 5) // '$5'
-  * ```
-  */
- export declare class Narrator implements NarratorInterface {
-     #private;
-     constructor(options?: NarratorOptions);
-     phrase(table: string, key: string, fallback?: string): string;
-     label(field: FieldPath): string;
-     line(id: string, values: Readonly<Record<string, unknown>>): string;
-     value(unit: string, raw: unknown): string;
-     describe(definition: Definition): string;
-     narrate(result: ReasonResult): string;
- }
-
- /**
-  * A pure formatting function for one lexicon `value()` unit.
-  *
-  * @remarks
-  * A `Narrator` calls this from `value()` inside a `try`/`catch` (AGENTS §21 —
-  * a wording engine must never crash a render) — a throwing formatter is
-  * caught and the raw value falls back to `String(raw)`.
-  */
- export declare type NarratorFormatter = (value: unknown) => string;
-
- /**
-  * The `Narrator` contract — a stateless, TOTAL, lexicon-driven rendering
-  * engine for the reverse direction.
-  *
-  * @remarks
-  * Every method is total — never throws. A lookup miss degrades to a
-  * `fallback` (when supplied), the lookup key itself, or a computed fallback
-  * (`formatField` for `label`, `String(raw)` for `value`) — never a thrown
-  * error, even for adversarial prototype-chain keys (`toString`,
-  * `constructor`, `__proto__`), guarded with `Object.hasOwn` at every lookup.
-  * `phrase` looks up a two-level `table`/`key` pair in the lexicon's
-  * `phrases`. `label` renders a field's display label from `labels`, falling
-  * back to `formatField`. `line` interpolates a named `templates` entry
-  * against `values`, falling back to an empty string when the id is absent.
-  * `value` runs a named formatter over a raw value, catching a throw and
-  * falling back to `String(raw)`. `describe` / `narrate` compose these
-  * primitives over a reasons `Definition` / `ReasonResult`.
-  */
- export declare interface NarratorInterface {
-     phrase(table: string, key: string, fallback?: string): string;
-     label(field: FieldPath): string;
-     line(id: string, values: Readonly<Record<string, unknown>>): string;
-     value(unit: string, raw: unknown): string;
-     describe(definition: Definition): string;
-     narrate(result: ReasonResult): string;
- }
-
- /** Options for `createNarrator` / the `Narrator` constructor. */
- export declare interface NarratorOptions {
-     readonly lexicon?: Lexicon;
-     readonly formatters?: Readonly<Record<string, NarratorFormatter>>;
- }
-
- /**
-  * The `Normalizer` stage: applies contraction, abbreviation, and correction
-  * substitutions in order, then collapses whitespace.
-  *
-  * @remarks
-  * Each caller map is merged OVER the neutral built-in default for its slot —
-  * `text` is never mutated (AGENTS §11). Every substitution actually applied
-  * (one entry per matching map KEY, not per occurrence) is recorded on the
-  * result's `changes`, in `contractions → abbreviations → corrections` order,
-  * so the audit trail explains every character difference between `text` and
-  * `NormalizeResult.text` (the final whitespace collapse carries no entry of
-  * its own — it is structural cleanup, not a substitution).
-  *
-  * @example
-  * ```ts
-  * import { Normalizer } from '@src/core'
-  *
-  * const normalizer = new Normalizer({ contractions: { "can't": 'cannot' } })
-  * normalizer.normalize("can't   stop")
-  * // { text: 'cannot stop', changes: [{ from: "can't", to: 'cannot' }] }
-  * ```
-  */
- export declare class Normalizer implements NormalizerInterface {
-     #private;
-     constructor(options?: NormalizerOptions);
-     normalize(text: string): NormalizeResult;
- }
-
- /** The `Normalizer` stage's output: the cleaned text plus every substitution applied. */
- export declare interface NormalizeResult {
-     readonly text: string;
-     readonly changes: readonly TextChange[];
- }
-
- /** The `Normalizer` stage contract: raw text in, cleaned text + applied changes out. */
- export declare interface NormalizerInterface {
-     normalize(text: string): NormalizeResult;
- }
-
- /**
-  * Options for `createNormalizer` / the `Normalizer` constructor.
-  *
-  * @remarks
-  * Each map is merged OVER the neutral built-in defaults, applied in order
-  * contractions → abbreviations → corrections, before whitespace collapse.
-  */
- export declare interface NormalizerOptions {
-     readonly contractions?: Readonly<Record<string, string>>;
-     readonly abbreviations?: Readonly<Record<string, string>>;
-     readonly corrections?: Readonly<Record<string, string>>;
- }
-
- /**
-  * The numeric-entity extraction pattern shared by `extractNumbers` and
-  * `assignEntities` — an optional leading `$`, thousands-comma-grouped digits,
-  * an optional decimal fraction, and an optional trailing `%`.
-  *
-  * @remarks
-  * Carries the global flag, so every call site builds a fresh `RegExp` from
-  * `.source` / `.flags` (mirrors the core-root `PLACEHOLDER_PATTERN` pattern)
-  * rather than sharing this instance's mutable `lastIndex` across scans.
-  */
- export declare const NUMBER_PATTERN: RegExp;
-
- /**
-  * Parse a JSON string into a `Template`, or `undefined` on invalid JSON or a
-  * shape that fails `isTemplate`.
-  *
-  * @remarks
-  * The module's sole JSON boundary (design §4) — an `Interpretation` and the
-  * versioned records are produced internally, never deserialized from
-  * untrusted JSON; replay re-runs `interpret`, it does not deserialize a
-  * stored result.
-  *
-  * @param value - The JSON text to parse
-  * @returns The parsed template, or `undefined`
-  *
-  * @example
-  * ```ts
-  * import { parseTemplate } from '@src/core'
-  *
-  * parseTemplate('not json') // undefined
-  * ```
-  */
- export declare function parseTemplate(value: string): Template | undefined;
-
- /** How one value landed — its origin category plus an optional strategy detail. */
- export declare interface Provenance {
-     readonly category: ProvenanceCategory;
-     readonly detail?: string;
- }
-
- /**
-  * How one {@link FieldMapping} / {@link Entity} value was obtained.
-  *
-  * @remarks
-  * `extracted` — mined from the raw text via keyword / alias / positional
-  * matching. `carried` — reused from a same-domain prior turn in an
-  * {@link InterpretContextInterface}. `default` — filled from a
-  * {@link Template}'s {@link FieldDefault}. `computed` — derived by evaluating
-  * a {@link ComputedField}'s expression. `subject` — already present on an
-  * injected base subject, untouched by this interpretation.
-  */
- export declare type ProvenanceCategory = 'extracted' | 'carried' | 'default' | 'computed' | 'subject';
-
- /**
-  * Evaluate a symbolic expression tree against resolved bindings.
-  *
-  * @remarks
-  * THE critical leaf (design-pinned, engine-parity semantics): an absent
-  * `right` operand on a binary operation defaults to `0` — matching
-  * `SymbolicReasoner`'s internal `#evaluate` — and is always passed as an
-  * EXPLICIT numeric operand, so the same tree evaluates identically here and
-  * inside the engine. Each arithmetic step delegates to the reasons
-  * `applyOperation` pure function, mapping the node's `.operator` field onto
-  * its `operator` parameter. An unresolved input variable, or a non-finite
-  * result (`NaN` from a divide-by-zero, or an overflowing `±Infinity`),
-  * becomes a gap — `undefined`, never landing on a subject.
-  *
-  * @param expression - The expression tree to evaluate
-  * @param bindings - The resolved variable bindings
-  * @returns The evaluated number, or `undefined` on an unresolved input or a
-  * non-finite result
-  *
-  * @example
-  * ```ts
-  * import { constant, operation, variable } from '@orkestrel/reason'
-  * import { resolveExpression } from '@src/core'
-  *
-  * resolveExpression(operation('divide', variable('deductible'), constant(12)), { deductible: 6000 }) // 500
-  * resolveExpression(operation('divide', constant(1), constant(0)), {}) // undefined — NaN gap
-  * resolveExpression(variable('missing'), {}) // undefined — unresolved input
-  * ```
-  */
- export declare function resolveExpression(expression: SymbolicExpression, bindings: Readonly<Record<string, number>>): number | undefined;
-
- /**
-  * Bigram (Dice coefficient) string similarity, case-insensitive.
-  *
-  * @param a - The first string
-  * @param b - The second string
-  * @returns A score in `[0, 1]` — `1` for an exact (case-insensitive) match,
-  * `0` when either string is shorter than 2 characters and they are not equal
-  *
-  * @example
-  * ```ts
-  * import { scoreSimilarity } from '@src/core'
-  *
-  * scoreSimilarity('rate', 'rate')  // 1
-  * scoreSimilarity('rate', 'value') // 0 — no shared bigrams
-  * ```
-  */
- export declare function scoreSimilarity(a: string, b: string): number;
-
- /**
-  * Score how well a classified intent matches one template's domain + action.
-  *
-  * @param intent - The classified intent
-  * @param template - The candidate template
-  * @returns A score in `[0, 1]` — the mean of the domain match (`1`/`0`) and
-  * the action match (`1`/`0`, `template.intents` containing `intent.action`)
-  *
-  * @example
-  * ```ts
-  * import { scoreTemplate } from '@src/core'
-  *
-  * scoreTemplate(
-  * 	{ action: 'compute', domain: 'rating', confidence: 1 },
-  * 	{ id: 't1', name: 'T', domain: 'rating', intents: ['compute'], mappings: [], defaults: [], computations: [], definition: { reasoning: 'symbolic', id: 't1', name: 'T', equations: [], variables: {} } },
-  * ) // 1
-  * ```
-  */
- export declare function scoreTemplate(intent: Intent, template: Template): number;
-
- export declare function setField(subject: Subject, field: FieldPath, value: unknown): Subject;
-
- /** A visible marker for a stage that threw, carrying its coded reason. */
- export declare interface StageFailure {
-     readonly stage: InterpretStage;
-     readonly code: InterpretErrorCode;
-     readonly message: string;
- }
-
- /**
-  * A structured input/output snapshot of one pipeline phase.
-  *
-  * @remarks
-  * `input` / `output` are live structured values, never a stringified JSON
-  * blob. No `duration` field — strict core forbids wall-clock timing
-  * (AGENTS §17.7); the audit story here is structural, not temporal.
-  */
- export declare interface StageRecord {
-     readonly stage: InterpretStage;
-     readonly input: unknown;
-     readonly output: unknown;
-     readonly failed: boolean;
-     readonly error?: string;
- }
-
- /**
-  * The subject registry — a self-owning, versioned and content-hashed
-  * record-holder that mints its OWN record identity for every {@link Subject}
-  * (a `Subject` carries no `id` field of its own).
-  *
-  * @remarks
-  * The defect-7 fix: scsr keyed stored subjects by their definition's id, so
-  * successive same-domain turns silently overwrote one shared subject. Here each
-  * `add` mints a fresh `subject-{n}` id (deterministic per instance, no host
-  * randomness — AGENTS §17.7) unless the caller overrides it via
-  * `ManagerAddOptions.id`. `hash` is content-derived (id-independent) and
-  * `version` bumps ONLY when the hash changes at a reused id. The batch
-  * `remove(ids)` form is all-or-nothing; `destroy()` is idempotent and every
-  * method afterwards throws `InterpretError('DESTROYED', …)`.
-  *
-  * @example
-  * ```ts
-  * import { SubjectManager } from '@src/core'
-  *
-  * const manager = new SubjectManager()
-  * const first = manager.add({ age: 25 })
-  * const second = manager.add({ age: 30 })
-  * first.id !== second.id // true — each subject gets its own identity
-  * ```
-  */
- export declare class SubjectManager implements SubjectManagerInterface {
-     #private;
-     constructor(options?: SubjectManagerOptions);
-     get emitter(): EmitterInterface<SubjectManagerEventMap>;
-     get size(): number;
-     has(id: string): boolean;
-     subject(id: string): SubjectRecord | undefined;
-     subjects(): readonly SubjectRecord[];
-     add(subject: Subject, options?: ManagerAddOptions): SubjectRecord;
-     remove(ids: readonly string[]): boolean;
-     remove(id: string): boolean;
-     remove(): void;
-     destroy(): void;
- }
-
- /** The push observation surface of a {@link SubjectManagerInterface} (AGENTS §13). */
- export declare type SubjectManagerEventMap = {
-     /** A subject record was added — carries its (own-minted) record id. */
-     readonly add: readonly [id: string];
-     /** A subject record was removed — carries its record id. */
-     readonly remove: readonly [id: string];
-     /** The manager was destroyed. */
-     readonly destroy: readonly [];
- };
-
- /**
-  * The subject registry — a self-owning, versioned/hashed record-holder
-  * that mints its own record ids (a `Subject` carries none).
-  */
- export declare interface SubjectManagerInterface {
-     readonly emitter: EmitterInterface<SubjectManagerEventMap>;
-     readonly size: number;
-     has(id: string): boolean;
-     subject(id: string): SubjectRecord | undefined;
-     subjects(): readonly SubjectRecord[];
-     add(subject: Subject, options?: ManagerAddOptions): SubjectRecord;
-     remove(ids: readonly string[]): boolean;
-     remove(id: string): boolean;
-     remove(): void;
-     destroy(): void;
- }
-
- /** Options for `createSubjectManager` / the `SubjectManager` constructor — the initial seed collection. */
- export declare interface SubjectManagerOptions {
-     readonly subjects?: readonly Subject[];
-     readonly on?: EmitterHooks<SubjectManagerEventMap>;
-     readonly error?: EmitterErrorHandler;
- }
-
- /**
-  * A versioned, content-hashed {@link Subject} as held by a
-  * {@link SubjectManagerInterface}.
-  *
-  * @remarks
-  * `id` is the manager's OWN minted identity — never `definition.id` — so
-  * successive turns never silently overwrite one shared subject (scsr's
-  * defect).
-  */
- export declare interface SubjectRecord {
-     readonly id: string;
-     readonly subject: Subject;
-     readonly version: number;
-     readonly hash: string;
- }
-
- /**
-  * A named, versionable interpretation template: which intents it answers,
-  * how to mine entities for it, its fallback data, its computed fields, and
-  * the reasons `Definition` it ultimately produces a `Subject` for.
-  *
-  * @remarks
-  * `definition` is inline and already expressed in terrain reasons vocabulary
-  * (`reasoning` / `Check` / `terms` / `form` / `origin`) — there is no
-  * scsr-era `template.id === definition.id` invariant; a `Template` and its
-  * `Definition` are simply the same authored record. `intents` lists the
-  * `Intent.action` values this template answers.
-  */
- export declare interface Template {
-     readonly id: string;
-     readonly name: string;
-     readonly domain: string;
-     readonly intents: readonly string[];
-     readonly mappings: readonly EntityMapping[];
-     readonly defaults: readonly FieldDefault[];
-     readonly computations: readonly ComputedField[];
-     readonly definition: Definition;
- }
-
- /**
-  * The template registry — a self-owning, versioned and content-hashed
-  * record-holder for the {@link Template}s an `Interpret` orchestrator matches
-  * against.
-  *
-  * @remarks
-  * `size` (never `count` — the sole tally in scope) plus the AGENTS §9.1
-  * singular/plural accessors (`template` / `templates`) and the §9.2 batch
-  * `remove` overloads. `add` derives each record's `hash` from the template's
-  * CONTENT (id-independent — the same template data hashes identically under
-  * any record id) and bumps `version` ONLY when that hash changes: an identical
-  * re-add keeps its version (unlike scsr, which bumped on every add). The
-  * batch `remove(ids)` form is ALL-OR-NOTHING — any id absent from the registry
-  * leaves the collection untouched and returns `false`. `destroy()` is
-  * idempotent; every method afterwards throws `InterpretError('DESTROYED', …)`.
-  *
-  * @example
-  * ```ts
-  * import { factorGroup, fieldFactor, quantitativeDefinition } from '@orkestrel/reason'
-  * import { TemplateManager } from '@src/core'
-  *
-  * const manager = new TemplateManager()
-  * const record = manager.add({
-  * 	id: 't1',
-  * 	name: 'Arithmetic',
-  * 	domain: 'arithmetic',
-  * 	intents: ['calculate'],
-  * 	mappings: [],
-  * 	defaults: [],
-  * 	computations: [],
-  * 	definition: quantitativeDefinition('t1', 'Arithmetic', [
-  * 		factorGroup('total', 'sum', [fieldFactor('value', 'value')]),
-  * 	]),
-  * })
-  * record.version // 1
-  * manager.size // 1
-  * ```
-  */
- export declare class TemplateManager implements TemplateManagerInterface {
-     #private;
-     constructor(options?: TemplateManagerOptions);
-     get emitter(): EmitterInterface<TemplateManagerEventMap>;
-     get size(): number;
-     has(id: string): boolean;
-     template(id: string): TemplateRecord | undefined;
-     templates(): readonly TemplateRecord[];
-     add(template: Template, options?: ManagerAddOptions): TemplateRecord;
-     remove(ids: readonly string[]): boolean;
-     remove(id: string): boolean;
-     remove(): void;
-     destroy(): void;
- }
-
- /**
-  * The push observation surface of a {@link TemplateManagerInterface} (AGENTS
-  * §13) — an id-keyed registry, so `add` / `remove` are the events (never
-  * ordered-list `append`/`prepend`).
-  */
- export declare type TemplateManagerEventMap = {
-     /** A template record was added — carries its record id. */
-     readonly add: readonly [id: string];
-     /** A template record was removed — carries its record id. */
-     readonly remove: readonly [id: string];
-     /** The manager was destroyed. */
-     readonly destroy: readonly [];
- };
-
- /**
-  * The template registry — a self-owning, versioned/hashed record-holder
-  * (AGENTS §9.1 singular/plural accessors, §9.2 batch overloads).
-  *
-  * @remarks
-  * `size` (never `count` — this is the sole tally in scope) mirrors the
-  * raters `ProgramManagerInterface` registry precedent. `remove`'s batch form
-  * is all-or-nothing: any missing id in the list leaves the collection
-  * untouched and returns `false`.
-  */
- export declare interface TemplateManagerInterface {
-     readonly emitter: EmitterInterface<TemplateManagerEventMap>;
-     readonly size: number;
-     has(id: string): boolean;
-     template(id: string): TemplateRecord | undefined;
-     templates(): readonly TemplateRecord[];
-     add(template: Template, options?: ManagerAddOptions): TemplateRecord;
-     remove(ids: readonly string[]): boolean;
-     remove(id: string): boolean;
-     remove(): void;
-     destroy(): void;
- }
-
- /** Options for `createTemplateManager` / the `TemplateManager` constructor — the initial seed collection. */
- export declare interface TemplateManagerOptions {
-     readonly templates?: readonly Template[];
-     readonly on?: EmitterHooks<TemplateManagerEventMap>;
-     readonly error?: EmitterErrorHandler;
- }
-
- /**
-  * A versioned, content-hashed {@link Template} as held by a
-  * {@link TemplateManagerInterface}.
-  *
-  * @remarks
-  * `version` bumps only when `hash` (derived from `template`'s content, not
-  * `id`) actually changes — an identical re-add keeps the same version,
-  * unlike scsr's version-bumps-on-every-add defect.
-  */
- export declare interface TemplateRecord {
-     readonly id: string;
-     readonly template: Template;
-     readonly version: number;
-     readonly hash: string;
- }
-
- /** One normalization substitution applied to the raw text. */
- export declare interface TextChange {
-     readonly from: string;
-     readonly to: string;
- }
-
- /**
-  * Split text into lowercase tokens, stripping punctuation outside a small
-  * numeric/currency-safe allowlist.
-  *
-  * @remarks
-  * Shared by `classifyIntent` and `assignEntities` — pure ECMAScript
-  * (no locale-aware `Intl` segmentation), so multi-byte / astral text tokenizes
-  * on ASCII word boundaries only.
-  *
-  * @param text - The text to tokenize
-  * @returns The lowercase tokens, punctuation-stripped, empty tokens dropped
-  *
-  * @example
-  * ```ts
-  * import { tokenize } from '@src/core'
-  *
-  * tokenize('The rate is 85%.') // ['the', 'rate', 'is', '85%']
-  * ```
-  */
- export declare function tokenize(text: string): readonly string[];
-
- /**
-  * Prototype-pollution-unsafe field-path segments — `setField` refuses to
-  * write ANY path containing one, returning its input unchanged.
-  */
- export declare const UNSAFE_FIELD_SEGMENTS: readonly string[];
-
- /**
-  * Collect every variable name referenced by a symbolic expression tree, in
-  * first-occurrence order.
-  *
-  * @param expression - The expression tree to scan
-  * @returns The referenced variable names, deduplicated
-  *
-  * @example
-  * ```ts
-  * import { constant, operation, variable } from '@orkestrel/reason'
-  * import { variablesOf } from '@src/core'
-  *
-  * variablesOf(operation('divide', variable('deductible'), constant(12))) // ['deductible']
-  * ```
-  */
- export declare function variablesOf(expression: SymbolicExpression): readonly string[];
-
- export { }