solve-engine 1.1.0 → 1.2.0

package/dist/{chunk-JIPATHVY.js → chunk-IJGOFP2J.js}

@@ -1,24 +1,24 @@
-import { ParseletRegistry, PrecedenceParser } from './chunk-I4GAWIPW.js';
+import { ParseletRegistry, PrecedenceParser } from './chunk-AOH6UR2L.js';
 import { ResolverRegistry } from './chunk-3VGDNEE3.js';
 import { abortLogger } from './chunk-FD5ZZHEU.js';
-import { executeBytecode, createVM, DependencyGraph, ScopeManager } from './chunk-WXEHD6TT.js';
-import { DiagnosticPipeline, TimelineDiagnosticCollector, DiagnosticEventType } from './chunk-CCBZZQAE.js';
-import { formatValue, DEFAULT_FORMATTING_SETTINGS } from './chunk-3OWCDIPN.js';
-import { BUILTIN_PACKAGES, containsSymbolicCall } from './chunk-RRLHC37V.js';
-import { BytecodeBuilder } from './chunk-ENKKJYD3.js';
-import { TokenNormalizer, BUILTIN_PHRASES, implicitMultiplyRule } from './chunk-JJIXHXFQ.js';
+import { executeBytecode, createVM, DependencyGraph, ScopeManager } from './chunk-FE4RC37D.js';
+import { DiagnosticPipeline, TimelineDiagnosticCollector, DiagnosticEventType } from './chunk-UF6JG5SG.js';
+import { formatValue, DEFAULT_FORMATTING_SETTINGS } from './chunk-YNIWOYW6.js';
+import { BUILTIN_PACKAGES, containsSymbolicCall } from './chunk-TPOK3UNI.js';
+import { BytecodeBuilder } from './chunk-IQJGDZOP.js';
+import { TokenNormalizer, BUILTIN_PHRASES, implicitMultiplyRule, createFusedToken } from './chunk-L5YHV6BQ.js';
 import { countLines } from './chunk-3BOK2LDK.js';
 import { createQueryClient, setActiveQueryClient, getActiveQueryClient } from './chunk-NLNDMWZC.js';
-import { sharedOpRegistry, createEngineContext, registerAsConverter, unregisterAsConverter, solveEquationValues, globalDagKey } from './chunk-NKW7LKYU.js';
-import { matrixMultiply, inverse } from './chunk-NNQ2TYDF.js';
-import { errorValue, pendingValue, stringValue, numberValue, freezeIfDev, Value, boolValue, uomValue, percentageValue, datetimeValue, bigIntValue, hexValue, ValueType } from './chunk-267JPOTF.js';
-import { mergeEngineConfig, DEFAULT_CONFIG, ENGINE_VERSION } from './chunk-G7Z4HJQA.js';
-import { Lexer, buildTokenLookup, sharedLexer } from './chunk-OADDUPT3.js';
-import { registerTokenCategory, unregisterTokenCategory } from './chunk-UO6BUV6K.js';
-import { LexerToken } from './chunk-GQMUHVE3.js';
-import { TokenTypes, tokenTypeId } from './chunk-4D6NIHE2.js';
+import { sharedOpRegistry, createEngineContext, registerAsConverter, unregisterAsConverter, solveEquationValues, globalDagKey } from './chunk-WMQRJTAO.js';
+import { matrixMultiply, inverse } from './chunk-ZNFFTYWH.js';
+import { errorValue, pendingValue, stringValue, numberValue, freezeIfDev, Value, boolValue, uomValue, percentageValue, datetimeValue, bigIntValue, hexValue, ValueType } from './chunk-5EFKSKMA.js';
+import { mergeEngineConfig, DEFAULT_CONFIG, ENGINE_VERSION } from './chunk-CSDQMDU2.js';
+import { Lexer, buildTokenLookup, sharedLexer } from './chunk-RNKDIXDV.js';
+import { registerTokenCategory, unregisterTokenCategory } from './chunk-LSALB3IN.js';
+import { LexerToken } from './chunk-ORM7CHYZ.js';
+import { TokenTypes, tokenTypeId } from './chunk-NAWZATKT.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
-import { normalizeUnknownError, ErrorFactory, EngineError } from './chunk-ERCOHGXD.js';
+import { normalizeUnknownError, ErrorFactory, EngineError } from './chunk-N7OA4WPJ.js';
 import { __commonJS, __toESM } from './chunk-YLJ4XMA6.js';
 
 // node_modules/semver/internal/constants.js
@@ -2769,7 +2769,8 @@ function extractReadsAndWrites(tokens) {
         }
       }
       reads.push(t.value);
-      if (i + 1 < tokens.length && tokens[i + 1].type === "EQUALS") {
+      const next = tokens[i + 1]?.type;
+      if (next === "EQUALS" || next === "PLUS_EQUALS" || next === "MINUS_EQUALS") {
         writes.push(t.value);
       }
     }
@@ -3109,6 +3110,14 @@ var _ExpressionEngine = class _ExpressionEngine {
     //#region Private Properties
     this.dag = new DependencyGraph();
     this.lineCache = new LineCache();
+    /**
+     * Names ever used as a running-total target (`total += 5`). A document is
+     * re-parsed top-to-bottom on every keystroke, so each accumulator is reset
+     * to undefined at the start of a batch pass and re-seeds from its opening
+     * `+=`/`-=` this pass, rather than reading its own previous pass's value
+     * (which grew the total without bound). See {@link tryCompoundAssignment}.
+     */
+    this.accumulatorNames = /* @__PURE__ */ new Set();
     this.scopeManager = new ScopeManager();
     /** Registry of async resolvers from registered packages. */
     this.resolverRegistry = new ResolverRegistry();
@@ -3757,6 +3766,7 @@ var _ExpressionEngine = class _ExpressionEngine {
     }
     if (!this.userUnits.isEmpty) this.bytecodeCache.clear();
     this.userUnits.clear();
+    this.resetAccumulators();
     const scanResults = this.lexer.scanDocument(input);
     const processedLines = this.processScanResults(scanResults);
     const result = {
@@ -3804,6 +3814,7 @@ var _ExpressionEngine = class _ExpressionEngine {
   evaluateLines(lines) {
     if (!this.userUnits.isEmpty) this.bytecodeCache.clear();
     this.userUnits.clear();
+    this.resetAccumulators();
     const documentText = lines.join("\n");
     const scanResults = this.lexer.scanDocument(documentText);
     return this.processScanResults(scanResults);
@@ -4172,6 +4183,90 @@ var _ExpressionEngine = class _ExpressionEngine {
     this.bytecodeCache.clear();
     return stringValue(`${nameWords.join(" ")} defined`);
   }
+  /**
+   * `name += expr` / `name -= expr`, a running total. The accumulator reads
+   * its current value, adds or subtracts the right-hand side, stores the
+   * result, and answers with the new value, so a note becomes a live ledger
+   * where each line adjusts a balance in place. Returns null to decline
+   * anything that is not the compound shape.
+   *
+   * Handled here, in the same effectful, cache-bypassing channel as
+   * {@link tryDefineUserUnit} and the bare `count = 10` assignment (see
+   * {@link trySymbolicGrammar}), rather than as a parselet: a bare identifier
+   * is a Tier-1 prefix that emits `LOAD_VAR name` before any infix parselet on
+   * `+=` could run, and that pre-emitted load throws UNDEFINED_VARIABLE for a
+   * first-use accumulator. Seeding 0 for a first `+=`/`-=` is a one-line
+   * `getVar`/`setVar` here where it cannot be from a parselet, a deliberate
+   * departure from a plain reference, which still reports the undefined name.
+   *
+   * The right-hand side is parenthesised and run through the ORDINARY (not
+   * symbolic-tolerant) path, so `bal += 3 * 4` is `bal + 12`, a genuine typo in
+   * it (`total += nope`) is a real UNDEFINED_VARIABLE, and the accumulation
+   * goes through the VM's own ADD/SUB: money stays money, a unit stays its
+   * unit, and the seed 0 added to a typed right-hand side takes that type on
+   * first use. The colon (`:name`) and `global :name` grammars are untouched:
+   * they lex their own leading token, never IDENT/UNIT, so they decline here.
+   */
+  tryCompoundAssignment(tokens, lineNumber = -1) {
+    if (tokens.length < 2) return null;
+    const nameTok = tokens[0];
+    const opTok = tokens[1];
+    const isName = nameTok.type === "IDENT" || nameTok.type === "UNIT";
+    const isCompound = opTok.type === "PLUS_EQUALS" || opTok.type === "MINUS_EQUALS";
+    if (!isName || !isCompound) return null;
+    const rhs = tokens.slice(2);
+    if (rhs.length === 0) {
+      throw ErrorFactory.parsing(
+        "COMPOUND_ASSIGN_REQUIRES_EXPRESSION",
+        `"${nameTok.value} ${opTok.value}" needs an expression on the right, e.g. "${nameTok.value} ${opTok.value} 10".`
+      );
+    }
+    const name = nameTok.value;
+    this.accumulatorNames.add(name);
+    if (this.vm.getVar(name) === void 0) this.vm.setVar(name, numberValue(0));
+    const op = opTok.type === "PLUS_EQUALS" ? { type: "PLUS", text: "+" } : { type: "MINUS", text: "-" };
+    const accTokens = [
+      createFusedToken("IDENT", name, [nameTok]),
+      createFusedToken(op.type, op.text, [opTok]),
+      createFusedToken("LPAREN", "(", [opTok]),
+      ...rhs,
+      createFusedToken("RPAREN", ")", [opTok])
+    ];
+    const result = executeBytecode(
+      this.compileAdHoc(accTokens),
+      this.vm,
+      void 0,
+      void 0,
+      this.makeLineContext(lineNumber),
+      false
+    );
+    if (result.type === "error") throw result.error;
+    if (result.type === "pending") {
+      throw ErrorFactory.execution(
+        "COMPOUND_ASSIGN_ASYNC_UNSUPPORTED",
+        `A running total (+= / -=) cannot use an async operation (weather/stocks/currency) on its right-hand side.`
+      );
+    }
+    this.vm.setVar(name, result.value);
+    return result.value;
+  }
+  /**
+   * Reset every running-total accumulator (`total += 5`) to undefined, and
+   * return their names.
+   *
+   * An accumulator seeds 0 only while its name is undefined, then reads that
+   * value on each `+=`/`-=`. A document is re-evaluated top-to-bottom on
+   * every keystroke, so unless the name is cleared first the total reads its
+   * own previous evaluation's value and grows without bound. The batch
+   * document pass (`parseDocument`/`evaluateLines`) calls this at the start
+   * of each pass; the incremental {@link ThreeTierEvaluator} calls it and
+   * then marks the lines that touch each name dirty, since it re-runs lines
+   * selectively rather than replaying the whole document.
+   */
+  resetAccumulators() {
+    for (const name of this.accumulatorNames) this.vm.deleteVar(name);
+    return this.accumulatorNames;
+  }
   trySymbolicGrammar(normalizedTokens, lineNumber = -1) {
     if (normalizedTokens.length === 0) return null;
     const last = normalizedTokens[normalizedTokens.length - 1];
@@ -4389,14 +4484,25 @@ var _ExpressionEngine = class _ExpressionEngine {
       return { kind: "error", stage: "complexity", error: complexityCheck.engineError, normalizedTokens };
     }
     let symbolicResult;
+    let compoundReadsWrites = null;
     try {
-      symbolicResult = this.tryDefineUserUnit(normalizedTokens) ?? this.trySymbolicGrammar(normalizedTokens, lineNumber);
+      symbolicResult = this.tryDefineUserUnit(normalizedTokens);
+      if (symbolicResult === null) {
+        const compound = this.tryCompoundAssignment(normalizedTokens, lineNumber);
+        if (compound !== null) {
+          symbolicResult = compound;
+          compoundReadsWrites = extractReadsAndWrites(normalizedTokens);
+        }
+      }
+      if (symbolicResult === null) {
+        symbolicResult = this.trySymbolicGrammar(normalizedTokens, lineNumber);
+      }
     } catch (e) {
       const { reads: reads2, writes: writes2 } = extractReadsAndWrites(normalizedTokens);
       return { kind: "error", stage: "parse", error: normalizeUnknownError(e), reads: reads2, writes: writes2, normalizedTokens };
     }
     if (symbolicResult !== null) {
-      return { kind: "symbolic-solve", normalizedTokens, value: symbolicResult };
+      return { kind: "symbolic-solve", normalizedTokens, value: symbolicResult, reads: compoundReadsWrites?.reads, writes: compoundReadsWrites?.writes };
     }
     const { reads, writes } = extractReadsAndWrites(normalizedTokens);
     const cachedProgram = this.bytecodeCache.get(expression);
@@ -4511,7 +4617,7 @@ var _ExpressionEngine = class _ExpressionEngine {
       throw prep.error;
     }
     if (prep.kind === "symbolic-solve") {
-      this.storeLineResult(lineNumber, prep.value, { opcodes: new Uint8Array(0), numbers: new Float64Array(0), strings: [], hasAsync: false }, [], [], expression);
+      this.storeLineResult(lineNumber, prep.value, { opcodes: new Uint8Array(0), numbers: new Float64Array(0), strings: [], hasAsync: false }, prep.reads ?? [], prep.writes ?? [], expression);
       return prep.value;
     }
     const { normalizedTokens, reads, writes, program } = prep;
@@ -4953,7 +5059,7 @@ var _ExpressionEngine = class _ExpressionEngine {
         });
       }
       const emptyProgram = { opcodes: new Uint8Array(0), numbers: new Float64Array(0), strings: [], hasAsync: false };
-      this.storeLineResult(lineNumber, prep.value, emptyProgram, [], [], expression);
+      this.storeLineResult(lineNumber, prep.value, emptyProgram, prep.reads ?? [], prep.writes ?? [], expression);
       return {
         value: prep.value,
         tokens: normalizedTokens,
@@ -5653,8 +5759,8 @@ var _ExpressionEngine = class _ExpressionEngine {
       return {
         program: { opcodes: new Uint8Array(0), numbers: new Float64Array(0), strings: [], hasAsync: false },
         tokens: prep.normalizedTokens,
-        reads: [],
-        writes: []
+        reads: prep.reads ?? [],
+        writes: prep.writes ?? []
       };
     }
     return { program: prep.program, tokens, reads: prep.reads, writes: prep.writes };
@@ -5778,6 +5884,7 @@ var _ExpressionEngine = class _ExpressionEngine {
     this.bytecodeCache.clear();
     this.vm.reset();
     this.userUnits.clear();
+    this.accumulatorNames.clear();
     this.lastTelemetry = null;
   }
   //#endregion
@@ -5836,7 +5943,12 @@ var _ExpressionEngine = class _ExpressionEngine {
     for (const [name, value] of this.vm.getVariableEntries()) {
       if (value.type === 12 /* Pending */) continue;
       if (latestWriter.get(name)?.async) continue;
-      variables[name] = serializeValue(value, `variable "${name}"`);
+      try {
+        variables[name] = serializeValue(value, `variable "${name}"`);
+      } catch (e) {
+        if (e instanceof EngineError && e.code === SnapshotErrorCodes.SNAPSHOT_UNSUPPORTED_VALUE) continue;
+        throw e;
+      }
     }
     const userFunctions = this.vm.getUserFunctionDefs().map(serializeUserFunction);
     const lineCache = [];
@@ -6788,5 +6900,5 @@ _AsyncResolutionBatcher.DEFAULT_HIGH_WATER_MARK = 64;
 var AsyncResolutionBatcher = _AsyncResolutionBatcher;
 
 export { AsyncResolutionBatcher, ExpressionEngine, SNAPSHOT_FORMAT, SNAPSHOT_VERSION, SnapshotErrorCodes, assertEngineVersionCompatible, checkEngineVersionCompatibility, checkExpressionComplexity, checkExpressionLength, checkPackageCompatibility, engine_worker_default, extractReadsAndWrites, findInlineSolvesInLine, isEmptyLine };
-//# sourceMappingURL=chunk-JIPATHVY.js.map
-//# sourceMappingURL=chunk-JIPATHVY.js.map
+//# sourceMappingURL=chunk-IJGOFP2J.js.map
+//# sourceMappingURL=chunk-IJGOFP2J.js.map