solve-engine 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/chunk-6NTVRDQV.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/vm/DependencyGraph.ts","../src/vm/ScopeManager.ts","../src/vm/VM.ts"],"names":["defaultEngineContext","numberValue","ErrorFactory","getMeasure","convertUnit","timecodeFps","isTimecodeUnit","errorValue","uomValue","splitRateUnit","isArenaActive","DiagnosticEventType","getOpCodeName","persistentValue","bigIntValue","hexValue","stringValue","boolValue","isWorkdayUnit","datetimeValue","binaryOp","matrixMultiply","isRateUnit","unifyUom","sharedCurrencyExchange","rateValue","symbolicPow","symbolicNeg","matrixCompare","builtinFunctions","SYMBOLIC_NATIVE_BUILTINS","symbolicBuiltin","symbolicValue","varNode","sharedGlobalVariableStore","percentageValue","asConverterRegistry","getConvertiblePossibilities","getBestUnit","matrixValue","rowMajorToColumnMajor","matIndex","matrixEntryToValue","inBounds","matAt","rangeValue","collectionToValues","normalizeUnknownError"],"mappings":"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","file":"chunk-6NTVRDQV.cjs","sourcesContent":["/** Serialized snapshot of the dependency graph for diagnostic rendering. */\nexport interface DagSnapshot {\n  consumers: Record<string, number[]>;\n  writes: Record<number, string[]>;\n  reads: Record<number, string[]>;\n  dataSourceDeps: Record<number, string[]>;\n  dataSourceConsumers: Record<string, number[]>;\n}\n\n/**\n * Dependency graph for variable and data-source tracking across document lines.\n *\n * Tracks which lines read/write which variables, and propagates changes through\n * the graph when a variable is modified. Supports:\n * - Variable dependency tracking (registerLine, getAffectedLines)\n * - Data-source dependency tracking (registerLineDataSourceDependency)\n * - Topological ordering of affected lines (getAffectedLinesInOrder)\n * - Efficient removal of deleted lines (removeLine)\n */\nexport class DependencyGraph {\n   private consumers: Map<string, Set<number>> = new Map();\n   private dependencies: Map<number, Set<string>> = new Map();\n   private writes: Map<number, Set<string>> = new Map();\n   private lineReads: Map<number, Set<string>> = new Map();\n\n   // Data source dependencies: line number -> Set of query keys\n   private dataSourceDependencies: Map<number, Set<string>> = new Map();\n   // Reverse map: query key -> Set of line numbers\n   private dataSourceConsumers: Map<string, Set<number>> = new Map();\n\n  /**\n   * Register a line's variable reads and writes in the dependency graph.\n   *\n   * If re-registering the same line (e.g., after editing), old consumer\n   * references are cleaned up first. Write-variables are removed from\n   * the consumer set so that redefinition breaks the old dependency chain.\n   *\n   * @param lineNumber - 1-based line number in the document\n   * @param reads - Variable names this line reads\n   * @param writes - Variable names this line writes (assigns to)\n   */\n   registerLine(lineNumber: number, reads: string[], writes: string[]): void {\n     // Clean up old consumer references if re-registering this line\n     const oldReads = this.lineReads.get(lineNumber);\n     if (oldReads) {\n       for (const oldRead of oldReads) {\n         const consumers = this.consumers.get(oldRead);\n         if (consumers) consumers.delete(lineNumber);\n       }\n     }\n\n     // Track what this line reads\n     this.lineReads.set(lineNumber, new Set(reads));\n\n     // Add new consumer references\n     for (const dep of reads) {\n       if (!this.consumers.has(dep)) this.consumers.set(dep, new Set());\n       this.consumers.get(dep)!.add(lineNumber);\n     }\n     if (writes.length > 0) {\n       this.dependencies.set(lineNumber, new Set(reads));\n       this.writes.set(lineNumber, new Set(writes));\n       for (const write of writes) {\n         const prevConsumer = this.consumers.get(write);\n         if (prevConsumer) prevConsumer.delete(lineNumber);\n       }\n     }\n   }\n\n  /**\n   * Register a line's dependency on an external data source (e.g., currency rate, OSRS GE price).\n   *\n   * When the data source updates, {@link getAffectedLinesByDataSource} returns all lines\n   * that depend on this data, enabling targeted re-evaluation.\n   *\n   * @param lineNumber - 1-based line number in the document\n   * @param dataSourceId - Unique identifier for the data source (e.g., \"currency\", \"osrs-ge\")\n   * @param queryKey - Query key array identifying the specific data (e.g., [\"USD\", \"EUR\"])\n   */\n  registerLineDataSourceDependency(lineNumber: number, dataSourceId: string, queryKey: string[]): void {\n    const queryKeyStr = JSON.stringify(queryKey);\n    const key = `${dataSourceId}:${queryKeyStr}`;\n    \n    if (!this.dataSourceDependencies.has(lineNumber)) {\n      this.dataSourceDependencies.set(lineNumber, new Set());\n    }\n    this.dataSourceDependencies.get(lineNumber)!.add(key);\n    \n    if (!this.dataSourceConsumers.has(key)) {\n      this.dataSourceConsumers.set(key, new Set());\n    }\n    this.dataSourceConsumers.get(key)!.add(lineNumber);\n  }\n\n  /**\n   * Find all lines affected by a changed variable via BFS through the consumer graph.\n   *\n   * When a variable is modified (e.g., `:x = 5` changes to `:x = 10`), this returns\n   * all lines that transitively depend on it, lines that read `x`, lines that read\n   * variables written by those lines, and so on.\n   *\n   * @param changedVariable - The variable name that changed\n   * @returns Set of line numbers that need re-evaluation\n   */\n  getAffectedLines(changedVariable: string): Set<number> {\n    const visited = new Set<number>();\n    const queue = [changedVariable];\n    while (queue.length > 0) {\n      const varName = queue.pop()!;\n      const consumers = this.consumers.get(varName);\n      if (!consumers) continue;\n      for (const line of consumers) {\n        if (visited.has(line)) continue;\n        visited.add(line);\n        const lineWrites = this.writes.get(line);\n        if (lineWrites) {\n          for (const writtenVar of lineWrites) {\n            queue.push(writtenVar);\n          }\n        }\n      }\n    }\n    return visited;\n  }\n\n  /**\n   * Phase 1.4 DAG-walk optimization: return affected lines in dependency-safe\n   * topological order. Uses Kahn's algorithm (BFS-based) to ensure every line\n   * is evaluated AFTER all lines it depends on have been processed.\n   *\n   * This is more correct than ascending line-number sort, which fails when\n   * variable definitions and their consumers are not in document order.\n   *\n   * @returns Line numbers in topological order (producers before consumers).\n   */\n  getAffectedLinesInOrder(startVariable: string): number[] {\n    const affected = this.getAffectedLines(startVariable);\n    if (affected.size === 0) return [];\n\n    // Build a local subgraph: for each affected line, compute in-degree\n    // (how many other affected lines produce variables it reads).\n    const inDegree = new Map<number, number>();\n    const adjacency = new Map<number, number[]>(); // line → downstream lines\n\n    for (const line of affected) {\n      if (!inDegree.has(line)) inDegree.set(line, 0);\n      if (!adjacency.has(line)) adjacency.set(line, []);\n    }\n\n    // Build a variable→producer map in one pass, then do O(1) lookups\n    // per read variable instead of O(n) scanning otherAffected lines.\n    const producerOf = new Map<string, number>();\n    for (const line of affected) {\n      const lineWrites = this.writes.get(line);\n      if (lineWrites) {\n        for (const w of lineWrites) producerOf.set(w, line);\n      }\n    }\n\n    // For each affected line, check if any reads are produced by another\n    // affected line. If so, add an edge from producer → consumer.\n    for (const line of affected) {\n      const reads = this.lineReads.get(line);\n      if (!reads) continue;\n\n      for (const readVar of reads) {\n        const producer = producerOf.get(readVar);\n        if (producer !== undefined && producer !== line) {\n          // producer writes readVar, which this line reads\n          // Edge: producer → line (producer → consumer)\n          adjacency.get(producer)!.push(line);\n          inDegree.set(line, (inDegree.get(line) ?? 0) + 1);\n        }\n      }\n    }\n\n    // Kahn's algorithm: start with zero-indegree lines (no dependencies within\n    // the affected set), then iteratively remove them, adding newly-freed lines.\n    const queue: number[] = [];\n    for (const [line, degree] of inDegree) {\n      if (degree === 0) queue.push(line);\n    }\n\n    // If every affected line has at least one dependency (cycle or external),\n    // start with the lowest line number as a fallback.\n    if (queue.length === 0 && affected.size > 0) {\n      const sorted = Array.from(affected).sort((a, b) => a - b);\n      queue.push(sorted[0]);\n    }\n\n    const ordered: number[] = [];\n    while (queue.length > 0) {\n      const current = queue.shift()!;\n      ordered.push(current);\n\n      for (const downstream of adjacency.get(current) ?? []) {\n        const newDegree = (inDegree.get(downstream) ?? 1) - 1;\n        inDegree.set(downstream, newDegree);\n        if (newDegree === 0) queue.push(downstream);\n      }\n    }\n\n    // Append any remaining lines that couldn't be topologically sorted\n    // (cycles or external-only dependencies) in ascending order.\n    if (ordered.length < affected.size) {\n      const orderedSet = new Set(ordered);\n      const remaining = Array.from(affected)\n        .filter((l) => !orderedSet.has(l))\n        .sort((a, b) => a - b);\n      ordered.push(...remaining);\n    }\n\n    return ordered;\n  }\n\n  /**\n   * Find all lines affected by a data source update.\n   *\n   * When an async data source resolves (e.g., currency rate fetch completes),\n   * this returns all lines that depend on that specific data query.\n   *\n   * @param dataSourceId - The data source identifier\n   * @param queryKey - The query key that was updated\n   * @returns Set of line numbers that need re-evaluation\n   */\n  getAffectedLinesByDataSource(dataSourceId: string, queryKey: string[]): Set<number> {\n    const queryKeyStr = JSON.stringify(queryKey);\n    const key = `${dataSourceId}:${queryKeyStr}`;\n    return this.dataSourceConsumers.get(key) ?? new Set();\n  }\n\n  /**\n   * Remove a line from the dependency graph (e.g., when a line is deleted from the document).\n   *\n   * Cleans up all consumer references, write registrations, and data source dependencies\n   * for the removed line. O(k) where k is the number of variables the line reads.\n   *\n   * @param lineNumber - The line number being removed\n   */\n  removeLine(lineNumber: number): void {\n     // Remove from consumers of variables this line read, O(k) not O(V)\n     const reads = this.lineReads.get(lineNumber);\n     if (reads) {\n       for (const readVar of reads) {\n         const consumers = this.consumers.get(readVar);\n         if (consumers) consumers.delete(lineNumber);\n       }\n       this.lineReads.delete(lineNumber);\n     }\n\n     this.dependencies.delete(lineNumber);\n     this.writes.delete(lineNumber);\n\n     // Remove from consumers of the data-source keys THIS line depends on\n     // O(k) via the line's own dependency set, not O(total unique keys in\n     // the document). Must read dataSourceDependencies before deleting it.\n     const dataSourceKeys = this.dataSourceDependencies.get(lineNumber);\n     if (dataSourceKeys) {\n       for (const key of dataSourceKeys) {\n         this.dataSourceConsumers.get(key)?.delete(lineNumber);\n       }\n       this.dataSourceDependencies.delete(lineNumber);\n     }\n   }\n\n  /**\n   * Get all line numbers that consume (read) a given variable.\n   *\n   * @param variable - The variable name\n   * @returns Set of line numbers that read this variable, or empty set if none\n   */\n  getConsumers(variable: string): Set<number> {\n    return this.consumers.get(variable) ?? new Set();\n  }\n\n  /**\n   * Get all variables that a line depends on (reads).\n   *\n   * @param lineNumber - The line number to query\n   * @returns Set of variable names this line reads, or empty set if none\n   */\n  getDependencies(lineNumber: number): Set<string> {\n    return this.dependencies.get(lineNumber) ?? new Set();\n  }\n\n  /**\n   * Get all variables that a line writes (assigns to).\n   *\n   * @param lineNumber - The line number to query\n   * @returns Set of variable names this line writes, or empty set if none\n   */\n  getWrites(lineNumber: number): Set<string> {\n    return this.writes.get(lineNumber) ?? new Set();\n  }\n\n  /**\n   * Get a serializable snapshot of the entire dependency graph for diagnostics.\n   *\n   * Returns plain objects (not Maps/Sets) so consumers don't need to reach\n   * into private fields. Used by playground diagnostic tabs for DAG visualization.\n   */\n  getSnapshot(): DagSnapshot {\n    const consumers: Record<string, number[]> = {};\n    for (const [variable, lines] of this.consumers) {\n      consumers[variable] = Array.from(lines);\n    }\n\n    const writes: Record<number, string[]> = {};\n    for (const [line, vars] of this.writes) {\n      writes[line] = Array.from(vars);\n    }\n\n    const reads: Record<number, string[]> = {};\n    for (const [line, vars] of this.lineReads) {\n      reads[line] = Array.from(vars);\n    }\n\n    const dataSourceDeps: Record<number, string[]> = {};\n    for (const [line, keys] of this.dataSourceDependencies) {\n      dataSourceDeps[line] = Array.from(keys);\n    }\n\n    const dataSourceConsumers: Record<string, number[]> = {};\n    for (const [key, lines] of this.dataSourceConsumers) {\n      dataSourceConsumers[key] = Array.from(lines);\n    }\n\n    return { consumers, writes, reads, dataSourceDeps, dataSourceConsumers };\n  }\n\n  /** Clear all dependency graph state. Called on document switch or engine reset. */\n  clear(): void {\n    this.consumers.clear();\n    this.dependencies.clear();\n    this.writes.clear();\n    this.lineReads.clear();\n    this.dataSourceDependencies.clear();\n    this.dataSourceConsumers.clear();\n  }\n}\n","import { Value } from \"@solve-js/vm/Value\";\n\n/**\n * Record of a compiled expression in the scope.\n * Tracks the expression text, compiled bytecode, last evaluation result,\n * and the variable reads/writes for dependency tracking.\n */\nexport interface ExpressionRecord {\n  lineNumber: number;\n  expression: string;\n  bytecode: { opcodes: Uint8Array; numbers: Float64Array; strings: string[] };\n  lastResult: Value;\n  readVariables: string[];\n  writeVariable: string | null;\n}\n\n/**\n * Scoped variable manager for expression evaluation.\n *\n * Tracks variable definitions across line numbers with write-on-read semantics.\n * When a value is read, the most recent definition at or before the reading line\n * is returned. Invalidation trims downstream definitions when a variable is redefined.\n */\nexport class ScopeManager {\n  private definitions: Map<string, { line: number; expr: ExpressionRecord }[]> = new Map();\n\n  /**\n   * Record a variable definition at `lineNumber`. A variable may have\n   * multiple definitions across different lines (e.g. redefined further\n   * down a document), each call adds one, keeping the internal stack\n   * sorted by line so {@link read} can binary-scan for \"most recent\n   * definition at or before\" a given line.\n   */\n  write(variable: string, lineNumber: number, expr: ExpressionRecord): void {\n    if (!this.definitions.has(variable)) {\n      this.definitions.set(variable, []);\n    }\n    const stack = this.definitions.get(variable)!;\n    stack.push({ line: lineNumber, expr });\n    stack.sort((a, b) => a.line - b.line);\n  }\n\n  /**\n   * Look up a variable's value as seen from `readLine`: returns the result\n   * of the closest definition at or before `readLine`, not simply the most\n   * recently-written one, so a read on line 5 of a variable redefined on\n   * lines 2 and 10 sees line 2's value, not line 10's. Returns `undefined`\n   * if the variable has no definition at or before `readLine`.\n   */\n  read(variable: string, readLine: number): Value | undefined {\n    const stack = this.definitions.get(variable);\n    if (!stack) return undefined;\n    for (let i = stack.length - 1; i >= 0; i--) {\n      if (stack[i].line <= readLine) return stack[i].expr.lastResult;\n    }\n    return undefined;\n  }\n\n  /**\n   * Drop every definition of `variable` that comes strictly after\n   * `definitionLine`. Call this when a line is re-evaluated with a new\n   * definition, so stale later-line definitions from a previous edit don't\n   * linger and get returned by {@link read}.\n   */\n  invalidateDownstream(variable: string, definitionLine: number): void {\n    const stack = this.definitions.get(variable);\n    if (!stack) return;\n    const idx = stack.findIndex(s => s.line === definitionLine);\n    if (idx === -1) return;\n    stack.splice(idx + 1);\n  }\n\n  /** Remove every tracked variable definition, used when an engine/document is reset. */\n  clear(): void {\n    this.definitions.clear();\n  }\n}\n","import { OpCode } from \"@solve-js/parser/OpCode\";\nimport { Value, ValueType, numberValue, stringValue, bigIntValue, hexValue, uomValue, matrixValue, boolValue, datetimeValue, percentageValue, persistentValue, isArenaActive, errorValue, rateValue, isRateUnit, splitRateUnit, isTimecodeUnit, timecodeFps, rangeValue, symbolicValue, type MatrixEntry, type MatrixData, type RangeData } from \"@solve-js/vm/Value\";\nimport { varNode as varSymbolicNode, type SymbolicNode as SymbolicNodeType } from \"@solve-js/symbolic\";\nimport { symbolicPow, symbolicNeg, symbolicBuiltin, SYMBOLIC_NATIVE_BUILTINS } from \"@solve-js/vm/SymbolicOps\";\nimport { rowMajorToColumnMajor, matrixMultiply, matrixCompare, matIndex, matAt, inBounds, collectionToValues, matrixEntryToValue } from \"@solve-js/vm/MatrixOps\";\nimport type { VM, OpRegistry, EquationDef, ScalarEquationDef } from \"@solve-js/vm/OpRegistry\";\nimport { convertUnit, getMeasure, getBestUnit, getConvertiblePossibilities, isWorkdayUnit } from \"@solve-js/uom/UomConverter\";\nimport { sharedCurrencyExchange } from \"@solve-js/uom/CurrencyExchange\";\nimport { ErrorFactory, normalizeUnknownError, type EngineError } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { DiagnosticPipeline, DiagnosticEventType } from \"@solve-js/diagnostics\";\nimport { builtinFunctions, asConverterRegistry } from \"@solve-js/vm/VMBuiltins\";\nimport { defaultEngineContext } from \"@solve-js/engine/EngineContext\";\nimport type { EngineContext } from \"@solve-js/engine/EngineContext\";\nimport { getOpCodeName } from \"@solve-js/parser/OpCode\";\nimport { unifyUom, binaryOp } from \"@solve-js/vm/VMConversion\";\nimport { sharedGlobalVariableStore } from \"@solve-js/vm/GlobalVariableStore\";\nimport type { BytecodeProgram, UserFunctionDef, AnonymousBodyDef } from \"@solve-js/parser/BytecodeBuilder\";\n\n/**\n * Create a new VM instance with the given opcode registry and configurable limits.\n *\n * The VM is a stack machine that executes compiled bytecode. It manages:\n * - A value stack (bounded by `maxStackDepth`)\n * - A variable store (Map of name → Value)\n * - An instruction counter (bounded by `maxInstructions`)\n * - An AbortSignal for async cancellation\n *\n * @param registry - Opcode handler registry for plugin-extensible opcodes\n * @param maxStackDepth - Maximum stack slots (default 200)\n * @param maxInstructions - Maximum opcodes per expression (default 50000)\n * @param maxFunctionRecursionDepth - Maximum nested user-defined-function\n *   calls (default 50). See the VM interface's `pushCallFrame` doc for why\n *   this exists as its own dedicated guard, separate from `maxInstructions`.\n */\nexport function createVM(\n    registry: OpRegistry,\n    maxStackDepth = 200,\n    maxInstructions = 50000,\n    maxFunctionRecursionDepth = 50,\n    // Defaults to the shared context so the many call sites that predate\n    // per-engine contexts keep working unchanged. An ExpressionEngine always\n    // passes its own.\n    context: EngineContext = defaultEngineContext,\n): VM {\n    const stack: Value[] = [];\n    const variables = new Map<string, Value>();\n    let instructionCount = 0;\n\n    let activeSignal: AbortSignal | undefined;\n    let abortCurrent: (() => void) | undefined;\n\n    // User-defined-function call frames, a real stack of name-keyed Maps\n    // not a flat map, so nested/recursive calls (double(double(5))) each\n    // get their own bound-argument scope instead of clobbering a shared\n    // one. `getVar` below only ever consults the INNERMOST frame (no\n    // lexical capture across nested calls). See OpRegistry.ts's VM\n    // interface doc for the full reasoning.\n    const callFrames: Map<string, Value>[] = [];\n    // VM-INSTANCE-scoped (not module-global), an intentional improvement\n    // over a shared-across-engines registry: two ExpressionEngine\n    // instances with different documents no longer risk one's `f(x)`\n    // clobbering the other's same-named function, which a module-level\n    // Map would allow (the same class of gap ARCHITECTURE.md §10's L1\n    // cross-instance-isolation item already tracks for pluginFunctionRegistry\n    // et al.. This VM-scoped design simply doesn't inherit it).\n    const userFunctions = new Map<string, UserFunctionDef>();\n    // Bare (colon-less) equations (`a*x = rhs`), keyed by their free\n    // variable. See OpRegistry.ts's EquationDef doc comment. Same\n    // VM-instance scoping reasoning as userFunctions above.\n    const equations = new Map<string, EquationDef>();\n    // Bare scalar equations (`x^2-4 = 0`), kept in their own map rather than\n    // sharing the one above, since the two are solved by entirely different\n    // machinery. See OpRegistry.ts's ScalarEquationDef doc comment.\n    const scalarEquations = new Map<string, ScalarEquationDef>();\n\n    return {\n      push(v: Value) {\n        if (stack.length < maxStackDepth) {\n          stack.push(v);\n        }\n      },\n      getMaxStackDepth() { return maxStackDepth; },\n      pop() {\n        if (stack.length === 0) {\n          return numberValue(0);\n        }\n        return stack.pop()!;\n      },\n      popNumber() { return stack.pop()!.toNumber(); },\n      popString() { return (stack.pop()!.value as string); },\n      peek() { return stack[stack.length - 1]; },\n      getStack() { return stack; },\n      registry,\n      getVar(key: string) {\n        if (callFrames.length > 0) {\n          const frameValue = callFrames[callFrames.length - 1].get(key);\n          if (frameValue !== undefined) return frameValue;\n        }\n        return variables.get(key);\n      },\n      setVar(key: string, val: Value) { variables.set(key, val); },\n      pushCallFrame(frame: Map<string, Value>) {\n        if (callFrames.length >= maxFunctionRecursionDepth) {\n          throw ErrorFactory.execution(\n            \"FUNCTION_RECURSION_LIMIT_EXCEEDED\",\n            `Function call nesting exceeded maximum depth of ${maxFunctionRecursionDepth} (possible infinite recursion, e.g. f(x) = f(x))`,\n            { maxFunctionRecursionDepth },\n          );\n        }\n        callFrames.push(frame);\n      },\n      popCallFrame() { callFrames.pop(); },\n      defineUserFunction(name: string, params: string[], program: BytecodeProgram) {\n        userFunctions.set(name, { name, params, program });\n      },\n      getUserFunction(name: string) { return userFunctions.get(name); },\n      hasUserFunction(name: string) { return userFunctions.has(name); },\n      defineEquation(variable: string, factorNames: string[], rhsProgram: BytecodeProgram) {\n        equations.set(variable, { variable, factorNames, rhsProgram });\n      },\n      getEquation(variable: string) { return equations.get(variable); },\n      hasEquation(variable: string) { return equations.has(variable); },\n      defineScalarEquation(variable: string, lhsProgram: BytecodeProgram, rhsProgram: BytecodeProgram) {\n        scalarEquations.set(variable, { variable, lhsProgram, rhsProgram });\n      },\n      getScalarEquation(variable: string) { return scalarEquations.get(variable); },\n      hasScalarEquation(variable: string) { return scalarEquations.has(variable); },\n      reset() {\n        stack.length = 0;\n        variables.clear();\n        callFrames.length = 0;\n        userFunctions.clear();\n        equations.clear();\n        scalarEquations.clear();\n        instructionCount = 0;\n        // Abort any in-flight async work for the previous expression\n        if (abortCurrent) { abortCurrent(); abortCurrent = undefined; }\n        activeSignal = undefined;\n      },\n      get activeSignal() { return activeSignal; },\n      set activeSignal(s: AbortSignal | undefined) { activeSignal = s; },\n      get abortCurrent() { return abortCurrent; },\n      set abortCurrent(f: (() => void) | undefined) { abortCurrent = f; },\n      context,\n      getMaxInstructions() { return maxInstructions; },\n      getInstructionCount() { return instructionCount; },\n      incrementInstructions(n: number) {\n        instructionCount += n;\n        if (instructionCount > maxInstructions) {\n          throw ErrorFactory.execution(\"INSTRUCTION_LIMIT_EXCEEDED\", `Execution exceeded maximum of ${maxInstructions} instructions`);\n        }\n      },\n    };\n}\n\n/**\n * Compiled bytecode ready for VM execution.\n *\n * Uses packed TypedArrays for cache-friendly memory layout:\n * - `opcodes`: Uint8Array of OpCode values\n * - `numbers`: Float64Array of numeric literals (indexed by opcode operands)\n * - `strings`: String table for identifiers, UoM units, and BigInt literals\n */\nexport interface Bytecode {\n    opcodes: Uint8Array;\n    numbers: Float64Array;\n    strings: string[];\n    /** User-defined-function bodies compiled alongside this program. See `parser/BytecodeBuilder.ts`'s `BytecodeProgram.userFunctionBodies`. */\n    userFunctionBodies?: UserFunctionDef[];\n    /** map/reduce anonymous transform bodies. See `parser/BytecodeBuilder.ts`'s `BytecodeProgram.anonymousBodies`. */\n    anonymousBodies?: AnonymousBodyDef[];\n}\n\n/**\n * Per-line execution context, threaded optionally through\n * {@link executeBytecode} down to `CALL_PLUGIN`'s plugin-function handlers\n * (see `vm/VMBuiltins.ts`'s `pluginFunctionRegistry`).\n *\n * Exists so a package can implement cross-line features (`prev`, `line<N>`,\n * range/above aggregation. See `packages/lines/`) without every other\n * plugin function having to care: it's optional, and every existing\n * handler ignores it unchanged. Before this, a plugin function's only\n * input was its own call-site arguments, no line number, no access to\n * any other line's cached result. `getLineResult`/`isLineBoundary` are\n * both `undefined` when there's no real document (e.g.\n * `ExpressionEngine.evaluateExpression()`'s single-expression path, which\n * uses `lineIndex = -1` as its existing \"no document\" sentinel), a\n * plugin function needing document access must check for that itself\n * and return a clear error, never silently treat it as line 0.\n */\nexport interface LineExecutionContext {\n    /** 1-based current line number, or -1 when there is no real document (see class doc above). */\n    lineIndex: number;\n    /** Look up another line's cached result by 1-based line number. `undefined` = not evaluated yet (or out of range), distinct from a line that evaluated to an actual `undefined`-like Value, which can't happen (every Value type has a concrete representation). */\n    getLineResult?: (lineNumber: number) => Value | undefined;\n    /** Whether line `lineNumber` is a blank line or a `#` heading, the stopping condition for \"total above\"/\"sum above\"/\"average above\" aggregation. */\n    isLineBoundary?: (lineNumber: number) => boolean;\n}\n\n/**\n * Discriminated union returned by {@link executeBytecode}.\n *\n * Two variants:\n * - `value`: execution completed synchronously with a concrete Value\n * - `pending`: an async plugin call was encountered, the orchestrator\n *   must await the resolver Promise, then re-execute\n *\n * Replaces the old throw-AsyncSuspenseError pattern, eliminating the need\n * for try/catch in the engine.\n */\nexport type EvalResult =\n    | { type: 'value'; value: Value }\n    | { type: 'pending'; queryKey: string; resolver: Promise<Value>; packageId: string; signal: AbortSignal }\n    /**\n     * NEW third arm, an internal invariant violation (stack underflow via\n     * `safePop()`, an unresolved global variable bypassing preflight, a\n     * safety limit exceeded) surfaced as a controlled, structured\n     * `EngineError` instead of letting a raw exception escape\n     * `executeBytecode()` uncaught. See `executeBytecode()`'s own doc\n     * comment on the try/catch this arm makes possible.\n     */\n    | { type: 'error'; error: EngineError };\n\n/**\n * Extract the Value from an EvalResult. Throws if the result is\n * `'pending'` (should not happen at call sites that have already resolved\n * async dependencies) or `'error'` (re-throws the original `EngineError`\n * as-is, preserving its structure. This used to be a raw `new Error(...)`).\n */\nexport function unwrapEvalResult(result: EvalResult): Value {\n    if (result.type === 'value') return result.value;\n    if (result.type === 'error') throw result.error;\n    throw ErrorFactory.internal(\"UNEXPECTED_PENDING_RESULT\", `Expected value result but got pending: ${result.queryKey}`);\n}\n\n// ── Shared helpers ─────────────────────────────────────────────────────\n// Kept as module-level functions so V8 can inline them at the switch case\n// call sites. Cost: zero when inlined by TurboFan.\n\n/**\n * Fatal-bug fix: pop the stack, throwing a controlled `EngineError` instead\n * of silently returning `undefined` on an empty stack. Every one of this\n * dispatch loop's ~90 opcode cases used to call the raw `stack.pop()!`\n * the `!` is compile-time-only, so if bytecode's push/pop counts ever\n * didn't match what an opcode expected (corrupted bytecode, a buggy\n * third-party package's parselet, an internal compiler bug), `pop()`\n * silently returned `undefined` and the NEXT property access on it threw\n * a raw, uncontrolled `TypeError`. This file's own comments already\n * flagged the general risk class (see `maxStackDepth`'s doc comment above)\n * but only ever built a backstop against stack GROWTH; underflow had none.\n * Caught for free by `executeBytecode()`'s new outer try/catch.\n */\nfunction safePop(stack: Value[]): Value {\n    if (stack.length === 0) {\n        throw ErrorFactory.internal({\n            code: \"STACK_UNDERFLOW\",\n            message: \"Stack underflow: an opcode expected a value on the stack but it was empty\",\n            expected: \"at least one value on the VM stack\",\n            found: \"an empty stack\",\n            suggestion: \"this indicates corrupted bytecode or a bug in a package's parselet (mismatched push/pop counts), not a user-input error\",\n        });\n    }\n    return stack.pop()!;\n}\n\n/**\n * Reentrantly executes a `map`/`reduce` transform body, either an\n * anonymous inline expression (`10*x` in `map(10*x, [...])`) or a real\n * user-defined function's own body (`map(f, ...)`), with a fresh call\n * frame binding `params[i] -> args[i]`. Mirrors `CALL_USER_FUNCTION`'s own\n * reentrant-`executeBytecode()` pattern exactly (see its case below for\n * the full reasoning on why this is safe); factored out here so\n * `MAP_INVOKE`/`REDUCE_INVOKE` don't each duplicate it twice (once per\n * transform kind that needs a call frame, the builtin-function kind\n * needs no frame at all, so it's handled inline at each call site\n * instead).\n *\n * `symbolicTolerant` (H.3) is threaded straight through from the\n * ENCLOSING `executeBytecode()` call's own flag (see MAP_INVOKE/\n * REDUCE_INVOKE below), not hardcoded true, so a map/reduce transform\n * body only tolerates an undefined variable (e.g. the free `b` in\n * `reduce(acc+x+b,[1,2,3])=>2b+6`) when the OUTER expression is itself\n * running in a `=>` solve/simplify context; ordinary (non-`=>`)\n * map/reduce usage keeps today's exact behavior, a genuinely undefined\n * variable inside the transform body still hard-throws.\n */\nfunction invokeFrameBody(\n    params: string[],\n    program: BytecodeProgram,\n    args: Value[],\n    vm: VM,\n    pipeline: DiagnosticPipeline | undefined,\n    expression: string | undefined,\n    context: LineExecutionContext | undefined,\n    symbolicTolerant: boolean,\n): Value {\n    const frame = new Map<string, Value>();\n    for (let i = 0; i < params.length; i++) frame.set(params[i], args[i]);\n    vm.pushCallFrame(frame);\n    let bodyResult: EvalResult;\n    try {\n        bodyResult = executeBytecode(program, vm, pipeline, expression, context, symbolicTolerant);\n    } finally {\n        vm.popCallFrame();\n    }\n    if (bodyResult.type === \"pending\") {\n        // Same v1 scope decision as CALL_USER_FUNCTION's own async body\n        // rejection, propagating a 'pending' result up through a\n        // reentrant executeBytecode() call would need the OUTER\n        // expression's own bytecode position/stack state to also be\n        // resumable later, which isn't implemented.\n        throw ErrorFactory.execution(\n            \"MAP_REDUCE_ASYNC_UNSUPPORTED\",\n            `map/reduce transform bodies calling an async operation (weather, stocks, currency, ...) aren't supported`,\n        );\n    }\n    if (bodyResult.type === \"error\") {\n        throw bodyResult.error;\n    }\n    return bodyResult.value;\n}\n\n/** Extract milliseconds from a duration Value (UoM time unit or plain number).\n *  Used by ADD/SUB datetime fast paths and DATE_ADD/DATE_SUB opcodes. */\nfunction extractDurationMs(value: Value): number {\n    if (value.type === ValueType.Uom) {\n        const unit = value.unit;\n        // Only a time-measure unit can be a duration. Checking the measure\n        // BEFORE converting, rather than relying on convertUnit() to throw for\n        // everything else, is deliberate: it makes `<date> + 5 kg` contribute\n        // zero because kilograms are not a duration, not because a conversion\n        // happened to fail. The two are the same today, but a single lenient\n        // conversion is all it takes for them to diverge, and when they do the\n        // symptom is a silently wrong date rather than an error. That is\n        // exactly how `today + 5 m` came to mean five minutes.\n        if (unit && getMeasure(unit) === \"time\") {\n            try { return convertUnit(value.toNumber(), unit, \"ms\"); } catch { /* Ignore */ }\n        }\n        return 0;\n    }\n    return value.toNumber();\n}\n\n/**\n * Advance (or, for negative `n`, retreat) a Datetime by `n` business days,\n * skipping Saturdays/Sundays, e.g. Friday + 1 workday lands on Monday, not\n * Saturday. Backs the datetime package's `<date> + N workdays` / `<date> -\n * N workdays` arithmetic (see this function's ADD/SUB call sites below).\n *\n * SCOPE DECISION: does NOT exclude public holidays, plain Mon-Fri\n * business-day math only. SoulverCore's own workday calculations\n * auto-exclude public holidays via a live-updating, region-configurable\n * holiday database; picking which holidays/region and keeping such a\n * database current is a real, separate piece of scope this pass\n * deliberately does not take on (matches this codebase's established\n * pattern of documenting a scoped-down simplification rather than silently\n * pretending to support something it doesn't, e.g. Finance's \"no\n * hardcoded tax rate\" decision in vm/VMBuiltins.ts).\n *\n * Walks one calendar day at a time (matching this file's existing\n * DATE_NEXT_WEEKDAY/DATE_LAST_WEEKDAY local-time convention below) rather\n * than a closed-form calculation, the exact skip pattern depends on which\n * day of the week the anchor date falls on, so there's no fixed ratio like\n * uom/UomConverter.ts's workday<->day RATE conversion (that's a linear\n * approximation acceptable for Rate math; actual date arithmetic needs the\n * real, exact answer).\n */\nfunction addBusinessDays(epochMs: number, n: number): number {\n    const date = new Date(epochMs);\n    let remaining = Math.trunc(Math.abs(n));\n    const direction = n >= 0 ? 1 : -1;\n    while (remaining > 0) {\n        date.setDate(date.getDate() + direction);\n        const day = date.getDay(); // 0=Sunday..6=Saturday\n        if (day !== 0 && day !== 6) remaining--;\n    }\n    return date.getTime();\n}\n\n/**\n * Combine a video-timecode Value (`Uom(totalFrames, \"timecode@fps\")`. See\n * `vm/Value.ts`'s timecode section) with a right-hand operand for ADD/SUB.\n * `sign` is +1 for ADD, -1 for SUB.\n *\n * Handles three right-hand shapes:\n * - Another timecode at the SAME fps -> combine frame counts directly.\n *   ADD (\"timecode + timecode\") keeps the timecode tag (SoulverCore treats\n *   a timecode primarily as a duration-since-zero, so summing two is\n *   meaningful, concatenating clip lengths, unlike summing two absolute\n *   Datetimes, which this file already rejects above). SUB (\"timecode -\n *   timecode\") produces a plain `Uom(diff, \"frames\")` instead, mirroring\n *   this file's Datetime-Datetime SUB convention just above (an absolute-\n *   ish quantity minus another yields a plain duration/count, not another\n *   absolute-ish value).\n * - A plain `Uom(\"frames\")` (see FrameCountParselet) -> add/subtract the\n *   frame count directly, no fps conversion needed.\n * - Any other Time-measure Uom (minutes, seconds, ...) -> convert to\n *   seconds via convertUnit() and multiply by the timecode's own fps to\n *   get a frame count.\n * - A bare Number -> treated as a raw frame count, for convenience.\n *\n * Deliberately NOT commutative (only handles `left` being the timecode)\n * the task grammar this backs always writes the timecode first\n * (\"timecode + N frames\", not \"N frames + timecode\"); see this file's\n * ADD/SUB call sites for where that asymmetry is accepted.\n */\nfunction combineTimecode(tc: Value, r: Value, sign: 1 | -1): Value {\n    const fps = timecodeFps(tc.unit!);\n\n    if (r.type === ValueType.Uom && isTimecodeUnit(r.unit)) {\n        const rFps = timecodeFps(r.unit!);\n        if (rFps !== fps) {\n            return errorValue(\n                \"TIMECODE_FPS_MISMATCH\",\n                `Cannot combine timecodes at different frame rates (${fps} fps vs ${rFps} fps)`\n            );\n        }\n        return sign === 1\n            ? uomValue(tc.toNumber() + r.toNumber(), tc.unit!)\n            : uomValue(tc.toNumber() - r.toNumber(), \"frames\");\n    }\n\n    if (r.type === ValueType.Uom && r.unit === \"frames\") {\n        return uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit!);\n    }\n\n    if (r.type === ValueType.Uom && r.unit && getMeasure(r.unit) === \"time\") {\n        const seconds = convertUnit(r.toNumber(), r.unit, \"s\");\n        return uomValue(tc.toNumber() + sign * seconds * fps, tc.unit!);\n    }\n\n    // Bare Number (or any other Uom), treated as a raw frame count.\n    return uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit!);\n}\n\n/**\n * Truthiness for a conditional/logical operand. `Boolean` values use\n * their own value directly; anything else falls back to a JS-like\n * \"nonzero is truthy\" reading of `toNumber()`, lets a plain numeric\n * expression work as a condition (`if x then ...`) without requiring an\n * explicit comparison, without adding a whole coercion framework.\n */\nfunction isTruthy(value: Value): boolean {\n    if (value.type === ValueType.Boolean) return value.value as boolean;\n    return value.toNumber() !== 0;\n}\n\n/**\n * Rate × Uom (matching the rate's denominator measure) -> plain\n * Uom/Number, the denominator cancelling out. E.g. \"$50/week\" ×\n * \"12 weeks\" -> \"$600\"; \"30 fps\" × \"3 minutes\" -> \"5,400 frames\".\n * Shared by `OpCode.RATE_MUL` (explicit) and `OpCode.MUL`'s automatic\n * rate detection (so plain \"*\"/\"×\" syntax works without a package having\n * to route through RATE_MUL specially).\n */\nfunction multiplyRateByMatchingUom(rate: Value, multiplier: Value): Value {\n    const { numerator, denominator } = splitRateUnit(rate.unit!);\n    const rateMeasure = getMeasure(denominator);\n    const multiplierMeasure = getMeasure(multiplier.unit!);\n    if (!rateMeasure || rateMeasure !== multiplierMeasure) {\n        return errorValue(\n            \"RATE_MUL_MEASURE_MISMATCH\",\n            `Cannot multiply a \"${denominator}\"-denominated rate by \"${multiplier.unit}\" — different measures`\n        );\n    }\n    const multiplierInDenominatorUnit = convertUnit(multiplier.toNumber(), multiplier.unit!, denominator);\n    const total = rate.toNumber() * multiplierInDenominatorUnit;\n    return numerator ? uomValue(total, numerator) : numberValue(total);\n}\n\n// ── Converters (`as <type>`) formatting helpers ───────────────────────────\n// Kept separate from FormatEngine.ts (display-only formatting of a Value\n// for the editor gutter): these PRODUCE a new Value (typically a String)\n// that becomes the expression's actual result, not just its rendering.\n\n/**\n * Simplify a decimal to the smallest fraction that reproduces it within a\n * tight tolerance, via continued-fraction expansion, so a float like\n * 0.3333333333333333 (not exactly 1/3) still resolves to \"1/3\" instead of\n * an unreadably large denominator.\n */\nfunction toFractionString(n: number): string {\n    if (Number.isNaN(n)) return \"NaN\";\n    if (!isFinite(n)) return n > 0 ? \"Infinity\" : \"-Infinity\";\n    const negative = n < 0;\n    const abs = Math.abs(n);\n    const whole = Math.floor(abs);\n    const frac = abs - whole;\n    if (frac < 1e-9) return `${negative ? \"-\" : \"\"}${whole}`;\n\n    let h0 = 0, h1 = 1, k0 = 1, k1 = 0;\n    let b = frac;\n    const maxDenominator = 1_000_000;\n    for (let i = 0; i < 30; i++) {\n        const a = Math.floor(b + 1e-9);\n        const h2 = a * h1 + h0, k2 = a * k1 + k0;\n        if (k2 > maxDenominator) break;\n        h0 = h1; h1 = h2; k0 = k1; k1 = k2;\n        if (Math.abs(frac - h1 / k1) < 1e-9) break;\n        const rem = b - a;\n        if (rem < 1e-9) break;\n        b = 1 / rem;\n    }\n    const numerator = whole * k1 + h1;\n    return `${negative ? \"-\" : \"\"}${numerator}/${k1}`;\n}\n\n/**\n * \"1 + n\" growth multiplier, e.g. a 50% increase (stored as the fraction\n * 0.5, matching Percentage's convention) reads as \"1.5x\".\n */\nfunction toMultiplierString(n: number): string {\n    const multiplier = Math.round((1 + n) * 1e6) / 1e6;\n    return `${multiplier}x`;\n}\n\n/** Scientific notation with trailing mantissa zeros trimmed (\"1.50e+6\" -> \"1.5e+6\"). */\nfunction toScientificString(n: number): string {\n    if (n === 0) return \"0e+0\";\n    const [mantissa, exponent] = n.toExponential().split(\"e\");\n    const trimmed = mantissa.includes(\".\") ? mantissa.replace(/0+$/, \"\").replace(/\\.$/, \"\") : mantissa;\n    return `${trimmed}e${exponent}`;\n}\n\n/**\n * Execute bytecode with optional diagnostic pipeline integration.\n *\n * Performance notes:\n * - Uses a `switch(op)` statement for dispatch. V8 compiles dense integer\n *   switches (OpCode values 0–200) into a jump table with O(1) dispatch.\n *   All handler code is inlined directly in the switch cases, allowing\n *   TurboFan to optimize across opcode boundaries.\n * - ADD/SUB/MUL have an inlined numeric fast path that skips the `binaryOp()`\n *   function call + closure allocation when both operands are plain numbers\n *   (>90% of arithmetic ops).\n * - Tracing uses a boolean guard (`shouldTrace`) that the JIT eliminates\n *   entirely when diagnostics are disabled. No function call overhead.\n * - `Value.toNumber()` caches its result, computed once, read thereafter.\n */\nexport function executeBytecode(\n    bytecode: Bytecode,\n    vm: VM,\n    pipeline?: DiagnosticPipeline | undefined,\n    expression?: string,\n    context?: LineExecutionContext,\n    // Symbolic-tolerant mode (default false, every existing evaluation\n    // path is completely unchanged): when true, LOAD_VAR pushes a\n    // Symbolic placeholder (symbolic/SymbolicNode.ts) for an undefined variable\n    // instead of throwing UNDEFINED_VARIABLE. Set only by the `=>`\n    // solve/simplify path (H.2) and map/reduce's own reentrant calls when\n    // folding a symbolic accumulator (H.3), never by top-level\n    // evaluation, so the hard UNDEFINED_VARIABLE throw stays exactly as-is\n    // for ordinary expressions.\n    symbolicTolerant?: boolean\n): EvalResult {\n    const { opcodes, numbers, strings, userFunctionBodies, anonymousBodies } = bytecode;\n    let ip = 0;\n    let localInstructionCount = 0;\n    const maxInstructions = vm.getMaxInstructions();\n    const maxStackDepth = vm.getMaxStackDepth();\n\n    // Direct stack array reference. Bypasses VM.push/pop's own bounds check\n    // (vm.push() silently no-ops past maxStackDepth, fine for the rare\n    // direct caller, wrong for the hot loop, which instead gets a single\n    // cheap depth check per instruction below, same cost class as the\n    // instruction-count check). Built-in packages' bytecode naturally stays\n    // well under maxStackDepth (nesting depth is already bounded by\n    // maxNestingDepth), but a third-party package's buggy parselet, or a\n    // host that raises maxComplexity/maxNestingDepth, has no other\n    // backstop against unbounded stack growth without this check.\n    const stack = vm.getStack();\n\n    // Boolean guard: JIT will eliminate the entire branch when false.\n    // No function call, no argument evaluation, zero overhead.\n    const shouldTrace = pipeline?.hasCollectors ?? false;\n\n    // Hoist arena check to a local constant, avoids a function call at\n    // every HALT/STORE_VAR/fallback-return in the dispatch loop.\n    // The arena is only active during scroll execution (ThreeTierEvaluator\n    // Tier 2); in all other paths this is always false and the JIT can\n    // eliminate the unreachable persistentValue() branch entirely.\n    const hasArena = isArenaActive();\n\n    if (opcodes.length === 0) return { type: 'value', value: numberValue(0) };\n\n    // Fatal-bug fix: this whole dispatch loop used to have NO surrounding\n    // try/catch at all, a safety-limit throw (INSTRUCTION_LIMIT_EXCEEDED/\n    // STACK_LIMIT_EXCEEDED, both just below), an UNDEFINED_VARIABLE throw,\n    // or a raw TypeError from a stack-underflow bug (see safePop() below)\n    // escaped this function entirely and was only ever caught because every\n    // production call site happened to sit inside SOMEONE ELSE's generic\n    // catch, confirmed NOT true for AsyncResolutionBatcher.reExecuteMainThread()\n    // which had none (now fixed separately, see that file). EvalResult's\n    // new {type:'error'} arm makes this function's contract match what it\n    // always should have been: three possible outcomes, all returned, none\n    // silently relying on an external catch. Deliberately NOT re-indented\n    // (a ~900-line body) to keep this diff reviewable, a future full pass\n    // could re-indent, this fix does not depend on it.\n    try {\n    while (ip < opcodes.length) {\n      // Tighten instruction limit check: combined increment + guard.\n      // V8 optimises `++localInstructionCount > maxInstructions` into a\n      // single fused add-and-compare on the hot path. The default limit\n      // (50k) is never reached in benchmarks, so this branch is statically\n      // predicted not-taken by the CPU.\n      if (++localInstructionCount > maxInstructions) {\n        throw ErrorFactory.execution(\"INSTRUCTION_LIMIT_EXCEEDED\", `Execution exceeded maximum of ${maxInstructions} instructions`);\n      }\n      // Same cost class as the check above, one comparison, statically\n      // predicted not-taken. Catches stack growth left over from the\n      // previous instruction's push(es); a bounded one-instruction delay\n      // is fine for a safety limit (see the comment on `stack` above).\n      if (stack.length > maxStackDepth) {\n        throw ErrorFactory.execution(\"STACK_LIMIT_EXCEEDED\", `Execution exceeded maximum stack depth of ${maxStackDepth}`);\n      }\n      const op = opcodes[ip++] as OpCode;\n\n      if (shouldTrace) {\n        const stackSnapshot = stack.map(v => ({\n          type: v.type,\n          value: v.value,\n          unit: v.unit,\n        }));\n        pipeline!.fireVmStep({\n          type: DiagnosticEventType.VmStep,\n          elapsedNs: 0,\n          expression: expression ?? \"\",\n          opcode: op,\n          opcodeName: getOpCodeName(op),\n          ip: ip - 1,\n          stackDepth: stack.length,\n          instructionNumber: localInstructionCount,\n          stack: stackSnapshot,\n        });\n      }\n\n      // ── switch dispatch: V8 compiles dense integer switches (OpCode 0–200)\n      //    into a jump table with O(1) dispatch. Sections mirror the OpCode\n      //    enum ordering for discoverability.\n      switch (op) {\n        // ═══════════════════════════════════════════════════════════════\n        // §1  Stack operations  (OpCode 0–3)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.NOP:\n          break;\n        case OpCode.HALT: {\n          const result = safePop(stack);\n          return { type: 'value', value: hasArena ? persistentValue(result) : result };\n        }\n        case OpCode.DUP:\n          stack.push(stack[stack.length - 1]);\n          break;\n        case OpCode.SWAP: {\n          const a = safePop(stack), b = safePop(stack);\n          stack.push(a);\n          stack.push(b);\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §2  Push literals  (OpCode 10–15)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.PUSH_NUMBER:\n          stack.push(numberValue(numbers[opcodes[ip++]]));\n          break;\n        case OpCode.PUSH_BIGINT:\n          stack.push(bigIntValue(BigInt(strings[opcodes[ip++]])));\n          break;\n        case OpCode.PUSH_HEX:\n          stack.push(hexValue(numbers[opcodes[ip++]]));\n          break;\n        case OpCode.PUSH_STRING:\n          stack.push(stringValue(strings[opcodes[ip++]]));\n          break;\n        case OpCode.PUSH_BOOLEAN:\n          stack.push(boolValue(opcodes[ip++] === 1));\n          break;\n\n        // ═══════════════════════════════════════════════════════════════\n        // §3  Arithmetic  (OpCode 20–27)\n        //     Binary ops (ADD/SUB/MUL/DIV/MOD/EXP) have inlined numeric\n        //     fast paths; unary ops (NEG/POS) handle BigInt and UoM.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.ADD: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(numberValue((l.value as number) + (r.value as number)));\n          } else if (l.type === ValueType.Boolean && r.type === ValueType.Boolean) {\n            // The word \"and\" lexes as PLUS (en.ts: `and: \"PLUS\"`, a\n            // long-standing synonym for arithmetic \"+\", \"5 and 3\" = 8).\n            // PLUS is a Tier-1 hardcoded infix operator (see\n            // parser/BindingPower.ts's BUILTIN_INFIX_BP), so a registered\n            // parselet can never intercept the word \"and\" the way it can\n            // for genuinely new tokens like \"or\"/\"&&\". This opcode-level\n            // type check is the only way \"true and false\" reads as logical\n            // AND rather than falling through to NaN-producing numeric\n            // addition. Mirrors the Datetime/Rate special-casing already\n            // done here for the same reason (operand-type-driven dispatch).\n            stack.push(boolValue((l.value as boolean) && (r.value as boolean)));\n          } else if (l.type === ValueType.Datetime) {\n            if (r.type === ValueType.Datetime) {\n              // Adding two absolute timestamps has no standard meaning\n              // (unlike subtracting them, which yields a duration).\n              stack.push(errorValue(\"INVALID_DATETIME_OP\", \"Cannot add two datetimes together\"));\n            } else if (r.type === ValueType.Uom && isWorkdayUnit(r.unit)) {\n              // \"<date> + N workdays\", business-day-skip arithmetic, NOT\n              // the generic linear-ms duration path below (a workday's\n              // real-world length depends on which specific calendar days\n              // it actually spans, unlike a fixed-length unit like \"day\").\n              // See addBusinessDays()'s doc comment above.\n              stack.push(datetimeValue(addBusinessDays(l.toNumber(), r.toNumber())));\n            } else {\n              stack.push(datetimeValue(l.toNumber() + extractDurationMs(r)));\n            }\n          } else if (l.type === ValueType.Uom && isTimecodeUnit(l.unit)) {\n            // \"timecode + N frames\" / \"timecode + duration\" / \"timecode +\n            // timecode\". See combineTimecode()'s doc comment above.\n            stack.push(combineTimecode(l, r, 1));\n          } else {\n            stack.push(binaryOp(l, r, (a, b) => a + b, (a, b) => a + b, \"add\"));\n          }\n          break;\n        }\n        case OpCode.SUB: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(numberValue((l.value as number) - (r.value as number)));\n          } else if (l.type === ValueType.Datetime) {\n            if (r.type === ValueType.Datetime) {\n              // \"now - now\" used to unconditionally re-wrap the result as\n              // ANOTHER Datetime, e.g. subtracting two timestamps close\n              // together produced a near-Unix-epoch date (\"01/01/1970,\n              // 01:00:00\") instead of the near-zero duration a user would\n              // expect. Two datetimes subtract to a duration, not a point\n              // in time, represented as a Uom in milliseconds, consistent\n              // with how extractDurationMs() reads durations elsewhere.\n              stack.push(uomValue(l.toNumber() - r.toNumber(), \"ms\"));\n            } else if (r.type === ValueType.Uom && isWorkdayUnit(r.unit)) {\n              // \"<date> - N workdays\". See the matching ADD case above.\n              stack.push(datetimeValue(addBusinessDays(l.toNumber(), -r.toNumber())));\n            } else {\n              stack.push(datetimeValue(l.toNumber() - extractDurationMs(r)));\n            }\n          } else if (l.type === ValueType.Uom && isTimecodeUnit(l.unit)) {\n            // \"timecode - timecode\" (difference) / \"timecode - duration\"\n            // see combineTimecode()'s doc comment above.\n            stack.push(combineTimecode(l, r, -1));\n          } else {\n            stack.push(binaryOp(l, r, (a, b) => a - b, (a, b) => a - b, \"sub\"));\n          }\n          break;\n        }\n        case OpCode.MUL: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(numberValue((l.value as number) * (r.value as number)));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            // Genuinely different from +/-/comparisons (which stay\n            // element-wise, via binaryOp() below), scalar broadcast vs.\n            // real matrix product, disambiguated by shape. Must run BEFORE\n            // binaryOp(), which only ever does element-wise Matrix math.\n            stack.push(matrixMultiply(l.value as MatrixData, r.value as MatrixData));\n          } else if (l.type === ValueType.Uom && isRateUnit(l.unit) && r.type === ValueType.Uom && r.unit) {\n            // \"30 fps × 3 minutes\" -> \"5,400 frames\" via plain \"×\"/\"*\"\n            // no package needs to route through RATE_MUL explicitly.\n            stack.push(multiplyRateByMatchingUom(l, r));\n          } else if (r.type === ValueType.Uom && isRateUnit(r.unit) && l.type === ValueType.Uom && l.unit) {\n            // Commutative: \"3 minutes × 30 fps\" too.\n            stack.push(multiplyRateByMatchingUom(r, l));\n          } else {\n            stack.push(binaryOp(l, r, (a, b) => a * b, (a, b) => a * b, \"mul\"));\n          }\n          break;\n        }\n        case OpCode.DIV: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, sameMeasure } = unifyUom(l, r);\n            if (sameMeasure) {\n              stack.push(numberValue(lv / rv));\n            } else if (sharedCurrencyExchange.isCurrency(l.unit!) && sharedCurrencyExchange.isCurrency(r.unit!)) {\n              // Both currencies, but unifyUom couldn't reconcile them (no\n              // live rate cached yet), an honest failure, not a rate:\n              // \"$X per €Y\" isn't a meaningful derived unit the way\n              // \"km/day\" is, so this stays INCOMPATIBLE_UNITS rather than\n              // silently becoming a nonsensical currency-pair rate.\n              stack.push(errorValue(\"INCOMPATIBLE_UNITS\", `Cannot combine incompatible units: ${l.unit} and ${r.unit}`));\n            } else {\n              // Genuinely different measures (e.g. \"90 km / 3 day\")\n              // construct a Rate rather than erroring, now that this\n              // codebase has a compound/derived-unit representation (see\n              // vm/Value.ts's rateValue()), matches RATE_DIV's explicit\n              // construction opcode, but reachable via plain \"/\" too.\n              stack.push(rateValue(lv / rv, l.unit!, r.unit!));\n            }\n          } else {\n            stack.push(binaryOp(l, r, (a, b) => a / b, (a, b) => a / b, \"div\"));\n          }\n          break;\n        }\n        case OpCode.MOD: {\n          const r = safePop(stack), l = safePop(stack);\n          stack.push(binaryOp(l, r, (a, b) => a % b, (a, b) => a % b));\n          break;\n        }\n        case OpCode.EXP: {\n          const r = safePop(stack), l = safePop(stack);\n          // Unlike ADD/SUB/MUL/DIV/MOD, EXP never routed through\n          // binaryOp() (VMConversion.ts), it called Math.pow() on raw\n          // toNumber() output unconditionally, so it needs its own\n          // Error/Pending short-circuit for the same reason binaryOp()\n          // now has one: toNumber() returns 0 for both, so\n          // `errorValue ^ 2` used to silently become `0`.\n          if (l.type === ValueType.Error) { stack.push(l); break; }\n          if (r.type === ValueType.Error) { stack.push(r); break; }\n          if (l.type === ValueType.Pending) { stack.push(l); break; }\n          if (r.type === ValueType.Pending) { stack.push(r); break; }\n          // Plain numbers first, so the overwhelmingly common case pays for no\n          // extra type test beyond the ones already above it.\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(numberValue(Math.pow(l.value as number, r.value as number)));\n            break;\n          }\n          // A symbolic operand has to build a `pow` node. Falling through to\n          // Math.pow() here is what made `x^2` evaluate to 0, silently, since\n          // Value.toNumber() reports 0 for a symbolic value.\n          if (l.type === ValueType.Symbolic || r.type === ValueType.Symbolic) {\n            stack.push(symbolicPow(l, r));\n            break;\n          }\n          stack.push(numberValue(Math.pow(l.toNumber(), r.toNumber())));\n          break;\n        }\n        case OpCode.NEG: {\n          const v = safePop(stack);\n          if (v.type === ValueType.BigInt) stack.push(bigIntValue(-(v.value as bigint)));\n          else if (v.type === ValueType.Uom) stack.push(uomValue(-v.toNumber(), v.unit!));\n          // Without this branch, unary minus on a free variable produced `-0`,\n          // for the same toNumber() reason as EXP above.\n          else if (v.type === ValueType.Symbolic) stack.push(symbolicNeg(v));\n          else stack.push(numberValue(-v.toNumber()));\n          break;\n        }\n        case OpCode.POS: {\n          const v = safePop(stack);\n          if (v.type === ValueType.Uom) stack.push(uomValue(v.toNumber(), v.unit!));\n          else stack.push(numberValue(v.toNumber()));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §4  Bitwise  (OpCode 30–36)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.LSHIFT: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(BigInt(l.toNumber()) << BigInt(r.toNumber())));\n          } else {\n            stack.push(numberValue(l.toNumber() << r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.RSHIFT: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(BigInt(l.toNumber()) >> BigInt(r.toNumber())));\n          } else {\n            stack.push(numberValue(l.toNumber() >> r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.URSHIFT: {\n          const r = safePop(stack), l = safePop(stack);\n          // No BigInt branch, unlike its siblings above. `>>>` is defined on a\n          // 32-bit unsigned word and JavaScript refuses it on a BigInt, so\n          // there is nothing to widen to: BigInt(-8) >>> 1n is a TypeError, not\n          // a large number. Both operands go through the 32-bit path.\n          stack.push(numberValue(l.toNumber() >>> r.toNumber()));\n          break;\n        }\n        case OpCode.BIT_AND: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(BigInt(l.toNumber()) & BigInt(r.toNumber())));\n          } else {\n            stack.push(numberValue(l.toNumber() & r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.BIT_OR: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(BigInt(l.toNumber()) | BigInt(r.toNumber())));\n          } else {\n            stack.push(numberValue(l.toNumber() | r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.BIT_XOR: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(BigInt(l.toNumber()) ^ BigInt(r.toNumber())));\n          } else {\n            stack.push(numberValue(l.toNumber() ^ r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.BIT_NOT: {\n          const v = safePop(stack);\n          if (v.type === ValueType.BigInt) stack.push(bigIntValue(~(v.value as bigint)));\n          else stack.push(numberValue(~v.toNumber()));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §4b Comparison  (OpCode 40–45)\n        //     Numeric fast path when both operands are Number;\n        //     EQ/NEQ support UoM unification for same-measure comparison.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.EQ: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(boolValue((l.value as number) === (r.value as number)));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, sameMeasure } = unifyUom(l, r);\n            stack.push(boolValue(sameMeasure && lv === rv));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            stack.push(matrixCompare(l.value as MatrixData, r.value as MatrixData, (a, b) => a === b));\n          } else {\n            stack.push(boolValue(l.toNumber() === r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.NEQ: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(boolValue((l.value as number) !== (r.value as number)));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, sameMeasure } = unifyUom(l, r);\n            stack.push(boolValue(!sameMeasure || lv !== rv));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            stack.push(matrixCompare(l.value as MatrixData, r.value as MatrixData, (a, b) => a !== b));\n          } else {\n            stack.push(boolValue(l.toNumber() !== r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.LT: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(boolValue((l.value as number) < (r.value as number)));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            stack.push(matrixCompare(l.value as MatrixData, r.value as MatrixData, (a, b) => a < b));\n          } else {\n            stack.push(boolValue(l.toNumber() < r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.LTE: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(boolValue((l.value as number) <= (r.value as number)));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            stack.push(matrixCompare(l.value as MatrixData, r.value as MatrixData, (a, b) => a <= b));\n          } else {\n            stack.push(boolValue(l.toNumber() <= r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.GT: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(boolValue((l.value as number) > (r.value as number)));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            stack.push(matrixCompare(l.value as MatrixData, r.value as MatrixData, (a, b) => a > b));\n          } else {\n            stack.push(boolValue(l.toNumber() > r.toNumber()));\n          }\n          break;\n        }\n        case OpCode.GTE: {\n          const r = safePop(stack), l = safePop(stack);\n          if (l.type === ValueType.Number && r.type === ValueType.Number) {\n            stack.push(boolValue((l.value as number) >= (r.value as number)));\n          } else if (l.type === ValueType.Matrix && r.type === ValueType.Matrix) {\n            stack.push(matrixCompare(l.value as MatrixData, r.value as MatrixData, (a, b) => a >= b));\n          } else {\n            stack.push(boolValue(l.toNumber() >= r.toNumber()));\n          }\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §4c Logical / conditional select  (OpCode 130–132)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.LOGICAL_AND: {\n          const r = safePop(stack), l = safePop(stack);\n          stack.push(boolValue(isTruthy(l) && isTruthy(r)));\n          break;\n        }\n        case OpCode.LOGICAL_OR: {\n          const r = safePop(stack), l = safePop(stack);\n          stack.push(boolValue(isTruthy(l) || isTruthy(r)));\n          break;\n        }\n        case OpCode.SELECT: {\n          // Eager ternary: both branches are ALREADY evaluated and on the\n          // stack by the time this opcode runs (this VM has no jump/branch\n          // opcodes. See OpCode.ts's comment on SELECT for why that's an\n          // intentional simplification, not an oversight). Stack order\n          // (bottom to top) matches the natural parse order of \"if\n          // condition then thenVal else elseVal\": [condition, thenVal, elseVal].\n          const elseVal = safePop(stack);\n          const thenVal = safePop(stack);\n          const condition = safePop(stack);\n          stack.push(isTruthy(condition) ? thenVal : elseVal);\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §5  Functions  (OpCode 50–52)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.CALL_PLUGIN: {\n          const fnIdx = opcodes[ip++];\n          const argCount = opcodes[ip++];\n          const args: Value[] = [];\n          for (let i = 0; i < argCount; i++) args.push(safePop(stack));\n          args.reverse();\n          const fn = vm.context.pluginFunctions[fnIdx];\n          if (!fn) {\n            stack.push(numberValue(0));\n          } else {\n            const result = fn(args, context);\n            if (result instanceof Promise) {\n              // Return pending result, no throw. The orchestrator checks\n              // result.type and handles async resolution outside the VM.\n              // The pluginId + domain are embedded in the cache key format:\n              //   {pluginId}:{domain}:{fnIdx}:{hash(args)}\n              // We use a deterministic key from fnIdx + args for now;\n              // the engine scopes it by pluginId before storing.\n              const cacheKey = `plugin:${fnIdx}:${args.map(a => String(a.value ?? '')).join('|')}`;\n              // activeSignal must be set by the engine before calling executeBytecode.\n              // If it's not (bug), we use a new signal that will never abort\n              // this is a safety net, not the expected path.\n              const signal = vm.activeSignal!;\n              // The owning package, so a failed or slow async call can be attributed.\n              // Falls back to the empty string only for a handler installed\n              // directly into a context rather than through registerPackage.\n              const packageId = vm.context.pluginFunctionOwners[fnIdx] ?? '';\n              return { type: 'pending', queryKey: cacheKey, resolver: result, packageId, signal };\n            }\n            stack.push(result);\n          }\n          break;\n        }\n        case OpCode.CALL_BUILTIN: {\n          const fnIdx = opcodes[ip++];\n          const argCount = opcodes[ip++];\n          const args: Value[] = [];\n          // The symbolic flag is tracked while popping rather than by a second\n          // pass, so the ordinary numeric call pays one type comparison per\n          // argument and nothing else.\n          let sawSymbolic = false;\n          for (let i = 0; i < argCount; i++) {\n            const arg = safePop(stack);\n            if (arg.type === ValueType.Symbolic) sawSymbolic = true;\n            args.push(arg);\n          }\n          const fn = builtinFunctions[fnIdx];\n          if (fn) {\n            const ordered = args.reverse();\n            // One dispatch point covers all ~60 builtins. Each of their\n            // implementations reads args[n].toNumber(), which reports 0 for a\n            // symbolic operand, so routing here is what stops `sqrt(x)` from\n            // quietly returning 0. An index with no symbolic reading comes back\n            // as an error rather than a number computed from that placeholder.\n            // The algebra verbs are the exception: they exist to take an\n            // expression containing unknowns, so they run their own handler.\n            const routeSymbolically = sawSymbolic && !SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);\n            stack.push(routeSymbolically ? symbolicBuiltin(fnIdx, ordered) : fn(ordered));\n          }\n          break;\n        }\n        case OpCode.DEFINE_USER_FUNCTION: {\n          // Registration happens HERE, at execution time, not at parse\n          // time, so a diagnostic/lookahead parse of a definition line\n          // that never actually executes (syntax highlighting, autocomplete\n          // preview, ...) has no side effect on vm.userFunctions. See\n          // BytecodeBuilder.ts's UserFunctionDef doc comment.\n          const bodyIdx = opcodes[ip++];\n          const def = userFunctionBodies?.[bodyIdx];\n          if (!def) {\n            // A compiler/VM invariant violation, not user-input, a\n            // mismatched bodyIdx means the bytecode compiler and this\n            // dispatch loop disagree about userFunctionBodies' contents,\n            // never something reachable by writing a normal `f(x) = ...`\n            // expression correctly. See ErrorCode.ts's own catalog comment.\n            throw ErrorFactory.internal(\n              \"INTERNAL_MISSING_FUNCTION_BODY\",\n              `Internal error: DEFINE_USER_FUNCTION referenced missing body index ${bodyIdx}`,\n              { bodyIdx },\n            );\n          }\n          vm.defineUserFunction(def.name, def.params, def.program);\n          break;\n        }\n        case OpCode.CALL_USER_FUNCTION: {\n          // User-defined, parameterized, reusable functions. `name`'s body\n          // was compiled to its OWN independent BytecodeProgram at\n          // definition time, parameter references inside it are ORDINARY\n          // LOAD_VAR opcodes (see BytecodeBuilder.ts's UserFunctionDef doc\n          // comment for why), resolved dynamically via the call frame\n          // pushed below. Re-executing the body here is a genuinely\n          // reentrant executeBytecode() call sharing this same `vm`/stack\n          // safe because any valid bytecode program, run to completion,\n          // leaves exactly one net value on the stack, the same invariant\n          // every other expression already relies on.\n          const nameIdx = opcodes[ip++];\n          const argCount = opcodes[ip++];\n          const name = strings[nameIdx];\n          const args: Value[] = [];\n          for (let i = 0; i < argCount; i++) args.push(safePop(stack));\n          args.reverse();\n          const fn = vm.getUserFunction(name);\n          if (!fn) {\n            throw ErrorFactory.execution(\"UNDEFINED_FUNCTION\", `Undefined function: ${name}`, { name });\n          }\n          if (argCount !== fn.params.length) {\n            throw ErrorFactory.execution(\n              \"FUNCTION_ARITY_MISMATCH\",\n              `${name} expects ${fn.params.length} argument(s) but got ${argCount}`,\n              { name, expected: fn.params.length, actual: argCount },\n            );\n          }\n          const frame = new Map<string, Value>();\n          for (let i = 0; i < fn.params.length; i++) frame.set(fn.params[i], args[i]);\n          // pushCallFrame() throws FUNCTION_RECURSION_LIMIT_EXCEEDED before\n          // ever reaching the reentrant executeBytecode() call below if\n          // this would exceed maxFunctionRecursionDepth, the backstop for\n          // f(x) = f(x), which would otherwise recurse via nested\n          // executeBytecode() calls (each with its OWN fresh\n          // localInstructionCount, so maxInstructions cannot catch this)\n          // until the native V8 stack overflows uncatchably.\n          vm.pushCallFrame(frame);\n          let bodyResult: EvalResult;\n          try {\n            bodyResult = executeBytecode(fn.program, vm, pipeline, expression, context);\n          } finally {\n            // Always pop, even if the body throws, an uncaught error inside\n            // one call must not leave a stale frame poisoning whatever\n            // (unrelated) expression runs next.\n            vm.popCallFrame();\n          }\n          if (bodyResult.type === \"pending\") {\n            // v1 scope decision: a user function's body calling an async\n            // plugin function (weather, stocks, ...) isn't supported yet\n            // propagating a 'pending' result up through a reentrant\n            // executeBytecode() call would need the OUTER expression's own\n            // bytecode position/stack state to also be resumable later,\n            // which this first pass doesn't implement. Also rejected at\n            // DEFINITION time (see PrecedenceParser.ts's\n            // parseUserFunctionDefinition). This is a defense-in-depth\n            // backstop, not the primary guard.\n            throw ErrorFactory.execution(\n              \"USER_FUNCTION_ASYNC_UNSUPPORTED\",\n              `${name}: user-defined functions with async bodies (weather, stocks, currency, ...) aren't supported`,\n              { name },\n            );\n          }\n          if (bodyResult.type === \"error\") {\n            // A controlled internal-invariant error inside the body, surface\n            // it as-is rather than swallowing/rewrapping (same convention as\n            // unwrapEvalResult()).\n            throw bodyResult.error;\n          }\n          stack.push(bodyResult.value);\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §6  Variables  (OpCode 60–63)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.LOAD_VAR: {\n          const varName = strings[opcodes[ip++]];\n          const val = vm.getVar(varName);\n          if (val !== undefined) {\n            stack.push(val);\n          } else if (symbolicTolerant) {\n            stack.push(symbolicValue(varSymbolicNode(varName)));\n          } else {\n            throw ErrorFactory.execution(\n              \"UNDEFINED_VARIABLE\",\n              `Undefined variable: ${varName}`,\n              { varName },\n            );\n          }\n          break;\n        }\n        case OpCode.STORE_VAR: {\n          const val = safePop(stack);\n          const varName = strings[opcodes[ip++]];\n          vm.setVar(varName, hasArena ? persistentValue(val) : val);\n          stack.push(val);\n          break;\n        }\n        case OpCode.LOAD_GLOBAL_VAR: {\n          // GlobalVariableAsyncResolver's preflight() runs BEFORE the VM ever\n          // reaches this opcode and is SUPPOSED to intercept the \"not yet\n          // declared by any loaded document\" case (returning a Pending value\n          // up front, mirroring how currency conversion's preflight\n          // intercepts before UOM_CONVERT_TO runs), but that invariant is\n          // confirmed violable: ThreeTierEvaluator's Tier 2 (executeCached())\n          // can mark a line \"clean\" and skip straight to VM execution without\n          // ever running preflightAll() (see ARCHITECTURE.md §7's P0 item\n          // still open, gated on the larger L1 migration). This used to be a\n          // bare `!` non-null assertion, a raw, uncontrolled TypeError the\n          // instant that invariant was violated, rather than a controlled\n          // error. Explicit check instead: the read is still expected to\n          // always succeed in the common case, but \"expected to always\n          // succeed\" was exactly the wrong assumption that produced the\n          // Tier-2 bypass bug in the first place.\n          const varName = strings[opcodes[ip++]];\n          const globalValue = sharedGlobalVariableStore.get(varName);\n          if (globalValue === undefined) {\n            // .internal(), not .execution(): this is the Tier-2/preflight-\n            // bypass invariant violation described above, not something an\n            // ordinary user expression can trigger by itself, the\n            // precondition (\"preflight already ran\") is the CALLER's\n            // (ThreeTierEvaluator's) responsibility, not the user's.\n            throw ErrorFactory.internal({\n              code: \"GLOBAL_VARIABLE_NOT_RESOLVED\",\n              message: `Global variable \"${varName}\" was read before it resolved`,\n              expected: `global variable \"${varName}\" to already be resolved (async preflight should guarantee this)`,\n              found: \"no value in the global variable store\",\n              context: { varName },\n            });\n          }\n          stack.push(globalValue);\n          break;\n        }\n        case OpCode.STORE_GLOBAL_VAR: {\n          const val = safePop(stack);\n          const varName = strings[opcodes[ip++]];\n          // Persisting here matters even more than for STORE_VAR: a global\n          // outlives not just this call's own VM but every OTHER document's\n          // arena-reset cycles too. An un-persisted arena Value stored here\n          // would get silently corrupted by a later, unrelated arena\n          // allocation in ANY document, not just this one.\n          sharedGlobalVariableStore.set(varName, hasArena ? persistentValue(val) : val);\n          stack.push(val);\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §7  Type conversions  (OpCode 70–74, 140–145)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.TO_NUMBER: {\n          const v = safePop(stack);\n          stack.push(numberValue(v.toNumber()));\n          break;\n        }\n        case OpCode.TO_HEX: {\n          const v = safePop(stack);\n          stack.push(hexValue(v.toNumber()));\n          break;\n        }\n        case OpCode.TO_PERCENTAGE: {\n          const v = safePop(stack);\n          stack.push(percentageValue(v.toNumber()));\n          break;\n        }\n        case OpCode.TO_FRACTION: {\n          const v = safePop(stack);\n          stack.push(stringValue(toFractionString(v.toNumber())));\n          break;\n        }\n        case OpCode.TO_MULTIPLIER: {\n          const v = safePop(stack);\n          stack.push(stringValue(toMultiplierString(v.toNumber())));\n          break;\n        }\n        case OpCode.TO_SCI: {\n          const v = safePop(stack);\n          stack.push(stringValue(toScientificString(v.toNumber())));\n          break;\n        }\n        // Numeric, like TO_HEX above. A base is a way of writing a number, so\n        // `(255 as binary) + 1` has to be 256; as a string it was 1.\n        case OpCode.TO_BINARY: {\n          const v = safePop(stack);\n          stack.push(hexValue(v.toNumber(), \"bin\"));\n          break;\n        }\n        case OpCode.TO_OCTAL: {\n          const v = safePop(stack);\n          stack.push(hexValue(v.toNumber(), \"oct\"));\n          break;\n        }\n        case OpCode.CALL_AS_CONVERTER: {\n          const name = (safePop(stack).value as string).toLowerCase();\n          const value = safePop(stack);\n          const converter = asConverterRegistry.get(name);\n          if (!converter) {\n            stack.push(errorValue(\"UNKNOWN_AS_CONVERTER\", `Unknown converter \"as ${name}\"`));\n          } else {\n            stack.push(converter(value));\n          }\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §8  UoM  (OpCode 80–84)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.UOM_CONVERT: {\n          const unit = (safePop(stack).value as string);\n          const val = safePop(stack).toNumber();\n          stack.push(uomValue(val, unit));\n          break;\n        }\n        case OpCode.UOM_CONVERT_TO: {\n          const toUnit = (safePop(stack).value as string);\n          const fromUnit = (safePop(stack).value as string);\n          const val = safePop(stack).toNumber();\n          const measure = getMeasure(fromUnit);\n          const isCurrency = sharedCurrencyExchange.isCurrency(fromUnit) && sharedCurrencyExchange.isCurrency(toUnit);\n          if (measure && getMeasure(toUnit) === measure) {\n            stack.push(uomValue(convertUnit(val, fromUnit, toUnit), toUnit));\n          } else if (isCurrency) {\n            const converted = sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);\n            if (converted !== null) {\n              stack.push(uomValue(converted, toUnit));\n            } else {\n              // No live rate cached yet (or the fetch failed). Pushing the\n              // unconverted value under its original unit would silently\n              // masquerade as a correct conversion, e.g. \"450 EUR to USD\"\n              // displaying as \"450.00 EUR\", which reads as a successful\n              // no-op rather than the missing-data case it actually is.\n              // An Error value makes the failure visible instead.\n              stack.push(errorValue(\"CURRENCY_RATE_UNAVAILABLE\", `No exchange rate available for ${fromUnit} to ${toUnit}`));\n            }\n          } else {\n            stack.push(uomValue(val, fromUnit));\n          }\n          break;\n        }\n        case OpCode.UOM_POSSIBILITIES: {\n          // \"sourceUnit to ?\", pops the source unit name string, pushes a\n          // human-readable list of every other unit in the same measure.\n          const unit = (safePop(stack).value as string);\n          const possibilities = getConvertiblePossibilities(unit);\n          stack.push(stringValue(possibilities.length > 0 ? possibilities.join(\", \") : `No known units for \"${unit}\"`));\n          break;\n        }\n        case OpCode.UOM_BEST: {\n          const unit = (safePop(stack).value as string);\n          const val = safePop(stack).toNumber();\n          const { value, unit: bestUnit } = getBestUnit(val, unit);\n          stack.push(uomValue(value, bestUnit));\n          break;\n        }\n        case OpCode.UOM_CONVERT_IN: {\n          const toUnit = (safePop(stack).value as string);\n          const left = safePop(stack);\n          if (left.type === ValueType.Uom) {\n            const fromUnit = left.unit!;\n            const val = left.toNumber();\n            const measure = getMeasure(fromUnit);\n            const isCurrency = sharedCurrencyExchange.isCurrency(fromUnit) && sharedCurrencyExchange.isCurrency(toUnit);\n            if (measure && getMeasure(toUnit) === measure) {\n              stack.push(uomValue(convertUnit(val, fromUnit, toUnit), toUnit));\n            } else if (isCurrency) {\n              const converted = sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);\n              if (converted !== null) {\n                stack.push(uomValue(converted, toUnit));\n              } else {\n                // See the matching comment in UOM_CONVERT_TO, pushing the\n                // original value here would silently pass off a missing\n                // exchange rate as a successful (non-)conversion.\n                stack.push(errorValue(\"CURRENCY_RATE_UNAVAILABLE\", `No exchange rate available for ${fromUnit} to ${toUnit}`));\n              }\n            } else {\n              stack.push(left);\n            }\n          } else {\n            stack.push(uomValue(left.toNumber(), toUnit));\n          }\n          break;\n        }\n        case OpCode.UOM_GET_VALUE: {\n          const v = safePop(stack);\n          stack.push(numberValue(v.toNumber()));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §8.5  Rate, \"quantity per unit of something\" (OpCode 110–112)\n        //       See vm/Value.ts's rateValue()/isRateUnit()/splitRateUnit().\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.RATE_DIV: {\n          // Construction: Uom ÷ Uom (different measures) -> Rate.\n          // \"90 km / 3 day\" -> \"30 km/day\": magnitude divides, units join.\n          const denominatorVal = safePop(stack);\n          const numeratorVal = safePop(stack);\n          if (denominatorVal.type !== ValueType.Uom || !denominatorVal.unit) {\n            stack.push(errorValue(\"RATE_MISSING_DENOMINATOR_UNIT\", \"Cannot build a rate: the right-hand side of \\\"/\\\" has no unit\"));\n            break;\n          }\n          const numeratorUnit = numeratorVal.type === ValueType.Uom ? (numeratorVal.unit ?? \"\") : \"\";\n          stack.push(rateValue(numeratorVal.toNumber() / denominatorVal.toNumber(), numeratorUnit, denominatorVal.unit));\n          break;\n        }\n        case OpCode.RATE_MUL: {\n          // Explicit form of the same rate-multiplication OpCode.MUL now\n          // applies automatically to any Uom×Uom pair where one side is\n          // rate-shaped. See multiplyRateByMatchingUom(). Kept as its own\n          // opcode for packages that want to emit it deliberately rather\n          // than relying on operand-type auto-detection.\n          const multiplier = safePop(stack);\n          const rate = safePop(stack);\n          if (rate.type !== ValueType.Uom || !isRateUnit(rate.unit)) {\n            stack.push(errorValue(\"RATE_MUL_LEFT_NOT_A_RATE\", \"Left-hand side of a rate multiplication must be a rate (e.g. \\\"$50/week\\\")\"));\n            break;\n          }\n          if (multiplier.type !== ValueType.Uom || !multiplier.unit) {\n            stack.push(errorValue(\"RATE_MUL_RIGHT_MISSING_UNIT\", \"Right-hand side of a rate multiplication must have a unit matching the rate's denominator\"));\n            break;\n          }\n          stack.push(multiplyRateByMatchingUom(rate, multiplier));\n          break;\n        }\n        case OpCode.RATE_CONVERT: {\n          // Rescale a rate's denominator to a new unit, preserving the\n          // real-world rate. \"30/week as /month\" -> \"~130/month\".\n          const newDenominatorUnit = (safePop(stack).value as string);\n          const rate = safePop(stack);\n          if (rate.type !== ValueType.Uom || !isRateUnit(rate.unit)) {\n            stack.push(errorValue(\"RATE_CONVERT_NOT_A_RATE\", \"Cannot convert a non-rate value's denominator\"));\n            break;\n          }\n          const { numerator, denominator } = splitRateUnit(rate.unit);\n          const rateMeasure = getMeasure(denominator);\n          const targetMeasure = getMeasure(newDenominatorUnit);\n          if (!rateMeasure || rateMeasure !== targetMeasure) {\n            stack.push(errorValue(\n              \"RATE_CONVERT_MEASURE_MISMATCH\",\n              `Cannot convert a \"${denominator}\"-denominated rate to \"${newDenominatorUnit}\" — different measures`\n            ));\n            break;\n          }\n          // How many `denominator` units are in one `newDenominatorUnit`\n          // (e.g. how many weeks in 1 month), the rate scales by that factor.\n          const factor = convertUnit(1, newDenominatorUnit, denominator);\n          stack.push(rateValue(rate.toNumber() * factor, numerator, newDenominatorUnit));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §8.7  Time, clock-time-of-day (OpCode 120)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.CLOCK_TIME_TODAY: {\n          // \"9:00am\"/\"16:00\", anchored to TODAY's calendar date, not a\n          // relative offset from `now` (so it stays correct regardless of\n          // what time it currently is, \"9:00am\" always means 9am today).\n          const totalMinutes = safePop(stack).toNumber();\n          const now = new Date();\n          const anchored = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);\n          anchored.setMinutes(totalMinutes);\n          stack.push(datetimeValue(anchored.getTime()));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §9  Datetime  (OpCode 90–93)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.DATE_NOW:\n          stack.push(datetimeValue(Date.now()));\n          break;\n        case OpCode.DATE_LITERAL:\n          stack.push(datetimeValue(numbers[opcodes[ip++]]));\n          break;\n        case OpCode.DATE_ADD: {\n          const durValue = safePop(stack), dtValue = safePop(stack);\n          stack.push(datetimeValue(dtValue.toNumber() + extractDurationMs(durValue)));\n          break;\n        }\n        case OpCode.DATE_SUB: {\n          const durValue = safePop(stack), dtValue = safePop(stack);\n          stack.push(datetimeValue(dtValue.toNumber() - extractDurationMs(durValue)));\n          break;\n        }\n        case OpCode.DATE_NEXT_WEEKDAY:\n        case OpCode.DATE_LAST_WEEKDAY: {\n          // Stack: [now, targetDayIndex], targetDayIndex on top (0=Sunday..6=Saturday).\n          // Computes the actual next/previous occurrence of that weekday,\n          // NOT a blind ±7-day offset, \"next Monday\" from a Monday lands\n          // 7 days ahead (next week's Monday), not today; \"last Monday\"\n          // from a Monday lands 7 days back, not today. Time-of-day is\n          // preserved from `now` (matches \"today\"/\"now\" both resolving to\n          // the current instant elsewhere in this file, not midnight).\n          const targetDay = safePop(stack).toNumber();\n          const nowValue = safePop(stack);\n          const now = nowValue.toNumber();\n          const currentDay = new Date(now).getDay();\n          let diffDays = op === OpCode.DATE_NEXT_WEEKDAY\n            ? (targetDay - currentDay + 7) % 7\n            : (currentDay - targetDay + 7) % 7;\n          if (diffDays === 0) diffDays = 7;\n          const offsetMs = diffDays * 24 * 60 * 60 * 1000;\n          stack.push(datetimeValue(op === OpCode.DATE_NEXT_WEEKDAY ? now + offsetMs : now - offsetMs));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §10 Matrix  (OpCode 152+, see parser/OpCode.ts's Matrix band)\n        //     Replaces the old ARR_* vector-only opcodes (100-107), which\n        //     were never emitted by any registered parselet in production\n        //     confirmed dead code, deleted outright rather than repurposed.\n        //     See vm/Value.ts's MatrixData and vm/MatrixOps.ts's shared\n        //     column-major storage helpers.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.MAT_NEW: {\n          const rows = opcodes[ip++];\n          const cols = opcodes[ip++];\n          const count = rows * cols;\n          // Cells were pushed in ROW-MAJOR reading order (matching how a\n          // literal like `[1,2;3,4]` is textually written), pop in\n          // reverse to restore that order, then transpose once into the\n          // column-major storage MatrixData actually uses.\n          const rowMajor = new Array<MatrixEntry>(count);\n          for (let i = count - 1; i >= 0; i--) {\n            const cellVal = safePop(stack);\n            rowMajor[i] = cellVal.type === ValueType.Boolean ? (cellVal.value as boolean)\n              : cellVal.type === ValueType.Symbolic ? (cellVal.value as SymbolicNodeType)\n              : cellVal.toNumber();\n          }\n          stack.push(matrixValue(rows, cols, rowMajorToColumnMajor(rows, cols, rowMajor)));\n          break;\n        }\n\n        case OpCode.MAT_INDEX1: {\n          const indexVal = safePop(stack), matrixVal = safePop(stack);\n          if (matrixVal.type === ValueType.Error) { stack.push(matrixVal); break; }\n          if (indexVal.type === ValueType.Error) { stack.push(indexVal); break; }\n          if (matrixVal.type !== ValueType.Matrix) {\n            stack.push(errorValue(\"MATRIX_INDEX_NOT_A_MATRIX\", `Cannot index a non-matrix value with \"[...]\".`));\n            break;\n          }\n          const m = matrixVal.value as MatrixData;\n          const index = Math.trunc(indexVal.toNumber());\n          if (index < 0 || index >= m.data.length) {\n            stack.push(errorValue(\n              \"MATRIX_INDEX_OUT_OF_BOUNDS\",\n              `Index ${index} is out of bounds for a ${m.rows}x${m.cols} matrix (valid range: 0-${m.data.length - 1}).`,\n            ));\n            break;\n          }\n          const cell = matIndex(m, index);\n          stack.push(matrixEntryToValue(cell));\n          break;\n        }\n\n        case OpCode.MAT_INDEX2: {\n          const colVal = safePop(stack), rowVal = safePop(stack), matrixVal = safePop(stack);\n          if (matrixVal.type === ValueType.Error) { stack.push(matrixVal); break; }\n          if (rowVal.type === ValueType.Error) { stack.push(rowVal); break; }\n          if (colVal.type === ValueType.Error) { stack.push(colVal); break; }\n          if (matrixVal.type !== ValueType.Matrix) {\n            stack.push(errorValue(\"MATRIX_INDEX_NOT_A_MATRIX\", `Cannot index a non-matrix value with \"[...]\".`));\n            break;\n          }\n          const m = matrixVal.value as MatrixData;\n          const row = Math.trunc(rowVal.toNumber());\n          const col = Math.trunc(colVal.toNumber());\n          if (!inBounds(m, row, col)) {\n            stack.push(errorValue(\n              \"MATRIX_INDEX_OUT_OF_BOUNDS\",\n              `[${row}, ${col}] is out of bounds for a ${m.rows}x${m.cols} matrix.`,\n            ));\n            break;\n          }\n          const cell = matAt(m, row, col);\n          stack.push(matrixEntryToValue(cell));\n          break;\n        }\n\n        case OpCode.RANGE_NEW: {\n          const maxVal = safePop(stack), minVal = safePop(stack);\n          if (minVal.type === ValueType.Error) { stack.push(minVal); break; }\n          if (maxVal.type === ValueType.Error) { stack.push(maxVal); break; }\n          if (minVal.type !== ValueType.Number || maxVal.type !== ValueType.Number) {\n            stack.push(errorValue(\"INVALID_RANGE_BOUND\", `A range's bounds must be plain numbers (e.g. \"0:3\").`));\n            break;\n          }\n          const min = minVal.value as number;\n          const max = maxVal.value as number;\n          if (!Number.isInteger(min) || !Number.isInteger(max)) {\n            stack.push(errorValue(\"NON_INTEGER_RANGE_BOUND\", `A range's bounds must be whole numbers, got \"${min}:${max}\".`));\n            break;\n          }\n          if (min > max) {\n            stack.push(errorValue(\n              \"DESCENDING_RANGE\",\n              `A range's min (${min}) cannot be greater than its max (${max}) — did you mean \"${max}:${min}\"?`,\n            ));\n            break;\n          }\n          stack.push(rangeValue(min, max));\n          break;\n        }\n\n        case OpCode.MAT_SLICE: {\n          const colRangeVal = safePop(stack), rowRangeVal = safePop(stack), matrixVal = safePop(stack);\n          if (matrixVal.type === ValueType.Error) { stack.push(matrixVal); break; }\n          if (rowRangeVal.type === ValueType.Error) { stack.push(rowRangeVal); break; }\n          if (colRangeVal.type === ValueType.Error) { stack.push(colRangeVal); break; }\n          if (matrixVal.type !== ValueType.Matrix) {\n            stack.push(errorValue(\"MATRIX_INDEX_NOT_A_MATRIX\", `Cannot slice a non-matrix value with \"[...]\".`));\n            break;\n          }\n          if (rowRangeVal.type !== ValueType.Range || colRangeVal.type !== ValueType.Range) {\n            stack.push(errorValue(\"INVALID_MATRIX_SLICE_BOUND\", `Matrix slicing needs range bounds (e.g. \"a[0:1, 1:2]\").`));\n            break;\n          }\n          const m = matrixVal.value as MatrixData;\n          const rowRange = rowRangeVal.value as RangeData;\n          const colRange = colRangeVal.value as RangeData;\n          if (rowRange.min < 0 || rowRange.max >= m.rows || colRange.min < 0 || colRange.max >= m.cols) {\n            stack.push(errorValue(\n              \"MATRIX_INDEX_OUT_OF_BOUNDS\",\n              `Slice [${rowRange.min}:${rowRange.max}, ${colRange.min}:${colRange.max}] is out of bounds for a ${m.rows}x${m.cols} matrix.`,\n            ));\n            break;\n          }\n          const newRows = rowRange.max - rowRange.min + 1;\n          const newCols = colRange.max - colRange.min + 1;\n          const data = new Array<MatrixEntry>(newRows * newCols);\n          for (let r = 0; r < newRows; r++) {\n            for (let c = 0; c < newCols; c++) {\n              data[r + c * newRows] = matAt(m, rowRange.min + r, colRange.min + c);\n            }\n          }\n          stack.push(matrixValue(newRows, newCols, data));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §11 map/reduce  (OpCode 157-158, see parser/OpCode.ts's Matrix\n        //     band). See packages/mapreduce/ for the parselets that decide\n        //     `kind` (0=inline anonymous body, 1=builtin function,\n        //     2=user-defined function) at parse time, and\n        //     `BytecodeBuilder.ts`'s AnonymousBodyDef doc comment for why\n        //     kind-0 bodies are a SEPARATE side-table from userFunctionBodies.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.MAP_INVOKE: {\n          const kind = opcodes[ip++];\n          const ref = opcodes[ip++];\n          const collectionCount = opcodes[ip++];\n\n          // Collections were pushed in declared param order, pop in\n          // reverse to restore that order (same convention as MAT_NEW's\n          // row-major restore).\n          const rawCollections: Value[] = new Array(collectionCount);\n          for (let i = collectionCount - 1; i >= 0; i--) rawCollections[i] = safePop(stack);\n\n          let paramNames: string[] = [];\n          let program: BytecodeProgram | undefined;\n          if (kind === 0) {\n            const def = anonymousBodies?.[ref];\n            if (!def) {\n              throw ErrorFactory.internal(\n                \"INTERNAL_MISSING_ANONYMOUS_BODY\",\n                `Internal error: MAP_INVOKE referenced missing anonymous body index ${ref}`,\n                { ref },\n              );\n            }\n            paramNames = def.params;\n            program = def.program;\n          } else if (kind === 2) {\n            const name = strings[ref];\n            const fn = vm.getUserFunction(name);\n            if (!fn) {\n              stack.push(errorValue(\"UNDEFINED_FUNCTION\", `map: undefined function \"${name}\"`));\n              break;\n            }\n            if (fn.params.length !== collectionCount) {\n              stack.push(errorValue(\n                \"FUNCTION_ARITY_MISMATCH\",\n                `map: \"${name}\" expects ${fn.params.length} argument(s) but ${collectionCount} collection(s) were given`,\n              ));\n              break;\n            }\n            paramNames = fn.params;\n            program = fn.program;\n          }\n\n          // Resolve every collection into a flat array of per-cell Values\n          // (a Matrix's own cells, or a materialized Range), all must\n          // agree on length (this is a ZIP, not a cartesian product).\n          let collectionLength = -1;\n          const cellArrays: Value[][] = new Array(collectionCount);\n          let mapEarlyError: Value | undefined;\n          for (let i = 0; i < collectionCount; i++) {\n            const resolved = collectionToValues(rawCollections[i]);\n            if (!Array.isArray(resolved)) { mapEarlyError = resolved; break; }\n            if (collectionLength === -1) {\n              collectionLength = resolved.length;\n            } else if (resolved.length !== collectionLength) {\n              mapEarlyError = errorValue(\n                \"MAP_COLLECTION_LENGTH_MISMATCH\",\n                `map: all collections must have the same length (got ${collectionLength} and ${resolved.length}).`,\n              );\n              break;\n            }\n            cellArrays[i] = resolved;\n          }\n          if (mapEarlyError) { stack.push(mapEarlyError); break; }\n\n          const resultData: MatrixEntry[] = new Array(collectionLength);\n          let mapError: Value | undefined;\n          for (let i = 0; i < collectionLength; i++) {\n            const args: Value[] = new Array(collectionCount);\n            for (let j = 0; j < collectionCount; j++) args[j] = cellArrays[j][i];\n\n            const resultVal = kind === 1\n              ? (builtinFunctions[ref]?.(args) ?? errorValue(\"UNKNOWN_BUILTIN_FUNCTION\", `map: unknown builtin function index ${ref}`))\n              : invokeFrameBody(paramNames, program!, args, vm, pipeline, expression, context, !!symbolicTolerant);\n\n            if (resultVal.type === ValueType.Error) { mapError = resultVal; break; }\n            resultData[i] = resultVal.type === ValueType.Boolean ? (resultVal.value as boolean)\n              : resultVal.type === ValueType.Symbolic ? (resultVal.value as SymbolicNodeType)\n              : resultVal.toNumber();\n          }\n          if (mapError) { stack.push(mapError); break; }\n\n          stack.push(matrixValue(1, collectionLength, resultData));\n          break;\n        }\n\n        case OpCode.REDUCE_INVOKE: {\n          const kind = opcodes[ip++];\n          const ref = opcodes[ip++];\n          const hasInitial = opcodes[ip++];\n\n          // Pushed in textual order (collection, then optional initial)\n          // pop in reverse.\n          const initialVal = hasInitial ? safePop(stack) : undefined;\n          const collectionVal = safePop(stack);\n\n          let paramNames: string[] = [];\n          let program: BytecodeProgram | undefined;\n          if (kind === 0) {\n            const def = anonymousBodies?.[ref];\n            if (!def) {\n              throw ErrorFactory.internal(\n                \"INTERNAL_MISSING_ANONYMOUS_BODY\",\n                `Internal error: REDUCE_INVOKE referenced missing anonymous body index ${ref}`,\n                { ref },\n              );\n            }\n            paramNames = def.params;\n            program = def.program;\n          } else if (kind === 2) {\n            const name = strings[ref];\n            const fn = vm.getUserFunction(name);\n            if (!fn) {\n              stack.push(errorValue(\"UNDEFINED_FUNCTION\", `reduce: undefined function \"${name}\"`));\n              break;\n            }\n            if (fn.params.length !== 2) {\n              stack.push(errorValue(\n                \"FUNCTION_ARITY_MISMATCH\",\n                `reduce: \"${name}\" must take exactly 2 arguments (accumulator, element), got ${fn.params.length}`,\n              ));\n              break;\n            }\n            paramNames = fn.params;\n            program = fn.program;\n          }\n\n          const cells = collectionToValues(collectionVal);\n          if (!Array.isArray(cells)) { stack.push(cells); break; }\n\n          let acc: Value;\n          let startIdx: number;\n          if (initialVal !== undefined) {\n            if (initialVal.type === ValueType.Error) { stack.push(initialVal); break; }\n            acc = initialVal;\n            startIdx = 0;\n          } else {\n            if (cells.length === 0) {\n              stack.push(errorValue(\"REDUCE_EMPTY_COLLECTION\", `reduce: cannot reduce an empty collection without an initial value.`));\n              break;\n            }\n            acc = cells[0];\n            startIdx = 1;\n          }\n\n          let reduceError: Value | undefined;\n          for (let i = startIdx; i < cells.length; i++) {\n            const args = [acc, cells[i]];\n            const resultVal = kind === 1\n              ? (builtinFunctions[ref]?.(args) ?? errorValue(\"UNKNOWN_BUILTIN_FUNCTION\", `reduce: unknown builtin function index ${ref}`))\n              : invokeFrameBody(paramNames, program!, args, vm, pipeline, expression, context, !!symbolicTolerant);\n\n            if (resultVal.type === ValueType.Error) { reduceError = resultVal; break; }\n            acc = resultVal;\n          }\n          if (reduceError) { stack.push(reduceError); break; }\n\n          stack.push(acc);\n          break;\n        }\n\n      }\n    }\n\n    // Fallback return (reached if while loop exits without HALT, shouldn't happen on valid bytecode)\n    const fallback = safePop(stack);\n    return { type: 'value', value: hasArena ? persistentValue(fallback) : fallback };\n    } catch (e) {\n        return { type: 'error', error: normalizeUnknownError(e) };\n    }\n}"]}

package/dist/chunk-C4XZV6E7.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parser/BytecodeBuilder.ts","../src/parser/BindingPower.ts"],"names":["ErrorFactory","TokenTypes","tokenTypeId"],"mappings":"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","file":"chunk-C4XZV6E7.cjs","sourcesContent":["import { OpCode } from \"@solve-js/parser/OpCode\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * `BytecodeProgram.opcodes` is a `Uint8Array`, every operand written into\n * it (including constant-pool indices from {@link BytecodeBuilder.emitNumber}/\n * {@link BytecodeBuilder.emitString}) is truncated to a single byte on\n * `build()`. Exceeding this silently wraps the index (e.g. entry 300 reads\n * back as entry 44), producing a wrong result with no error. See\n * {@link BytecodeBuilder.emitNumber} for the guard that turns this into a\n * thrown error instead.\n */\nconst MAX_CONSTANT_POOL_INDEX = 255;\n\n/**\n * Compiled bytecode program produced by {@link BytecodeBuilder}.\n * Ready for consumption by {@link executeBytecode} without further processing.\n */\nexport interface BytecodeProgram {\n\topcodes: Uint8Array;\n\tnumbers: Float64Array;\n\tstrings: string[];\n\tconstants?: Map<number, number>;\n\t/**\n\t * Whether the program contains any async opcodes (CALL_PLUGIN, etc.).\n\t * Set during compilation by the BytecodeBuilder. Allows the engine\n\t * to skip the O(n) resolver preflight check in O(1) for purely\n\t * synchronous expressions like `2 + 2`.\n\t */\n\thasAsync: boolean;\n\t/**\n\t * User-defined-function bodies compiled alongside this program (one\n\t * entry per `name(params) = body` definition on this line). See\n\t * {@link BytecodeBuilder.emitUserFunctionBody}. `OpCode.DEFINE_USER_FUNCTION`'s\n\t * operand is an index into this array, resolved at VM-execution time\n\t * (not parse time) so a diagnostic/lookahead parse that never actually\n\t * executes the definition line has no side effect on `vm.userFunctions`.\n\t */\n\tuserFunctionBodies?: UserFunctionDef[];\n\t/**\n\t * Anonymous function bodies compiled alongside this program, one entry\n\t * per `map`/`reduce` inline transform expression (e.g. the `10*x` in\n\t * `map(10*x, [0,1,500])`). See {@link BytecodeBuilder.emitAnonymousBody}.\n\t * Deliberately a SEPARATE side-table from `userFunctionBodies`, not\n\t * routed through `vm.userFunctions` at all: an inline body has no name\n\t * and must never leak into the persistent name-keyed registry the way\n\t * a real `f(x) = ...` definition does.\n\t */\n\tanonymousBodies?: AnonymousBodyDef[];\n}\n\n/**\n * An anonymous transform body for `map`/`reduce`'s inline-expression form\n * (e.g. `10*x` in `map(10*x, [0,1,500])`, or `acc+x` in `reduce(acc+x,\n * [1,2,3])`). Structurally identical to {@link UserFunctionDef} minus the\n * `name`. See `OpCode.MAP_INVOKE`/`REDUCE_INVOKE` and\n * `vm/VM.ts`'s handlers, which build a call frame from `params`/`args`\n * exactly like `CALL_USER_FUNCTION` does, just without ever registering\n * the body in `vm.userFunctions`.\n */\nexport interface AnonymousBodyDef {\n\tparams: string[];\n\tprogram: BytecodeProgram;\n}\n\n/**\n * A user-defined, parameterized, reusable function's compiled form\n * (`f(x) = 2*x + 1`). See `OpCode.DEFINE_USER_FUNCTION`/`CALL_USER_FUNCTION`\n * and `vm/VM.ts`'s `VM.defineUserFunction`/`getUserFunction`.\n *\n * `program` is the body compiled to its OWN independent `BytecodeProgram`,\n * not a fragment of the definition line's own bytecode. Parameter names\n * inside the body compile to ORDINARY `LOAD_VAR <name>` opcodes, no\n * parse-time rewriting, because parameter resolution happens dynamically\n * at the VM level: `CALL_USER_FUNCTION` pushes a name-keyed call frame\n * (`Map<string, Value>`) before re-executing `program`, and `VM.getVar()`\n * checks the innermost call frame before falling back to the flat\n * document-variable store. This is why a `UNIT`-collision parameter name\n * (e.g. `h` in `area(w, h) = w * h`, which lexes as the \"hour\" unit) needs\n * no special handling anywhere, it's just another `LOAD_VAR \"h\"`, resolved\n * the same way as any other name.\n */\nexport interface UserFunctionDef {\n\tname: string;\n\tparams: string[];\n\tprogram: BytecodeProgram;\n}\n\n/**\n * Direct-to-bytecode compiler for the Pratt parser.\n *\n * Accumulates opcodes, numeric constants, and string references during parsing,\n * then produces a {@link BytecodeProgram} for VM execution. Supports:\n * - Standard build via {@link build}\n * - Zero-copy build into pre-allocated buffers via {@link buildInto}\n * - In-place reset for reuse without reallocation\n */\nexport class BytecodeBuilder {\n\tprivate opcodes: number[] = [];\n\tprivate numbers: number[] = [];\n\tprivate strings: string[] = [];\n\tprivate stringIndex = new Map<string, number>();\n\tprivate _hasAsync = false;\n\tprivate userFunctionBodies: UserFunctionDef[] = [];\n\tprivate anonymousBodies: AnonymousBodyDef[] = [];\n\n\t/** Emit an {@link OpCode} instruction. */\n\temitOpcode(op: OpCode): void {\n\t\tthis.opcodes.push(op);\n\t\tif (op === OpCode.CALL_PLUGIN) {\n\t\t\tthis._hasAsync = true;\n\t\t}\n\t}\n\n\t/**\n\t * Emit a numeric literal: appends `n` to the program's constant pool and\n\t * writes its index into the opcode stream (read back by the VM as e.g.\n\t * `PUSH_NUMBER <idx>`).\n\t *\n\t * Numeric constants are NOT deduplicated (unlike {@link emitString})\n\t * every call appends a new entry, so an expression with more than\n\t * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences\n\t * throws rather than silently wrapping the index (see\n\t * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).\n\t *\n\t * @throws If the constant pool would exceed 256 entries.\n\t */\n\temitNumber(n: number): void {\n\t\tconst idx = this.numbers.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_NUMERIC_CONSTANTS\",\n\t\t\t\t`Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} numeric literals, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.numbers.push(n);\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/**\n\t * Emit a string literal: interns `s` into the program's string pool\n\t * (deduplicated via `stringIndex`) and writes its index into the opcode\n\t * stream. Subject to the same constant-pool bound as {@link emitNumber},\n\t * but since strings ARE deduplicated, only distinct string values count\n\t * against the limit.\n\t *\n\t * @throws If the string pool would exceed 256 distinct entries.\n\t */\n\temitString(s: string): void {\n\t\tlet idx = this.stringIndex.get(s);\n\t\tif (idx === undefined) {\n\t\t\tidx = this.strings.length;\n\t\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\t\"TOO_MANY_STRING_CONSTANTS\",\n\t\t\t\t\t`Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} distinct string literals, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t\t);\n\t\t\t}\n\t\t\tthis.strings.push(s);\n\t\t\tthis.stringIndex.set(s, idx);\n\t\t}\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/**\n\t * Emit a raw numeric operand (0-255) following an opcode, e.g. a\n\t * plugin-function index for `CALL_PLUGIN`, or an argument count. Unlike\n\t * {@link emitOpcode}, this does not go through the `OpCode` enum, so\n\t * package authors use this (not an unsafe cast to `OpCode`) to push\n\t * operands their own opcode handler expects to read positionally.\n\t */\n\temitIndex(idx: number): void {\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/** Emit a raw byte (0-255), used for fixed small operands like argument counts. */\n\temitByte(b: number): void {\n\t\tthis.opcodes.push(b);\n\t}\n\n\t/** Number of opcodes/operands emitted so far, used to compute jump targets before {@link patchJump}. */\n\tget currentLength(): number {\n\t\treturn this.opcodes.length;\n\t}\n\n\t/**\n\t * Register a compiled user-defined-function body, returning its index\n\t * into this program's `userFunctionBodies` side-table, the caller emits\n\t * that index as `DEFINE_USER_FUNCTION`'s operand via {@link emitIndex}.\n\t * Subject to the same {@link MAX_CONSTANT_POOL_INDEX} bound as\n\t * {@link emitNumber}/{@link emitString} (the index itself is a single\n\t * opcode-stream byte), in practice a single line defines at most a\n\t * handful of functions, so this limit is never realistically reached.\n\t *\n\t * @throws If more than 256 function bodies are registered on one program.\n\t */\n\temitUserFunctionBody(name: string, params: string[], program: BytecodeProgram): number {\n\t\tconst idx = this.userFunctionBodies.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_FUNCTION_DEFINITIONS\",\n\t\t\t\t`More than ${MAX_CONSTANT_POOL_INDEX + 1} function definitions on one line, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.userFunctionBodies.push({ name, params, program });\n\t\treturn idx;\n\t}\n\n\t/**\n\t * Register a compiled `map`/`reduce` anonymous transform body, returning\n\t * its index into this program's `anonymousBodies` side-table, the\n\t * caller emits that index as `MAP_INVOKE`/`REDUCE_INVOKE`'s operand via\n\t * {@link emitIndex}. Same {@link MAX_CONSTANT_POOL_INDEX} bound as\n\t * {@link emitUserFunctionBody}.\n\t *\n\t * @throws If more than 256 anonymous bodies are registered on one program.\n\t */\n\temitAnonymousBody(params: string[], program: BytecodeProgram): number {\n\t\tconst idx = this.anonymousBodies.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_ANONYMOUS_BODIES\",\n\t\t\t\t`More than ${MAX_CONSTANT_POOL_INDEX + 1} map/reduce transform expressions on one line, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.anonymousBodies.push({ params, program });\n\t\treturn idx;\n\t}\n\n\t/** Overwrite a previously-emitted placeholder operand at `position` with the real jump `target`, once known. */\n\tpatchJump(position: number, target: number): void {\n\t\tthis.opcodes[position] = target;\n\t}\n\n\t/**\n\t * Build the accumulated opcodes/numbers/strings into a BytecodeProgram.\n\t * Creates new TypedArrays, the builder can be reused after this call.\n\t */\n\tbuild(): BytecodeProgram {\n\t\treturn {\n\t\t\topcodes: new Uint8Array(this.opcodes),\n\t\t\tnumbers: new Float64Array(this.numbers),\n\t\t\t// Defensive copy: .length = 0 in reset() would clear a shared reference.\n\t\t\t// Strings are rare (only UoM/datetime parselets emit them), so the copy\n\t\t\t// cost is negligible.\n\t\t\tstrings: [...this.strings],\n\t\t\tconstants: new Map(),\n\t\t\thasAsync: this._hasAsync,\n\t\t\tuserFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : undefined,\n\t\t\tanonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : undefined,\n\t\t};\n\t}\n\n\t/**\n\t * Build directly into a pre-allocated buffer for zero-copy VM consumption.\n\t *\n\t * When `buf` is provided and large enough, writes into it and returns\n\t * subarray **views** (not copies), the returned TypedArrays share the\n\t * buffer's underlying ArrayBuffer. The caller MUST NOT mutate the buffer\n\t * until the returned BytecodeProgram is no longer needed.\n\t *\n\t * If the caller intends to cache the result, they must copy the TypedArrays\n\t * (e.g. `new Uint8Array(program.opcodes)`) before reusing the buffer pool.\n\t *\n\t * When `buf` is omitted or too small, allocates fresh TypedArrays.\n\t */\n\tbuildInto(buf?: { opcodes: Uint8Array; numbers: Float64Array }): BytecodeProgram {\n\t\tconst opLen = this.opcodes.length;\n\t\tconst numLen = this.numbers.length;\n\n\t\tconst reuseOpcodes = buf && buf.opcodes.length >= opLen;\n\t\tconst reuseNumbers = buf && buf.numbers.length >= numLen;\n\n\t\t// Subarray views that share the buffer's ArrayBuffer (zero-copy)\n\t\tconst opcodes = reuseOpcodes\n\t\t\t? new Uint8Array(buf!.opcodes.buffer, buf!.opcodes.byteOffset, opLen)\n\t\t\t: new Uint8Array(opLen);\n\t\tconst numbers = reuseNumbers\n\t\t\t? new Float64Array(buf!.numbers.buffer, buf!.numbers.byteOffset, numLen)\n\t\t\t: new Float64Array(numLen);\n\n\t\t// Write data into the views\n\t\tfor (let i = 0; i < opLen; i++) opcodes[i] = this.opcodes[i];\n\t\tfor (let i = 0; i < numLen; i++) numbers[i] = this.numbers[i];\n\n\t\treturn {\n\t\t\topcodes,\n\t\t\tnumbers,\n\t\t\tstrings: [...this.strings],\n\t\t\tconstants: new Map(),\n\t\t\thasAsync: this._hasAsync,\n\t\t\tuserFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : undefined,\n\t\t\tanonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : undefined,\n\t\t};\n\t}\n\n\treset(): void {\n\t\t// Retain backing stores with .length = 0 to avoid reallocation on growth.\n\t\t// = [] discards the ArrayBuffer, forcing V8 to reallocate on every push()\n\t\t// threshold (4→8→16→32...). For a 50-opcode expression, that's 3-4 copies.\n\t\tthis.opcodes.length = 0;\n\t\tthis.numbers.length = 0;\n\t\tthis.strings.length = 0;\n\t\tthis.stringIndex.clear();\n\t\tthis._hasAsync = false;\n\t\tthis.userFunctionBodies.length = 0;\n\t\tthis.anonymousBodies.length = 0;\n\t}\n}\n","/**\n * Named precedence levels for the Pratt parser, from loosest (`Lowest`) to\n * tightest (`Call`) binding. A custom infix parselet compares its own\n * binding power against the current expression's to decide whether to\n * consume the next operator (higher power binds tighter, e.g. `*` over `+`).\n *\n * Package authors reference these when registering an infix parselet via\n * `IPackageRegistry.registerInfixParselet`. See the built-in packages for\n * examples of picking an appropriate level (e.g. arithmetic `+`/`-` use\n * `Sum`, `*`/`/` use `Product`).\n */\nexport const BindingPower = {\n  Lowest: 0,\n  Assignment: 10,\n  LogicalOr: 12,   // `or`, `||` — loosest of the boolean-logic operators\n  LogicalAnd: 14,  // `&&` — binds tighter than `or` (\"a or b and c\" = \"a or (b and c)\")\n  Conditional: 20, // comparisons (`==`, `<`, `>=`, ...) — tighter than and/or, looser than arithmetic\n  Sum: 30,\n  BitwiseXor: 35,\n  Product: 40,\n  Exponent: 50,\n  Prefix: 60,\n  Postfix: 70,\n  Call: 80,\n} as const;\n\n/**\n * Set the binding power of a named operator.\n *\n * Binding power is what decides precedence in the Pratt parser: a higher number\n * binds tighter, so `*` outranks `+`. Changing one changes how every existing\n * expression using that operator parses, which is why packages should allocate\n * a new name rather than adjust a built-in.\n *\n * @param name - Operator name.\n * @param power - Higher binds tighter.\n */\nexport function setBindingPower(name: string, power: number): void {\n  (BindingPower as Record<string, number>)[name] = power;\n}\n\n/**\n * Read the binding power of a named operator.\n *\n * @param name - Operator name.\n * @returns Its binding power, or 0 when the name is unknown, which makes an\n * unregistered operator terminate an expression rather than swallow the rest\n * of it.\n */\nexport function getBindingPower(name: string): number {\n  return (BindingPower as Record<string, number>)[name] ?? 0;\n}\n\n// ── Built-in Infix Operator Binding Power Table ──────────────────────────────\n// Pre-computed Uint8Array lookup indexed by token typeId.\n// value > 0  → built-in infix operator with that binding power\n// value = 0  → not a built-in infix, fall through to Tier 2 parselet registry\n//\n// Built at module load via buildBindingPowerTable(). The table is sparse\n// most entries are 0 since only ~15 of 80+ token types are infix operators.\n//\n// Performance: Uint8Array[typeId] is a single typed array load, no Map.get()\n// no string hashing, no property chain. V8 eliminates bounds checks when typeId\n// is known to be within array length.\n\nimport { TokenTypes } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\n\n/**\n * Mapping of token type names → binding powers for built-in infix operators.\n * Only operators listed here get the Tier 1 fast path in PrecedenceParser.\n * All other infix tokens use the Tier 2 parselet registry fallback.\n */\nconst BUILTIN_INFIX_BP: Record<string, number> = {\n  // Arithmetic (infix, left-associative)\n  [TokenTypes.PLUS]:     BindingPower.Sum,\n  [TokenTypes.MINUS]:    BindingPower.Sum,\n  [TokenTypes.STAR]:     BindingPower.Product,\n  [TokenTypes.SLASH]:    BindingPower.Product,\n  [TokenTypes.MOD]:      BindingPower.Product,\n\n  // Arithmetic (infix, RIGHT-associative, PrecedenceParser handles this specially)\n  [TokenTypes.CARET]:    BindingPower.Exponent,\n\n  // Bitwise (infix, left-associative)\n  [TokenTypes.LSHIFT]:   BindingPower.BitwiseXor,\n  [TokenTypes.RSHIFT]:   BindingPower.BitwiseXor,\n  [TokenTypes.BIT_AND]:  BindingPower.BitwiseXor,\n  [TokenTypes.BIT_OR]:   BindingPower.BitwiseXor,\n  [TokenTypes.BIT_XOR]:  BindingPower.BitwiseXor,\n\n  // Postfix (no right operand, PrecedenceParser handles this specially)\n  [TokenTypes.PERCENT]:  BindingPower.Postfix,\n\n  // Percentage keyword (infix, left-associative: \"50% of 200\" → MUL)\n  [TokenTypes.OF]:       BindingPower.Product,\n};\n\n// Note: These token types are intentionally NOT in the BP_TABLE, they stay in\n// the Tier 2 parselet registry because they require complex handling:\n//   IN, TO    → UoM conversion parselets (peek at target unit token, complex logic)\n//   DOT       → Property access (chained OBJ_GET, needs left-token tracking)\n//   EQUALS    → Assignment (VariableParselet handles :var = expr pattern)\n//   EQUALITY, NEQ, GTE, LTE → Comparison ops (need dedicated VM opcodes, task 2.15a)\n//   COMMA     → Argument separator (function calls, array/object literals)\n\n/** Cached BP_TABLE, built once at module load, immutable thereafter. */\nlet _bpTable: Uint8Array | null = null;\n\n/**\n * Build the Uint8Array binding power table indexed by token typeId.\n * Idempotent, returns cached table on subsequent calls.\n *\n * Must be called after all token types are registered (via registerAllTokenTypes())\n * and after plugin providers have registered their token types.\n */\nexport function buildBindingPowerTable(): Uint8Array {\n  if (_bpTable) return _bpTable;\n\n  // Size to the largest registered typeId + 1\n  let maxId = 0;\n  for (const name of Object.keys(BUILTIN_INFIX_BP)) {\n    const id = tokenTypeId(name);\n    if (id > maxId) maxId = id;\n  }\n  // Also scan all TokenTypes to ensure table covers all registered IDs\n  for (const name of Object.values(TokenTypes)) {\n    const id = tokenTypeId(name);\n    if (id > maxId) maxId = id;\n  }\n\n  const table = new Uint8Array(maxId + 1);\n  for (const [name, bp] of Object.entries(BUILTIN_INFIX_BP)) {\n    const id = tokenTypeId(name);\n    table[id] = bp;\n  }\n\n  _bpTable = table;\n  return table;\n}\n\n/**\n * Invalidate the cached BP table, call when plugins register new token types\n * that should participate in the built-in fast path.\n */\nexport function invalidateBindingPowerTable(): void {\n  _bpTable = null;\n}\n"]}

package/dist/chunk-CLL7RUQV.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lexer/LexerState.ts","../src/lexer/Lexer.ts","../src/lexer/TokenClassRegistry.ts","../src/lexer/tokenRegistration.ts"],"names":["LexerState","ExpressionLexer","getTokenCategory","getLocale","knownUnits"],"mappings":";;;;;;;;AAMO,IAAK,UAAA,qBAAAA,WAAAA,KAAL;AACN,EAAAA,YAAA,MAAA,CAAA,GAAO,MAAA;AACP,EAAAA,YAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,YAAA,QAAA,CAAA,GAAS,QAAA;AAHE,EAAA,OAAAA,WAAAA;AAAA,CAAA,EAAA,UAAA,IAAA,EAAA;;;ACaL,IAAM,QAAN,MAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBjB,WAAA,CAAY,UAAA,GAAa,IAAA,EAAM,WAAA,EAA2B;AAf1D,IAAA,IAAA,CAAQ,YAAA,GAAA,MAAA;AAER,IAAA,IAAA,CAAQ,SAAA,GAAY,KAAA;AAIpB;AAAA;AAAA,IAAA,IAAA,CAAQ,SAAkB,EAAC;AAC3B,IAAA,IAAA,CAAQ,QAAA,GAAmB,CAAA;AAYzB,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAIC,iCAAA,CAAgB,UAAA,EAAY,WAAW,CAAA;AAAA,EACpE;AAAA,EAEA,KAAA,CAAM,OAAe,KAAA,EAA0B;AAC7C,IAAA,MAAM,QAAA,GAAW,KAAA,IAAA,MAAA;AACjB,IAAA,IAAA,CAAK,YAAA,GAAe,QAAA;AACpB,IAAA,IAAA,CAAK,SAAA,GAAY,KAAA;AACjB,IAAA,IAAA,CAAK,WAAA,GAAc,MAAA;AAKnB,IAAA,IAAI,QAAA,KAAA,MAAA,aAA8B;AAChC,MAAA,MAAM,cAAA,GAAiB,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,KAAK,CAAA;AAC9D,MAAA,IAAI,eAAe,IAAA,EAAM;AACvB,QAAA,IAAA,CAAK,SAAS,EAAC;AACf,QAAA,IAAA,CAAK,QAAA,GAAW,CAAA;AAChB,QAAA;AAAA,MACF;AAEA,MAAA,IAAA,CAAK,eAAA,CAAgB,MAAM,KAAK,CAAA;AAChC,MAAA,IAAA,CAAK,MAAA,GAAS,IAAA,CAAK,eAAA,CAAgB,WAAA,EAAY;AAC/C,MAAA,IAAA,CAAK,QAAA,GAAW,CAAA;AAAA,IAClB,CAAA,MAAO;AAEL,MAAA,IAAA,CAAK,eAAA,CAAgB,MAAM,KAAK,CAAA;AAChC,MAAA,IAAA,CAAK,MAAA,GAAS,IAAA,CAAK,eAAA,CAAgB,WAAA,EAAY;AAC/C,MAAA,IAAA,CAAK,QAAA,GAAW,CAAA;AAAA,IAClB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAa,QAAA,EAAsC;AACjD,IAAA,OAAO,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,QAAQ,CAAA;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,iBAAiB,QAAA,EAAkB;AACjC,IAAA,OAAO,IAAA,CAAK,eAAA,CAAgB,gBAAA,CAAiB,QAAQ,CAAA;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAA,GAAsC;AACpC,IAAA,OAAO,IAAA,CAAK,gBAAgB,WAAA,EAAY;AAAA,EAC1C;AAAA,EAEA,IAAA,GAA0B;AACxB,IAAA,IAAI,KAAK,SAAA,EAAW;AAClB,MAAA,IAAA,CAAK,SAAA,GAAY,KAAA;AACjB,MAAA,OAAO,IAAA,CAAK,WAAA;AAAA,IACd;AAEA,IAAA,IAAI,IAAA,CAAK,QAAA,GAAW,IAAA,CAAK,MAAA,CAAO,MAAA,EAAQ;AACtC,MAAA,OAAO,IAAA,CAAK,MAAA,CAAO,IAAA,CAAK,QAAA,EAAU,CAAA;AAAA,IACpC;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA,EAEA,IAAA,GAA0B;AACxB,IAAA,IAAI,IAAA,CAAK,SAAA,EAAW,OAAO,IAAA,CAAK,WAAA;AAChC,IAAA,IAAA,CAAK,WAAA,GAAc,KAAK,IAAA,EAAK;AAC7B,IAAA,IAAA,CAAK,SAAA,GAAY,IAAA;AACjB,IAAA,OAAO,IAAA,CAAK,WAAA;AAAA,EACd;AAAA,EAEA,CAAC,MAAA,CAAO,QAAQ,CAAA,GAAqB;AACnC,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,MAAA,CAAO,QAAQ,CAAA,EAAE;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,mBAAmB,MAAA,EAA+B;AAChD,IAAA,IAAA,CAAK,eAAA,CAAgB,mBAAmB,MAAM,CAAA;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,qBAAqB,MAAA,EAA+B;AAClD,IAAA,IAAA,CAAK,eAAA,CAAgB,qBAAqB,MAAM,CAAA;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,gBAAgB,KAAA,EAAqB;AACnC,IAAA,IAAA,CAAK,YAAA,GAAA,MAAA;AACL,IAAA,IAAA,CAAK,SAAA,GAAY,KAAA;AACjB,IAAA,IAAA,CAAK,WAAA,GAAc,MAAA;AACnB,IAAA,IAAA,CAAK,eAAA,CAAgB,MAAM,KAAK,CAAA;AAChC,IAAA,IAAA,CAAK,MAAA,GAAS,IAAA,CAAK,eAAA,CAAgB,WAAA,EAAY;AAC/C,IAAA,IAAA,CAAK,QAAA,GAAW,CAAA;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,aAAa,IAAA,EAAgC;AAC3C,IAAA,OAAO,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,IAAI,CAAA;AAAA,EAC/C;AAAA,EAEA,QAAA,GAAuB;AACrB,IAAA,OAAO,IAAA,CAAK,YAAA;AAAA,EACd;AAAA,EAEA,SAAS,KAAA,EAAyB;AAChC,IAAA,IAAA,CAAK,YAAA,GAAe,KAAA;AAAA,EACtB;AAAA,EAEA,mBAAmB,QAAA,EAAqI;AACtJ,IAAA,MAAM,cAAA,GAAiB,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,QAAQ,CAAA;AAKjE,IAAA,IAAI,cAAA,CAAe,IAAA,IAAQ,QAAA,CAAS,UAAA,CAAW,IAAI,CAAA,EAAG;AACpD,MAAA,OAAO,IAAA,CAAK,sBAAA,CAAuB,QAAA,CAAS,KAAA,CAAM,CAAC,CAAC,CAAA;AAAA,IACtD;AAEA,IAAA,IAAI,eAAe,IAAA,EAAM;AACvB,MAAA,OAAO,EAAC;AAAA,IACV;AAEA,IAAA,OAAO,IAAA,CAAK,uBAAuB,QAAQ,CAAA;AAAA,EAC7C;AAAA,EAEQ,uBAAuB,QAAA,EAAqI;AAClK,IAAA,IAAA,CAAK,gBAAgB,QAAQ,CAAA;AAC7B,IAAA,MAAM,SAA4H,EAAC;AACnI,IAAA,KAAA,MAAW,SAAS,IAAA,EAAM;AACxB,MAAA,IAAI,KAAA,CAAM,IAAA,KAAS,IAAA,IAAQ,KAAA,CAAM,SAAS,SAAA,EAAW;AACrD,MAAA,IAAI,KAAA,CAAM,IAAA,CAAK,UAAA,CAAW,KAAK,CAAA,EAAG;AAClC,MAAA,IAAI,KAAA,CAAM,IAAA,KAAS,oBAAA,IAAwB,KAAA,CAAM,SAAS,gBAAA,EAAkB;AAC5E,MAAA,MAAA,CAAO,IAAA,CAAK;AAAA,QACV,MAAM,KAAA,CAAM,IAAA;AAAA,QACZ,OAAO,KAAA,CAAM,KAAA;AAAA,QACb,QAAQ,KAAA,CAAM,MAAA;AAAA,QACd,KAAK,KAAA,CAAM,GAAA;AAAA,QACX,MAAA,EAAQ,MAAM,KAAA,CAAM,MAAA;AAAA,QACpB,QAAA,EAAUC,kCAAA,CAAiB,KAAA,CAAM,IAAI;AAAA,OACtC,CAAA;AAAA,IACH;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAcO,IAAM,WAAA,GAAc,IAAI,KAAA,CAAM,IAAA,EAAM,MAAS;;;ACxH7C,IAAM,qBAAN,MAAyB;AAAA,EAAzB,WAAA,GAAA;AACL,IAAA,IAAA,CAAQ,UAAwB,EAAC;AACjC,IAAA,IAAA,CAAQ,gBAAA,GAAkD,IAAA;AAC1D,IAAA,IAAA,CAAQ,eAAA,GAAiD,IAAA;AACzD,IAAA,IAAA,CAAQ,SAAA,GAAwC,IAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUhD,SAAS,UAAA,EAA8B;AACrC,IAAA,IAAA,CAAK,OAAA,CAAQ,KAAK,UAAU,CAAA;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAW,SAAA,EAAyB;AAClC,IAAA,IAAA,CAAK,UAAU,IAAA,CAAK,OAAA,CAAQ,OAAO,CAAA,CAAA,KAAK,CAAA,CAAE,cAAc,SAAS,CAAA;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAA,CAAU,YAAoC,SAAA,EAA0C;AACtF,IAAA,IAAA,CAAK,gBAAA,GAAmB,UAAA;AACxB,IAAA,IAAA,CAAK,kBAAkB,SAAA,IAAa,IAAA;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,SAAS,SAAA,EAAsC;AAC7C,IAAA,IAAA,CAAK,SAAA,GAAY,SAAA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,KAAA,GAAqB;AACnB,IAAA,MAAM,aAAA,uBAAoB,GAAA,EAAoB;AAG9C,IAAA,IAAI,KAAK,gBAAA,EAAkB;AACzB,MAAA,KAAA,MAAW,CAAC,SAAS,SAAS,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,gBAAgB,CAAA,EAAG;AACxE,QAAA,aAAA,CAAc,GAAA,CAAI,OAAA,CAAQ,WAAA,EAAY,EAAG,SAAS,CAAA;AAAA,MACpD;AAAA,IACF;AAGA,IAAA,MAAM,MAAA,GAAS,CAAC,GAAG,IAAA,CAAK,OAAO,CAAA,CAAE,IAAA,CAAK,CAAC,CAAA,EAAG,OAAO,CAAA,CAAE,QAAA,IAAY,CAAA,KAAM,CAAA,CAAE,YAAY,CAAA,CAAE,CAAA;AACrF,IAAA,KAAA,MAAW,MAAM,MAAA,EAAQ;AACvB,MAAA,KAAA,MAAW,OAAA,IAAW,MAAA,CAAO,IAAA,CAAK,EAAA,CAAG,QAAQ,CAAA,EAAG;AAC9C,QAAA,aAAA,CAAc,GAAA,CAAI,OAAA,CAAQ,WAAA,EAAY,EAAG,GAAG,SAAS,CAAA;AAAA,MACvD;AAAA,IACF;AAGA,IAAA,MAAM,UAAA,GAAa,KAAK,eAAA,EAAgB;AAGxC,IAAA,MAAM,gBAAA,GAAmB,KAAK,qBAAA,EAAsB;AAEpD,IAAA,OAAO;AAAA,MACL,aAAA;AAAA,MACA,UAAA;AAAA,MACA,gBAAA;AAAA,MACA,SAAA,EAAW,IAAA,CAAK,SAAA,oBAAa,IAAI,GAAA;AAAI,KACvC;AAAA,EACF;AAAA;AAAA,EAIQ,eAAA,GAAqC;AAC3C,IAAA,MAAM,IAAA,GAAmB,EAAE,QAAA,kBAAU,IAAI,KAAI,EAAE;AAG/C,IAAA,IAAI,KAAK,eAAA,EAAiB;AACxB,MAAA,KAAA,MAAW,CAAC,QAAQ,SAAS,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,eAAe,CAAA,EAAG;AACtE,QAAA,IAAA,CAAK,YAAA,CAAa,IAAA,EAAM,MAAA,CAAO,WAAA,IAAe,SAAS,CAAA;AAAA,MACzD;AAAA,IACF;AAGA,IAAA,KAAA,MAAW,EAAA,IAAM,KAAK,OAAA,EAAS;AAC7B,MAAA,IAAI,CAAC,GAAG,OAAA,EAAS;AACjB,MAAA,KAAA,MAAW,MAAA,IAAU,MAAA,CAAO,IAAA,CAAK,EAAA,CAAG,OAAO,CAAA,EAAG;AAC5C,QAAA,IAAA,CAAK,aAAa,IAAA,EAAM,MAAA,CAAO,WAAA,EAAY,EAAG,GAAG,SAAS,CAAA;AAAA,MAC5D;AAAA,IACF;AAEA,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,IAAA,GAAO,CAAA,GAAI,IAAA,GAAO,IAAA;AAAA,EACzC;AAAA,EAEQ,YAAA,CAAa,IAAA,EAAkB,MAAA,EAAgB,SAAA,EAAyB;AAC9E,IAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA;AAC9B,IAAA,IAAI,IAAA,GAAO,IAAA;AACX,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,CAAC,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA,EAAG;AAC5B,QAAA,IAAA,CAAK,QAAA,CAAS,IAAI,IAAA,EAAM,EAAE,0BAAU,IAAI,GAAA,IAAO,CAAA;AAAA,MACjD;AACA,MAAA,IAAA,GAAO,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA;AAAA,IAC/B;AAEA,IAAA,IAAI,CAAC,KAAK,IAAA,EAAM;AACd,MAAA,IAAA,CAAK,IAAA,GAAO,SAAA;AAAA,IACd;AAAA,EACF;AAAA,EAEQ,qBAAA,GAAqC;AAC3C,IAAA,MAAM,UAAA,uBAAiB,GAAA,EAAY;AAGnC,IAAA,IAAI,KAAK,eAAA,EAAiB;AACxB,MAAA,KAAA,MAAW,MAAA,IAAU,MAAA,CAAO,IAAA,CAAK,IAAA,CAAK,eAAe,CAAA,EAAG;AACtD,QAAA,MAAM,QAAQ,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,EAAE,WAAA,EAAY;AAC/C,QAAA,UAAA,CAAW,IAAI,KAAK,CAAA;AAAA,MACtB;AAAA,IACF;AAGA,IAAA,KAAA,MAAW,EAAA,IAAM,KAAK,OAAA,EAAS;AAC7B,MAAA,IAAI,CAAC,GAAG,OAAA,EAAS;AACjB,MAAA,KAAA,MAAW,MAAA,IAAU,MAAA,CAAO,IAAA,CAAK,EAAA,CAAG,OAAO,CAAA,EAAG;AAC5C,QAAA,MAAM,QAAQ,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,EAAE,WAAA,EAAY;AAC/C,QAAA,UAAA,CAAW,IAAI,KAAK,CAAA;AAAA,MACtB;AAAA,IACF;AAEA,IAAA,OAAO,UAAA;AAAA,EACT;AACF,CAAA;;;AClOA,IAAM,eAAA,GAA0C;AAAA,EAC9C,iBAAA,EAAmB,OAAA;AAAA,EACnB,UAAA,EAAY,OAAA;AAAA,EACZ,aAAA,EAAe,aAAA;AAAA,EACf,aAAA,EAAe,aAAA;AAAA,EACf,UAAA,EAAY,UAAA;AAAA,EACZ,aAAA,EAAe,aAAA;AAAA,EACf,WAAA,EAAa;AACf,CAAA;AAiBO,SAAS,gBAAA,CAAiB,aAAa,IAAA,EAAmB;AAC/D,EAAA,MAAM,MAAA,GAAkBC,4BAAU,UAAU,CAAA;AAC5C,EAAA,MAAM,QAAA,GAAW,IAAI,kBAAA,EAAmB;AAGxC,EAAA,QAAA,CAAS,SAAA,CAAU,MAAA,CAAO,UAAA,EAAY,eAAe,CAAA;AAGrD,EAAA,QAAA,CAAS,SAASC,4BAAU,CAAA;AAG5B,EAAA,OAAO,SAAS,KAAA,EAAM;AACxB","file":"chunk-CLL7RUQV.cjs","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  private collectHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    this.resetExpression(lineText);\n    const result: {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] = [];\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({\n        type: token.type,\n        value: token.value,\n        offset: token.offset,\n        col: token.col,\n        length: token.value.length,\n        category: getTokenCategory(token.type),\n      });\n    }\n    return result;\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  '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"]}