solve-engine 2.24.0 → 2.25.0

package/dist/{BytecodeBuilder-aqVa7Plx.d.cts → BytecodeBuilder-DSWKZi4f.d.cts}

@@ -199,6 +199,8 @@ declare class BytecodeBuilder {
     private numbers;
     private strings;
     private stringIndex;
+    /** Value (or {@link NEGATIVE_ZERO_KEY}) to its slot in `numbers`, so a repeated literal is emitted once. */
+    private numberIndex;
     private _hasAsync;
     private userFunctionBodies;
     private anonymousBodies;
@@ -222,17 +224,17 @@ declare class BytecodeBuilder {
     /** Emit an {@link OpCode} instruction. */
     emitOpcode(op: OpCode): void;
     /**
-     * Emit a numeric literal: appends `n` to the program's constant pool and
-     * writes its index into the opcode stream (read back by the VM as e.g.
-     * `PUSH_NUMBER <idx>`).
+     * Emit a numeric literal: interns `n` into the program's constant pool
+     * (deduplicated, like {@link emitString}) and writes its index into the
+     * opcode stream (read back by the VM as e.g. `PUSH_NUMBER <idx>`).
      *
-     * Numeric constants are NOT deduplicated (unlike {@link emitString})
-     * every call appends a new entry, so an expression with more than
-     * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences
-     * throws rather than silently wrapping the index (see
-     * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).
+     * Deduplicated so that the 256-entry pool counts distinct values rather
+     * than occurrences: a long line of repeated literals used to exhaust it
+     * long before it held 256 different numbers. Negative zero keeps its own
+     * slot, because `1 / -0` is not `1 / 0`; NaN shares one, since every NaN
+     * reads the same.
      *
-     * @throws If the constant pool would exceed 256 entries.
+     * @throws If the pool would exceed 256 distinct entries.
      */
     emitNumber(n: number): void;
     /**

package/dist/{BytecodeBuilder-aqVa7Plx.d.ts → BytecodeBuilder-DSWKZi4f.d.ts}

@@ -199,6 +199,8 @@ declare class BytecodeBuilder {
     private numbers;
     private strings;
     private stringIndex;
+    /** Value (or {@link NEGATIVE_ZERO_KEY}) to its slot in `numbers`, so a repeated literal is emitted once. */
+    private numberIndex;
     private _hasAsync;
     private userFunctionBodies;
     private anonymousBodies;
@@ -222,17 +224,17 @@ declare class BytecodeBuilder {
     /** Emit an {@link OpCode} instruction. */
     emitOpcode(op: OpCode): void;
     /**
-     * Emit a numeric literal: appends `n` to the program's constant pool and
-     * writes its index into the opcode stream (read back by the VM as e.g.
-     * `PUSH_NUMBER <idx>`).
+     * Emit a numeric literal: interns `n` into the program's constant pool
+     * (deduplicated, like {@link emitString}) and writes its index into the
+     * opcode stream (read back by the VM as e.g. `PUSH_NUMBER <idx>`).
      *
-     * Numeric constants are NOT deduplicated (unlike {@link emitString})
-     * every call appends a new entry, so an expression with more than
-     * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences
-     * throws rather than silently wrapping the index (see
-     * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).
+     * Deduplicated so that the 256-entry pool counts distinct values rather
+     * than occurrences: a long line of repeated literals used to exhaust it
+     * long before it held 256 different numbers. Negative zero keeps its own
+     * slot, because `1 / -0` is not `1 / 0`; NaN shares one, since every NaN
+     * reads the same.
      *
-     * @throws If the constant pool would exceed 256 entries.
+     * @throws If the pool would exceed 256 distinct entries.
      */
     emitNumber(n: number): void;
     /**

package/dist/{EngineError-D1kXsjIj.d.cts → EngineError-fR1K1rvx.d.cts}

@@ -38,6 +38,8 @@ declare const CoreErrorCodes: {
     readonly UNEXPECTED_TRAILING_TOKEN: "UNEXPECTED_TRAILING_TOKEN";
     readonly PARSE_ERROR: "PARSE_ERROR";
     readonly TOO_MANY_NUMERIC_CONSTANTS: "TOO_MANY_NUMERIC_CONSTANTS";
+    /** A raw bytecode operand outside 0 to 255, or a jump patch outside the emitted stream (`parser/BytecodeBuilder.ts`'s `emitIndex`, `emitByte`, `patchJump`). `build()` keeps one byte per operand, so 300 used to become 44 with no error and the program read the wrong constant or plugin function. A package-authoring fault, reported at compile time. */
+    readonly BYTECODE_OPERAND_OUT_OF_RANGE: "BYTECODE_OPERAND_OUT_OF_RANGE";
     readonly TOO_MANY_STRING_CONSTANTS: "TOO_MANY_STRING_CONSTANTS";
     readonly NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE";
     readonly INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN";

package/dist/{EngineError-D1kXsjIj.d.ts → EngineError-fR1K1rvx.d.ts}

@@ -38,6 +38,8 @@ declare const CoreErrorCodes: {
     readonly UNEXPECTED_TRAILING_TOKEN: "UNEXPECTED_TRAILING_TOKEN";
     readonly PARSE_ERROR: "PARSE_ERROR";
     readonly TOO_MANY_NUMERIC_CONSTANTS: "TOO_MANY_NUMERIC_CONSTANTS";
+    /** A raw bytecode operand outside 0 to 255, or a jump patch outside the emitted stream (`parser/BytecodeBuilder.ts`'s `emitIndex`, `emitByte`, `patchJump`). `build()` keeps one byte per operand, so 300 used to become 44 with no error and the program read the wrong constant or plugin function. A package-authoring fault, reported at compile time. */
+    readonly BYTECODE_OPERAND_OUT_OF_RANGE: "BYTECODE_OPERAND_OUT_OF_RANGE";
     readonly TOO_MANY_STRING_CONSTANTS: "TOO_MANY_STRING_CONSTANTS";
     readonly NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE";
     readonly INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN";

package/dist/{Lexer-CqagTewQ.d.ts → Lexer-Bmctxl0n.d.ts}

@@ -1,4 +1,5 @@
 import { T as Token } from './Token-CbP_OutD.js';
+import { E as EngineError } from './EngineError-fR1K1rvx.js';
 
 /** Trie node for multi-word phrase matching. */
 interface PhraseNode {
@@ -101,6 +102,14 @@ interface ScanLineResult {
     tokens: Token[];
     /** Inline solve spans found in this line (empty if none). */
     inlineSolves: InlineSolveSpan[];
+    /**
+     * The structured error the tokeniser raised on this line, if it raised one
+     * (an unterminated string literal is the one it can raise today). The line
+     * carries no tokens then, and the rest of the document is unaffected: a
+     * half-typed quote used to escape {@link ExpressionLexer.scanDocument} as
+     * a throw and take every other line's result down with it.
+     */
+    error?: EngineError;
 }
 /**
  * A token, as the lexer produces it.
@@ -208,16 +217,6 @@ interface LexerVocabulary {
  */
 declare class ExpressionLexer {
     private static readonly CHAR_CLASS;
-    /**
-     * Configured TokenLookup from TokenClassRegistry. When set, replaces
-     * the internal keyword map and unit set with registry-built equivalents.
-     * Enables data-driven keyword/unit registration across locale keywords,
-     * provider keywords, and plugins.
-     *
-     * Set at construction time via the constructor parameter. Plugin-registered
-     * keywords/units (via registerVocabulary()) are checked alongside
-     * the configuredLookup, neither source is bypassed.
-     */ private configuredLookup;
     private input;
     private pos;
     private len;
@@ -227,7 +226,16 @@ declare class ExpressionLexer {
     private keywordMap;
     private mergedKeywords;
     private mergedUnits;
-    private pluginKeywordMap;
+    /**
+     * Who registered each plugin keyword, unit and two-character operator, in
+     * registration order. Two packages may claim the same word (the
+     * compatibility index warns, and the last registered wins, as before); the
+     * owner lists make unregistration exact, so removing one package hands the
+     * word back to the other rather than deleting it for both.
+     */
+    private pluginKeywordOwners;
+    private pluginUnitOwners;
+    private pluginOperatorOwners;
     private pluginOperators;
     private pluginUnits;
     private hasPluginOps;
@@ -235,7 +243,7 @@ declare class ExpressionLexer {
     private locale;
     /**
      * Inline solve spans collected during the most recent tokenization pass.
-     * Populated by [Symbol.iterator]() and consumed by scanDocument().
+     * Populated by tokenizeInto() and consumed by scanDocument().
      */
     _inlineSolveSpans: InlineSolveSpan[];
     private pluginRawLinePatterns;
@@ -260,7 +268,14 @@ declare class ExpressionLexer {
     private matchRawLine;
     /** Rebuild merged keyword and unit collections after plugin registration. */
     private rebuildMergedUnits;
-    constructor(localeCode?: string, lookup?: TokenLookup);
+    /**
+     * @param localeCode - Locale whose keyword table seeds the lexer.
+     * @param _lookup - Ignored. The lexer built its keyword, unit and phrase
+     *   tables from the locale and the registered packages and never read the
+     *   lookup it was handed; the parameter stays so existing callers compile.
+     *   @deprecated Removed in 3.0.
+     */
+    constructor(localeCode?: string, _lookup?: TokenLookup);
     /**
      * Register a plugin to extend the lexer with custom tokens.
      *
@@ -276,6 +291,10 @@ declare class ExpressionLexer {
      * that conflicts with a built-in one.
      */
     registerVocabulary(plugin: LexerVocabulary): void;
+    /** Record `owner`'s claim on `key`. The newest claim is the one in force. */
+    private claim;
+    /** Drop `owner`'s claim on `key`, and return the claim now in force, if any is left. */
+    private release;
     /**
      * Unregister a plugin, removing its custom tokens from the lexer.
      *
@@ -307,9 +326,9 @@ declare class ExpressionLexer {
      *   lines that classifyLine() marks as having inline solves.
      *
      * Tokenization is scoped to each line by temporarily restricting
-     * `this.len` to the line end position, so the [Symbol.iterator]
-     * generator naturally stops at the line boundary. After tokenization,
-     * `this.len` is restored and `this.pos` advances past the newline.
+     * `this.len` to the line end position, so tokenizeInto() naturally
+     * stops at the line boundary. After tokenization, `this.len` is
+     * restored and `this.pos` advances past the newline.
      *
      * @param text The full document text (with newlines).
      * @returns Array of ScanLineResult, one per line, in document order.
@@ -318,9 +337,7 @@ declare class ExpressionLexer {
     /**
      * Tokenize an expression string into an array of Tokens.
      *
-     * Delegates to the lazy [Symbol.iterator]() generator and collects all
-     * yielded tokens via Array.from(). For memory-sensitive use cases, prefer
-     * iterating the lexer directly with for...of to avoid array allocation.
+     * Runs {@link tokenizeInto} into a fresh array.
      *
      * Optimizations:
      *  - CHAR_CLASS jump table (Uint8Array) → switch on small integers
@@ -332,20 +349,31 @@ declare class ExpressionLexer {
      */
     tokenizeAll(): Token[];
     /**
-     * Lazy token-by-token generator. Yields each token without allocating an
-     * intermediate Token[] array. Supports for...of and spread usage.
+     * Scan the current input and append every token to `out`.
+     *
+     * This is the scanner itself: {@link tokenizeAll} and the iterator are
+     * thin wrappers over it. It pushes into an array the caller owns rather
+     * than yielding, because a generator paid a resume per token and
+     * `Array.from` a second pass on top, and because a caller that catches a
+     * tokeniser fault (highlighting a line with an unterminated quote) still
+     * holds the tokens read before it.
      *
-     * Usage:
-     *   for (const t of lexer) { ... }  // lazy, no array allocation
-     *   const tokens = [...lexer];       // materializes via spread
-     *   const tokens = lexer.tokenizeAll(); // materializes via Array.from()
+     * IMPORTANT: `this.len` is read ONCE on entry (const len = this.len).
+     * `scanDocument()` relies on this to scope a pass to a single line by
+     * restricting `this.len` to the line end before calling. Do not re-read
+     * `this.len` mid-loop without also updating `scanDocument()`.
      *
-     * IMPORTANT: This generator captures `this.len` ONCE at creation time
-     * (const len = this.len). `scanDocument()` relies on this behavior to
-     * scope tokenization to a single line by temporarily restricting
-     * `this.len` to the line end position before creating the iterator.
-     * Do NOT refactor to re-read `this.len` mid-loop without also updating
-     * `scanDocument()`.
+     * @param out - The array to append to. Left as it was if the input is empty.
+     */
+    tokenizeInto(out: Token[]): void;
+    /**
+     * Iterate the tokens of the current input.
+     *
+     * Runs {@link tokenizeInto} first, so the tokens are the same as before,
+     * but a fault part way through the line is thrown from the first
+     * `next()` rather than at the token it occurred on. A caller that wants
+     * the tokens read before a fault calls {@link tokenizeInto} with its own
+     * array.
      */
     [Symbol.iterator](): Generator<Token, void, undefined>;
     /**
@@ -456,6 +484,27 @@ declare class ExpressionLexer {
      * `#12345` (length 5), `#ff0000zz` (trailing word) do not.
      */
     private matchHexColourEnd;
+    /**
+     * Whether an inline-solve opener (`s` + backtick) occurs in `[from, end)`.
+     *
+     * Bounded by hand rather than written as `input.indexOf("s\`", from)`. This
+     * used to be the `indexOf` form with an `idx < end` check afterwards, which
+     * is correct but not bounded: when {@link scanDocument} is classifying,
+     * `this.input` is the whole document, so a line with no marker scanned to
+     * the END OF THE DOCUMENT before the check could reject the hit. Every line
+     * paid for every line after it, and a whole-document parse was quadratic in
+     * line count (measured at 28.9 us per line at 10,000 lines against 10.1 us
+     * at 1,000, and two thirds of the parse's self time in a profile). A prose
+     * document with many candidate `s` characters was worse still. The
+     * wikilink close in {@link indexOfWithin} had the same shape.
+     */
+    private hasInlineSolveWithin;
+    /**
+     * `input.indexOf(needle, from)` restricted to `[from, end)`, returning -1
+     * when the needle does not occur wholly before `end`. See
+     * {@link hasInlineSolveWithin} for why the plain `indexOf` was not enough.
+     */
+    private indexOfWithin;
     private classifyFromPositions;
     /**
      * Classify a single line of markdown text.
@@ -530,11 +579,11 @@ declare class Lexer {
     private tokenIdx;
     /**
      * @param localeCode - Locale code (e.g., "en", "de"). Defaults to "en".
-     * @param tokenLookup - Optional TokenLookup from TokenClassRegistry.
-     *   When provided, configures ExpressionLexer to use registry-built
-     *   keyword/unit/phrase lookups instead of internal instance maps.
+     * @param _tokenLookup - Ignored. The lexer never read the lookup it was
+     *   handed; the parameter stays so existing callers compile.
+     *   @deprecated Removed in 3.0.
      */
-    constructor(localeCode?: string, tokenLookup?: TokenLookup);
+    constructor(localeCode?: string, _tokenLookup?: TokenLookup);
     reset(input: string, state?: LexerState): void;
     /**
      * Classify a single line of markdown text (Phase B).

package/dist/{Lexer-CCHFDcgP.d.cts → Lexer-aB95pjoX.d.cts}

@@ -1,4 +1,5 @@
 import { T as Token } from './Token-CbP_OutD.cjs';
+import { E as EngineError } from './EngineError-fR1K1rvx.cjs';
 
 /** Trie node for multi-word phrase matching. */
 interface PhraseNode {
@@ -101,6 +102,14 @@ interface ScanLineResult {
     tokens: Token[];
     /** Inline solve spans found in this line (empty if none). */
     inlineSolves: InlineSolveSpan[];
+    /**
+     * The structured error the tokeniser raised on this line, if it raised one
+     * (an unterminated string literal is the one it can raise today). The line
+     * carries no tokens then, and the rest of the document is unaffected: a
+     * half-typed quote used to escape {@link ExpressionLexer.scanDocument} as
+     * a throw and take every other line's result down with it.
+     */
+    error?: EngineError;
 }
 /**
  * A token, as the lexer produces it.
@@ -208,16 +217,6 @@ interface LexerVocabulary {
  */
 declare class ExpressionLexer {
     private static readonly CHAR_CLASS;
-    /**
-     * Configured TokenLookup from TokenClassRegistry. When set, replaces
-     * the internal keyword map and unit set with registry-built equivalents.
-     * Enables data-driven keyword/unit registration across locale keywords,
-     * provider keywords, and plugins.
-     *
-     * Set at construction time via the constructor parameter. Plugin-registered
-     * keywords/units (via registerVocabulary()) are checked alongside
-     * the configuredLookup, neither source is bypassed.
-     */ private configuredLookup;
     private input;
     private pos;
     private len;
@@ -227,7 +226,16 @@ declare class ExpressionLexer {
     private keywordMap;
     private mergedKeywords;
     private mergedUnits;
-    private pluginKeywordMap;
+    /**
+     * Who registered each plugin keyword, unit and two-character operator, in
+     * registration order. Two packages may claim the same word (the
+     * compatibility index warns, and the last registered wins, as before); the
+     * owner lists make unregistration exact, so removing one package hands the
+     * word back to the other rather than deleting it for both.
+     */
+    private pluginKeywordOwners;
+    private pluginUnitOwners;
+    private pluginOperatorOwners;
     private pluginOperators;
     private pluginUnits;
     private hasPluginOps;
@@ -235,7 +243,7 @@ declare class ExpressionLexer {
     private locale;
     /**
      * Inline solve spans collected during the most recent tokenization pass.
-     * Populated by [Symbol.iterator]() and consumed by scanDocument().
+     * Populated by tokenizeInto() and consumed by scanDocument().
      */
     _inlineSolveSpans: InlineSolveSpan[];
     private pluginRawLinePatterns;
@@ -260,7 +268,14 @@ declare class ExpressionLexer {
     private matchRawLine;
     /** Rebuild merged keyword and unit collections after plugin registration. */
     private rebuildMergedUnits;
-    constructor(localeCode?: string, lookup?: TokenLookup);
+    /**
+     * @param localeCode - Locale whose keyword table seeds the lexer.
+     * @param _lookup - Ignored. The lexer built its keyword, unit and phrase
+     *   tables from the locale and the registered packages and never read the
+     *   lookup it was handed; the parameter stays so existing callers compile.
+     *   @deprecated Removed in 3.0.
+     */
+    constructor(localeCode?: string, _lookup?: TokenLookup);
     /**
      * Register a plugin to extend the lexer with custom tokens.
      *
@@ -276,6 +291,10 @@ declare class ExpressionLexer {
      * that conflicts with a built-in one.
      */
     registerVocabulary(plugin: LexerVocabulary): void;
+    /** Record `owner`'s claim on `key`. The newest claim is the one in force. */
+    private claim;
+    /** Drop `owner`'s claim on `key`, and return the claim now in force, if any is left. */
+    private release;
     /**
      * Unregister a plugin, removing its custom tokens from the lexer.
      *
@@ -307,9 +326,9 @@ declare class ExpressionLexer {
      *   lines that classifyLine() marks as having inline solves.
      *
      * Tokenization is scoped to each line by temporarily restricting
-     * `this.len` to the line end position, so the [Symbol.iterator]
-     * generator naturally stops at the line boundary. After tokenization,
-     * `this.len` is restored and `this.pos` advances past the newline.
+     * `this.len` to the line end position, so tokenizeInto() naturally
+     * stops at the line boundary. After tokenization, `this.len` is
+     * restored and `this.pos` advances past the newline.
      *
      * @param text The full document text (with newlines).
      * @returns Array of ScanLineResult, one per line, in document order.
@@ -318,9 +337,7 @@ declare class ExpressionLexer {
     /**
      * Tokenize an expression string into an array of Tokens.
      *
-     * Delegates to the lazy [Symbol.iterator]() generator and collects all
-     * yielded tokens via Array.from(). For memory-sensitive use cases, prefer
-     * iterating the lexer directly with for...of to avoid array allocation.
+     * Runs {@link tokenizeInto} into a fresh array.
      *
      * Optimizations:
      *  - CHAR_CLASS jump table (Uint8Array) → switch on small integers
@@ -332,20 +349,31 @@ declare class ExpressionLexer {
      */
     tokenizeAll(): Token[];
     /**
-     * Lazy token-by-token generator. Yields each token without allocating an
-     * intermediate Token[] array. Supports for...of and spread usage.
+     * Scan the current input and append every token to `out`.
+     *
+     * This is the scanner itself: {@link tokenizeAll} and the iterator are
+     * thin wrappers over it. It pushes into an array the caller owns rather
+     * than yielding, because a generator paid a resume per token and
+     * `Array.from` a second pass on top, and because a caller that catches a
+     * tokeniser fault (highlighting a line with an unterminated quote) still
+     * holds the tokens read before it.
      *
-     * Usage:
-     *   for (const t of lexer) { ... }  // lazy, no array allocation
-     *   const tokens = [...lexer];       // materializes via spread
-     *   const tokens = lexer.tokenizeAll(); // materializes via Array.from()
+     * IMPORTANT: `this.len` is read ONCE on entry (const len = this.len).
+     * `scanDocument()` relies on this to scope a pass to a single line by
+     * restricting `this.len` to the line end before calling. Do not re-read
+     * `this.len` mid-loop without also updating `scanDocument()`.
      *
-     * IMPORTANT: This generator captures `this.len` ONCE at creation time
-     * (const len = this.len). `scanDocument()` relies on this behavior to
-     * scope tokenization to a single line by temporarily restricting
-     * `this.len` to the line end position before creating the iterator.
-     * Do NOT refactor to re-read `this.len` mid-loop without also updating
-     * `scanDocument()`.
+     * @param out - The array to append to. Left as it was if the input is empty.
+     */
+    tokenizeInto(out: Token[]): void;
+    /**
+     * Iterate the tokens of the current input.
+     *
+     * Runs {@link tokenizeInto} first, so the tokens are the same as before,
+     * but a fault part way through the line is thrown from the first
+     * `next()` rather than at the token it occurred on. A caller that wants
+     * the tokens read before a fault calls {@link tokenizeInto} with its own
+     * array.
      */
     [Symbol.iterator](): Generator<Token, void, undefined>;
     /**
@@ -456,6 +484,27 @@ declare class ExpressionLexer {
      * `#12345` (length 5), `#ff0000zz` (trailing word) do not.
      */
     private matchHexColourEnd;
+    /**
+     * Whether an inline-solve opener (`s` + backtick) occurs in `[from, end)`.
+     *
+     * Bounded by hand rather than written as `input.indexOf("s\`", from)`. This
+     * used to be the `indexOf` form with an `idx < end` check afterwards, which
+     * is correct but not bounded: when {@link scanDocument} is classifying,
+     * `this.input` is the whole document, so a line with no marker scanned to
+     * the END OF THE DOCUMENT before the check could reject the hit. Every line
+     * paid for every line after it, and a whole-document parse was quadratic in
+     * line count (measured at 28.9 us per line at 10,000 lines against 10.1 us
+     * at 1,000, and two thirds of the parse's self time in a profile). A prose
+     * document with many candidate `s` characters was worse still. The
+     * wikilink close in {@link indexOfWithin} had the same shape.
+     */
+    private hasInlineSolveWithin;
+    /**
+     * `input.indexOf(needle, from)` restricted to `[from, end)`, returning -1
+     * when the needle does not occur wholly before `end`. See
+     * {@link hasInlineSolveWithin} for why the plain `indexOf` was not enough.
+     */
+    private indexOfWithin;
     private classifyFromPositions;
     /**
      * Classify a single line of markdown text.
@@ -530,11 +579,11 @@ declare class Lexer {
     private tokenIdx;
     /**
      * @param localeCode - Locale code (e.g., "en", "de"). Defaults to "en".
-     * @param tokenLookup - Optional TokenLookup from TokenClassRegistry.
-     *   When provided, configures ExpressionLexer to use registry-built
-     *   keyword/unit/phrase lookups instead of internal instance maps.
+     * @param _tokenLookup - Ignored. The lexer never read the lookup it was
+     *   handed; the parameter stays so existing callers compile.
+     *   @deprecated Removed in 3.0.
      */
-    constructor(localeCode?: string, tokenLookup?: TokenLookup);
+    constructor(localeCode?: string, _tokenLookup?: TokenLookup);
     reset(input: string, state?: LexerState): void;
     /**
      * Classify a single line of markdown text (Phase B).

package/dist/{PackageCompatibility-Bq82y0ZN.d.ts → PackageCompatibility-BludTs7v.d.ts}

@@ -1,4 +1,4 @@
-import { I as IEnginePackage } from './PackageRegistry-CDEgfhT_.js';
+import { I as IEnginePackage } from './PackageRegistry-DT-x32OM.js';
 
 /**
  * Package load-time compatibility checking, the "detect overlapping

package/dist/{PackageCompatibility-CeAPVHZr.d.cts → PackageCompatibility-CUVg8tmt.d.cts}

@@ -1,4 +1,4 @@
-import { I as IEnginePackage } from './PackageRegistry-B9-7fJGH.cjs';
+import { I as IEnginePackage } from './PackageRegistry-Dvn4i2QK.cjs';
 
 /**
  * Package load-time compatibility checking, the "detect overlapping

package/dist/{PackageRegistry-CDEgfhT_.d.ts → PackageRegistry-DT-x32OM.d.ts}

@@ -1,12 +1,12 @@
-import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-BwDqKFfK.js';
+import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-DqTbbtWA.js';
 import { V as Value, a as ValueType } from './Value-Ds3Gy07C.js';
-import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-CqagTewQ.js';
+import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-Bmctxl0n.js';
 import { IAsyncResolver } from './resolvers.js';
-import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-OTPS0Otq.js';
-import { D as DependencyGraph, V as VM, a as DagSnapshot, b as EngineContext, S as ScopeManager, P as PluginFunctionHandler } from './ScopeManager-BQBhlDAu.js';
-import { a as BytecodeProgram } from './BytecodeBuilder-aqVa7Plx.js';
+import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-CLBtiE8M.js';
+import { D as DependencyGraph, V as VM, a as DagSnapshot, b as EngineContext, S as ScopeManager, P as PluginFunctionHandler } from './ScopeManager-B636am7Y.js';
+import { a as BytecodeProgram } from './BytecodeBuilder-DSWKZi4f.js';
 import { QueryClient } from '@tanstack/query-core';
-import { E as EngineError } from './EngineError-D1kXsjIj.js';
+import { E as EngineError } from './EngineError-fR1K1rvx.js';
 import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-DTqGLPsV.js';
 import { T as Token } from './Token-CbP_OutD.js';
 import { E as EngineConfigOverride, a as EngineConfig } from './Configuration-DnzYPmoK.js';
@@ -1640,6 +1640,13 @@ declare class ExpressionEngine {
      * every `name(` call word instead of one rule per package.
      */
     private callFusions;
+    /**
+     * Which packages claim each call-fusion word, in registration order. The
+     * newest claim is the one {@link callFusions} holds; removing a package
+     * hands the word back to the previous claimant rather than deleting it
+     * for both.
+     */
+    private callFusionOwners;
     /**
      * Incremental index behind the package-compatibility check. Kept in step
      * with {@link registeredPackages} so each `registerPackage` costs O(that
@@ -1806,6 +1813,45 @@ declare class ExpressionEngine {
     /** TanStack Query client, injected into resolvers for cache reads/writes. */
     readonly queryClient: QueryClient;
     private bytecodeCache;
+    /**
+     * What the front half of the pipeline produced for a cached program: the
+     * normalised tokens the program was compiled from and the reads and
+     * writes extracted from them. Keyed like {@link bytecodeCache} and kept
+     * in step with it (same eviction, same clears), so a hit here means a hit
+     * there.
+     *
+     * A bytecode-cache hit used to pay for the whole front half anyway: the
+     * length check, lexing, normalising, the complexity score, the three
+     * effectful-grammar tries and the reads/writes extraction all ran before
+     * `bytecodeCache.get`, and on a cache-hit evaluation of an ordinary line
+     * lexing and normalising were about two fifths of the cost. Everything
+     * the later stages read from the front half is remembered here instead,
+     * so a hit skips straight to the async preflight and the VM. Entries
+     * restored from a snapshot carry a program but no front half; the first
+     * evaluation after a restore runs the full front half once and fills it.
+     * The memory is a few hundred bytes per cached expression, bounded by the
+     * same `defaultCacheSize` as the programs.
+     */
+    private compiledFrontHalf;
+    /**
+     * Expressions whose last parse threw, with what the front half produced
+     * for them. A line that does not parse is the ordinary state of a line
+     * being typed, and every re-evaluation of the document lexed, normalised
+     * and re-parsed it, paying for the throw each time. The entry is used
+     * only after the effectful-grammar tries, which still run because they
+     * read the VM (a stored equation, a running total), so nothing that
+     * depends on document state is skipped: only the pure front half and the
+     * parse that is known to fail. The error object is the one first thrown,
+     * so its timestamp is the first failure's. Cleared with the compiled
+     * caches, because the vocabulary and parselet changes that would change
+     * a program can change whether a line parses at all. Bounded by the same
+     * `defaultCacheSize` as the programs.
+     */
+    private failedParses;
+    /** Whether `expression` can be answered without lexing or normalising: both compiled caches hold it, or its parse is known to fail. */
+    private frontHalfCached;
+    /** Drop every cached program, its front half and every remembered parse failure. Every invalidation goes through here so the three cannot drift. */
+    private clearCompiledCache;
     /**
      * Insert into the bytecode cache, evicting the oldest entry when full.
      *
@@ -1818,6 +1864,8 @@ declare class ExpressionEngine {
      * the bytecode-cache benefit on re-evaluation regardless of config.
      */
     private cacheBytecode;
+    /** Remember a parse failure, evicting the oldest when full: bounded like the program cache. */
+    private rememberFailedParse;
     private pluginFunctionIndexByName;
     private builderPool;
     private builderPoolIndex;