solve-engine 1.1.1 → 1.2.0

package/dist/{chunk-DLEBSLF4.js.map → chunk-RNKDIXDV.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/lexer/LexerState.ts","../src/lexer/Lexer.ts","../src/lexer/TokenClassRegistry.ts","../src/lexer/tokenRegistration.ts"],"names":["LexerState"],"mappings":"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","file":"chunk-DLEBSLF4.js","sourcesContent":["/**\n * Lexer state machine modes.\n * - Main: document-level scanning with markdown classification\n * - Inline: expression embedded in markdown inline solve (`s\\`...\\``)\n * - String: inside a double-quoted string literal\n */\nexport enum LexerState {\n\tMain = \"main\",\n\tInline = \"inline\",\n\tString = \"string\",\n}\n","import { ExpressionLexer, LineClassification, LexerVocabulary, type ScanLineResult } from \"./ExpressionLexer\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { LexerState } from \"@solve-js/lexer/LexerState\";\nimport { getTokenCategory } from \"@solve-js/language/TokenCategoryMap\";\nimport type { TokenCategory } from \"@solve-js/language/TokenCategory\";\nimport type { TokenLookup } from \"@solve-js/lexer/TokenClassRegistry\";\n\n/**\n * Public tokenizer wrapper around {@link ExpressionLexer}.\n *\n * `ExpressionLexer` does the actual character-by-character scanning;\n * `Lexer` adds a materialized-token-array streaming interface\n * (`next()`/`peek()`) plus line-classification state (`reset()`) so\n * callers can iterate a line's tokens without re-scanning on each peek.\n *\n * Each `ExpressionEngine` instance owns its own `Lexer`, and packages\n * extend it via {@link registerVocabulary} (keywords, operators, units)\n * see `IEnginePackage.lexerVocabulary`.\n */\nexport class Lexer {\n  /** Expression-mode lexer (Phase A: V8-optimized, replaces moo) */\n  private expressionLexer: ExpressionLexer;\n  private currentState: LexerState = LexerState.Main;\n  private peekedToken: Token | undefined;\n  private hasPeeked = false;\n\n  // Materialized token array from the last reset() call, used for\n  // next()/peek() streaming access.\n  private tokens: Token[] = [];\n  private tokenIdx: number = 0;\n\n  /**\n   * @param localeCode - Locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n   * @param tokenLookup - Optional TokenLookup from TokenClassRegistry.\n   *   When provided, configures ExpressionLexer to use registry-built\n   *   keyword/unit/phrase lookups instead of internal instance maps.\n   */\n  constructor(localeCode = \"en\", tokenLookup?: TokenLookup) {\n    // Pass the lookup directly to ExpressionLexer's constructor, it's an\n    // instance field now, not a static. Each Lexer instance gets its own\n    // isolated lookup, preventing cross-instance corruption.\n    this.expressionLexer = new ExpressionLexer(localeCode, tokenLookup);\n  }\n\n  reset(input: string, state?: LexerState): void {\n    const newState = state ?? LexerState.Main;\n    this.currentState = newState;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n\n    // Phase B: Main state classifies the line with the markdown scanner.\n    // Skip lines (headings, fences, HRs, etc.) produce empty token arrays.\n    // Expression lines and lines with inline solves are tokenized normally.\n    if (newState === LexerState.Main) {\n      const classification = this.expressionLexer.classifyLine(input);\n      if (classification.skip) {\n        this.tokens = [];\n        this.tokenIdx = 0;\n        return;\n      }\n      // Expression line or markdown line with inline solves, tokenize.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    } else {\n      // Non-main states (Inline, String), expression tokenization.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    }\n  }\n\n  /**\n   * Classify a single line of markdown text (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  classifyLine(lineText: string): LineClassification {\n    return this.expressionLexer.classifyLine(lineText);\n  }\n\n  /**\n   * Find all inline solve markers in a line (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  findInlineSolves(lineText: string) {\n    return this.expressionLexer.findInlineSolves(lineText);\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes (locale + plugin-contributed),\n   * mapped to the token type it lexes to. Delegates to the ExpressionLexer.\n   */\n  getKeywords(): Record<string, string> {\n    return this.expressionLexer.getKeywords();\n  }\n\n  next(): Token | undefined {\n    if (this.hasPeeked) {\n      this.hasPeeked = false;\n      return this.peekedToken;\n    }\n    // Materialized token array (ExpressionLexer path).\n    if (this.tokenIdx < this.tokens.length) {\n      return this.tokens[this.tokenIdx++];\n    }\n    return undefined;\n  }\n\n  peek(): Token | undefined {\n    if (this.hasPeeked) return this.peekedToken;\n    this.peekedToken = this.next();\n    this.hasPeeked = true;\n    return this.peekedToken;\n  }\n\n  [Symbol.iterator](): Iterator<Token> {\n    return this.tokens[Symbol.iterator]();\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   * Delegates to the underlying ExpressionLexer.\n   *\n   * @see LexerVocabulary for the supported extension points.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.registerVocabulary(plugin);\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   * Delegates to the underlying ExpressionLexer.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.unregisterVocabulary(plugin);\n  }\n\n  /**\n   * Reset the lexer for expression-only text, skips the classifyLine()\n   * overhead in reset() for callers that already know the input is an\n   * evaluable expression (e.g., after isEmptyLine() confirmed non-skip).\n   */\n  resetExpression(input: string): void {\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(input);\n    this.tokens = this.expressionLexer.tokenizeAll();\n    this.tokenIdx = 0;\n  }\n\n  /**\n   * Scan a full document in one pass, classifying each line and\n   * tokenizing non-skipped lines. Delegates to ExpressionLexer.\n   *\n   * @returns ScanLineResult[], one per line, with classification + tokens.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    return this.expressionLexer.scanDocument(text);\n  }\n\n  getState(): LexerState {\n    return this.currentState;\n  }\n\n  setState(state: LexerState): void {\n    this.currentState = state;\n  }\n\n  getHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n\n    // For blockquote lines, strip the \"> \" prefix and tokenize the expression content.\n    // This lets expressions inside blockquotes (e.g., \"> 1 + 2\") get syntax highlighted\n    // while pure structural lines (headings, code fences) remain unhighlighted.\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectHighlightTokens(lineText.slice(2));\n    }\n\n    if (classification.skip) {\n      return [];\n    }\n\n    return this.collectHighlightTokens(lineText);\n  }\n\n  /**\n   * The same tokens {@link getHighlightTokens} reduces, before reduction.\n   *\n   * Exists because normalization operates on tokens, not on the flattened\n   * shape, and a consumer that wants phrase-fused highlighting has to run the\n   * normalizer between the two. See `LanguageService.getSemanticTokens`.\n   *\n   * @param lineText - One line of source.\n   * @returns Every token on the line that is worth painting, unreduced.\n   */\n  getHighlightTokenObjects(lineText: string): Token[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectTokenObjects(lineText.slice(2));\n    }\n    if (classification.skip) return [];\n    return this.collectTokenObjects(lineText);\n  }\n\n  private collectTokenObjects(lineText: string): Token[] {\n    this.resetExpression(lineText);\n    const result: Token[] = [];\n    for (const token of this) {\n      if (token.type === \"WS\" || token.type === \"NEWLINE\") continue;\n      if (token.type.startsWith(\"MD_\")) continue;\n      if (token.type === \"INLINE_SOLVE_START\" || token.type === \"BACKTICK_CLOSE\") continue;\n      result.push(token);\n    }\n    return result;\n  }\n\n  private collectHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    return this.collectTokenObjects(lineText).map(token => ({\n      type: token.type,\n      value: token.value,\n      offset: token.offset,\n      col: token.col,\n      // `text`, not `value`: this is a span into the source, and the two\n      // differ for a string literal, whose value is the payload while its\n      // text still carries the quote characters the reader typed.\n      length: token.text.length,\n      category: getTokenCategory(token.type),\n    }));\n  }\n}\n\n/**\n * A lexer for operations that do not depend on registered vocabulary.\n *\n * Line classification and inline-solve detection read characters looking for\n * headings, comment markers, fences and backtick spans, and never consult the\n * keyword, unit or operator tables. Every lexer therefore returns the same\n * answer, so the callers that have no engine to ask can use this one. Checked\n * by `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n *\n * Do not tokenize with this. An engine's own lexer carries the vocabulary its\n * packages registered; this one carries none.\n */\nexport const sharedLexer = new Lexer(\"en\", undefined);","/**\n * TokenClass, Plugin-extensible keyword registration for the Lexer.\n *\n * Providers call `registry.register(tokenClass)` to teach the lexer about\n * their keywords. The registry merges locale keywords, provider keywords,\n * phrase mappings, and unit names into an optimized TokenLookup structure\n * consumed by the Lexer.\n *\n * @example\n * registry.register({\n *   tokenType: 'CARET',\n *   keywords: {},\n *   phrases: { 'to the power of': true, 'power of': true },\n *   priority: 10,\n *   description: 'Exponentiation operators (x^y)',\n * });\n */\nexport interface TokenClass {\n  /** The token type string produced by the lexer (e.g., \"FUNC\", \"PI\", \"CARET\").\n   *  Must match a token type that a ParseletRegistry has a parselet for. */\n  tokenType: string;\n\n  /** Single-word keywords (case-insensitive). The lexer lowercases input\n   *  before lookup, so these should be lowercase. Example:\n   *  { sqrt: true, abs: true, sin: true, cos: true } for tokenType \"FUNC\" */\n  keywords: Record<string, boolean>;\n\n  /** Multi-word phrases (case-insensitive). Matched by the built-in PhraseMatcher\n   *  via the phrase trie. Example:\n   *  { \"to the power of\": true, \"power of\": true } for tokenType \"CARET\" */\n  phrases?: Record<string, boolean>;\n\n  /** Priority for conflict resolution. When two TokenClasses register\n   *  the same keyword, the higher-priority class wins. Locale keywords\n   *  have priority 0 (set via setLocale). Providers should use\n   *  priority >= 10 to override locale defaults. Default: 0 */\n  priority?: number;\n\n  /** Human-readable description for debugging and introspection */\n  description?: string;\n}\n\n// ── Phrase Trie ──────────────────────────────────────────────────────────────\n\n/** Trie node for multi-word phrase matching. */\nexport interface PhraseNode {\n  /** Complete phrase token type (null = intermediate node) */\n  type?: string;\n  children: Map<string, PhraseNode>;\n}\n\n// ── TokenLookup, Optimized lookup structure for the Lexer ──────────────────\n\n/**\n * The optimized lookup structure built by TokenClassRegistry.build().\n * Consumed by the Lexer for O(1) keyword → token type lookups and\n * O(word-count) phrase matching.\n */\nexport interface TokenLookup {\n  /** Lowercase keyword → token type. O(1) Map lookup. */\n  keywordToType: Map<string, string>;\n\n  /** Phrase trie for multi-word matching. Root node with children maps.\n   *  Null if no phrases registered. */\n  phraseTrie: PhraseNode | null;\n\n  /** Set of lowercase first-words of all registered phrases.\n   *  Used by the lexer to emit IDENT (not a phrase keyword) for words\n   *  that start multi-word phrases, deferring to the PhraseMatcher.\n   *\n   *  Example: \"to\" is in phraseStartWords because \"to the power of\" is a phrase.\n   *  When the lexer sees \"to\", it emits IDENT and lets the phrase matcher\n   *  combine \"to the power of\" into a single CARET token.\n   *\n   *  This prevents plugins from accidentally overriding phrase-start words.\n   */\n  phraseStartWords: Set<string>;\n\n  /** Case-sensitive unit names for UNIT fallback after keyword lookup fails. */\n  unitNames: ReadonlySet<string>;\n}\n\n// ── TokenClassRegistry ───────────────────────────────────────────────────────\n\n/**\n * Central registry for keyword→token-type mappings.\n *\n * Providers register TokenClasses; locales provide keyword maps;\n * units provide a name set. `build()` merges all sources into an\n * optimized TokenLookup consumed by the Lexer.\n *\n * Merge order (later overrides earlier):\n *   1. Locale keywords (priority 0)\n *   2. Provider keywords (sorted by priority ascending, higher priority wins)\n *\n * Unit names are stored separately (checked AFTER keyword lookup fails).\n * Phrases are stored in a trie for O(phrase-length) matching.\n */\nexport class TokenClassRegistry {\n  private classes: TokenClass[] = [];\n  private localeKeywordMap: Record<string, string> | null = null;\n  private localePhraseMap: Record<string, string> | null = null;\n  private unitNames: ReadonlySet<string> | null = null;\n\n  /**\n   * Register a provider's TokenClass. Must be called BEFORE build().\n   * Can be called multiple times to add more entries.\n   *\n   * Built-in token types CANNOT be overridden, throws a EngineError\n   * if the TokenClass attempts to register a keyword that conflicts\n   * with an already-registered token type.\n   */\n  register(tokenClass: TokenClass): void {\n    this.classes.push(tokenClass);\n  }\n\n  /**\n   * Unregister all TokenClasses for a given token type.\n   * Useful for plugin unload. Requires rebuild() to take effect.\n   */\n  unregister(tokenType: string): void {\n    this.classes = this.classes.filter(c => c.tokenType !== tokenType);\n  }\n\n  /**\n   * Set the locale's keyword→type map and optional phrase map.\n   * Called on locale change. Priority 0 (cannot override providers with higher priority).\n   */\n  setLocale(keywordMap: Record<string, string>, phraseMap?: Record<string, string>): void {\n    this.localeKeywordMap = keywordMap;\n    this.localePhraseMap = phraseMap ?? null;\n  }\n\n  /**\n   * Set the unit name set. Called when unit list changes.\n   * Units are stored separately (checked AFTER keyword lookup fails).\n   *\n   * Takes a ReadonlySet because the caller's set is derived from the\n   * conversion tables and must not be mutated; this class only ever reads it.\n   */\n  setUnits(unitNames: ReadonlySet<string>): void {\n    this.unitNames = unitNames;\n  }\n\n  /**\n   * Build the optimized TokenLookup from all registered sources.\n   *\n   * Merge order (later overrides earlier):\n   *   1. Locale keywords (priority 0)\n   *   2. Provider classes (sorted by priority ascending)\n   *\n   * Returns a frozen TokenLookup that the Lexer consumes.\n   * Call build() again after register()/setLocale()/setUnits() changes.\n   */\n  build(): TokenLookup {\n    const keywordToType = new Map<string, string>();\n\n    // Layer 1: Locale keywords (priority 0, lowest)\n    if (this.localeKeywordMap) {\n      for (const [keyword, tokenType] of Object.entries(this.localeKeywordMap)) {\n        keywordToType.set(keyword.toLowerCase(), tokenType);\n      }\n    }\n\n    // Layer 2: Provider keywords (sorted by priority ascending, higher wins)\n    const sorted = [...this.classes].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));\n    for (const tc of sorted) {\n      for (const keyword of Object.keys(tc.keywords)) {\n        keywordToType.set(keyword.toLowerCase(), tc.tokenType);\n      }\n    }\n\n    // Build phrase trie from locale + provider phrases\n    const phraseTrie = this.buildPhraseTrie();\n\n    // Build phraseStartWords set (first word of every phrase)\n    const phraseStartWords = this.buildPhraseStartWords();\n\n    return {\n      keywordToType,\n      phraseTrie,\n      phraseStartWords,\n      unitNames: this.unitNames ?? new Set(),\n    };\n  }\n\n  // ── Private helpers ─────────────────────────────────────────────────────\n\n  private buildPhraseTrie(): PhraseNode | null {\n    const root: PhraseNode = { children: new Map() };\n\n    // Layer 1: Locale phrases\n    if (this.localePhraseMap) {\n      for (const [phrase, tokenType] of Object.entries(this.localePhraseMap)) {\n        this.insertPhrase(root, phrase.toLowerCase(), tokenType);\n      }\n    }\n\n    // Layer 2: Provider phrases\n    for (const tc of this.classes) {\n      if (!tc.phrases) continue;\n      for (const phrase of Object.keys(tc.phrases)) {\n        this.insertPhrase(root, phrase.toLowerCase(), tc.tokenType);\n      }\n    }\n\n    return root.children.size > 0 ? root : null;\n  }\n\n  private insertPhrase(root: PhraseNode, phrase: string, tokenType: string): void {\n    const words = phrase.split(' ');\n    let node = root;\n    for (const word of words) {\n      if (!node.children.has(word)) {\n        node.children.set(word, { children: new Map() });\n      }\n      node = node.children.get(word)!;\n    }\n    // Only set type if not already set, first-registered (locale) wins\n    if (!node.type) {\n      node.type = tokenType;\n    }\n  }\n\n  private buildPhraseStartWords(): Set<string> {\n    const startWords = new Set<string>();\n\n    // Locale phrase first words\n    if (this.localePhraseMap) {\n      for (const phrase of Object.keys(this.localePhraseMap)) {\n        const first = phrase.split(' ')[0].toLowerCase();\n        startWords.add(first);\n      }\n    }\n\n    // Provider phrase first words\n    for (const tc of this.classes) {\n      if (!tc.phrases) continue;\n      for (const phrase of Object.keys(tc.phrases)) {\n        const first = phrase.split(' ')[0].toLowerCase();\n        startWords.add(first);\n      }\n    }\n\n    return startWords;\n  }\n}","/**\n * tokenRegistration.ts, Bootstrap for building TokenLookup from locale, units, and phrases.\n *\n * This module centralizes the assembly of the TokenLookup consumed by ExpressionLexer.\n * It merges:\n *   1. Locale keywords (from ILocale.keywordMap)\n *   2. Built-in phrase patterns (to the power of, increase by, etc.)\n *   3. Known unit names (from units.ts)\n *\n * The resulting TokenLookup is frozen and passed to ExpressionLexer.configuredLookup\n * at construction time, enabling data-driven keyword/unit/phrase resolution.\n */\nimport { TokenClassRegistry } from '@solve-js/lexer/TokenClassRegistry';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { knownUnits } from '@solve-js/lexer/units';\n\n// ── Built-in phrase map ───────────────────────────────────────────────────\n// These are the multi-word expressions handled as compound tokens.\n// Matched by the PhraseMatcher (trie-based) in ExpressionLexer.tryMatchPhrase().\nconst BUILTIN_PHRASES: Record<string, string> = {\n  'to the power of': 'CARET',\n  'power of': 'CARET',\n  'increase by': 'INCREASE_BY',\n  'decrease by': 'DECREASE_BY',\n  'times by': 'TIMES_BY',\n  'multiply by': 'MULTIPLY_BY',\n  'multiplied by': 'MULTIPLY_BY',\n  'divide by': 'DIVIDE_BY',\n};\n\n/**\n * Build a TokenLookup from locale keywords, known units, and built-in phrases.\n *\n * Merge order (later overrides earlier):\n *   1. Locale keywords (priority 0, lowest, can be overridden by providers)\n *   2. Built-in phrases (via locale phraseMap)\n *   3. Known units (checked AFTER keyword lookup fails, via unitNames set)\n *\n * The resulting TokenLookup replaces the internal keyword map, unit set,\n * phrase trie, and phraseStartWords in ExpressionLexer when set via\n * ExpressionLexer.configuredLookup.\n *\n * @param localeCode - The locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n * @returns A frozen TokenLookup ready for consumption by the lexer.\n */\nexport function buildTokenLookup(localeCode = 'en'): TokenLookup {\n  const locale: ILocale = getLocale(localeCode);\n  const registry = new TokenClassRegistry();\n\n  // Layer 1: Locale keywords (priority 0, lowest)\n  registry.setLocale(locale.keywordMap, BUILTIN_PHRASES);\n\n  // Layer 2: Known units (checked after keyword lookup)\n  registry.setUnits(knownUnits);\n\n  // Build and return the lookup\n  return registry.build();\n}\n"]}
+{"version":3,"sources":["../src/lexer/LexerState.ts","../src/lexer/Lexer.ts","../src/lexer/TokenClassRegistry.ts","../src/lexer/tokenRegistration.ts"],"names":["LexerState"],"mappings":"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","file":"chunk-RNKDIXDV.js","sourcesContent":["/**\n * Lexer state machine modes.\n * - Main: document-level scanning with markdown classification\n * - Inline: expression embedded in markdown inline solve (`s\\`...\\``)\n * - String: inside a double-quoted string literal\n */\nexport enum LexerState {\n\tMain = \"main\",\n\tInline = \"inline\",\n\tString = \"string\",\n}\n","import { ExpressionLexer, LineClassification, LexerVocabulary, type ScanLineResult } from \"./ExpressionLexer\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { LexerState } from \"@solve-js/lexer/LexerState\";\nimport { getTokenCategory } from \"@solve-js/language/TokenCategoryMap\";\nimport type { TokenCategory } from \"@solve-js/language/TokenCategory\";\nimport type { TokenLookup } from \"@solve-js/lexer/TokenClassRegistry\";\n\n/**\n * Public tokenizer wrapper around {@link ExpressionLexer}.\n *\n * `ExpressionLexer` does the actual character-by-character scanning;\n * `Lexer` adds a materialized-token-array streaming interface\n * (`next()`/`peek()`) plus line-classification state (`reset()`) so\n * callers can iterate a line's tokens without re-scanning on each peek.\n *\n * Each `ExpressionEngine` instance owns its own `Lexer`, and packages\n * extend it via {@link registerVocabulary} (keywords, operators, units)\n * see `IEnginePackage.lexerVocabulary`.\n */\nexport class Lexer {\n  /** Expression-mode lexer (Phase A: V8-optimized, replaces moo) */\n  private expressionLexer: ExpressionLexer;\n  private currentState: LexerState = LexerState.Main;\n  private peekedToken: Token | undefined;\n  private hasPeeked = false;\n\n  // Materialized token array from the last reset() call, used for\n  // next()/peek() streaming access.\n  private tokens: Token[] = [];\n  private tokenIdx: number = 0;\n\n  /**\n   * @param localeCode - Locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n   * @param tokenLookup - Optional TokenLookup from TokenClassRegistry.\n   *   When provided, configures ExpressionLexer to use registry-built\n   *   keyword/unit/phrase lookups instead of internal instance maps.\n   */\n  constructor(localeCode = \"en\", tokenLookup?: TokenLookup) {\n    // Pass the lookup directly to ExpressionLexer's constructor, it's an\n    // instance field now, not a static. Each Lexer instance gets its own\n    // isolated lookup, preventing cross-instance corruption.\n    this.expressionLexer = new ExpressionLexer(localeCode, tokenLookup);\n  }\n\n  reset(input: string, state?: LexerState): void {\n    const newState = state ?? LexerState.Main;\n    this.currentState = newState;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n\n    // Phase B: Main state classifies the line with the markdown scanner.\n    // Skip lines (headings, fences, HRs, etc.) produce empty token arrays.\n    // Expression lines and lines with inline solves are tokenized normally.\n    if (newState === LexerState.Main) {\n      const classification = this.expressionLexer.classifyLine(input);\n      if (classification.skip) {\n        this.tokens = [];\n        this.tokenIdx = 0;\n        return;\n      }\n      // Expression line or markdown line with inline solves, tokenize.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    } else {\n      // Non-main states (Inline, String), expression tokenization.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    }\n  }\n\n  /**\n   * Classify a single line of markdown text (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  classifyLine(lineText: string): LineClassification {\n    return this.expressionLexer.classifyLine(lineText);\n  }\n\n  /**\n   * Find all inline solve markers in a line (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  findInlineSolves(lineText: string) {\n    return this.expressionLexer.findInlineSolves(lineText);\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes (locale + plugin-contributed),\n   * mapped to the token type it lexes to. Delegates to the ExpressionLexer.\n   */\n  getKeywords(): Record<string, string> {\n    return this.expressionLexer.getKeywords();\n  }\n\n  next(): Token | undefined {\n    if (this.hasPeeked) {\n      this.hasPeeked = false;\n      return this.peekedToken;\n    }\n    // Materialized token array (ExpressionLexer path).\n    if (this.tokenIdx < this.tokens.length) {\n      return this.tokens[this.tokenIdx++];\n    }\n    return undefined;\n  }\n\n  peek(): Token | undefined {\n    if (this.hasPeeked) return this.peekedToken;\n    this.peekedToken = this.next();\n    this.hasPeeked = true;\n    return this.peekedToken;\n  }\n\n  [Symbol.iterator](): Iterator<Token> {\n    return this.tokens[Symbol.iterator]();\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   * Delegates to the underlying ExpressionLexer.\n   *\n   * @see LexerVocabulary for the supported extension points.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.registerVocabulary(plugin);\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   * Delegates to the underlying ExpressionLexer.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.unregisterVocabulary(plugin);\n  }\n\n  /**\n   * Reset the lexer for expression-only text, skips the classifyLine()\n   * overhead in reset() for callers that already know the input is an\n   * evaluable expression (e.g., after isEmptyLine() confirmed non-skip).\n   */\n  resetExpression(input: string): void {\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(input);\n    this.tokens = this.expressionLexer.tokenizeAll();\n    this.tokenIdx = 0;\n  }\n\n  /**\n   * Scan a full document in one pass, classifying each line and\n   * tokenizing non-skipped lines. Delegates to ExpressionLexer.\n   *\n   * @returns ScanLineResult[], one per line, with classification + tokens.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    return this.expressionLexer.scanDocument(text);\n  }\n\n  getState(): LexerState {\n    return this.currentState;\n  }\n\n  setState(state: LexerState): void {\n    this.currentState = state;\n  }\n\n  getHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n\n    // For blockquote lines, strip the \"> \" prefix and tokenize the expression content.\n    // This lets expressions inside blockquotes (e.g., \"> 1 + 2\") get syntax highlighted\n    // while pure structural lines (headings, code fences) remain unhighlighted.\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectHighlightTokens(lineText.slice(2));\n    }\n\n    if (classification.skip) {\n      return [];\n    }\n\n    return this.collectHighlightTokens(lineText);\n  }\n\n  /**\n   * The same tokens {@link getHighlightTokens} reduces, before reduction.\n   *\n   * Exists because normalization operates on tokens, not on the flattened\n   * shape, and a consumer that wants phrase-fused highlighting has to run the\n   * normalizer between the two. See `LanguageService.getSemanticTokens`.\n   *\n   * @param lineText - One line of source.\n   * @returns Every token on the line that is worth painting, unreduced.\n   */\n  getHighlightTokenObjects(lineText: string): Token[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectTokenObjects(lineText.slice(2));\n    }\n    if (classification.skip) return [];\n    return this.collectTokenObjects(lineText);\n  }\n\n  private collectTokenObjects(lineText: string): Token[] {\n    this.resetExpression(lineText);\n    const result: Token[] = [];\n    for (const token of this) {\n      if (token.type === \"WS\" || token.type === \"NEWLINE\") continue;\n      if (token.type.startsWith(\"MD_\")) continue;\n      if (token.type === \"INLINE_SOLVE_START\" || token.type === \"BACKTICK_CLOSE\") continue;\n      result.push(token);\n    }\n    return result;\n  }\n\n  private collectHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    return this.collectTokenObjects(lineText).map(token => ({\n      type: token.type,\n      value: token.value,\n      offset: token.offset,\n      col: token.col,\n      // `text`, not `value`: this is a span into the source, and the two\n      // differ for a string literal, whose value is the payload while its\n      // text still carries the quote characters the reader typed.\n      length: token.text.length,\n      category: getTokenCategory(token.type),\n    }));\n  }\n}\n\n/**\n * A lexer for operations that do not depend on registered vocabulary.\n *\n * Line classification and inline-solve detection read characters looking for\n * headings, comment markers, fences and backtick spans, and never consult the\n * keyword, unit or operator tables. Every lexer therefore returns the same\n * answer, so the callers that have no engine to ask can use this one. Checked\n * by `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n *\n * Do not tokenize with this. An engine's own lexer carries the vocabulary its\n * packages registered; this one carries none.\n */\nexport const sharedLexer = new Lexer(\"en\", undefined);","/**\n * TokenClass, Plugin-extensible keyword registration for the Lexer.\n *\n * Providers call `registry.register(tokenClass)` to teach the lexer about\n * their keywords. The registry merges locale keywords, provider keywords,\n * phrase mappings, and unit names into an optimized TokenLookup structure\n * consumed by the Lexer.\n *\n * @example\n * registry.register({\n *   tokenType: 'CARET',\n *   keywords: {},\n *   phrases: { 'to the power of': true, 'power of': true },\n *   priority: 10,\n *   description: 'Exponentiation operators (x^y)',\n * });\n */\nexport interface TokenClass {\n  /** The token type string produced by the lexer (e.g., \"FUNC\", \"PI\", \"CARET\").\n   *  Must match a token type that a ParseletRegistry has a parselet for. */\n  tokenType: string;\n\n  /** Single-word keywords (case-insensitive). The lexer lowercases input\n   *  before lookup, so these should be lowercase. Example:\n   *  { sqrt: true, abs: true, sin: true, cos: true } for tokenType \"FUNC\" */\n  keywords: Record<string, boolean>;\n\n  /** Multi-word phrases (case-insensitive). Matched by the built-in PhraseMatcher\n   *  via the phrase trie. Example:\n   *  { \"to the power of\": true, \"power of\": true } for tokenType \"CARET\" */\n  phrases?: Record<string, boolean>;\n\n  /** Priority for conflict resolution. When two TokenClasses register\n   *  the same keyword, the higher-priority class wins. Locale keywords\n   *  have priority 0 (set via setLocale). Providers should use\n   *  priority >= 10 to override locale defaults. Default: 0 */\n  priority?: number;\n\n  /** Human-readable description for debugging and introspection */\n  description?: string;\n}\n\n// ── Phrase Trie ──────────────────────────────────────────────────────────────\n\n/** Trie node for multi-word phrase matching. */\nexport interface PhraseNode {\n  /** Complete phrase token type (null = intermediate node) */\n  type?: string;\n  children: Map<string, PhraseNode>;\n}\n\n// ── TokenLookup, Optimized lookup structure for the Lexer ──────────────────\n\n/**\n * The optimized lookup structure built by TokenClassRegistry.build().\n * Consumed by the Lexer for O(1) keyword → token type lookups and\n * O(word-count) phrase matching.\n */\nexport interface TokenLookup {\n  /** Lowercase keyword → token type. O(1) Map lookup. */\n  keywordToType: Map<string, string>;\n\n  /** Phrase trie for multi-word matching. Root node with children maps.\n   *  Null if no phrases registered. */\n  phraseTrie: PhraseNode | null;\n\n  /** Set of lowercase first-words of all registered phrases.\n   *  Used by the lexer to emit IDENT (not a phrase keyword) for words\n   *  that start multi-word phrases, deferring to the PhraseMatcher.\n   *\n   *  Example: \"to\" is in phraseStartWords because \"to the power of\" is a phrase.\n   *  When the lexer sees \"to\", it emits IDENT and lets the phrase matcher\n   *  combine \"to the power of\" into a single CARET token.\n   *\n   *  This prevents plugins from accidentally overriding phrase-start words.\n   */\n  phraseStartWords: Set<string>;\n\n  /** Case-sensitive unit names for UNIT fallback after keyword lookup fails. */\n  unitNames: ReadonlySet<string>;\n}\n\n// ── TokenClassRegistry ───────────────────────────────────────────────────────\n\n/**\n * Central registry for keyword→token-type mappings.\n *\n * Providers register TokenClasses; locales provide keyword maps;\n * units provide a name set. `build()` merges all sources into an\n * optimized TokenLookup consumed by the Lexer.\n *\n * Merge order (later overrides earlier):\n *   1. Locale keywords (priority 0)\n *   2. Provider keywords (sorted by priority ascending, higher priority wins)\n *\n * Unit names are stored separately (checked AFTER keyword lookup fails).\n * Phrases are stored in a trie for O(phrase-length) matching.\n */\nexport class TokenClassRegistry {\n  private classes: TokenClass[] = [];\n  private localeKeywordMap: Record<string, string> | null = null;\n  private localePhraseMap: Record<string, string> | null = null;\n  private unitNames: ReadonlySet<string> | null = null;\n\n  /**\n   * Register a provider's TokenClass. Must be called BEFORE build().\n   * Can be called multiple times to add more entries.\n   *\n   * Built-in token types CANNOT be overridden, throws a EngineError\n   * if the TokenClass attempts to register a keyword that conflicts\n   * with an already-registered token type.\n   */\n  register(tokenClass: TokenClass): void {\n    this.classes.push(tokenClass);\n  }\n\n  /**\n   * Unregister all TokenClasses for a given token type.\n   * Useful for plugin unload. Requires rebuild() to take effect.\n   */\n  unregister(tokenType: string): void {\n    this.classes = this.classes.filter(c => c.tokenType !== tokenType);\n  }\n\n  /**\n   * Set the locale's keyword→type map and optional phrase map.\n   * Called on locale change. Priority 0 (cannot override providers with higher priority).\n   */\n  setLocale(keywordMap: Record<string, string>, phraseMap?: Record<string, string>): void {\n    this.localeKeywordMap = keywordMap;\n    this.localePhraseMap = phraseMap ?? null;\n  }\n\n  /**\n   * Set the unit name set. Called when unit list changes.\n   * Units are stored separately (checked AFTER keyword lookup fails).\n   *\n   * Takes a ReadonlySet because the caller's set is derived from the\n   * conversion tables and must not be mutated; this class only ever reads it.\n   */\n  setUnits(unitNames: ReadonlySet<string>): void {\n    this.unitNames = unitNames;\n  }\n\n  /**\n   * Build the optimized TokenLookup from all registered sources.\n   *\n   * Merge order (later overrides earlier):\n   *   1. Locale keywords (priority 0)\n   *   2. Provider classes (sorted by priority ascending)\n   *\n   * Returns a frozen TokenLookup that the Lexer consumes.\n   * Call build() again after register()/setLocale()/setUnits() changes.\n   */\n  build(): TokenLookup {\n    const keywordToType = new Map<string, string>();\n\n    // Layer 1: Locale keywords (priority 0, lowest)\n    if (this.localeKeywordMap) {\n      for (const [keyword, tokenType] of Object.entries(this.localeKeywordMap)) {\n        keywordToType.set(keyword.toLowerCase(), tokenType);\n      }\n    }\n\n    // Layer 2: Provider keywords (sorted by priority ascending, higher wins)\n    const sorted = [...this.classes].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));\n    for (const tc of sorted) {\n      for (const keyword of Object.keys(tc.keywords)) {\n        keywordToType.set(keyword.toLowerCase(), tc.tokenType);\n      }\n    }\n\n    // Build phrase trie from locale + provider phrases\n    const phraseTrie = this.buildPhraseTrie();\n\n    // Build phraseStartWords set (first word of every phrase)\n    const phraseStartWords = this.buildPhraseStartWords();\n\n    return {\n      keywordToType,\n      phraseTrie,\n      phraseStartWords,\n      unitNames: this.unitNames ?? new Set(),\n    };\n  }\n\n  // ── Private helpers ─────────────────────────────────────────────────────\n\n  private buildPhraseTrie(): PhraseNode | null {\n    const root: PhraseNode = { children: new Map() };\n\n    // Layer 1: Locale phrases\n    if (this.localePhraseMap) {\n      for (const [phrase, tokenType] of Object.entries(this.localePhraseMap)) {\n        this.insertPhrase(root, phrase.toLowerCase(), tokenType);\n      }\n    }\n\n    // Layer 2: Provider phrases\n    for (const tc of this.classes) {\n      if (!tc.phrases) continue;\n      for (const phrase of Object.keys(tc.phrases)) {\n        this.insertPhrase(root, phrase.toLowerCase(), tc.tokenType);\n      }\n    }\n\n    return root.children.size > 0 ? root : null;\n  }\n\n  private insertPhrase(root: PhraseNode, phrase: string, tokenType: string): void {\n    const words = phrase.split(' ');\n    let node = root;\n    for (const word of words) {\n      if (!node.children.has(word)) {\n        node.children.set(word, { children: new Map() });\n      }\n      node = node.children.get(word)!;\n    }\n    // Only set type if not already set, first-registered (locale) wins\n    if (!node.type) {\n      node.type = tokenType;\n    }\n  }\n\n  private buildPhraseStartWords(): Set<string> {\n    const startWords = new Set<string>();\n\n    // Locale phrase first words\n    if (this.localePhraseMap) {\n      for (const phrase of Object.keys(this.localePhraseMap)) {\n        const first = phrase.split(' ')[0].toLowerCase();\n        startWords.add(first);\n      }\n    }\n\n    // Provider phrase first words\n    for (const tc of this.classes) {\n      if (!tc.phrases) continue;\n      for (const phrase of Object.keys(tc.phrases)) {\n        const first = phrase.split(' ')[0].toLowerCase();\n        startWords.add(first);\n      }\n    }\n\n    return startWords;\n  }\n}","/**\n * tokenRegistration.ts, Bootstrap for building TokenLookup from locale, units, and phrases.\n *\n * This module centralizes the assembly of the TokenLookup consumed by ExpressionLexer.\n * It merges:\n *   1. Locale keywords (from ILocale.keywordMap)\n *   2. Built-in phrase patterns (to the power of, increase by, etc.)\n *   3. Known unit names (from units.ts)\n *\n * The resulting TokenLookup is frozen and passed to ExpressionLexer.configuredLookup\n * at construction time, enabling data-driven keyword/unit/phrase resolution.\n */\nimport { TokenClassRegistry } from '@solve-js/lexer/TokenClassRegistry';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { knownUnits } from '@solve-js/lexer/units';\n\n// ── Built-in phrase map ───────────────────────────────────────────────────\n// These are the multi-word expressions handled as compound tokens.\n// Matched by the PhraseMatcher (trie-based) in ExpressionLexer.tryMatchPhrase().\nconst BUILTIN_PHRASES: Record<string, string> = {\n  'to the power of': 'CARET',\n  'power of': 'CARET',\n  'increase by': 'INCREASE_BY',\n  'decrease by': 'DECREASE_BY',\n  'times by': 'TIMES_BY',\n  'multiply by': 'MULTIPLY_BY',\n  'multiplied by': 'MULTIPLY_BY',\n  'divide by': 'DIVIDE_BY',\n};\n\n/**\n * Build a TokenLookup from locale keywords, known units, and built-in phrases.\n *\n * Merge order (later overrides earlier):\n *   1. Locale keywords (priority 0, lowest, can be overridden by providers)\n *   2. Built-in phrases (via locale phraseMap)\n *   3. Known units (checked AFTER keyword lookup fails, via unitNames set)\n *\n * The resulting TokenLookup replaces the internal keyword map, unit set,\n * phrase trie, and phraseStartWords in ExpressionLexer when set via\n * ExpressionLexer.configuredLookup.\n *\n * @param localeCode - The locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n * @returns A frozen TokenLookup ready for consumption by the lexer.\n */\nexport function buildTokenLookup(localeCode = 'en'): TokenLookup {\n  const locale: ILocale = getLocale(localeCode);\n  const registry = new TokenClassRegistry();\n\n  // Layer 1: Locale keywords (priority 0, lowest)\n  registry.setLocale(locale.keywordMap, BUILTIN_PHRASES);\n\n  // Layer 2: Known units (checked after keyword lookup)\n  registry.setUnits(knownUnits);\n\n  // Build and return the lookup\n  return registry.build();\n}\n"]}

package/dist/{chunk-YRIKITGF.cjs → chunk-TC6BTUSU.cjs}

@@ -1,13 +1,13 @@
 'use strict';
 
-var chunkT6ZYQJ63_cjs = require('./chunk-T6ZYQJ63.cjs');
+var chunkBESTLPRK_cjs = require('./chunk-BESTLPRK.cjs');
 var chunkL2TE7PMO_cjs = require('./chunk-L2TE7PMO.cjs');
 var chunkADBA3XBE_cjs = require('./chunk-ADBA3XBE.cjs');
-var chunk7ZX6B7SY_cjs = require('./chunk-7ZX6B7SY.cjs');
-var chunk2TZKENDH_cjs = require('./chunk-2TZKENDH.cjs');
-var chunkE23GZEWL_cjs = require('./chunk-E23GZEWL.cjs');
-var chunkN5NNW4VG_cjs = require('./chunk-N5NNW4VG.cjs');
-var chunkB4HBEFTB_cjs = require('./chunk-B4HBEFTB.cjs');
+var chunkFR7RNOPT_cjs = require('./chunk-FR7RNOPT.cjs');
+var chunkIT74O4BE_cjs = require('./chunk-IT74O4BE.cjs');
+var chunkLO7HU5WB_cjs = require('./chunk-LO7HU5WB.cjs');
+var chunk7USV76HV_cjs = require('./chunk-7USV76HV.cjs');
+var chunkMIGXCBXT_cjs = require('./chunk-MIGXCBXT.cjs');
 
 // src/engine/SegmentTree.ts
 var SegmentTree = class {
@@ -225,7 +225,7 @@ var DocumentModel = class {
    * 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 = chunkE23GZEWL_cjs.DEFAULT_CONFIG.performance.maxDocumentLines) {
+  constructor(maxLines = chunkLO7HU5WB_cjs.DEFAULT_CONFIG.performance.maxDocumentLines) {
     /** Persistent line ID → LineState. */
     this.lines = /* @__PURE__ */ new Map();
     /** Order-statistic treap representing the current document line order. */
@@ -264,7 +264,7 @@ var DocumentModel = class {
   setDocument(text) {
     const lineCount = chunkADBA3XBE_cjs.countLines(text, this.maxLines);
     if (lineCount > this.maxLines) {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+      throw chunkMIGXCBXT_cjs.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 }
@@ -699,7 +699,7 @@ var CompilationWorkerManager = class {
    */
   ensureWorker() {
     if (this.worker) return this.worker;
-    this.worker = chunkT6ZYQJ63_cjs.engine_worker_default();
+    this.worker = chunkBESTLPRK_cjs.engine_worker_default();
     this.worker.onmessage = (event) => {
       const data = event.data;
       if (!data || data.type !== "COMPILE_RESULT") return;
@@ -984,7 +984,7 @@ var PageManager = class _PageManager {
             });
           }
         } else {
-          const inlineSpans = chunkN5NNW4VG_cjs.sharedLexer.findInlineSolves(state.text);
+          const inlineSpans = chunk7USV76HV_cjs.sharedLexer.findInlineSolves(state.text);
           if (inlineSpans.length > 0) {
             for (const span of inlineSpans) {
               if (!span.expression.trim()) continue;
@@ -1090,8 +1090,8 @@ var ThreeTierEvaluator = class {
     this.checkpointer = checkpointer ?? null;
     this.pageManager = new PageManager();
     this.engine.setDocumentModel(this.doc);
-    this.globalUnsubscribe = chunk7ZX6B7SY_cjs.sharedGlobalVariableStore.subscribe((name) => {
-      for (const lineNumber of this.dag.getAffectedLines(chunk7ZX6B7SY_cjs.globalDagKey(name))) {
+    this.globalUnsubscribe = chunkFR7RNOPT_cjs.sharedGlobalVariableStore.subscribe((name) => {
+      for (const lineNumber of this.dag.getAffectedLines(chunkFR7RNOPT_cjs.globalDagKey(name))) {
         this.doc.markDirtyByLineNumber(lineNumber);
       }
     });
@@ -1108,8 +1108,9 @@ var ThreeTierEvaluator = class {
    */
   evaluate(viewport, signal) {
     this.engine.setKeystrokeSignal(signal ?? null);
-    chunk2TZKENDH_cjs.enableValueArena();
+    chunkIT74O4BE_cjs.enableValueArena();
     try {
+      this.reseedAccumulators();
       const lines = [];
       const resultMap = /* @__PURE__ */ new Map();
       const tierCounts = { tier1: 0, tier2: 0, tier3: 0, skipped: 0 };
@@ -1136,7 +1137,7 @@ var ThreeTierEvaluator = class {
       return { lines, resultMap, tierCounts };
     } finally {
       this.engine.setKeystrokeSignal(null);
-      chunk2TZKENDH_cjs.disableValueArena();
+      chunkIT74O4BE_cjs.disableValueArena();
     }
   }
   /**
@@ -1269,13 +1270,13 @@ var ThreeTierEvaluator = class {
     this.pageManager.maintainAfterEval(viewport, this.doc);
     this.preloadNextPages(viewport);
     this.restoreTo(viewport.startLine - 1);
-    chunk2TZKENDH_cjs.enableValueArena();
+    chunkIT74O4BE_cjs.enableValueArena();
     try {
       const result = this.collectEvalResults(viewport.startLine, viewport.endLine);
       return result;
     } finally {
       this.engine.setKeystrokeSignal(null);
-      chunk2TZKENDH_cjs.disableValueArena();
+      chunkIT74O4BE_cjs.disableValueArena();
     }
   }
   /**
@@ -1334,6 +1335,36 @@ var ThreeTierEvaluator = class {
     };
   }
   // ── Private helpers ─────────────────────────────────────────────────
+  /**
+   * Reset running-total accumulators and mark the lines that touch them
+   * dirty, so the from-line-1 pass in {@link evaluate} recomputes each total
+   * from its seed instead of reading its own previous evaluation's value.
+   *
+   * A `total += 5` line compiles to no bytecode (it rides the symbolic
+   * channel), so a clean one would be skipped by the tier dispatch rather
+   * than re-run. It must re-run to re-apply its delta over the freshly-reset
+   * base, so every line that WRITES an accumulator name is forced dirty (the
+   * DAG drops a self-writing line from its own variable's consumers, so
+   * getAffectedLines can't surface them). Pure readers of the total keep
+   * their real bytecode and re-run via Tier 2 once the total is correct, so
+   * they need no special handling. Cheap: a no-op unless the document
+   * actually uses `+=`/`-=`, and accumulators are rare.
+   */
+  reseedAccumulators() {
+    const names = this.engine.resetAccumulators();
+    if (names.size === 0) return;
+    const docEnd = this.doc.lineCount;
+    for (let pos = 1; pos <= docEnd; pos++) {
+      const writes = this.dag.getWrites(pos);
+      if (writes.size === 0) continue;
+      for (const w of writes) {
+        if (names.has(w)) {
+          this.doc.markDirtyByLineNumber(pos);
+          break;
+        }
+      }
+    }
+  }
   /**
    * Collect evaluation results for a contiguous range of lines.
    *
@@ -1411,7 +1442,7 @@ var ThreeTierEvaluator = class {
       lineId: state.lineId,
       lineNumber
     };
-    if (state.isEmpty || chunkT6ZYQJ63_cjs.isEmptyLine(state.text)) {
+    if (state.isEmpty || chunkBESTLPRK_cjs.isEmptyLine(state.text)) {
       state.isEmpty = true;
       this.doc.markClean(state.lineId);
       return { ...baseResult, tier: 0 /* Skipped */, result: null, error: null };
@@ -1478,7 +1509,7 @@ var ThreeTierEvaluator = class {
       if (value) {
         allResults.push(value);
       } else {
-        allResults.push([chunk2TZKENDH_cjs.errorValue("eval_failed", firstError ?? "unknown error")]);
+        allResults.push([chunkIT74O4BE_cjs.errorValue("eval_failed", firstError ?? "unknown error")]);
       }
       if (entry) {
         allBytecodes.push(entry.bytecode);
@@ -1496,7 +1527,7 @@ var ThreeTierEvaluator = class {
           if (writes2.length > 0) hasVariableDef = true;
         } catch (compileErr) {
           allBytecodes.push({ opcodes: new Uint8Array(0), numbers: new Float64Array(0), strings: [], hasAsync: false });
-          if (compileErr instanceof chunkB4HBEFTB_cjs.EngineError && compileErr.context) {
+          if (compileErr instanceof chunkMIGXCBXT_cjs.EngineError && compileErr.context) {
             const errReads = compileErr.context.reads;
             const errWrites = compileErr.context.writes;
             if (Array.isArray(errReads)) for (const r of errReads) allReads.add(r);
@@ -1572,7 +1603,7 @@ var ThreeTierEvaluator = class {
         const errorMessage = e instanceof Error ? e.message : String(e);
         if (!firstError) firstError = errorMessage;
         anyFailed = true;
-        results.push([chunk2TZKENDH_cjs.errorValue("exec_failed", errorMessage)]);
+        results.push([chunkIT74O4BE_cjs.errorValue("exec_failed", errorMessage)]);
       }
     }
     this.dag.registerLine(lineNumber, state.reads, state.writes);
@@ -1719,7 +1750,7 @@ var ThreeTierEvaluator = class {
       if (!state) continue;
       if (!state.dirty) continue;
       if (state.bytecodes.length > 0 && !state.isVariableDef) continue;
-      if (state.isEmpty || chunkT6ZYQJ63_cjs.isEmptyLine(state.text)) continue;
+      if (state.isEmpty || chunkBESTLPRK_cjs.isEmptyLine(state.text)) continue;
       const { expressions } = this.extractExpressions(state);
       if (expressions.length === 0) continue;
       for (const expression of expressions) {
@@ -1750,7 +1781,7 @@ var ThreeTierEvaluator = class {
     }
     const trimmed = state.text.trim();
     if (trimmed.length === 0) return { expressions: [], inlineSolveCount: 0 };
-    const inlineSpans = chunkN5NNW4VG_cjs.sharedLexer.findInlineSolves(state.text);
+    const inlineSpans = chunk7USV76HV_cjs.sharedLexer.findInlineSolves(state.text);
     if (inlineSpans.length > 0) {
       return {
         expressions: inlineSpans.map((s) => s.expression),
@@ -1764,5 +1795,5 @@ var ThreeTierEvaluator = class {
 exports.DocumentModel = DocumentModel;
 exports.EvalTier = EvalTier;
 exports.ThreeTierEvaluator = ThreeTierEvaluator;
-//# sourceMappingURL=chunk-YRIKITGF.cjs.map
-//# sourceMappingURL=chunk-YRIKITGF.cjs.map
+//# sourceMappingURL=chunk-TC6BTUSU.cjs.map
+//# sourceMappingURL=chunk-TC6BTUSU.cjs.map