solve-engine 1.0.0-beta.6 → 1.0.0

package/dist/{chunk-NUR3K7EW.js → chunk-3VNGREMU.js}

@@ -1,19 +1,20 @@
-import { ParseletRegistry, PrecedenceParser } from './chunk-MEOHSQEH.js';
+import { ParseletRegistry, PrecedenceParser } from './chunk-3LAEG75D.js';
 import { ResolverRegistry } from './chunk-3VGDNEE3.js';
 import { abortLogger, djb2Hash } from './chunk-IF532O7C.js';
-import { executeBytecode, createVM, DependencyGraph, ScopeManager } from './chunk-BAMZT3GL.js';
+import { executeBytecode, createVM, DependencyGraph, ScopeManager } from './chunk-5WVP4YHP.js';
 import { DiagnosticPipeline, TimelineDiagnosticCollector, DiagnosticEventType } from './chunk-G535KJEG.js';
-import { BUILTIN_PACKAGES, containsSymbolicCall } from './chunk-GVWHCL2N.js';
-import { BytecodeBuilder } from './chunk-6GCKCWLB.js';
-import { TokenNormalizer, BUILTIN_PHRASES, implicitMultiplyRule } from './chunk-OFXOTECC.js';
+import { BUILTIN_PACKAGES, containsSymbolicCall } from './chunk-HMOISHXR.js';
+import { BytecodeBuilder } from './chunk-526PMQOA.js';
+import { TokenNormalizer, BUILTIN_PHRASES, implicitMultiplyRule } from './chunk-YPPPYLSR.js';
+import { countLines } from './chunk-3BOK2LDK.js';
 import { createQueryClient, setActiveQueryClient, getActiveQueryClient } from './chunk-NLNDMWZC.js';
-import { sharedOpRegistry, createEngineContext, registerAsConverter, unregisterAsConverter, solveEquationValues, globalDagKey, sharedGlobalVariableStore } from './chunk-MVBEL57Q.js';
-import { matrixMultiply, inverse } from './chunk-CYFK5SY2.js';
-import { pendingValue, errorValue, stringValue, numberValue, freezeIfDev, boolValue, uomValue, percentageValue, datetimeValue, bigIntValue, hexValue, enableValueArena, disableValueArena } from './chunk-BVAR5J2F.js';
-import { mergeEngineConfig, DEFAULT_CONFIG, ENGINE_VERSION } from './chunk-LVLUHTRD.js';
-import { Lexer, buildTokenLookup, sharedLexer } from './chunk-2CS6OMZK.js';
+import { sharedOpRegistry, createEngineContext, registerAsConverter, unregisterAsConverter, solveEquationValues, globalDagKey, sharedGlobalVariableStore } from './chunk-Y7FT4IQT.js';
+import { matrixMultiply, inverse } from './chunk-O3ANBHSA.js';
+import { pendingValue, errorValue, stringValue, numberValue, freezeIfDev, boolValue, uomValue, percentageValue, datetimeValue, bigIntValue, hexValue, enableValueArena, disableValueArena } from './chunk-GQCOSXMG.js';
+import { mergeEngineConfig, DEFAULT_CONFIG, ENGINE_VERSION } from './chunk-GLG5ZMX7.js';
+import { Lexer, buildTokenLookup, sharedLexer } from './chunk-5F4C26RU.js';
 import { registerTokenCategory, unregisterTokenCategory } from './chunk-AJA6LUI7.js';
-import { normalizeUnknownError, ErrorFactory, EngineError } from './chunk-6RDSQURE.js';
+import { normalizeUnknownError, ErrorFactory, EngineError } from './chunk-3D7V24DG.js';
 import { __commonJS, __toESM } from './chunk-YLJ4XMA6.js';
 
 // node_modules/semver/internal/constants.js
@@ -3457,6 +3458,11 @@ var ExpressionEngine = class {
       this.config.vm.maxStackDepth,
       this.config.vm.maxInstructions,
       void 0,
+      this.config.vm.maxCollectionSize,
+      this.config.vm.maxAllocatedElements,
+      this.config.vm.maxFunctionCalls,
+      this.config.date.maxOffsetYears,
+      this.config.date.minOffsetYears,
       this.context
     );
     this.queryClient = createQueryClient();
@@ -3577,7 +3583,8 @@ var ExpressionEngine = class {
       resolverNamespaces: [],
       tokenCategories: [],
       lexerVocabulary: pkg.lexerVocabulary,
-      asConverterNames: []
+      asConverterNames: [],
+      normalizerRuleNames: []
     };
     if (pkg.lexerVocabulary) {
       this.lexer.registerVocabulary(pkg.lexerVocabulary);
@@ -3619,6 +3626,7 @@ var ExpressionEngine = class {
     if (pkg.normalizerRules) {
       for (const rule of pkg.normalizerRules) {
         this.normalizer.register(rule);
+        contribution.normalizerRuleNames.push(rule.name);
       }
     }
     if (pkg.tokenCategories) {
@@ -3652,9 +3660,17 @@ var ExpressionEngine = class {
    * own contract). This engine-instance-local registration is reversed
    * here too, even though it isn't a "shared" registry, so a package's
    * lexer and highlighting contributions clean up together rather than
-   * only half-reversing on unregister. Per-engine parselets/phrases are
-   * still left in place: they live in this engine's isolated registries
-   * and are discarded with the engine instance.
+   * only half-reversing on unregister. Normalizer rules are reversed here
+   * for the same reason: they are per-engine, but they live in an ARRAY the
+   * normalizer walks at every token position, so re-registering a package
+   * appended a second copy of every rule and lexing got slower with every
+   * register/unregister cycle.
+   *
+   * Per-engine parselets and phrases are still left in place: a parselet
+   * lives in this engine's isolated registry and a phrase goes into a
+   * text-keyed trie where registering the same phrase twice is the same as
+   * registering it once, so neither accumulates and both are discarded with
+   * the engine instance.
    *
    * Clears the bytecode cache, removing handlers changes what compiled
    * bytecode is valid.
@@ -3684,6 +3700,9 @@ var ExpressionEngine = class {
     for (const name of contribution.asConverterNames) {
       unregisterAsConverter(name);
     }
+    for (const ruleName of contribution.normalizerRuleNames) {
+      this.normalizer.unregister(ruleName);
+    }
     this.packageCompletionItems.delete(packageName);
     this.packageContributions.delete(packageName);
     this.registeredPackages.delete(packageName);
@@ -3861,6 +3880,14 @@ var ExpressionEngine = class {
    * with precise coordinate mapping for inline solves.
    */
   parseDocument(input, options = { inputType: "markdown" }) {
+    const maxLines = this.config.performance.maxDocumentLines;
+    if (countLines(input, maxLines) > maxLines) {
+      throw ErrorFactory.execution(
+        "DOCUMENT_TOO_LARGE",
+        `This document has more than ${maxLines.toLocaleString("en-US")} lines, which is the most the engine will process in one pass`,
+        { maxLines }
+      );
+    }
     const scanResults = this.lexer.scanDocument(input);
     const processedLines = this.processScanResults(scanResults);
     const result = {
@@ -4009,8 +4036,14 @@ var ExpressionEngine = class {
    * parseExpression(). Abstracts the API difference between the two parsers:
    * - PrecedenceParser:  parser.setBuilder(builder); parser.parseExpression(0)
    * - RD:                parser.builder = builder; parser.parseExpression(0)
+   *
+   * @param allowLabelFallback - Whether a line that does not parse whole may
+   * be retried as "<label>: <expression>". True for a real line, false for
+   * the retries that fallback makes itself, which is what stops it costing
+   * exponential time; see the loop below, and the comment on its recursive
+   * call for the measurement.
    */
-  parseExpression(builder, tokens, hasParens) {
+  parseExpression(builder, tokens, hasParens, allowLabelFallback = true) {
     this.parser.setBuilder(builder);
     this.parser.load(tokens, this.config.validation.autoBalanceParens ? hasParens : false);
     this.parser.parseExpression(0);
@@ -4019,12 +4052,28 @@ var ExpressionEngine = class {
       if (leftover.type === "EQUALS" && !this.parser.peekAt(1)) {
         return;
       }
-      for (let i = tokens.length - 1; i >= 1; i--) {
+      for (let i = allowLabelFallback ? tokens.length - 1 : 0; i >= 1; i--) {
         if (tokens[i].type !== "COLON") continue;
         if (i + 1 >= tokens.length) continue;
+        let labelIsAllNumeric = true;
+        for (let j = 0; j < i; j++) {
+          const type = tokens[j].type;
+          if (type !== "NUMBER" && type !== "COLON") {
+            labelIsAllNumeric = false;
+            break;
+          }
+        }
+        if (labelIsAllNumeric) {
+          const literal = tokens.slice(0, i + 2).map((t) => t.value).join("");
+          throw ErrorFactory.parsing(
+            "INVALID_TIME_LITERAL",
+            `"${literal}" is not a valid time`,
+            { tokenType: tokens[i].type, tokenValue: literal }
+          );
+        }
         builder.reset();
         try {
-          this.parseExpression(builder, tokens.slice(i + 1), hasParens);
+          this.parseExpression(builder, tokens.slice(i + 1), hasParens, false);
           return;
         } catch {
         }
@@ -4060,9 +4109,17 @@ var ExpressionEngine = class {
    * (a bare assignment's RHS, and an equation's own RHS at solve time)
    *, every one of these needs forward-tolerant reads of not-yet-defined
    * names, which ordinary evaluation deliberately never allows.
+   *
+   * `lineNumber` is the 1-based document line this program belongs to, so
+   * the RHS still receives a {@link makeLineContext}, a bare assignment's
+   * right-hand side (`total = prev`, `x = line2`) can therefore read
+   * cross-line results exactly as a bare expression line does. Defaults to
+   * `-1` (the "no real document" sentinel) for the expression-level and
+   * `=>`-without-a-document callers, which naturally yields the same
+   * `LINE_REF_NO_DOCUMENT` a single-expression eval already returns.
    */
-  executeSymbolicTolerant(program) {
-    const result = executeBytecode(program, this.vm, void 0, void 0, void 0, true);
+  executeSymbolicTolerant(program, lineNumber = -1) {
+    const result = executeBytecode(program, this.vm, void 0, void 0, this.makeLineContext(lineNumber), true);
     if (result.type === "error") throw result.error;
     if (result.type === "pending") {
       throw ErrorFactory.execution(
@@ -4072,9 +4129,9 @@ var ExpressionEngine = class {
     }
     return result.value;
   }
-  /** Compiles and executes `tokens` in symbolic-tolerant mode, the "just simplify this" `=>` fallback when there's no stored equation to solve. */
-  simplifySymbolically(tokens) {
-    return this.executeSymbolicTolerant(this.compileAdHoc(tokens));
+  /** Compiles and executes `tokens` in symbolic-tolerant mode, the "just simplify this" `=>` fallback when there's no stored equation to solve. `lineNumber` (1-based, `-1` outside a document) is forwarded so a bare assignment's RHS can resolve cross-line references. */
+  simplifySymbolically(tokens, lineNumber = -1) {
+    return this.executeSymbolicTolerant(this.compileAdHoc(tokens), lineNumber);
   }
   /**
    * Parses a bare (colon-less) equation's left-hand side, `factor1 *
@@ -4119,7 +4176,7 @@ var ExpressionEngine = class {
    * errors propagate as values" convention (DIMENSION_MISMATCH,
    * SINGULAR_MATRIX, ...).
    */
-  solveEquation(equation) {
+  solveEquation(equation, lineNumber = -1) {
     const factorValues = [];
     for (const name of equation.factorNames) {
       const v = this.vm.getVar(name);
@@ -4145,7 +4202,7 @@ var ExpressionEngine = class {
     }
     const inv = inverse(combined);
     if (inv.type === 13 /* Error */) return inv;
-    const rhsValue = this.executeSymbolicTolerant(equation.rhsProgram);
+    const rhsValue = this.executeSymbolicTolerant(equation.rhsProgram, lineNumber);
     if (rhsValue.type !== 7 /* Matrix */) {
       return errorValue(
         "EQUATION_RHS_NOT_MATRIX",
@@ -4185,7 +4242,7 @@ var ExpressionEngine = class {
    * session's own Phase H.2 scope decision (full symbolic MATRICES, not
    * a general CAS).
    */
-  trySymbolicGrammar(normalizedTokens) {
+  trySymbolicGrammar(normalizedTokens, lineNumber = -1) {
     if (normalizedTokens.length === 0) return null;
     const last = normalizedTokens[normalizedTokens.length - 1];
     if (last.type === "THEREFORE") {
@@ -4198,18 +4255,18 @@ var ExpressionEngine = class {
         const equation = this.vm.getEquation(name);
         const scalar = this.vm.getScalarEquation(name);
         if (equation) {
-          const solved = this.solveEquation(equation);
+          const solved = this.solveEquation(equation, lineNumber);
           const isNotMatrix = solved.type === 13 /* Error */ && solved.value === "EQUATION_FACTOR_NOT_MATRIX";
           if (!isNotMatrix || !scalar) return solved;
         }
         if (scalar) {
-          return this.solveScalarEquation(scalar);
+          return this.solveScalarEquation(scalar, lineNumber);
         }
       }
-      return this.simplifySymbolically(beforeTokens);
+      return this.simplifySymbolically(beforeTokens, lineNumber);
     }
     if (containsSymbolicCall(normalizedTokens)) {
-      return this.simplifySymbolically(normalizedTokens);
+      return this.simplifySymbolically(normalizedTokens, lineNumber);
     }
     if (normalizedTokens[0].type === "COLON" || normalizedTokens[0].type === "GLOBAL") return null;
     const eqIdx = normalizedTokens.findIndex((t) => t.type === "EQUALS");
@@ -4220,7 +4277,7 @@ var ExpressionEngine = class {
     }
     const rhsTokens = normalizedTokens.slice(eqIdx + 1);
     if (names.length === 1) {
-      const result = this.simplifySymbolically(rhsTokens);
+      const result = this.simplifySymbolically(rhsTokens, lineNumber);
       this.vm.setVar(names[0], result);
       return result;
     }
@@ -4306,9 +4363,9 @@ var ExpressionEngine = class {
    * @returns The solution, rendered by the same helper `solve()` uses, so the
    * two surfaces cannot disagree about how an outcome reads.
    */
-  solveScalarEquation(equation) {
-    const lhs = this.executeSymbolicTolerant(equation.lhsProgram);
-    const rhs = this.executeSymbolicTolerant(equation.rhsProgram);
+  solveScalarEquation(equation, lineNumber = -1) {
+    const lhs = this.executeSymbolicTolerant(equation.lhsProgram, lineNumber);
+    const rhs = this.executeSymbolicTolerant(equation.rhsProgram, lineNumber);
     return solveEquationValues(lhs, rhs, equation.variable);
   }
   //#endregion
@@ -4386,7 +4443,7 @@ var ExpressionEngine = class {
    * produced negative-allocation readings (a GC sweep landing inside the
    * wider window) in `AllocationTracker.spec.ts` well over half the time.
    */
-  prepareExpression(expression, tokens, hasParens, onFusion) {
+  prepareExpression(expression, tokens, hasParens, onFusion, lineNumber = -1) {
     const lengthCheck = checkExpressionLength(expression, this.config.validation);
     if (!lengthCheck.passed) {
       return { kind: "error", stage: "length", error: lengthCheck.error.engineError };
@@ -4400,7 +4457,7 @@ var ExpressionEngine = class {
     if (!complexityCheck.passed) {
       return { kind: "error", stage: "complexity", error: complexityCheck.engineError, normalizedTokens };
     }
-    const symbolicResult = this.trySymbolicGrammar(normalizedTokens);
+    const symbolicResult = this.trySymbolicGrammar(normalizedTokens, lineNumber);
     if (symbolicResult !== null) {
       return { kind: "symbolic-solve", normalizedTokens, value: symbolicResult };
     }
@@ -4507,7 +4564,7 @@ var ExpressionEngine = class {
    * {@link preflightAsync}) + VM execution (via {@link executeAndStore}).
    */
   evaluateWithTokens(lineNumber, expression, tokens, hasParens) {
-    const prep = this.prepareExpression(expression, tokens, hasParens);
+    const prep = this.prepareExpression(expression, tokens, hasParens, void 0, lineNumber);
     if (prep.kind === "empty") {
       const v = numberValue(0);
       this.lineCache.set(lineNumber, new LineCacheEntry(v, { opcodes: new Uint8Array(0), numbers: new Float64Array(0), strings: [], hasAsync: false }, [], null), expression);
@@ -4836,7 +4893,7 @@ var ExpressionEngine = class {
     if (hasCollectors && !cachedBefore) {
       this.parser.setDiagnosticPipeline(pipeline, expression);
     }
-    const prep = this.prepareExpression(expression, tokens, hasParens, onFusion);
+    const prep = this.prepareExpression(expression, tokens, hasParens, onFusion, lineNumber);
     if (trackEnabled && prep.kind === "ready" && prep.parserAlloc) {
       stageAllocs.push(prep.parserAlloc);
     }
@@ -5945,7 +6002,14 @@ function pseudoRandom(seed) {
 
 // src/engine/DocumentModel.ts
 var DocumentModel = class {
-  constructor() {
+  /**
+   * @param maxLines - Ceiling on the line count, defaulting to the engine's
+   * configured one. Every line costs a LineState with six arrays in it
+   * whatever the line says, so the cost of a document is its line count and
+   * nothing else bounds it: two hundred thousand lines of `1 + 1` exhausted
+   * the heap here, before a single expression had been looked at.
+   */
+  constructor(maxLines = DEFAULT_CONFIG.performance.maxDocumentLines) {
     /** Persistent line ID → LineState. */
     this.lines = /* @__PURE__ */ new Map();
     /** Order-statistic treap representing the current document line order. */
@@ -5970,13 +6034,26 @@ var DocumentModel = class {
      * bottom of a 20k-line document before this fix.
      */
     this.dirtyLineIds = /* @__PURE__ */ new Set();
+    this.maxLines = maxLines;
   }
   // ── Initialization ──────────────────────────────────────────────────
   /**
    * Initialize or replace the entire document from a text blob.
    * Clears all existing state and assigns new persistent line IDs.
+   *
+   * @throws `DOCUMENT_TOO_LARGE` for a document past {@link maxLines}, before
+   * any of it is stored. Recoverable: nothing has been replaced yet, so the
+   * model still holds whatever it held.
    */
   setDocument(text) {
+    const lineCount = countLines(text, this.maxLines);
+    if (lineCount > this.maxLines) {
+      throw ErrorFactory.execution(
+        "DOCUMENT_TOO_LARGE",
+        `This document has more than ${this.maxLines.toLocaleString("en-US")} lines, which is the most the engine will hold at once`,
+        { maxLines: this.maxLines }
+      );
+    }
     this.lines.clear();
     this.orderTree.clear();
     this._positionCache = null;
@@ -7469,5 +7546,5 @@ var ThreeTierEvaluator = class {
 };
 
 export { AsyncResolutionBatcher, DocumentModel, EvalTier, ExpressionEngine, ThreeTierEvaluator, assertEngineVersionCompatible, checkEngineVersionCompatibility, checkExpressionComplexity, checkExpressionLength, checkPackageCompatibility, extractReadsAndWrites, findInlineSolvesInLine, isEmptyLine };
-//# sourceMappingURL=chunk-NUR3K7EW.js.map
-//# sourceMappingURL=chunk-NUR3K7EW.js.map
+//# sourceMappingURL=chunk-3VNGREMU.js.map
+//# sourceMappingURL=chunk-3VNGREMU.js.map