solve-engine 2.32.0 → 2.34.0

package/dist/{EngineError-CqGtaT_v.d.cts → EngineError-Bm4OYmw8.d.cts}

@@ -119,6 +119,8 @@ declare const CoreErrorCodes: {
     readonly MALFORMED_BYTECODE_BIGINT_LITERAL: "MALFORMED_BYTECODE_BIGINT_LITERAL";
     /** `executeBytecode()` called with something that is not a runnable program at all. Checked before the destructure that used to throw outside the function's own try/catch. */
     readonly MALFORMED_BYTECODE_PROGRAM: "MALFORMED_BYTECODE_PROGRAM";
+    /** An opcode the dispatch switch has no arm for, refused at the instruction that carries it (the `offset` in its context). The switch used to have no default arm, so an unknown opcode ran as a no-op and the program failed some instructions later with a STACK_UNDERFLOW naming the wrong instruction. Covers the two enum members no arm handles (`PUSH_VARIABLE`, `RETURN`) and the dynamic range an `OpRegistry` once claimed. See `vm/VM.ts`'s default arm. */
+    readonly MALFORMED_BYTECODE_UNKNOWN_OPCODE: "MALFORMED_BYTECODE_UNKNOWN_OPCODE";
     /** A coefficient grew past `RATIONAL_MAX_BITS`, e.g. repeated exact elimination multiplying denominators together. */
     readonly SYMBOLIC_RATIONAL_OVERFLOW: "SYMBOLIC_RATIONAL_OVERFLOW";
     /** `NaN` or `±Infinity` reaching a symbolic expression, neither of which has an exact rational value. */
@@ -156,6 +158,8 @@ declare const CoreErrorCodes: {
     /** A document with more lines than `performance.maxDocumentLines`. The per-line limits above bound what one line may ask for and say nothing about how many lines there are; two hundred thousand of `1 + 1` exhausted the heap on the line records alone. Recoverable. */
     readonly DOCUMENT_TOO_LARGE: "DOCUMENT_TOO_LARGE";
     readonly NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED";
+    /** The normaliser was still changing the token stream after its pass budget (`maxPasses`, 100 by default): a rule chain that never settles. Reported rather than returning whatever the last pass left. Recoverable. */
+    readonly NORMALIZER_PASS_LIMIT_EXCEEDED: "NORMALIZER_PASS_LIMIT_EXCEEDED";
     /** `"=>"` with nothing before it, needs an expression or variable name to solve/simplify. */
     readonly THEREFORE_REQUIRES_EXPRESSION: "THEREFORE_REQUIRES_EXPRESSION";
     /** A `"=>"`-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies. */
@@ -193,6 +197,8 @@ declare const CoreErrorCodes: {
     /** A `resize` was written without one of its parts: the dimensions, the `to`, the size, or the side it names. Recoverable. */
     readonly RESIZE_EXPECTED_SHAPE: "RESIZE_EXPECTED_SHAPE";
     readonly PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION";
+    /** A package registered an operator the scanner cannot read: not exactly two characters, or a first character the scanner does not class as an operator. It used to register and never fire. Recoverable. */
+    readonly PLUGIN_OPERATOR_UNSUPPORTED: "PLUGIN_OPERATOR_UNSUPPORTED";
     readonly PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION";
     readonly PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION";
     /** A package's declared `IEnginePackage.engineVersion` semver range doesn't satisfy the running engine's ENGINE_VERSION. See api/EngineVersionCompatibility.ts. */

package/dist/{EngineError-CqGtaT_v.d.ts → EngineError-Bm4OYmw8.d.ts}

@@ -119,6 +119,8 @@ declare const CoreErrorCodes: {
     readonly MALFORMED_BYTECODE_BIGINT_LITERAL: "MALFORMED_BYTECODE_BIGINT_LITERAL";
     /** `executeBytecode()` called with something that is not a runnable program at all. Checked before the destructure that used to throw outside the function's own try/catch. */
     readonly MALFORMED_BYTECODE_PROGRAM: "MALFORMED_BYTECODE_PROGRAM";
+    /** An opcode the dispatch switch has no arm for, refused at the instruction that carries it (the `offset` in its context). The switch used to have no default arm, so an unknown opcode ran as a no-op and the program failed some instructions later with a STACK_UNDERFLOW naming the wrong instruction. Covers the two enum members no arm handles (`PUSH_VARIABLE`, `RETURN`) and the dynamic range an `OpRegistry` once claimed. See `vm/VM.ts`'s default arm. */
+    readonly MALFORMED_BYTECODE_UNKNOWN_OPCODE: "MALFORMED_BYTECODE_UNKNOWN_OPCODE";
     /** A coefficient grew past `RATIONAL_MAX_BITS`, e.g. repeated exact elimination multiplying denominators together. */
     readonly SYMBOLIC_RATIONAL_OVERFLOW: "SYMBOLIC_RATIONAL_OVERFLOW";
     /** `NaN` or `±Infinity` reaching a symbolic expression, neither of which has an exact rational value. */
@@ -156,6 +158,8 @@ declare const CoreErrorCodes: {
     /** A document with more lines than `performance.maxDocumentLines`. The per-line limits above bound what one line may ask for and say nothing about how many lines there are; two hundred thousand of `1 + 1` exhausted the heap on the line records alone. Recoverable. */
     readonly DOCUMENT_TOO_LARGE: "DOCUMENT_TOO_LARGE";
     readonly NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED";
+    /** The normaliser was still changing the token stream after its pass budget (`maxPasses`, 100 by default): a rule chain that never settles. Reported rather than returning whatever the last pass left. Recoverable. */
+    readonly NORMALIZER_PASS_LIMIT_EXCEEDED: "NORMALIZER_PASS_LIMIT_EXCEEDED";
     /** `"=>"` with nothing before it, needs an expression or variable name to solve/simplify. */
     readonly THEREFORE_REQUIRES_EXPRESSION: "THEREFORE_REQUIRES_EXPRESSION";
     /** A `"=>"`-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies. */
@@ -193,6 +197,8 @@ declare const CoreErrorCodes: {
     /** A `resize` was written without one of its parts: the dimensions, the `to`, the size, or the side it names. Recoverable. */
     readonly RESIZE_EXPECTED_SHAPE: "RESIZE_EXPECTED_SHAPE";
     readonly PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION";
+    /** A package registered an operator the scanner cannot read: not exactly two characters, or a first character the scanner does not class as an operator. It used to register and never fire. Recoverable. */
+    readonly PLUGIN_OPERATOR_UNSUPPORTED: "PLUGIN_OPERATOR_UNSUPPORTED";
     readonly PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION";
     readonly PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION";
     /** A package's declared `IEnginePackage.engineVersion` semver range doesn't satisfy the running engine's ENGINE_VERSION. See api/EngineVersionCompatibility.ts. */

package/dist/{Lexer-CqFjYoRA.d.ts → Lexer-DPn5dfCH.d.ts}

@@ -1,5 +1,5 @@
 import { T as Token } from './Token-D8f7yaz1.js';
-import { E as EngineError } from './EngineError-CqGtaT_v.js';
+import { E as EngineError } from './EngineError-Bm4OYmw8.js';
 
 /** Trie node for multi-word phrase matching. */
 interface PhraseNode {
@@ -451,18 +451,6 @@ declare class ExpressionLexer {
      * which is the other half of why they are stripped here rather than later.
      */
     private tokenizeString;
-    /**
-     * L1 expression gating: quickly determine if a line contains any
-     * characters that indicate an expression (digits, operators, currency,
-     * backticks, parentheses, etc.).
-     *
-     * Pure prose lines (e.g., "The quick brown fox jumps over the lazy dog")
-     * return false and can be skipped without full tokenization (L2).
-     *
-     * This is a fast character-by-character scan that stops at the first
-     * expression indicator. Called once per line in classifyFromPositions().
-     */
-    static hasExpressionIndicators(input: string, start: number, end: number): boolean;
     /**
      * Classify a line by its character positions within this.input.
      * Reads directly from this.input using start/end boundaries.

package/dist/{Lexer-sCI05tqO.d.cts → Lexer-DaWkCu84.d.cts}

@@ -1,5 +1,5 @@
 import { T as Token } from './Token-D8f7yaz1.cjs';
-import { E as EngineError } from './EngineError-CqGtaT_v.cjs';
+import { E as EngineError } from './EngineError-Bm4OYmw8.cjs';
 
 /** Trie node for multi-word phrase matching. */
 interface PhraseNode {
@@ -451,18 +451,6 @@ declare class ExpressionLexer {
      * which is the other half of why they are stripped here rather than later.
      */
     private tokenizeString;
-    /**
-     * L1 expression gating: quickly determine if a line contains any
-     * characters that indicate an expression (digits, operators, currency,
-     * backticks, parentheses, etc.).
-     *
-     * Pure prose lines (e.g., "The quick brown fox jumps over the lazy dog")
-     * return false and can be skipped without full tokenization (L2).
-     *
-     * This is a fast character-by-character scan that stops at the first
-     * expression indicator. Called once per line in classifyFromPositions().
-     */
-    static hasExpressionIndicators(input: string, start: number, end: number): boolean;
     /**
      * Classify a line by its character positions within this.input.
      * Reads directly from this.input using start/end boundaries.

package/dist/{PackageCompatibility-phvSFP4f.d.ts → PackageCompatibility-CkzZfoJ3.d.ts}

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

package/dist/{PackageCompatibility-Bn-T_xKW.d.cts → PackageCompatibility-E_5GtcQW.d.cts}

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

package/dist/{PackageRegistry-C78jVkI9.d.ts → PackageRegistry-DSqic8kz.d.ts}

@@ -1,14 +1,14 @@
-import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-Dgymjxzd.js';
-import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-CqFjYoRA.js';
+import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-CQjcHOKw.js';
+import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-DPn5dfCH.js';
 import { IAsyncResolver } from './resolvers.js';
-import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-IF7nPRMp.js';
-import { D as DependencyGraph, V as VM, f as DagSnapshot, g as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-Du9y8sEo.js';
-import { V as Value, b as ValueType, D as DatetimeGrain } from './Value-BYHw-x7q.js';
+import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-DAzPp-j1.js';
+import { D as DependencyGraph, V as VM, f as DagSnapshot, g as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-qgzA6qGi.js';
+import { V as Value, b as ValueType, D as DatetimeGrain } from './Value-2TIKi-YL.js';
 import { a as BytecodeProgram } from './BytecodeBuilder-DSWKZi4f.js';
 import { C as CalendarBackend } from './CalendarBackend-MdS3Bb4P.js';
 import { QueryClient } from '@tanstack/query-core';
-import { E as EngineError } from './EngineError-CqGtaT_v.js';
-import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-Cl7KW8CB.js';
+import { E as EngineError } from './EngineError-Bm4OYmw8.js';
+import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-DOo3KHaq.js';
 import { T as Token } from './Token-D8f7yaz1.js';
 import { D as DateAmbiguity, E as EngineConfigOverride, a as EngineConfig } from './Configuration-BxriK9Kw.js';
 
@@ -714,7 +714,15 @@ interface BatchEntry {
  * `highWaterMark` of 64 events to limit the internal buffer size.
  */
 declare class AsyncResolutionBatcher {
+    /**
+     * Resolutions waiting for the next flush, keyed by `packageId:queryKey`
+     * so a repeat within the tick is refused in constant time. This used to
+     * be an array scanned on every add, which made a tick that resolves
+     * thousands of keys quadratic.
+     */
     private pending;
+    /** How many adds this tick were refused as repeats of a key already pending. Reset on flush. */
+    private collapsed;
     private scheduled;
     /** Set to true by clearPending(), flush() checks this to abort stale work. */
     private cleared;
@@ -822,7 +830,11 @@ declare class AsyncResolutionBatcher {
     getEventStream(): ReadableStream<AsyncResolutionEvent>;
     /** Number of resolutions currently queued for the next flush. */
     get pendingCount(): number;
-    /** Number of pending entries collapsed by (packageId, queryKey) deduplication. */
+    /**
+     * Number of resolutions this tick collapsed into one already pending for
+     * the same (packageId, queryKey). Counted as they are refused: the batch
+     * itself never holds a repeat, so recounting it here always gave zero.
+     */
     get dedupCount(): number;
     /**
      * Whether the internal event stream currently has an active reader.
@@ -1539,7 +1551,12 @@ interface AsyncPreflightOutput {
     pendingQueryKey?: string;
     /** Number of registered async resolvers */
     resolverCount: number;
-    /** Whether the preflight guard was skipped (no async opcodes, no resolvers) */
+    /**
+     * Whether the preflight was skipped because no registered resolver could
+     * intercept this program: it calls no plugin function and contains none of
+     * the opcodes a resolver declared it watches (see
+     * `IAsyncResolver.watchedOpcodes`).
+     */
     skippedGuard: boolean;
 }
 /** Stage 12: Stack VM execution of the compiled bytecode program. */
@@ -1943,6 +1960,22 @@ declare class ExpressionEngine {
      */
     private batchScanResults;
     private batchParsedLines;
+    /**
+     * The context handed to every line of the current pass, its line number
+     * set by mutation before each execution. The closures inside read only
+     * the document model, or the batch pass's scan and results array, and
+     * those are fixed for the length of a pass, so one object serves the
+     * pass: {@link makeLineContext} rebuilds it the moment any of the three
+     * changes, and a batch pass drops it as it ends so a finished pass's scan
+     * is not retained. The goal-seek re-entry builds its own instead (see
+     * {@link evaluateLineWithBinding}): it runs inside another line's
+     * evaluation, and moving the shared line number under that line would
+     * misdirect every cross-line read it makes afterwards.
+     */
+    private lineContext;
+    private lineContextDoc;
+    private lineContextScan;
+    private lineContextParsed;
     /**
      * Called once by `ThreeTierEvaluator`'s constructor. Not part of the
      * public evaluate-a-document contract, purely internal wiring so
@@ -1992,14 +2025,27 @@ declare class ExpressionEngine {
      */
     warmUp(): void;
     /**
-     * Build the {@link LineExecutionContext} passed to `executeBytecode()`
-     * for a given line. `lineNumber = -1` (the existing sentinel
+     * The {@link LineExecutionContext} passed to `executeBytecode()` for a
+     * given line. `lineNumber = -1` (the existing sentinel
      * `evaluateExpression()`/`evaluateLine(-1, ...)` already use for "no
      * real document") naturally produces a context with both closures
      * `undefined`, a cross-line plugin function must check for that itself
      * and return a clear error, never assume line 0 exists.
+     *
+     * One object serves a whole pass, its line number set by mutation here:
+     * the closures read only the document model, or the batch pass's scan
+     * and results, and those are fixed for the length of a pass, so the
+     * context is rebuilt only when one of them changes. See
+     * {@link lineContext} for the re-entrant case that must not share it.
      */
     private makeLineContext;
+    /**
+     * Allocate a context over the given cross-line sources. Every ordinary
+     * line goes through {@link makeLineContext}, which keeps one of these per
+     * pass; this is the allocation itself, called directly where a fresh
+     * object is required.
+     */
+    private buildLineContext;
     /**
      * Re-evaluate line `targetLine`'s compiled expression with `variable` bound
      * to `bound` for that one run, the primitive goal seek drives while
@@ -2035,9 +2081,9 @@ declare class ExpressionEngine {
      * is aborted, causing all in-flight async work (fetches, preflight checks,
      * batcher flushes) to be canceled atomically.
      *
-     * executeAndStore() and executeRaw() link their local AbortControllers to
-     * this signal so that when the keystroke changes, all per-evaluation controllers
-     * are aborted together.
+     * {@link armCancellation} links each per-evaluation AbortController to
+     * this signal, for a line that can have work in flight, so that when the
+     * keystroke changes, all of them are aborted together.
      */
     private keystrokeSignal;
     /**
@@ -2056,6 +2102,13 @@ declare class ExpressionEngine {
      * its results as current; the manager's own timers are what stop the work.
      */
     private readonly backgroundRefreshSignal;
+    /**
+     * The signal a line no resolver could intercept executes under. Never
+     * aborted: such a line has no in-flight work for a keystroke to cancel,
+     * so it shares this one signal rather than allocating a controller and
+     * linking a listener nothing could fire. See {@link armCancellation}.
+     */
+    private readonly inertSignal;
     /** Post-lexer token normalizer for phrase fusion, implicit multiply, etc. */
     private normalizer;
     /**
@@ -2109,7 +2162,8 @@ declare class ExpressionEngine {
     /** 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.
+     * Insert into the bytecode cache, evicting the least recently used entry
+     * when full.
      *
      * Bug fix (found during release hardening): this used to check against
      * a hardcoded `BYTECODE_CACHE_MAX_ENTRIES = 2000` constant that never
@@ -2120,8 +2174,40 @@ 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. */
+    /**
+     * Mark a cached program as just used, so eviction passes over it.
+     *
+     * Re-inserting the key moves it to the end of the Map's insertion order,
+     * which makes the first key the least recently used, and that is where
+     * {@link cacheBytecode} evicts from. Insertion order alone evicted the
+     * earliest compiled line however hot it was: a document re-evaluated on
+     * every keystroke touches all of its lines, and each one-off expression
+     * (an inline solve, a classification probe of a prose line) pushed one
+     * of them out once the cap was reached. About 45 ns per hit, measured.
+     * The front half is not moved: it is keyed identically, evicted with the
+     * same victim, and its own order is never consulted.
+     *
+     * Only once the cache is full, which is the whole point: recency decides
+     * who gets evicted, and nothing is evicted below the cap, so under it the
+     * delete and re-insert buy nothing and cost on the hottest path there is.
+     * The 45 ns measured for one hit is not what it costs in a document, where
+     * every keystroke touches every line: a variable chain measured 1.17 ms
+     * before this guard and 2.10 ms after the LRU went in, in the same CI run
+     * as its own merge base. A Map holds a deleted key's slot until it
+     * compacts, so a delete-and-add on every hit pays for that repeatedly
+     * rather than once.
+     *
+     * The trade this leaves: the first eviction after the cache fills reads
+     * insertion order rather than true recency, because nothing before the cap
+     * was ordered. Every hit after that re-inserts, so the order is accurate
+     * from the second eviction on, and the first victim is at worst the same
+     * one insertion order would have chosen anyway.
+     */
+    private touchCompiled;
+    /** Remember a parse failure, evicting the least recently used when full: bounded like the program cache. */
     private rememberFailedParse;
+    /** Mark a remembered parse failure as just used; the same move, and the same guard, as {@link touchCompiled}. */
+    private touchFailedParse;
     private pluginFunctionIndexByName;
     private builderPool;
     private builderPoolIndex;
@@ -2269,6 +2355,29 @@ declare class ExpressionEngine {
      * Extracted common pattern from 8 call sites.
      */
     private storeLineResult;
+    /**
+     * Whether `program` can have work in flight: it calls a plugin function
+     * (the VM hands its signal to the pending result), or a registered
+     * resolver watches an opcode it contains. Everything else is a plain
+     * line, which skips the async preflight and the cancellation state.
+     */
+    private mayResolve;
+    /**
+     * Point the VM at the signal `program` executes under.
+     *
+     * A line that can have work in flight gets a fresh controller linked to
+     * the keystroke signal (One AbortController Per Keystroke): when the user
+     * types again the keystroke aborts, which aborts this controller, which
+     * cancels the fetch. A plain line gets the shared {@link inertSignal} and
+     * links nothing, since there is nothing a keystroke could cancel; on a
+     * large document the controller and the two listener changes per line
+     * were most of what a cached line cost.
+     *
+     * @returns The unlink step, to run once the evaluation settles
+     * synchronously (a pending result keeps its link so a later keystroke
+     * still cancels it), or null when nothing was linked.
+     */
+    private armCancellation;
     /**
      * Execute bytecode and handle the result.
      *
@@ -2665,13 +2774,13 @@ declare class ExpressionEngine {
     /**
      * Shared async-resolver preflight check, run before VM execution.
      *
-     * O(1) guard: skips the O(n) resolver scan when the bytecode has no
-     * async opcodes AND no resolvers are registered. Either condition alone
-     * is enough to warrant a preflight scan:
-     *   - program.hasAsync: bytecode contains CALL_PLUGIN (async VM path)
-     *   - resolverRegistry.size > 0: resolvers may intercept any expression
-     * For purely sync expressions (e.g., `2 + 2`) with no resolvers, this is
-     * an O(1) fast-path that bypasses the resolver scan entirely.
+     * Skipped outright for a line no registered resolver could intercept
+     * (see {@link mayResolve}): no resolver scan, no controller, no keystroke
+     * listener. With every built-in package loaded that used to be no line at
+     * all, since the old gate asked only whether any resolver was registered,
+     * so `2 + 2` paid for seven scans and two listener changes on every
+     * keystroke. A plugin call (`program.hasAsync`) always takes the full
+     * pass, which the VM's pending path relies on.
      *
      * If any registered resolver says "data not ready", registers a DAG
      * data-source dependency, stores a Pending result, and fires async

package/dist/{PackageRegistry-B-C1duZw.d.cts → PackageRegistry-js47hr28.d.cts}

@@ -1,14 +1,14 @@
-import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-DF3864la.cjs';
-import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-sCI05tqO.cjs';
+import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-s1sRRn8H.cjs';
+import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-DaWkCu84.cjs';
 import { IAsyncResolver } from './resolvers.cjs';
-import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-Pe3_390t.cjs';
-import { D as DependencyGraph, V as VM, f as DagSnapshot, g as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-BkKzhj6C.cjs';
-import { V as Value, b as ValueType, D as DatetimeGrain } from './Value-BYHw-x7q.cjs';
+import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-D382VSYh.cjs';
+import { D as DependencyGraph, V as VM, f as DagSnapshot, g as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-JCavlQUj.cjs';
+import { V as Value, b as ValueType, D as DatetimeGrain } from './Value-2TIKi-YL.cjs';
 import { a as BytecodeProgram } from './BytecodeBuilder-DSWKZi4f.cjs';
 import { C as CalendarBackend } from './CalendarBackend-MdS3Bb4P.cjs';
 import { QueryClient } from '@tanstack/query-core';
-import { E as EngineError } from './EngineError-CqGtaT_v.cjs';
-import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-BYkKNpql.cjs';
+import { E as EngineError } from './EngineError-Bm4OYmw8.cjs';
+import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-Bum6y1B9.cjs';
 import { T as Token } from './Token-D8f7yaz1.cjs';
 import { D as DateAmbiguity, E as EngineConfigOverride, a as EngineConfig } from './Configuration-BxriK9Kw.cjs';
 
@@ -714,7 +714,15 @@ interface BatchEntry {
  * `highWaterMark` of 64 events to limit the internal buffer size.
  */
 declare class AsyncResolutionBatcher {
+    /**
+     * Resolutions waiting for the next flush, keyed by `packageId:queryKey`
+     * so a repeat within the tick is refused in constant time. This used to
+     * be an array scanned on every add, which made a tick that resolves
+     * thousands of keys quadratic.
+     */
     private pending;
+    /** How many adds this tick were refused as repeats of a key already pending. Reset on flush. */
+    private collapsed;
     private scheduled;
     /** Set to true by clearPending(), flush() checks this to abort stale work. */
     private cleared;
@@ -822,7 +830,11 @@ declare class AsyncResolutionBatcher {
     getEventStream(): ReadableStream<AsyncResolutionEvent>;
     /** Number of resolutions currently queued for the next flush. */
     get pendingCount(): number;
-    /** Number of pending entries collapsed by (packageId, queryKey) deduplication. */
+    /**
+     * Number of resolutions this tick collapsed into one already pending for
+     * the same (packageId, queryKey). Counted as they are refused: the batch
+     * itself never holds a repeat, so recounting it here always gave zero.
+     */
     get dedupCount(): number;
     /**
      * Whether the internal event stream currently has an active reader.
@@ -1539,7 +1551,12 @@ interface AsyncPreflightOutput {
     pendingQueryKey?: string;
     /** Number of registered async resolvers */
     resolverCount: number;
-    /** Whether the preflight guard was skipped (no async opcodes, no resolvers) */
+    /**
+     * Whether the preflight was skipped because no registered resolver could
+     * intercept this program: it calls no plugin function and contains none of
+     * the opcodes a resolver declared it watches (see
+     * `IAsyncResolver.watchedOpcodes`).
+     */
     skippedGuard: boolean;
 }
 /** Stage 12: Stack VM execution of the compiled bytecode program. */
@@ -1943,6 +1960,22 @@ declare class ExpressionEngine {
      */
     private batchScanResults;
     private batchParsedLines;
+    /**
+     * The context handed to every line of the current pass, its line number
+     * set by mutation before each execution. The closures inside read only
+     * the document model, or the batch pass's scan and results array, and
+     * those are fixed for the length of a pass, so one object serves the
+     * pass: {@link makeLineContext} rebuilds it the moment any of the three
+     * changes, and a batch pass drops it as it ends so a finished pass's scan
+     * is not retained. The goal-seek re-entry builds its own instead (see
+     * {@link evaluateLineWithBinding}): it runs inside another line's
+     * evaluation, and moving the shared line number under that line would
+     * misdirect every cross-line read it makes afterwards.
+     */
+    private lineContext;
+    private lineContextDoc;
+    private lineContextScan;
+    private lineContextParsed;
     /**
      * Called once by `ThreeTierEvaluator`'s constructor. Not part of the
      * public evaluate-a-document contract, purely internal wiring so
@@ -1992,14 +2025,27 @@ declare class ExpressionEngine {
      */
     warmUp(): void;
     /**
-     * Build the {@link LineExecutionContext} passed to `executeBytecode()`
-     * for a given line. `lineNumber = -1` (the existing sentinel
+     * The {@link LineExecutionContext} passed to `executeBytecode()` for a
+     * given line. `lineNumber = -1` (the existing sentinel
      * `evaluateExpression()`/`evaluateLine(-1, ...)` already use for "no
      * real document") naturally produces a context with both closures
      * `undefined`, a cross-line plugin function must check for that itself
      * and return a clear error, never assume line 0 exists.
+     *
+     * One object serves a whole pass, its line number set by mutation here:
+     * the closures read only the document model, or the batch pass's scan
+     * and results, and those are fixed for the length of a pass, so the
+     * context is rebuilt only when one of them changes. See
+     * {@link lineContext} for the re-entrant case that must not share it.
      */
     private makeLineContext;
+    /**
+     * Allocate a context over the given cross-line sources. Every ordinary
+     * line goes through {@link makeLineContext}, which keeps one of these per
+     * pass; this is the allocation itself, called directly where a fresh
+     * object is required.
+     */
+    private buildLineContext;
     /**
      * Re-evaluate line `targetLine`'s compiled expression with `variable` bound
      * to `bound` for that one run, the primitive goal seek drives while
@@ -2035,9 +2081,9 @@ declare class ExpressionEngine {
      * is aborted, causing all in-flight async work (fetches, preflight checks,
      * batcher flushes) to be canceled atomically.
      *
-     * executeAndStore() and executeRaw() link their local AbortControllers to
-     * this signal so that when the keystroke changes, all per-evaluation controllers
-     * are aborted together.
+     * {@link armCancellation} links each per-evaluation AbortController to
+     * this signal, for a line that can have work in flight, so that when the
+     * keystroke changes, all of them are aborted together.
      */
     private keystrokeSignal;
     /**
@@ -2056,6 +2102,13 @@ declare class ExpressionEngine {
      * its results as current; the manager's own timers are what stop the work.
      */
     private readonly backgroundRefreshSignal;
+    /**
+     * The signal a line no resolver could intercept executes under. Never
+     * aborted: such a line has no in-flight work for a keystroke to cancel,
+     * so it shares this one signal rather than allocating a controller and
+     * linking a listener nothing could fire. See {@link armCancellation}.
+     */
+    private readonly inertSignal;
     /** Post-lexer token normalizer for phrase fusion, implicit multiply, etc. */
     private normalizer;
     /**
@@ -2109,7 +2162,8 @@ declare class ExpressionEngine {
     /** 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.
+     * Insert into the bytecode cache, evicting the least recently used entry
+     * when full.
      *
      * Bug fix (found during release hardening): this used to check against
      * a hardcoded `BYTECODE_CACHE_MAX_ENTRIES = 2000` constant that never
@@ -2120,8 +2174,40 @@ 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. */
+    /**
+     * Mark a cached program as just used, so eviction passes over it.
+     *
+     * Re-inserting the key moves it to the end of the Map's insertion order,
+     * which makes the first key the least recently used, and that is where
+     * {@link cacheBytecode} evicts from. Insertion order alone evicted the
+     * earliest compiled line however hot it was: a document re-evaluated on
+     * every keystroke touches all of its lines, and each one-off expression
+     * (an inline solve, a classification probe of a prose line) pushed one
+     * of them out once the cap was reached. About 45 ns per hit, measured.
+     * The front half is not moved: it is keyed identically, evicted with the
+     * same victim, and its own order is never consulted.
+     *
+     * Only once the cache is full, which is the whole point: recency decides
+     * who gets evicted, and nothing is evicted below the cap, so under it the
+     * delete and re-insert buy nothing and cost on the hottest path there is.
+     * The 45 ns measured for one hit is not what it costs in a document, where
+     * every keystroke touches every line: a variable chain measured 1.17 ms
+     * before this guard and 2.10 ms after the LRU went in, in the same CI run
+     * as its own merge base. A Map holds a deleted key's slot until it
+     * compacts, so a delete-and-add on every hit pays for that repeatedly
+     * rather than once.
+     *
+     * The trade this leaves: the first eviction after the cache fills reads
+     * insertion order rather than true recency, because nothing before the cap
+     * was ordered. Every hit after that re-inserts, so the order is accurate
+     * from the second eviction on, and the first victim is at worst the same
+     * one insertion order would have chosen anyway.
+     */
+    private touchCompiled;
+    /** Remember a parse failure, evicting the least recently used when full: bounded like the program cache. */
     private rememberFailedParse;
+    /** Mark a remembered parse failure as just used; the same move, and the same guard, as {@link touchCompiled}. */
+    private touchFailedParse;
     private pluginFunctionIndexByName;
     private builderPool;
     private builderPoolIndex;
@@ -2269,6 +2355,29 @@ declare class ExpressionEngine {
      * Extracted common pattern from 8 call sites.
      */
     private storeLineResult;
+    /**
+     * Whether `program` can have work in flight: it calls a plugin function
+     * (the VM hands its signal to the pending result), or a registered
+     * resolver watches an opcode it contains. Everything else is a plain
+     * line, which skips the async preflight and the cancellation state.
+     */
+    private mayResolve;
+    /**
+     * Point the VM at the signal `program` executes under.
+     *
+     * A line that can have work in flight gets a fresh controller linked to
+     * the keystroke signal (One AbortController Per Keystroke): when the user
+     * types again the keystroke aborts, which aborts this controller, which
+     * cancels the fetch. A plain line gets the shared {@link inertSignal} and
+     * links nothing, since there is nothing a keystroke could cancel; on a
+     * large document the controller and the two listener changes per line
+     * were most of what a cached line cost.
+     *
+     * @returns The unlink step, to run once the evaluation settles
+     * synchronously (a pending result keeps its link so a later keystroke
+     * still cancels it), or null when nothing was linked.
+     */
+    private armCancellation;
     /**
      * Execute bytecode and handle the result.
      *
@@ -2665,13 +2774,13 @@ declare class ExpressionEngine {
     /**
      * Shared async-resolver preflight check, run before VM execution.
      *
-     * O(1) guard: skips the O(n) resolver scan when the bytecode has no
-     * async opcodes AND no resolvers are registered. Either condition alone
-     * is enough to warrant a preflight scan:
-     *   - program.hasAsync: bytecode contains CALL_PLUGIN (async VM path)
-     *   - resolverRegistry.size > 0: resolvers may intercept any expression
-     * For purely sync expressions (e.g., `2 + 2`) with no resolvers, this is
-     * an O(1) fast-path that bypasses the resolver scan entirely.
+     * Skipped outright for a line no registered resolver could intercept
+     * (see {@link mayResolve}): no resolver scan, no controller, no keystroke
+     * listener. With every built-in package loaded that used to be no line at
+     * all, since the old gate asked only whether any resolver was registered,
+     * so `2 + 2` paid for seven scans and two listener changes on every
+     * keystroke. A plugin call (`program.hasAsync`) always takes the full
+     * pass, which the VM's pending path relies on.
      *
      * If any registered resolver says "data not ready", registers a DAG
      * data-source dependency, stores a Pending result, and fires async