solve-engine 1.0.0-beta.7 → 1.0.0

package/dist/chunk-BAMZT3GL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/vm/DependencyGraph.ts","../src/vm/ScopeManager.ts","../src/vm/VM.ts"],"names":[],"mappings":"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","file":"chunk-BAMZT3GL.js","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 { CURRENCY_DISPLAY } from \"@solve-js/uom/CurrencyAliases\";\nimport { UNIT_TABLE } from \"@solve-js/uom/generated/UnitTable.generated\";\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/**\n * `$20/day + $300/week`, two rates over different periods.\n *\n * Adding them reported incompatible units, because USD/day and USD/week are\n * literally different unit strings. They are the same kind of thing measured\n * per different periods, though, so one converts into the other and the sum is\n * meaningful. The right operand's period wins, which is the one the reader\n * just wrote and so the one they are thinking in.\n *\n * @returns The converted left magnitude, or null when these are not two rates\n * sharing a numerator.\n */\nfunction unifyRatePeriods(l: Value, r: Value): number | null {\n    if (l.type !== ValueType.Uom || r.type !== ValueType.Uom) return null;\n    const leftUnit = l.unit;\n    const rightUnit = r.unit;\n    if (leftUnit === undefined || rightUnit === undefined) return null;\n\n    const leftSlash = leftUnit.indexOf(\"/\");\n    const rightSlash = rightUnit.indexOf(\"/\");\n    if (leftSlash < 0 || rightSlash < 0) return null;\n    // Same thing being measured, or there is nothing to reconcile.\n    if (leftUnit.slice(0, leftSlash) !== rightUnit.slice(0, rightSlash)) return null;\n\n    const leftPeriod = UNIT_TABLE[leftUnit.slice(leftSlash + 1).toLowerCase()] as readonly [number, number] | undefined;\n    const rightPeriod = UNIT_TABLE[rightUnit.slice(rightSlash + 1).toLowerCase()] as readonly [number, number] | undefined;\n    if (leftPeriod === undefined || rightPeriod === undefined) return null;\n    if (leftPeriod[0] !== rightPeriod[0]) return null;\n\n    // Per a longer period is a larger number: $20/day is $140/week.\n    return l.toNumber() * (rightPeriod[1] / leftPeriod[1]);\n}\n\n/**\n * `$30 × 4 days`, money multiplied by a count of something.\n *\n * The unit system refused this outright, because there is no such unit as a\n * dollar-day and combining the two is genuinely undefined in general. But it\n * is not undefined in the one case where exactly one side is money: the other\n * side is then a count, and the answer is that much money.\n *\n * Restricted to money on purpose. `3 kg × 4 days` really has no meaning worth\n * guessing at, and it still says so.\n *\n * @returns The product, or null when this is not the money case.\n */\nfunction moneyTimesQuantity(l: Value, r: Value): Value | null {\n    if (l.type !== ValueType.Uom || r.type !== ValueType.Uom) return null;\n    // Captured before the rate guard, which narrows the property away.\n    const leftUnit = l.unit;\n    const rightUnit = r.unit;\n    if (leftUnit === undefined || rightUnit === undefined) return null;\n    // Checked directly rather than through isRateUnit(), whose `unit is\n    // string` signature narrows both locals to never on the negative branch.\n    if (leftUnit.includes(\"/\") || rightUnit.includes(\"/\")) return null;\n\n    const leftIsMoney = CURRENCY_DISPLAY[leftUnit.toUpperCase()] !== undefined;\n    const rightIsMoney = CURRENCY_DISPLAY[rightUnit.toUpperCase()] !== undefined;\n    // Exactly one side. Money times money is not a thing either.\n    if (leftIsMoney === rightIsMoney) return null;\n\n    return uomValue(l.toNumber() * r.toNumber(), leftIsMoney ? leftUnit : rightUnit);\n}\n\n/**\n * `X + 10%` and `X - 10%`, where the percentage is relative to X.\n *\n * A percentage on its own means nothing; it is a proportion *of* something.\n * Which of the two readings applies depends on what it is being combined with,\n * so the decision is made here where both operands are known, the same way\n * Datetime and Rate are handled in these opcodes:\n *\n *   200 + 10%     220        a percentage of a quantity is relative to it\n *   $300 + 15%    $345.00    and that includes money and other units\n *   10% + 20%     30%        two percentages are just proportions, they add\n *   30% + 0.4     70%        as does a percentage and a bare fraction\n *   100% + 2      300%       which is why this is 300% and not 3\n *\n * Returns `null` when neither operand is a Percentage, leaving the caller's\n * existing paths untouched.\n *\n * @param sign - `1` for addition, `-1` for subtraction.\n */\nfunction combinePercentage(l: Value, r: Value, sign: 1 | -1): Value | null {\n    if (l.type === ValueType.Percentage) {\n        // A percentage on the left keeps the result a percentage, whatever is\n        // on the right, because the thing being described is still a\n        // proportion. Only Number/Percentage make sense here; anything else\n        // (a date, a matrix) falls through to the ordinary error path.\n        if (r.type !== ValueType.Percentage && r.type !== ValueType.Number) return null;\n        return percentageValue(l.toNumber() + sign * r.toNumber());\n    }\n    if (r.type !== ValueType.Percentage) return null;\n\n    // A percentage on the right of something concrete scales it. Uom covers\n    // money and every other unit, and the unit has to survive: \"$300 + 15%\"\n    // is $345.00, not a bare 345.\n    const factor = 1 + sign * r.toNumber();\n    if (l.type === ValueType.Number) return numberValue(l.toNumber() * factor);\n    // A Uom with no unit string is not something this can scale meaningfully,\n    // so it falls through to the ordinary path rather than inventing one.\n    if (l.type === ValueType.Uom && l.unit !== undefined) return uomValue(l.toNumber() * factor, l.unit);\n    return null;\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 * A value rendered as a multiple, \"4x\".\n *\n * What counts as the multiple depends on what is being converted, which is why\n * this takes the Value rather than a number:\n *\n * - A **percentage** is a change, so it grows: 50% more is 1.5x, and\n *   `20 to 40 as x` (a 100% change) is 2x.\n * - **Anything else** is already the ratio: `20/5 as multiplier` is 4x.\n *\n * It used to add 1 unconditionally, so `20/5 as multiplier` answered 5x.\n * Telling the two apart only became possible when `%` started producing a\n * Percentage-typed value instead of a bare fraction (see PercentParselet.ts).\n */\nfunction toMultiplierString(value: Value): string {\n    const n = value.toNumber();\n    const multiple = value.type === ValueType.Percentage ? 1 + n : n;\n    return `${Math.round(multiple * 1e6) / 1e6}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          const pctAdd = combinePercentage(l, r, 1);\n          const ratePeriodAdd = pctAdd === null ? unifyRatePeriods(l, r) : null;\n          if (pctAdd !== null) {\n            stack.push(pctAdd);\n          } else if (ratePeriodAdd !== null) {\n            // Two rates over different periods, reconciled onto the right\n            // operand's period before adding.\n            stack.push(uomValue(ratePeriodAdd + r.toNumber(), r.unit!));\n          } else 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\" is a synonym for arithmetic \"+\" (\"5 and 3\" = 8)\n            // and also the boolean conjunction (\"true and false\"). It has its\n            // own token type now (AND_CONJ, see Token.ts) rather than mapping\n            // onto PLUS, but it still compiles to this opcode, because which\n            // of the two meanings applies is a property of the operands rather\n            // than of the word. So the dispatch stays here, where the operand\n            // types are known, mirroring the Datetime/Rate special-casing\n            // already done in this opcode for the same reason.\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          const pctSub = combinePercentage(l, r, -1);\n          const ratePeriodSub = pctSub === null ? unifyRatePeriods(l, r) : null;\n          if (pctSub !== null) {\n            stack.push(pctSub);\n          } else if (ratePeriodSub !== null) {\n            stack.push(uomValue(ratePeriodSub - r.toNumber(), r.unit!));\n          } else 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 if (moneyTimesQuantity(l, r) !== null) {\n            // \"$30 × 4 days\" is $120: an amount of money multiplied by a\n            // count of something. Without this the unit system refused it\n            // outright (\"Cannot combine incompatible units: USD and days\"),\n            // because there is no such unit as a dollar-day.\n            stack.push(moneyTimesQuantity(l, r)!);\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)));\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-BVAR5J2F.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/vm/Value.ts"],"names":["ValueType","v"],"mappings":"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","file":"chunk-BVAR5J2F.js","sourcesContent":["import { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport type { SymbolicNode } from \"@solve-js/symbolic\";\n\n/**\n * A single matrix cell. `boolean` covers element-wise comparison results\n * (`[1,6;3,8] < [5,2;7,4]` produces a Matrix of booleans, not numbers). A\n * `SymbolicNode` cell is a free-variable algebraic entry, e.g. `s =\n * [sx,0,0;0,sy,0;0,0,1]` where `sx`/`sy` are never assigned, so those\n * cells store a real `SymbolicNode` (a bare `var` node initially) rather\n * than degrading to `0`. See `MatrixOps.ts`'s `entryToSymbolic()`/\n * `symbolicToEntry()` for the two-way conversion every symbolic-aware\n * matrix op (multiply, inverse, determinant) uses.\n */\nexport type MatrixEntry = number | boolean | SymbolicNode;\n\n/**\n * A general rows×cols matrix, a vector is just a 1×N (row) or N×1 (column)\n * matrix. `data` is COLUMN-MAJOR (`data[row + col*rows]`), matching the\n * spec's own `a[index]` column-major indexing semantics directly (no\n * translation needed for single-index reads). `hasSymbolic` lets every\n * numeric matrix op fast-path the all-numeric case with one boolean check,\n * mirroring `binaryOp()`'s existing Number+Number fast path, computed by\n * `matrixValue()` itself (true the moment any cell is a `SymbolicNode`\n * object rather than a plain number/boolean), not something callers set\n * by hand.\n */\nexport interface MatrixData {\n\treadonly rows: number;\n\treadonly cols: number;\n\treadonly data: readonly MatrixEntry[];\n\treadonly hasSymbolic: boolean;\n}\n\n/** A first-class integer range `min:max`, both bounds inclusive. */\nexport interface RangeData {\n\treadonly min: number;\n\treadonly max: number;\n}\n\n/**\n * Discriminated union tag for {@link Value} objects.\n *\n * Determines the runtime type of a Value and how its `value` field should\n * be interpreted. Used by the VM for type-aware dispatch in arithmetic,\n * comparison, and conversion operations.\n */\nexport enum ValueType {\n\t/** Plain 64-bit floating point number (IEEE 754 double) */\n\tNumber = 0,\n\tHex = 1,\n\tBigInt = 2,\n\tString = 3,\n\tDatetime = 4,\n\tPercentage = 5,\n\tUom = 6,\n\t/** General rows×cols matrix (a vector is a 1×N or N×1 matrix). Value is {@link MatrixData}. */\n\tMatrix = 7,\n\t/** A first-class integer range `min:max`, both inclusive. Value is {@link RangeData}. */\n\tRange = 8,\n\t/** A symbolic/algebraic expression tree (free-variable formula, not a concrete number). Value is a `SymbolicNode` (`@solve-js/symbolic`). */\n\tSymbolic = 9,\n\t/** Boolean true/false. Value is `boolean`. */\n\tBoolean = 10,\n\t/** Unit of measurement token (lexer only, not a runtime value). */\n\tUnit = 11,\n\t/** Async result pending resolution. Value stores the queryKey string. */\n\tPending = 12,\n\t/** Plugin-raised error propagated through the DAG. Value stores error code, unit stores message. */\n\tError = 13,\n}\n\n// ── ValueArena ────────────────────────────────────────────────────────────\n// Phase 5.3: Bump-allocator arena for zero-allocation Value reuse during scroll.\n// Instead of allocating new Value objects per instruction, we pre-allocate a\n// block and bump an index. A single arena.reset() per scroll frame recycles all\n// Values, no per-value release overhead, no GC pressure during 60fps scrolling.\n\n/**\n * Bump-allocator arena for zero-allocation Value reuse during scroll.\n *\n * Instead of allocating new Value objects per instruction, pre-allocates a\n * block and bumps an index. `arena.reset()` per scroll frame recycles all\n * Values, no per-value release overhead, no GC pressure during 60fps scrolling.\n *\n * Only active during Tier 2 scroll execution (ThreeTierEvaluator).\n */\nexport class ValueArena {\n\tprivate arena: Value[] = [];\n\tprivate index: number = 0;\n\n\t/** Pre-allocate initial block. 512 Values covers ~30-line viewport comfortably. */\n\tconstructor(initialSize: number = 512) {\n\t\tfor (let i = 0; i < initialSize; i++) {\n\t\t\tthis.arena.push(new Value(ValueType.Number, 0));\n\t\t}\n\t}\n\n\t/** Bump-allocate a recycled Value. Falls back to allocation only for overflow. */\n\tacquire(type: ValueType, value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode, unit?: string): Value {\n\t\tif (this.index < this.arena.length) {\n\t\t\tconst v = this.arena[this.index++];\n\t\t\tv.recycle(type, value, unit);\n\t\t\treturn v;\n\t\t}\n\t\t// Arena overflow, allocate fresh (rare, only for very complex expressions)\n\t\tconst v = new Value(type, value, unit);\n\t\tthis.arena.push(v);\n\t\tthis.index++;\n\t\treturn v;\n\t}\n\n\t/** Reset for next scroll frame. O(1), just resets the index. */\n\treset(): void {\n\t\tthis.index = 0;\n\t}\n\n\t/** Current arena utilization (for diagnostics). */\n\tget usage(): number { return this.index; }\n\tget capacity(): number { return this.arena.length; }\n}\n\n// Module-level arena toggle. Single-threaded JS, so global state is safe.\n// The arena is ONLY active during Tier 2 scroll execution, the ThreeTierEvaluator\n// enables it before evaluating visible lines and disables it after.\n//\n// The arena INSTANCE survives disable(): constructing a ValueArena allocates\n// its whole initial block (512 Values), so dropping it on every disable would\n// pay that allocation cost again on the next enable, more garbage than the\n// arena saves. Instead, an `_arenaActive` flag gates use of the long-lived\n// instance; enable() just resets the bump index.\nlet _arena: ValueArena | null = null;\nlet _arenaActive = false;\n\n/** Enable the Value arena for zero-allocation scroll execution. */\nexport function enableValueArena(size?: number): ValueArena {\n\tif (!_arena) _arena = new ValueArena(size);\n\t_arena.reset();\n\t_arenaActive = true;\n\treturn _arena;\n}\n\n/** Disable the arena (returns to normal GC-collected allocation). */\nexport function disableValueArena(): void {\n\t_arenaActive = false;\n}\n\n/** Check if arena is active (used by STORE_VAR / HALT to decide cloning). */\nexport function isArenaActive(): boolean {\n\treturn _arenaActive;\n}\n\n/**\n * Allocate a Value that persists beyond the current arena cycle.\n * Used for values stored in variables (STORE_VAR) and final expression results\n * (HALT return), these must survive arena.reset() in the next scroll frame.\n */\nexport function persistentValue(v: Value): Value {\n\treturn new Value(v.type, v.value, v.unit);\n}\n\n// ── Dev-mode immutability guard (Part II, L5, Value model hardening) ──\n//\n// Value is documented immutable by convention, not enforcement: the arena\n// mutates objects in place via recycle() (by design, for Tier-2 scroll\n// performance), so Value can never be unconditionally frozen. This guard\n// freezes a Value ONLY when it is safe to do so, i.e. NOT while the arena\n// is active, since an arena-active Value may still be recycled later in\n// the same scroll frame. It is a no-op outside development builds (matches\n// the existing `process.env.NODE_ENV === \"development\"` convention used by\n// the app-layer logger) so there is zero runtime cost in production.\nconst isDevelopmentBuild = process.env.NODE_ENV === \"development\";\n\n/**\n * Freeze a Value in development builds, catching accidental external\n * mutation of \"immutable\" results early. Safe to call unconditionally\n * it is a no-op in production and a no-op whenever the arena is active\n * (an arena-active Value may still be recycle()'d before this scroll\n * frame ends, and freezing it would make recycle() throw).\n *\n * Intended for values leaving a public evaluation boundary\n * (ExpressionEngine.evaluateLine* / evaluateExpression), not for values\n * still moving through internal VM/arena machinery.\n */\nexport function freezeIfDev<T extends Value>(value: T): T {\n\tif (isDevelopmentBuild && !isArenaActive()) {\n\t\t// toNumber() lazily memoizes _cachedNumber for bigint/string values\n\t\t// (Number/Hex are already eagerly cached by the constructor), warm\n\t\t// it now so a later toNumber() call on the frozen object doesn't\n\t\t// try to write to a frozen field.\n\t\tvalue.toNumber();\n\t\tObject.freeze(value);\n\t}\n\treturn value;\n}\n\n/**\n * Universal runtime value for the solve-js VM.\n *\n * Carries a {@link ValueType} discriminant, a polymorphic `value` payload,\n * and an optional `unit` string (for UoM values). Treated as immutable after\n * construction, the arena reuses objects internally via `recycle()`, but\n * external code should never mutate Value fields.\n *\n * A cached `_cachedNumber` avoids repeated `toNumber()` computation on\n * hot paths (ADD/SUB/MUL in the VM dispatch loop).\n */\nexport class Value {\n\t// Cached numeric representation, computed once on first toNumber() call.\n\t// Cleared on recycle() when the arena reuses this Value for a new value.\n\tprivate _cachedNumber: number | undefined;\n\n\t// Fields are NOT readonly, the arena reuses Value objects by calling\n\t// recycle() which overwrites all fields. External code should treat Values\n\t// as immutable after construction (arena handles mutation internally).\n\tpublic type: ValueType;\n\tpublic value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode;\n\tpublic unit?: string;\n\t/** Set by async resolvers when a fetch timed out, the result is a fallback (typically 0). */\n\tpublic timedOut?: boolean;\n\n\tconstructor(\n\t\ttype: ValueType,\n\t\tvalue: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode,\n\t\tunit?: string\n\t) {\n\t\tthis.type = type;\n\t\tthis.value = value;\n\t\tthis.unit = unit;\n\t\t// Eagerly cache for Number and Hex types (the most common case).\n\t\t// This avoids a method call + type-check on first toNumber().\n\t\tif (typeof value === 'number') {\n\t\t\tthis._cachedNumber = value;\n\t\t}\n\t}\n\n\t/**\n\t * Phase 5.3: Reset all fields for arena reuse.\n\t * Called by ValueArena.acquire(), zero allocation, just field assignment.\n\t */\n\trecycle(type: ValueType, value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode, unit?: string): void {\n\t\tthis.type = type;\n\t\tthis.value = value;\n\t\tthis.unit = unit;\n\t\t// Clear cache, value changed, cached number is stale.\n\t\t// Re-eager-cache for Number type (most common).\n\t\tthis._cachedNumber = typeof value === 'number' ? value : undefined;\n\t\t// Clear timeout flag, recycled Values shouldn't inherit stale metadata.\n\t\tthis.timedOut = undefined;\n\t}\n\n\tisNumber(): this is Value & { value: number } {\n\t\treturn this.type === ValueType.Number;\n\t}\n\n\tisHex(): this is Value & { value: number } {\n\t\treturn this.type === ValueType.Hex;\n\t}\n\n\tisBigInt(): this is Value & { value: bigint } {\n\t\treturn this.type === ValueType.BigInt;\n\t}\n\n\tisString(): this is Value & { value: string } {\n\t\treturn this.type === ValueType.String;\n\t}\n\n\tisMatrix(): this is Value & { value: MatrixData } {\n\t\treturn this.type === ValueType.Matrix;\n\t}\n\n\t/** A Matrix shaped like a vector, 1×N (row) or N×1 (column). */\n\tisVectorShape(): boolean {\n\t\tif (this.type !== ValueType.Matrix) return false;\n\t\tconst m = this.value as MatrixData;\n\t\treturn m.rows === 1 || m.cols === 1;\n\t}\n\n\tisRange(): this is Value & { value: RangeData } {\n\t\treturn this.type === ValueType.Range;\n\t}\n\n\tisSymbolic(): this is Value & { value: SymbolicNode } {\n\t\treturn this.type === ValueType.Symbolic;\n\t}\n\n\ttoNumber(): number {\n\t\t// Pending/Error have no numeric representation at all, 0 (established\n\t\t// convention). A genuinely multi-cell Matrix has no single numeric\n\t\t// representation either (real callers branch on `.isMatrix()` BEFORE\n\t\t// reaching this fallback. See e.g. VM.ts's MUL/comparison dispatch)\n\t\t// but a 1x1 Matrix, the shape `float(x)`'s legacy sugar produces, see\n\t\t// packages/vector/parselets/FloatParselet.ts, IS a scalar in every\n\t\t// meaningful sense, so it degrades to that single cell's numeric value\n\t\t// rather than 0 (this exact case used to work \"by accident\" pre-Matrix,\n\t\t// since `parseFloat([2].toString())` happened to yield `2`).\n\t\tif (this.type === ValueType.Pending) return 0;\n\t\tif (this.type === ValueType.Error) return 0;\n\t\tif (this.type === ValueType.Matrix) {\n\t\t\tconst m = this.value as MatrixData;\n\t\t\tif (m.rows === 1 && m.cols === 1 && typeof m.data[0] === \"number\") return m.data[0];\n\t\t\treturn 0;\n\t\t}\n\t\tif (this.type === ValueType.Range) return 0;\n\t\t// A symbolic expression has no single concrete numeric value by\n\t\t// definition (it's a free-variable formula), 0, matching the\n\t\t// Pending/Error/Range convention. Real callers branch on\n\t\t// `.isSymbolic()` BEFORE reaching this fallback (see\n\t\t// `VMConversion.ts`'s `binaryOp()`).\n\t\tif (this.type === ValueType.Symbolic) return 0;\n\n\t\tif (this._cachedNumber !== undefined) return this._cachedNumber;\n\n\t\tif (typeof this.value === 'bigint') {\n\t\t\tthis._cachedNumber = Number(this.value);\n\t\t\treturn this._cachedNumber;\n\t\t}\n\t\t// Prevent silent NaN propagation from non-numeric strings\n\t\tconst result = parseFloat(this.value as string);\n\t\tthis._cachedNumber = isNaN(result) ? 0 : result;\n\t\treturn this._cachedNumber;\n\t}\n\n\tisNaN(): boolean {\n\t\tif (this.type === ValueType.Pending) return false;\n\t\tif (this.type === ValueType.Error) return false;\n\t\tif (this.type === ValueType.Matrix) {\n\t\t\tconst m = this.value as MatrixData;\n\t\t\tif (m.rows === 1 && m.cols === 1 && typeof m.data[0] === \"number\") return isNaN(m.data[0]);\n\t\t\treturn false;\n\t\t}\n\t\tif (this.type === ValueType.Range) return false;\n\t\tif (this.type === ValueType.Symbolic) return false;\n\t\tif (typeof this.value === 'number') return isNaN(this.value);\n\t\tif (typeof this.value === 'bigint') return false;\n\t\treturn isNaN(parseFloat(this.value as string));\n\t}\n}\n\n/**\n * Create a Number-typed Value. Uses the arena when active for zero-allocation.\n * This is the most common factory, over 90% of all Value creations.\n */\nexport function numberValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Number, n);\n\treturn new Value(ValueType.Number, n);\n}\n\n/** Which base a {@link ValueType.Hex} value is displayed in. */\nexport type DisplayBase = \"hex\" | \"bin\" | \"oct\";\n\n/**\n * Create a Hex-typed Value: a **number** that displays in another base.\n *\n * The type is numeric on purpose, and that is the whole point of it. A base is\n * a way of writing a quantity, not a different kind of quantity, so `0xFF + 1`\n * has to be 256. Returning a string instead makes it 1, because a string reads\n * as zero in arithmetic, and nothing about that failure is visible at the point\n * of use.\n *\n * @param n - The number itself, in full precision.\n * @param base - How to display it, defaulting to hexadecimal. Carried in the\n * `unit` slot, which is free for this type.\n */\nexport function hexValue(n: number, base: DisplayBase = \"hex\"): Value {\n\tconst tag = base === \"hex\" ? undefined : base;\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Hex, n, tag);\n\treturn new Value(ValueType.Hex, n, tag);\n}\n\n/** Create a BigInt-typed Value (arbitrary-precision integer). */\nexport function bigIntValue(n: bigint): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.BigInt, n);\n\treturn new Value(ValueType.BigInt, n);\n}\n\n/** Create a String-typed Value. */\nexport function stringValue(s: string): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.String, s);\n\treturn new Value(ValueType.String, s);\n}\n\n/** Create a Unit-of-Measurement Value (typed number with unit annotation). */\nexport function uomValue(n: number, unit: string): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Uom, n, unit);\n\treturn new Value(ValueType.Uom, n, unit);\n}\n\n// ── Rate, \"quantity per unit of something\" (SoulverCore: `$99/week`\n// `3 hours/day`, `30 fps`). Represented as a `ValueType.Uom` (no new\n// ValueType, a rate IS a unit-of-measurement, just a compound one) whose\n// `unit` string is `\"<numerator>/<denominator>\"`. The numerator is an\n// opaque label (may be a real convertible unit like \"USD\"/\"km\", or a bare\n// tag like \"frames\" that the `convert` package doesn't know about, rate\n// arithmetic never needs to convert the numerator, only compare it for\n// equality when combining two rates). The denominator MUST be a unit\n// `convertUnit()`/`getMeasure()` (uom/UomConverter.ts) recognizes, since\n// that's the part rate arithmetic actually rescales. See `vm/VM.ts`'s\n// `RATE_CONVERT`/`RATE_MUL`/`RATE_DIV` opcodes for the operations built on\n// this representation.\n\n/** Create a Rate value: `magnitude` of `numeratorUnit` per one `denominatorUnit`. */\nexport function rateValue(magnitude: number, numeratorUnit: string, denominatorUnit: string): Value {\n\treturn uomValue(magnitude, `${numeratorUnit}/${denominatorUnit}`);\n}\n\n/** Whether `unit` is a compound rate unit (`\"X/Y\"`) rather than a plain unit. */\nexport function isRateUnit(unit: string | undefined): unit is string {\n\treturn typeof unit === \"string\" && unit.includes(\"/\");\n}\n\n/**\n * Split a rate unit string into its numerator/denominator halves.\n * @throws if `unit` isn't a rate unit, check with {@link isRateUnit} first.\n */\nexport function splitRateUnit(unit: string): { numerator: string; denominator: string } {\n\tconst idx = unit.indexOf(\"/\");\n\tif (idx < 0) {\n\t\tthrow ErrorFactory.internal(\n\t\t\t\"INVALID_RATE_UNIT\",\n\t\t\t`splitRateUnit: \"${unit}\" is not a rate unit (expected \"numerator/denominator\")`,\n\t\t\t{ unit },\n\t\t);\n\t}\n\treturn { numerator: unit.slice(0, idx), denominator: unit.slice(idx + 1) };\n}\n\n/** Join a numerator/denominator pair back into a rate unit string. */\nexport function joinRateUnit(numeratorUnit: string, denominatorUnit: string): string {\n\treturn `${numeratorUnit}/${denominatorUnit}`;\n}\n\n// ── Video timecode, \"HH:MM:SS:FF at a given fps\" (SoulverCore: video\n// editing timecode literals, e.g. `01:02:03:04 at 30fps`). Represented the\n// same way Rate is above: NOT a new ValueType, just a `ValueType.Uom` whose\n// `unit` string is `\"timecode@<fps>\"` and whose numeric `value` is the\n// TOTAL FRAME COUNT since 00:00:00:00 at that fps, e.g. \"00:00:01:00 at\n// 30fps\" is `Uom(30, \"timecode@30\")`.\n//\n// Storing the total frame count (rather than four separate H/M/S/F fields)\n// means ordinary integer addition/subtraction on the numeric value is\n// ALREADY correct carry/borrow-aware arithmetic with zero extra logic\n// e.g. \"frame 29 + 2 frames\" at 30fps is just `29 + 2 = 31`, and 31 total\n// frames at 30fps IS frame 1 of the next second, with no explicit carry\n// step required. Carry/borrow only needs to be reconstructed when\n// converting a total frame count back into HH:MM:SS:FF display notation\n// see `packages/time/timecode/TimecodeMath.ts`'s `framesToTimecodeString()`.\n// See `vm/VM.ts`'s ADD/SUB dispatch for the arithmetic built on this\n// representation (timecode + frames, + duration, + timecode, - timecode).\n\nconst TIMECODE_UNIT_PREFIX = \"timecode@\";\n\n/** Build a timecode Uom unit string embedding its frame rate, e.g. `timecodeUnit(30)` -> `\"timecode@30\"`. */\nexport function timecodeUnit(fps: number): string {\n\treturn `${TIMECODE_UNIT_PREFIX}${fps}`;\n}\n\n/** Whether `unit` is a compound video-timecode unit (`\"timecode@<fps>\"`). */\nexport function isTimecodeUnit(unit: string | undefined): unit is string {\n\treturn typeof unit === \"string\" && unit.startsWith(TIMECODE_UNIT_PREFIX);\n}\n\n/**\n * Extract the fps from a timecode unit string.\n * @throws if `unit` isn't a timecode unit, check with {@link isTimecodeUnit} first.\n */\nexport function timecodeFps(unit: string): number {\n\tif (!isTimecodeUnit(unit)) {\n\t\tthrow ErrorFactory.internal(\n\t\t\t\"INVALID_TIMECODE_UNIT\",\n\t\t\t`timecodeFps: \"${unit}\" is not a timecode unit (expected \"timecode@<fps>\")`,\n\t\t\t{ unit },\n\t\t);\n\t}\n\treturn parseFloat(unit.slice(TIMECODE_UNIT_PREFIX.length));\n}\n\n/**\n * Create a Matrix value from an explicit shape + column-major data array.\n * `data.length` must equal `rows*cols`, callers building a matrix from\n * row-major source syntax (e.g. the `[1,2;3,4]` literal) must transpose\n * into column-major order before calling this; see `MatrixOps.ts`'s\n * `rowMajorToColumnMajor()`.\n */\nexport function matrixValue(rows: number, cols: number, data: readonly MatrixEntry[]): Value {\n\t// A SymbolicNode cell is the only object-typed MatrixEntry variant\n\t// (number/boolean are primitives), a cheap, always-correct way to\n\t// derive hasSymbolic without asking every caller to track it by hand.\n\t// The `\"kind\" in cell` half is a tripwire, not redundancy. MatrixEntry is\n\t// `number | boolean | SymbolicNode`, so an object cell should always be a\n\t// node; requiring the discriminant means a Rational that escaped\n\t// MatrixOps.ts's symbolicToEntry() shows up as a wrong result rather than as\n\t// a matrix that silently believes it is symbolic.\n\tconst hasSymbolic = data.some(cell => typeof cell === \"object\" && cell !== null && \"kind\" in cell);\n\tconst m: MatrixData = { rows, cols, data, hasSymbolic };\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Matrix, m);\n\treturn new Value(ValueType.Matrix, m);\n}\n\n/** A 1×N row-vector Matrix, row-major and column-major storage are identical for a single row. */\nexport function rowVectorValue(data: readonly number[]): Value {\n\treturn matrixValue(1, data.length, data);\n}\n\n/** An N×1 column-vector Matrix, row-major and column-major storage are identical for a single column. */\nexport function colVectorValue(data: readonly number[]): Value {\n\treturn matrixValue(data.length, 1, data);\n}\n\n/** Create a Range value, a first-class integer range `min:max`, both bounds inclusive. */\nexport function rangeValue(min: number, max: number): Value {\n\tconst r: RangeData = { min, max };\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Range, r);\n\treturn new Value(ValueType.Range, r);\n}\n\n/** Create a Symbolic value, a free-variable algebraic expression tree (`symbolic/SymbolicNode.ts`'s `SymbolicNode`), not a concrete number. */\nexport function symbolicValue(node: SymbolicNode): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Symbolic, node);\n\treturn new Value(ValueType.Symbolic, node);\n}\n\n\n\n/** Create a Boolean-typed Value. */\nexport function boolValue(b: boolean): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Boolean, b);\n\treturn new Value(ValueType.Boolean, b);\n}\n\n/** Create a Datetime-typed Value (Unix timestamp in milliseconds). */\nexport function datetimeValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Datetime, n);\n\treturn new Value(ValueType.Datetime, n);\n}\n\n/** Create a Percentage-typed Value (stored as fraction, e.g. 0.5 for 50%). */\nexport function percentageValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Percentage, n);\n\treturn new Value(ValueType.Percentage, n);\n}\n\n/**\n * Create a Pending value, signals that an async result is not yet resolved.\n * The value field stores the queryKey string for deduplication and diagnostics.\n * Pending values should NEVER be stored in the arena (they persist across\n * scroll frames until resolution completes).\n */\nexport function pendingValue(queryKey: string): Value {\n\treturn new Value(ValueType.Pending, queryKey);\n}\n\n/**\n * Create an Error value, propagated through the DAG when a plugin raises an error.\n * The value field stores the EngineError code, unit stores the message.\n * Downstream consumers (lines that depend on errored data) bubble this up.\n * Should NEVER be stored in the arena.\n */\nexport function errorValue(code: string, message: string): Value {\n\treturn new Value(ValueType.Error, code, message);\n}\n"]}