solve-engine 1.2.0 → 2.1.0

package/dist/chunk-C2OMO3WN.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/vm/DependencyGraph.ts","../src/vm/ScopeManager.ts","../src/vm/BusinessDays.ts","../src/vm/VMBuiltinArity.ts","../src/vm/VM.ts"],"names":["ErrorFactory","defaultEngineContext","numberValue","getOpCodeName","ValueType","symbolicValue","varNode","UNIT_TABLE","CURRENCY_DISPLAY","uomValue","scaleMoneyByPercent","percentageValue","numberValueUncertain","sharedCurrencyExchange","scaleMoneyExact","getMeasure","convertUnit","addBusinessDays","MS_PER_DAY","isWorkdayUnit","timecodeFps","isTimecodeUnit","errorValue","describeConversionMismatch","toBigIntOperand","bigIntValue","splitRateUnit","isArenaActive","beginEvaluation","DiagnosticEventType","persistentValue","decimalFromLiteral","numberValueExact","decimalToNumber","hexValue","stringValue","boolValue","faultedOperand","uncertainOp","exactRationalOp","datetimeValue","binaryOp","checkAllocation","matrixMultiply","isRateUnit","unifyUom","rateValue","bigIntDivisionByZero","power","matrixPower","symbolicPow","uomValueExact","decimalNegate","symbolicNeg","numberValueRational","rationalNeg","compareRationalOperands","compareBigIntOperands","compareUom","matrixCompare","incomparableUnitsError","faultedIn","builtinFunctions","SYMBOLIC_NATIVE_BUILTINS","symbolicBuiltin","chargeFunctionCall","sharedGlobalVariableStore","colourValue","asConverterRegistry","moneyExactMagnitude","convertRate","getConvertiblePossibilities","getBestUnit","CoreErrorCodes","checkedArray","matrixValue","rowMajorToColumnMajor","matIndex","matrixEntryToValue","inBounds","matAt","rangeValue","collectionToValues","chargeAllocation","normalizeUnknownError","endEvaluation"],"mappings":"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","file":"chunk-C2OMO3WN.cjs","sourcesContent":["/** Serialized snapshot of the dependency graph for diagnostic rendering. */\nexport interface DagSnapshot {\n  consumers: Record<string, number[]>;\n  writes: Record<number, string[]>;\n  reads: Record<number, string[]>;\n  dataSourceDeps: Record<number, string[]>;\n  dataSourceConsumers: Record<string, number[]>;\n}\n\n/**\n * Dependency graph for variable and data-source tracking across document lines.\n *\n * Tracks which lines read/write which variables, and propagates changes through\n * the graph when a variable is modified. Supports:\n * - Variable dependency tracking (registerLine, getAffectedLines)\n * - Data-source dependency tracking (registerLineDataSourceDependency)\n * - Topological ordering of affected lines (getAffectedLinesInOrder)\n * - Efficient removal of deleted lines (removeLine)\n */\nexport class DependencyGraph {\n   private consumers: Map<string, Set<number>> = new Map();\n   private dependencies: Map<number, Set<string>> = new Map();\n   private writes: Map<number, Set<string>> = new Map();\n   private lineReads: Map<number, Set<string>> = new Map();\n\n   // Data source dependencies: line number -> Set of query keys\n   private dataSourceDependencies: Map<number, Set<string>> = new Map();\n   // Reverse map: query key -> Set of line numbers\n   private dataSourceConsumers: Map<string, Set<number>> = new Map();\n\n  /**\n   * Register a line's variable reads and writes in the dependency graph.\n   *\n   * If re-registering the same line (e.g., after editing), old consumer\n   * references are cleaned up first. Write-variables are removed from\n   * the consumer set so that redefinition breaks the old dependency chain.\n   *\n   * @param lineNumber - 1-based line number in the document\n   * @param reads - Variable names this line reads\n   * @param writes - Variable names this line writes (assigns to)\n   */\n   registerLine(lineNumber: number, reads: string[], writes: string[]): void {\n     // Clean up old consumer references if re-registering this line\n     const oldReads = this.lineReads.get(lineNumber);\n     if (oldReads) {\n       for (const oldRead of oldReads) {\n         const consumers = this.consumers.get(oldRead);\n         if (consumers) consumers.delete(lineNumber);\n       }\n     }\n\n     // Track what this line reads\n     this.lineReads.set(lineNumber, new Set(reads));\n\n     // Add new consumer references\n     for (const dep of reads) {\n       if (!this.consumers.has(dep)) this.consumers.set(dep, new Set());\n       this.consumers.get(dep)!.add(lineNumber);\n     }\n     if (writes.length > 0) {\n       this.dependencies.set(lineNumber, new Set(reads));\n       this.writes.set(lineNumber, new Set(writes));\n       for (const write of writes) {\n         const prevConsumer = this.consumers.get(write);\n         if (prevConsumer) prevConsumer.delete(lineNumber);\n       }\n     }\n   }\n\n  /**\n   * Register a line's dependency on an external data source (e.g., currency rate, OSRS GE price).\n   *\n   * When the data source updates, {@link getAffectedLinesByDataSource} returns all lines\n   * that depend on this data, enabling targeted re-evaluation.\n   *\n   * @param lineNumber - 1-based line number in the document\n   * @param dataSourceId - Unique identifier for the data source (e.g., \"currency\", \"osrs-ge\")\n   * @param queryKey - Query key array identifying the specific data (e.g., [\"USD\", \"EUR\"])\n   */\n  registerLineDataSourceDependency(lineNumber: number, dataSourceId: string, queryKey: string[]): void {\n    const queryKeyStr = JSON.stringify(queryKey);\n    const key = `${dataSourceId}:${queryKeyStr}`;\n    \n    if (!this.dataSourceDependencies.has(lineNumber)) {\n      this.dataSourceDependencies.set(lineNumber, new Set());\n    }\n    this.dataSourceDependencies.get(lineNumber)!.add(key);\n    \n    if (!this.dataSourceConsumers.has(key)) {\n      this.dataSourceConsumers.set(key, new Set());\n    }\n    this.dataSourceConsumers.get(key)!.add(lineNumber);\n  }\n\n  /**\n   * Find all lines affected by a changed variable via BFS through the consumer graph.\n   *\n   * When a variable is modified (e.g., `:x = 5` changes to `:x = 10`), this returns\n   * all lines that transitively depend on it, lines that read `x`, lines that read\n   * variables written by those lines, and so on.\n   *\n   * @param changedVariable - The variable name that changed\n   * @returns Set of line numbers that need re-evaluation\n   */\n  getAffectedLines(changedVariable: string): Set<number> {\n    const visited = new Set<number>();\n    const queue = [changedVariable];\n    while (queue.length > 0) {\n      const varName = queue.pop()!;\n      const consumers = this.consumers.get(varName);\n      if (!consumers) continue;\n      for (const line of consumers) {\n        if (visited.has(line)) continue;\n        visited.add(line);\n        const lineWrites = this.writes.get(line);\n        if (lineWrites) {\n          for (const writtenVar of lineWrites) {\n            queue.push(writtenVar);\n          }\n        }\n      }\n    }\n    return visited;\n  }\n\n  /**\n   * Phase 1.4 DAG-walk optimization: return affected lines in dependency-safe\n   * topological order. Uses Kahn's algorithm (BFS-based) to ensure every line\n   * is evaluated AFTER all lines it depends on have been processed.\n   *\n   * This is more correct than ascending line-number sort, which fails when\n   * variable definitions and their consumers are not in document order.\n   *\n   * @returns Line numbers in topological order (producers before consumers).\n   */\n  getAffectedLinesInOrder(startVariable: string): number[] {\n    const affected = this.getAffectedLines(startVariable);\n    if (affected.size === 0) return [];\n\n    // Build a local subgraph: for each affected line, compute in-degree\n    // (how many other affected lines produce variables it reads).\n    const inDegree = new Map<number, number>();\n    const adjacency = new Map<number, number[]>(); // line → downstream lines\n\n    for (const line of affected) {\n      if (!inDegree.has(line)) inDegree.set(line, 0);\n      if (!adjacency.has(line)) adjacency.set(line, []);\n    }\n\n    // Build a variable→producer map in one pass, then do O(1) lookups\n    // per read variable instead of O(n) scanning otherAffected lines.\n    const producerOf = new Map<string, number>();\n    for (const line of affected) {\n      const lineWrites = this.writes.get(line);\n      if (lineWrites) {\n        for (const w of lineWrites) producerOf.set(w, line);\n      }\n    }\n\n    // For each affected line, check if any reads are produced by another\n    // affected line. If so, add an edge from producer → consumer.\n    for (const line of affected) {\n      const reads = this.lineReads.get(line);\n      if (!reads) continue;\n\n      for (const readVar of reads) {\n        const producer = producerOf.get(readVar);\n        if (producer !== undefined && producer !== line) {\n          // producer writes readVar, which this line reads\n          // Edge: producer → line (producer → consumer)\n          adjacency.get(producer)!.push(line);\n          inDegree.set(line, (inDegree.get(line) ?? 0) + 1);\n        }\n      }\n    }\n\n    // Kahn's algorithm: start with zero-indegree lines (no dependencies within\n    // the affected set), then iteratively remove them, adding newly-freed lines.\n    const queue: number[] = [];\n    for (const [line, degree] of inDegree) {\n      if (degree === 0) queue.push(line);\n    }\n\n    // If every affected line has at least one dependency (cycle or external),\n    // start with the lowest line number as a fallback.\n    if (queue.length === 0 && affected.size > 0) {\n      const sorted = Array.from(affected).sort((a, b) => a - b);\n      queue.push(sorted[0]);\n    }\n\n    const ordered: number[] = [];\n    while (queue.length > 0) {\n      const current = queue.shift()!;\n      ordered.push(current);\n\n      for (const downstream of adjacency.get(current) ?? []) {\n        const newDegree = (inDegree.get(downstream) ?? 1) - 1;\n        inDegree.set(downstream, newDegree);\n        if (newDegree === 0) queue.push(downstream);\n      }\n    }\n\n    // Append any remaining lines that couldn't be topologically sorted\n    // (cycles or external-only dependencies) in ascending order.\n    if (ordered.length < affected.size) {\n      const orderedSet = new Set(ordered);\n      const remaining = Array.from(affected)\n        .filter((l) => !orderedSet.has(l))\n        .sort((a, b) => a - b);\n      ordered.push(...remaining);\n    }\n\n    return ordered;\n  }\n\n  /**\n   * Find all lines affected by a data source update.\n   *\n   * When an async data source resolves (e.g., currency rate fetch completes),\n   * this returns all lines that depend on that specific data query.\n   *\n   * @param dataSourceId - The data source identifier\n   * @param queryKey - The query key that was updated\n   * @returns Set of line numbers that need re-evaluation\n   */\n  getAffectedLinesByDataSource(dataSourceId: string, queryKey: string[]): Set<number> {\n    const queryKeyStr = JSON.stringify(queryKey);\n    const key = `${dataSourceId}:${queryKeyStr}`;\n    return this.dataSourceConsumers.get(key) ?? new Set();\n  }\n\n  /**\n   * Remove a line from the dependency graph (e.g., when a line is deleted from the document).\n   *\n   * Cleans up all consumer references, write registrations, and data source dependencies\n   * for the removed line. O(k) where k is the number of variables the line reads.\n   *\n   * @param lineNumber - The line number being removed\n   */\n  removeLine(lineNumber: number): void {\n     // Remove from consumers of variables this line read, O(k) not O(V)\n     const reads = this.lineReads.get(lineNumber);\n     if (reads) {\n       for (const readVar of reads) {\n         const consumers = this.consumers.get(readVar);\n         if (consumers) consumers.delete(lineNumber);\n       }\n       this.lineReads.delete(lineNumber);\n     }\n\n     this.dependencies.delete(lineNumber);\n     this.writes.delete(lineNumber);\n\n     // Remove from consumers of the data-source keys THIS line depends on\n     // O(k) via the line's own dependency set, not O(total unique keys in\n     // the document). Must read dataSourceDependencies before deleting it.\n     const dataSourceKeys = this.dataSourceDependencies.get(lineNumber);\n     if (dataSourceKeys) {\n       for (const key of dataSourceKeys) {\n         this.dataSourceConsumers.get(key)?.delete(lineNumber);\n       }\n       this.dataSourceDependencies.delete(lineNumber);\n     }\n   }\n\n  /**\n   * Get all line numbers that consume (read) a given variable.\n   *\n   * @param variable - The variable name\n   * @returns Set of line numbers that read this variable, or empty set if none\n   */\n  getConsumers(variable: string): Set<number> {\n    return this.consumers.get(variable) ?? new Set();\n  }\n\n  /**\n   * Get all variables that a line depends on (reads).\n   *\n   * @param lineNumber - The line number to query\n   * @returns Set of variable names this line reads, or empty set if none\n   */\n  getDependencies(lineNumber: number): Set<string> {\n    return this.dependencies.get(lineNumber) ?? new Set();\n  }\n\n  /**\n   * Get all variables that a line writes (assigns to).\n   *\n   * @param lineNumber - The line number to query\n   * @returns Set of variable names this line writes, or empty set if none\n   */\n  getWrites(lineNumber: number): Set<string> {\n    return this.writes.get(lineNumber) ?? new Set();\n  }\n\n  /**\n   * Get a serializable snapshot of the entire dependency graph for diagnostics.\n   *\n   * Returns plain objects (not Maps/Sets) so consumers don't need to reach\n   * into private fields. Used by playground diagnostic tabs for DAG visualization.\n   */\n  getSnapshot(): DagSnapshot {\n    const consumers: Record<string, number[]> = {};\n    for (const [variable, lines] of this.consumers) {\n      consumers[variable] = Array.from(lines);\n    }\n\n    const writes: Record<number, string[]> = {};\n    for (const [line, vars] of this.writes) {\n      writes[line] = Array.from(vars);\n    }\n\n    const reads: Record<number, string[]> = {};\n    for (const [line, vars] of this.lineReads) {\n      reads[line] = Array.from(vars);\n    }\n\n    const dataSourceDeps: Record<number, string[]> = {};\n    for (const [line, keys] of this.dataSourceDependencies) {\n      dataSourceDeps[line] = Array.from(keys);\n    }\n\n    const dataSourceConsumers: Record<string, number[]> = {};\n    for (const [key, lines] of this.dataSourceConsumers) {\n      dataSourceConsumers[key] = Array.from(lines);\n    }\n\n    return { consumers, writes, reads, dataSourceDeps, dataSourceConsumers };\n  }\n\n  /** Clear all dependency graph state. Called on document switch or engine reset. */\n  clear(): void {\n    this.consumers.clear();\n    this.dependencies.clear();\n    this.writes.clear();\n    this.lineReads.clear();\n    this.dataSourceDependencies.clear();\n    this.dataSourceConsumers.clear();\n  }\n}\n","import { Value } from \"@solve-js/vm/Value\";\n\n/**\n * Record of a compiled expression in the scope.\n * Tracks the expression text, compiled bytecode, last evaluation result,\n * and the variable reads/writes for dependency tracking.\n */\nexport interface ExpressionRecord {\n  lineNumber: number;\n  expression: string;\n  bytecode: { opcodes: Uint8Array; numbers: Float64Array; strings: string[] };\n  lastResult: Value;\n  readVariables: string[];\n  writeVariable: string | null;\n}\n\n/**\n * Scoped variable manager for expression evaluation.\n *\n * Tracks variable definitions across line numbers with write-on-read semantics.\n * When a value is read, the most recent definition at or before the reading line\n * is returned. Invalidation trims downstream definitions when a variable is redefined.\n */\nexport class ScopeManager {\n  private definitions: Map<string, { line: number; expr: ExpressionRecord }[]> = new Map();\n\n  /**\n   * Record a variable definition at `lineNumber`. A variable may have\n   * multiple definitions across different lines (e.g. redefined further\n   * down a document), each call adds one, keeping the internal stack\n   * sorted by line so {@link read} can binary-scan for \"most recent\n   * definition at or before\" a given line.\n   */\n  write(variable: string, lineNumber: number, expr: ExpressionRecord): void {\n    if (!this.definitions.has(variable)) {\n      this.definitions.set(variable, []);\n    }\n    const stack = this.definitions.get(variable)!;\n    stack.push({ line: lineNumber, expr });\n    stack.sort((a, b) => a.line - b.line);\n  }\n\n  /**\n   * Look up a variable's value as seen from `readLine`: returns the result\n   * of the closest definition at or before `readLine`, not simply the most\n   * recently-written one, so a read on line 5 of a variable redefined on\n   * lines 2 and 10 sees line 2's value, not line 10's. Returns `undefined`\n   * if the variable has no definition at or before `readLine`.\n   */\n  read(variable: string, readLine: number): Value | undefined {\n    const stack = this.definitions.get(variable);\n    if (!stack) return undefined;\n    for (let i = stack.length - 1; i >= 0; i--) {\n      if (stack[i].line <= readLine) return stack[i].expr.lastResult;\n    }\n    return undefined;\n  }\n\n  /**\n   * Drop every definition of `variable` that comes strictly after\n   * `definitionLine`. Call this when a line is re-evaluated with a new\n   * definition, so stale later-line definitions from a previous edit don't\n   * linger and get returned by {@link read}.\n   */\n  invalidateDownstream(variable: string, definitionLine: number): void {\n    const stack = this.definitions.get(variable);\n    if (!stack) return;\n    const idx = stack.findIndex(s => s.line === definitionLine);\n    if (idx === -1) return;\n    stack.splice(idx + 1);\n  }\n\n  /** Remove every tracked variable definition, used when an engine/document is reset. */\n  clear(): void {\n    this.definitions.clear();\n  }\n}\n","/**\n * Pure business-day arithmetic: the calendar walk behind workday offsets and\n * the working-day count.\n *\n * Weekends (Saturday and Sunday) are decidable from the date alone, so they\n * are always skipped. Public holidays are not decidable from the date, so they\n * arrive as an optional `isHoliday` predicate the host supplies (see\n * `vm/HolidayCalendar.ts` and `constants/Configuration.ts`'s `date.holidays`).\n * With no predicate the walk is weekends-only, which is the honest default:\n * the engine skips exactly the days it can prove are non-working, and nothing\n * more.\n *\n * These functions are deliberately free of engine types and of `Value`, so the\n * skipping logic can be unit-tested directly (see\n * `__tests__/vm/BusinessDays.spec.ts`) rather than only through a whole\n * expression. `vm/VM.ts` is the one caller that wires in the host predicate and\n * the configured offset limits, and turns a `null` (limit reached) into the\n * engine's structured error.\n *\n * Every walk steps the `Date` day field (`setDate`) rather than adding a fixed\n * number of milliseconds, matching `vm/VM.ts`'s `addCalendarDays()`: a day that\n * contains a daylight-saving transition is 23 or 25 hours long, and being an\n * hour out is enough to land on the day before or after the one asked for.\n */\n\n/** A host-supplied test for whether an instant falls on a public holiday. */\nexport type HolidayPredicate = (epochMs: number) => boolean;\n\n/** Milliseconds in a day with no daylight-saving transition. Used only to size\n *  a span into whole days, never to move a date, so the DST caveat above does\n *  not apply (the caller rounds, and the walk itself steps the day field). */\nconst MS_PER_DAY = 86_400_000;\n\n/** True for Saturday or Sunday, in the local time zone the rest of the engine's\n *  date arithmetic already works in. */\nexport function isWeekend(epochMs: number): boolean {\n\tconst day = new Date(epochMs).getDay(); // 0 = Sunday .. 6 = Saturday\n\treturn day === 0 || day === 6;\n}\n\n/**\n * True for a working day: a weekday that the host's calendar, if any, does not\n * mark as a holiday. With no calendar this is just \"not a weekend\".\n */\nexport function isBusinessDay(epochMs: number, isHoliday?: HolidayPredicate): boolean {\n\tif (isWeekend(epochMs)) return false;\n\treturn isHoliday ? !isHoliday(epochMs) : true;\n}\n\n/** Local midnight of the calendar date `epochMs` falls on, so a time-of-day\n *  cannot tip a count onto the wrong day. */\nfunction startOfLocalDay(epochMs: number): number {\n\tconst d = new Date(epochMs);\n\treturn new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();\n}\n\n/**\n * Advance (or, for negative `n`, retreat) `startMs` by `n` business days,\n * landing on a business day: `Friday + 1 working day` is the following Monday,\n * and if a Monday is a configured holiday it is the Tuesday.\n *\n * `maxCalendarSteps` caps the walk. A caller passes the number of calendar days\n * its configured offset limit allows, which also makes a pathological calendar\n * (one that marks every day a holiday, so no step ever counts) terminate rather\n * than loop forever. Returns `null` when the cap is reached, which the caller\n * reports as a limit error, distinct from a real landing date.\n */\nexport function addBusinessDays(\n\tstartMs: number,\n\tn: number,\n\tisHoliday: HolidayPredicate | undefined,\n\tmaxCalendarSteps: number,\n): number | null {\n\t// Truncated to whole business days, mirroring the milliseconds path: a\n\t// fractional count of working days names no calendar date of its own.\n\tlet remaining = Math.trunc(Math.abs(n));\n\tconst direction = n >= 0 ? 1 : -1;\n\tconst date = new Date(startMs);\n\tlet steps = 0;\n\twhile (remaining > 0) {\n\t\tdate.setDate(date.getDate() + direction);\n\t\tsteps++;\n\t\tif (steps > maxCalendarSteps) return null;\n\t\tif (isBusinessDay(date.getTime(), isHoliday)) remaining--;\n\t}\n\treturn date.getTime();\n}\n\n/**\n * Count the business days between two dates, INCLUSIVE of both endpoints and\n * independent of the order the two are written in (there is no direction to\n * \"between\" in English, so `A and B` counts the same as `B and A`).\n *\n * Counted on calendar-date granularity: the time of day on either endpoint is\n * dropped first, so `working days between 1 Jan and 31 Jan` is every working\n * day in that window, both ends included. Inclusive is the reading a deadline\n * question wants (\"how many working days do I have from today through Friday\").\n *\n * `maxCalendarSteps` bounds the span the same way {@link addBusinessDays} bounds\n * its walk; returns `null` when the two dates are further apart than that, which\n * the caller reports as a range error.\n */\nexport function countBusinessDaysBetween(\n\taMs: number,\n\tbMs: number,\n\tisHoliday: HolidayPredicate | undefined,\n\tmaxCalendarSteps: number,\n): number | null {\n\tconst startDay = startOfLocalDay(Math.min(aMs, bMs));\n\tconst endDay = startOfLocalDay(Math.max(aMs, bMs));\n\t// Rounded because a span crossing a daylight-saving change is a whole\n\t// number of days plus or minus an hour, and both endpoints are already\n\t// local midnights.\n\tconst spanDays = Math.round((endDay - startDay) / MS_PER_DAY);\n\tif (spanDays > maxCalendarSteps) return null;\n\tlet count = 0;\n\tconst date = new Date(startDay);\n\tfor (let i = 0; i <= spanDays; i++) {\n\t\tif (isBusinessDay(date.getTime(), isHoliday)) count++;\n\t\tdate.setDate(date.getDate() + 1);\n\t}\n\treturn count;\n}\n","import { ErrorFactory } from \"@solve-js/errors/EngineError\";\nimport type { EngineError } from \"@solve-js/errors/EngineError\";\n\n/**\n * How many arguments each builtin actually takes.\n *\n * Every implementation in `VMBuiltins.ts` indexes `args` positionally and none\n * of them checks the length first, so `sqrt()` reached `args[0].toNumber()`\n * with an empty array and threw a raw `TypeError`. That TypeError was caught by\n * `normalizeUnknownError()` and re-labelled `UNEXPECTED_ERROR` in category\n * INTERNAL, which told the host that a user's typo was an engine bug, in V8's\n * words, and named no function at all.\n *\n * The check belongs here rather than in each of the ~90 implementations because\n * the `CALL_BUILTIN` dispatch is the one place that knows both the index and\n * the argument count, and because a table can be read and audited against the\n * implementations in one sitting.\n *\n * `max` is `Infinity` for the genuinely variadic builtins (`min`, `max`,\n * `hypot`, the aggregates, `jacobian`). Everything else is strict in both\n * directions: an extra argument was silently discarded before, so `sqrt(1,2,3)`\n * answered 1 and the reader never learned that two thirds of what they typed\n * was thrown away.\n *\n * The name is the canonical one for the index. Several indices are reachable\n * under more than one spelling (`arcsin` and `asin` are both index 11, `fact`\n * and `factorial` are both 62) and several are reachable only through a phrase\n * parselet rather than by name at all, so this is the name the message uses\n * rather than whatever the reader typed, which the VM does not receive.\n */\ninterface BuiltinArity {\n  readonly name: string;\n  readonly min: number;\n  readonly max: number;\n}\n\n/** One entry per index in `builtinFunctions`. Kept in the same order as that table. */\nconst BUILTIN_ARITY: Record<number, BuiltinArity> = {\n  0:  { name: \"sqrt\",     min: 1, max: 1 },\n  1:  { name: \"abs\",      min: 1, max: 1 },\n  2:  { name: \"sin\",      min: 1, max: 1 },\n  3:  { name: \"cos\",      min: 1, max: 1 },\n  4:  { name: \"tan\",      min: 1, max: 1 },\n  5:  { name: \"log\",      min: 1, max: 1 },\n  6:  { name: \"ceil\",     min: 1, max: 1 },\n  7:  { name: \"floor\",    min: 1, max: 1 },\n  8:  { name: \"round\",    min: 1, max: 2 },\n  // min/max compare as many operands as they are given.\n  9:  { name: \"min\",      min: 1, max: Infinity },\n  10: { name: \"max\",      min: 1, max: Infinity },\n  11: { name: \"asin\",     min: 1, max: 1 },\n  12: { name: \"acos\",     min: 1, max: 1 },\n  13: { name: \"atan\",     min: 1, max: 1 },\n  14: { name: \"atan2\",    min: 2, max: 2 },\n  15: { name: \"sinh\",     min: 1, max: 1 },\n  16: { name: \"cosh\",     min: 1, max: 1 },\n  17: { name: \"tanh\",     min: 1, max: 1 },\n  18: { name: \"asinh\",    min: 1, max: 1 },\n  19: { name: \"acosh\",    min: 1, max: 1 },\n  20: { name: \"atanh\",    min: 1, max: 1 },\n  21: { name: \"cbrt\",     min: 1, max: 1 },\n  22: { name: \"clz32\",    min: 1, max: 1 },\n  23: { name: \"expm1\",    min: 1, max: 1 },\n  24: { name: \"exp\",      min: 1, max: 1 },\n  25: { name: \"fround\",   min: 1, max: 1 },\n  // hypot is the length of a vector with as many components as it is given.\n  26: { name: \"hypot\",    min: 1, max: Infinity },\n  27: { name: \"imul\",     min: 2, max: 2 },\n  28: { name: \"log10\",    min: 1, max: 1 },\n  29: { name: \"log1p\",    min: 1, max: 1 },\n  30: { name: \"log2\",     min: 1, max: 1 },\n  31: { name: \"pow\",      min: 2, max: 2 },\n  32: { name: \"random\",   min: 0, max: 0 },\n  33: { name: \"sign\",     min: 1, max: 1 },\n  34: { name: \"trunc\",    min: 1, max: 1 },\n  35: { name: \"degtorad\", min: 1, max: 1 },\n  36: { name: \"radtodeg\", min: 1, max: 1 },\n  37: { name: \"roll\",     min: 2, max: 2 },\n  38: { name: \"gcd\",      min: 2, max: 2 },\n  39: { name: \"lcm\",      min: 2, max: 2 },\n  40: { name: \"permutation\", min: 2, max: 2 },\n  41: { name: \"combination\", min: 2, max: 2 },\n  // The aggregates back \"average of X, Y, Z\" and friends, so they take a\n  // list. Their implementations already answer for an empty list rather\n  // than indexing into it, and the phrase parselets can emit an empty one,\n  // so the minimum stays 0 here instead of being tightened on the way past.\n  42: { name: \"average\",  min: 0, max: Infinity },\n  43: { name: \"median\",   min: 0, max: Infinity },\n  44: { name: \"total\",    min: 0, max: Infinity },\n  45: { name: \"count\",    min: 0, max: Infinity },\n  46: { name: \"proportion\", min: 3, max: 3 },\n  47: { name: \"clamp\",    min: 3, max: 3 },\n  48: { name: \"hex\",      min: 1, max: 1 },\n  49: { name: \"bin\",      min: 1, max: 1 },\n  50: { name: \"int\",      min: 1, max: 1 },\n  51: { name: \"compoundInterest\",     min: 3, max: 3 },\n  52: { name: \"interestEarned\",       min: 3, max: 3 },\n  53: { name: \"compoundInterestRate\", min: 3, max: 3 },\n  54: { name: \"compoundInterestYears\", min: 3, max: 3 },\n  55: { name: \"loanRepayment\",        min: 4, max: 4 },\n  56: { name: \"loanInterest\",         min: 4, max: 4 },\n  57: { name: \"monthlyPayment\",       min: 3, max: 3 },\n  58: { name: \"taxAdd\",     min: 2, max: 2 },\n  59: { name: \"taxRemove\",  min: 2, max: 2 },\n  60: { name: \"inflationAdjust\", min: 3, max: 3 },\n  61: { name: \"root\",       min: 2, max: 2 },\n  62: { name: \"fact\",       min: 1, max: 1 },\n  63: { name: \"transpose\",  min: 1, max: 1 },\n  64: { name: \"det\",        min: 1, max: 1 },\n  65: { name: \"inv\",        min: 1, max: 1 },\n  66: { name: \"dot\",        min: 2, max: 2 },\n  67: { name: \"expand\",     min: 1, max: 1 },\n  68: { name: \"factor\",     min: 1, max: 1 },\n  // solve pushes the two sides of the equation and then the unknown's name.\n  69: { name: \"solve\",      min: 3, max: 3 },\n  // der's order of differentiation is optional and defaults to 1.\n  70: { name: \"der\",        min: 2, max: 3 },\n  71: { name: \"integral\",   min: 2, max: 2 },\n  72: { name: \"taylor\",     min: 4, max: 4 },\n  // jacobian differentiates however many functions it is handed.\n  73: { name: \"jacobian\",   min: 1, max: Infinity },\n  74: { name: \"imaginary\",  min: 1, max: 1 },\n  75: { name: \"conj\",       min: 1, max: 1 },\n  76: { name: \"re\",         min: 1, max: 1 },\n  77: { name: \"im\",         min: 1, max: 1 },\n  78: { name: \"cancel\",     min: 1, max: 1 },\n  79: { name: \"apart\",      min: 1, max: 1 },\n  80: { name: \"compoundInterestEvery\",        min: 4, max: 4 },\n  81: { name: \"compoundInterestEarnedEvery\",  min: 4, max: 4 },\n  82: { name: \"presentValue\",      min: 3, max: 3 },\n  83: { name: \"roi\",               min: 2, max: 2 },\n  84: { name: \"annualisedReturn\",  min: 3, max: 3 },\n  85: { name: \"taxIn\",   min: 2, max: 2 },\n  86: { name: \"taxOn\",   min: 2, max: 2 },\n  87: { name: \"sind\",    min: 1, max: 1 },\n  88: { name: \"cosd\",    min: 1, max: 1 },\n  89: { name: \"tand\",    min: 1, max: 1 },\n  90: { name: \"asind\",   min: 1, max: 1 },\n  91: { name: \"acosd\",   min: 1, max: 1 },\n  92: { name: \"atand\",   min: 1, max: 1 },\n  93: { name: \"daysCount\",  min: 1, max: 1 },\n  94: { name: \"asTwoUnits\", min: 3, max: 3 },\n  95: { name: \"makeRate\",   min: 2, max: 2 },\n  96: { name: \"atRate\",     min: 2, max: 2 },\n  // Not reachable by name, only through `<value> to <n> dp`; see\n  // converters/parselets/RoundingParselets.ts.\n  97: { name: \"roundToPlaces\", min: 2, max: 2 },\n  98: { name: \"splitEach\", min: 2, max: 2 },\n  99: { name: \"savingsGoalPayment\", min: 3, max: 3 },\n  100: { name: \"savingsGoalPeriods\", min: 5, max: 5 },\n};\n\n/** \"1 argument\" / \"2 arguments\", so the message reads as English either way. */\nfunction plural(count: number): string {\n  return count === 1 ? \"1 argument\" : `${count} arguments`;\n}\n\n/** How the expected count reads: exact, \"at least\", or a range. */\nfunction expectation(arity: BuiltinArity): string {\n  if (arity.max === Infinity) return `at least ${plural(arity.min)}`;\n  if (arity.min === arity.max) return plural(arity.min);\n  return `${arity.min} to ${plural(arity.max)}`;\n}\n\n/**\n * Checks a builtin call's argument count before the implementation runs.\n *\n * @param index - The builtin index, the first operand of `OpCode.CALL_BUILTIN`.\n * @param argCount - The number of arguments the bytecode says were pushed.\n * @returns An `EngineError` to throw when the count is wrong, or `undefined`\n * when the call is well formed. Returned rather than thrown so the caller keeps\n * the throw at its own site, where the VM's own containment can see it.\n *\n * An index with no entry passes, which keeps a package that registers its own\n * builtin index working rather than making this table a gate on extensibility.\n */\nexport function builtinArityError(index: number, argCount: number): EngineError | undefined {\n  const arity = BUILTIN_ARITY[index];\n  if (arity === undefined) return undefined;\n  if (argCount >= arity.min && argCount <= arity.max) return undefined;\n\n  return ErrorFactory.execution(\n    \"BUILTIN_ARITY_MISMATCH\",\n    `${arity.name}() takes ${expectation(arity)}, but was given ${argCount === 0 ? \"none\" : plural(argCount)}`,\n    { functionName: arity.name, expectedMin: arity.min, expectedMax: arity.max, actual: argCount },\n  );\n}\n","import { OpCode } from \"@solve-js/parser/OpCode\";\nimport { Value, ValueType, numberValue, numberValueExact, numberValueRational, numberValueUncertain, stringValue, bigIntValue, hexValue, uomValue, uomValueExact, matrixValue, boolValue, datetimeValue, percentageValue, persistentValue, isArenaActive, errorValue, rateValue, isRateUnit, splitRateUnit, isTimecodeUnit, timecodeFps, rangeValue, symbolicValue, colourValue, faultedOperand, faultedIn, type MatrixEntry, type MatrixData, type RangeData, type ColourData } from \"@solve-js/vm/Value\";\nimport { decimalFromLiteral, decimalNegate, decimalToNumber } from \"@solve-js/decimal\";\nimport { moneyExactMagnitude, scaleMoneyByPercent, scaleMoneyExact } from \"@solve-js/vm/MoneyExact\";\nimport { varNode as varSymbolicNode, type SymbolicNode as SymbolicNodeType, type Rational, rationalNeg } from \"@solve-js/symbolic\";\nimport { symbolicPow, symbolicNeg, symbolicBuiltin, SYMBOLIC_NATIVE_BUILTINS } from \"@solve-js/vm/SymbolicOps\";\nimport { rowMajorToColumnMajor, matrixMultiply, matrixPower, matrixCompare, matIndex, matAt, inBounds, collectionToValues, matrixEntryToValue } from \"@solve-js/vm/MatrixOps\";\nimport type { VM, OpRegistry, EquationDef, ScalarEquationDef } from \"@solve-js/vm/OpRegistry\";\nimport { convertUnit, convertRate, 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 { CoreErrorCodes } from \"@solve-js/errors/ErrorCode\";\nimport { addBusinessDays as walkBusinessDays, countBusinessDaysBetween } from \"@solve-js/vm/BusinessDays\";\nimport { DiagnosticPipeline, DiagnosticEventType } from \"@solve-js/diagnostics\";\nimport { builtinFunctions, asConverterRegistry } from \"@solve-js/vm/VMBuiltins\";\nimport { builtinArityError } from \"@solve-js/vm/VMBuiltinArity\";\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, compareUom, incomparableUnitsError, describeConversionMismatch, toBigIntOperand, compareBigIntOperands, bigIntDivisionByZero, power, exactRationalOp, compareRationalOperands, uncertainOp } 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 { beginEvaluation, chargeAllocation, chargeFunctionCall, checkAllocation, checkedArray, endEvaluation } from \"@solve-js/vm/AllocationBudget\";\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 * @param maxCollectionSize - Maximum elements a Range or Matrix may be\n *   expanded to by `map`/`reduce` (default 100000). Neither of the two\n *   counters above can see that expansion, since it happens inside one\n *   opcode and never touches the value stack.\n * @param maxAllocatedElements - Maximum elements one evaluation may\n *   materialise in TOTAL (default 2000000). The parameter above bounds one\n *   collection; per-site bounds do not compose, and an operation whose result\n *   is the product of two legal operands (a matrix multiply) is bounded by\n *   neither. See `vm/AllocationBudget.ts`.\n * @param maxFunctionCalls - Maximum user-defined-function calls one\n *   evaluation may make in total (default 10000). `maxFunctionRecursionDepth`\n *   above bounds how deep they nest and cannot see how many there are: a\n *   doubling chain reaches two million calls at a depth of twenty-two.\n * @param maxDateOffsetYears - How far forward `<date> + N workdays` may\n *   reach, in years (default 100). The one date offset that walks rather than\n *   computing, so the one that needs a ceiling. See `addBusinessDays()`.\n * @param minDateOffsetYears - The same bound backwards, negative (default\n *   -100).\n * @param context - Registries belonging to the engine that created this VM.\n */\nexport function createVM(\n    registry: OpRegistry,\n    maxStackDepth = 200,\n    maxInstructions = 50000,\n    maxFunctionRecursionDepth = 50,\n    maxCollectionSize = 100000,\n    maxAllocatedElements = 2000000,\n    maxFunctionCalls = 10000,\n    maxDateOffsetYears = 100,\n    minDateOffsetYears = -100,\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    // The host's resolved holiday predicate for working-day arithmetic, or\n    // undefined for weekends-only. Last, and optional, so every existing\n    // createVM() call site keeps the honest default without changing. An\n    // ExpressionEngine passes what `resolveHolidayPredicate(date.holidays)`\n    // returns. See constants/Configuration.ts's `date.holidays`.\n    holidayPredicate?: (epochMs: number) => boolean,\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      getMaxCollectionSize() { return maxCollectionSize; },\n      getMaxAllocatedElements() { return maxAllocatedElements; },\n      getMaxFunctionCalls() { return maxFunctionCalls; },\n      getMaxDateOffsetYears() { return maxDateOffsetYears; },\n      getMinDateOffsetYears() { return minDateOffsetYears; },\n      // False whenever no calendar was configured, which is what makes\n      // unconfigured working-day arithmetic weekends-only. See\n      // vm/BusinessDays.ts, the only reader.\n      isHoliday(epochMs: number) { return holidayPredicate ? holidayPredicate(epochMs) : false; },\n      pop() {\n        if (stack.length === 0) {\n          return numberValue(0);\n        }\n        return stack.pop()!;\n      },\n      /**\n       * Popped through `safePop()` for the same reason as `popString()` below.\n       * Only the underflow half applies here: `toNumber()` is a real method on\n       * every Value, so there was no cast to make a non-number look like one,\n       * and the `!` was the whole bug.\n       */\n      popNumber() { return safePop(stack).toNumber(); },\n      /**\n       * Popped through the same two guards the dispatch loop below uses, and\n       * for the same reason: a package's opcode handler can disagree with its\n       * own bytecode exactly as this engine's compiler can disagree with\n       * hand-assembled input.\n       *\n       * This was `stack.pop()!.value as string`, which had neither guard. The\n       * `!` is compile-time only, so an empty stack reached `.value` and threw\n       * a raw TypeError; so is the cast, so any Value the stack happened to be\n       * holding was handed back as a \"string\" and threw in the handler's own\n       * code some lines later. Nothing in this repo calls this method, which is\n       * the only reason the fuzz corpus never found either.\n       */\n      popString() { return stringOperand(safePop(stack), \"VM.popString()\"); },\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      deleteVar(key: string) { variables.delete(key); },\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      getCallFrame() { return callFrames.length > 0 ? callFrames[callFrames.length - 1] : undefined; },\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      getVariableEntries() { return Array.from(variables.entries()); },\n      getUserFunctionDefs() { return Array.from(userFunctions.values()); },\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        // The allocation tally deliberately isn't touched here. It belongs to\n        // an evaluation rather than to a VM, and the outermost\n        // `beginEvaluation()` zeroes it on the way in, so a reset would be\n        // redundant work on a method the benchmark suite calls in its inner\n        // loop.\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     * The variables another line's expression reads, by 1-based line number, or\n     * `undefined` when the line has no evaluated expression (forward reference,\n     * out of range, or markdown). Goal seek (`packages/goalseek/`) uses it to\n     * refuse up front when the variable it was asked to vary is one the target\n     * line never reads, rather than searching a relationship that cannot move.\n     */\n    getLineReads?: (lineNumber: number) => string[] | undefined;\n    /**\n     * Re-evaluate another line's already-compiled expression with `variable`\n     * bound to `bound` for that one evaluation, without disturbing the\n     * document's own value for it. This is the primitive goal seek\n     * (`packages/goalseek/`) drives: binding a numeric candidate probes the\n     * relationship, binding a symbolic placeholder (with `symbolicTolerant`)\n     * reads it back in closed form. Returns an error Value when there is no\n     * document, the line is not a plain expression ready to run, or its\n     * re-evaluation itself faults. The binding is a call frame, so it shadows\n     * the document's value exactly the way a function parameter does and is\n     * gone the moment the probe returns.\n     */\n    evaluateLineWithBinding?: (\n        lineNumber: number,\n        variable: string,\n        bound: Value,\n        symbolicTolerant: boolean,\n    ) => Value;\n    /**\n     * The hard ceiling on goal seek's bisection steps, from\n     * `config.vm.maxGoalSeekIterations`. Carried on the context so the search,\n     * which runs as a plugin function with no other view of engine config, is\n     * bounded by the host's configured limit rather than a hardcoded one.\n     */\n    goalSeekMaxIterations?: number;\n    /**\n     * The RAW markdown text of line `lineNumber` (1-based), or `undefined`\n     * when there is no real document or the line is out of range. Distinct\n     * from `getLineResult`, which returns a line's evaluated Value: a\n     * markdown table's rows are skipped by the evaluator and hold no result,\n     * so reading a column as data has to go back to the source text. Backs\n     * the tables package (`packages/tables/`), which walks upward from the\n     * current line to find the nearest table and read one of its columns.\n     */\n    getLineText?: (lineNumber: number) => string | undefined;\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 * How many cells `matrixMultiply(l, r)` will materialise, computed from the\n * shapes alone so the answer is available before the multiply runs.\n *\n * Mirrors that function's own three cases. A dimension mismatch returns 0\n * rather than a product: the multiply refuses that pair without allocating, and\n * charging for an allocation that never happens would refuse a later, legal one.\n *\n * @param l - Left operand's shape and data.\n * @param r - Right operand's shape and data.\n * @returns Cell count of the result, or 0 when the shapes cannot be multiplied.\n */\nfunction matrixProductCells(l: MatrixData, r: MatrixData): number {\n    // A 1x1 operand broadcasts over the other rather than contracting with it,\n    // so the result is the size of the other operand.\n    if (l.rows === 1 && l.cols === 1) return r.data.length;\n    if (r.rows === 1 && r.cols === 1) return l.data.length;\n    if (l.cols !== r.rows) return 0;\n    return l.rows * r.cols;\n}\n\n/**\n * How many cells {@link matrixPower} will materialise across its whole run.\n *\n * It squares repeatedly rather than multiplying one factor at a time, so the\n * count is per squaring step and not just the size of the answer: `a^1000000`\n * is twenty multiplications of a full-size matrix, each one a fresh allocation.\n *\n * @param m - The base, which must be square for the power to be attempted.\n * @param exponent - The power.\n * @returns Total cells the repeated squaring will allocate.\n */\nfunction matrixPowerCells(m: MatrixData, exponent: number): number {\n    if (!Number.isInteger(exponent) || exponent < 0) return 0;\n    const cells = m.rows * m.cols;\n    // The identity, then up to two products per bit of the exponent (one\n    // squaring, one accumulation).\n    return cells * (1 + (exponent < 2 ? 1 : 2 * Math.floor(Math.log2(exponent))));\n}\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 * What to tell a caller who handed `executeBytecode()` a program it cannot run.\n *\n * `executeBytecode` is a public export, so a bytecode program is CALLER INPUT in\n * exactly the way an expression string is. It was not being treated that way:\n * every operand was read on trust, so a truncated stream or an out-of-range\n * pool index reached `BigInt(undefined)`, `code.toUpperCase()` on a boolean, or\n * a reentrant call with no program at all. Each of those arrived as a raw\n * TypeError, was normalised to UNEXPECTED_ERROR/INTERNAL, and told the caller\n * the engine had a bug when what actually happened was that they passed\n * eleven bytes of nonsense.\n *\n * VALIDATION rather than INTERNAL, and recoverable, because that is what it is.\n */\nconst MALFORMED_BYTECODE_SUGGESTION =\n    \"bytecode is caller input on this entry point: rebuild the program with the engine's compiler, or fix the hand-assembled stream\";\n\n/**\n * Whatever was running when a malformation was found, for the message to name.\n *\n * The dispatch loop always has an OpCode. The `VM` interface's `popString()`\n * does not: it is called from a package's own opcode handler, which knows its\n * opcode perfectly well but has no way to pass it to a method whose signature\n * is fixed SDK surface. The method name is the next-best locator, and it is the\n * one that author is looking at anyway, so a site is either of the two.\n */\ntype BytecodeSite = OpCode | string;\n\n/** A site's name for the message: an opcode's mnemonic, or a method name as given. */\nfunction siteName(site: BytecodeSite): string {\n    return typeof site === \"number\" ? getOpCodeName(site) : site;\n}\n\n/**\n * Builds the refusal, naming the site and what it was reaching for.\n *\n * @param code - Which class of malformation this is.\n * @param site - The opcode being executed when the problem was found, or the\n *   VM-interface method that found it. See {@link BytecodeSite}.\n * @param problem - Completes \"Malformed bytecode: <SITE> ...\".\n * @param expected - What a well-formed program would have had here.\n * @param found - What was there instead.\n * @param context - Anything else worth carrying, e.g. the offending index.\n * @returns The error to throw.\n */\nfunction malformedBytecode(\n    code: string,\n    site: BytecodeSite,\n    problem: string,\n    expected: string,\n    found: string,\n    context: Record<string, unknown> = {},\n): EngineError {\n    const name = siteName(site);\n    return ErrorFactory.validation({\n        code,\n        message: `Malformed bytecode: ${name} ${problem}`,\n        expected,\n        found,\n        suggestion: MALFORMED_BYTECODE_SUGGESTION,\n        // A named site reports under `site` rather than borrowing `opcodeName`,\n        // so a host reading `opcode`/`opcodeName` never gets a method name\n        // where it expects an opcode, and never has to tell a missing opcode\n        // apart from opcode 0.\n        context: typeof site === \"number\"\n            ? { opcode: site, opcodeName: name, ...context }\n            : { site: name, ...context },\n    });\n}\n\n/**\n * Reads one operand byte, refusing a stream that ends mid-instruction.\n *\n * `opcodes[at]` on a `Uint8Array` past its end is `undefined` rather than a\n * throw, so an operand read off the end propagates silently into whatever the\n * handler does next. A one-byte `[PUSH_BIGINT]` program used to reach\n * `BigInt(undefined)` this way.\n *\n * @param opcodes - The instruction stream.\n * @param at - Offset of the operand byte, i.e. the caller passes `ip++`.\n * @param op - The opcode being executed, for the message.\n * @param role - What the operand is, e.g. \"constant-pool index\".\n * @returns The operand byte.\n */\nfunction operandByte(opcodes: Uint8Array, at: number, op: OpCode, role: string): number {\n    if (at >= opcodes.length) {\n        throw malformedBytecode(\n            \"MALFORMED_BYTECODE_TRUNCATED\",\n            op,\n            `is missing its ${role}: the program ends mid-instruction`,\n            `an operand byte at offset ${at}`,\n            `a program only ${opcodes.length} byte(s) long`,\n            { offset: at, length: opcodes.length, role },\n        );\n    }\n    return opcodes[at];\n}\n\n/**\n * Reads one operand byte and checks it actually indexes the pool it names.\n *\n * @param opcodes - The instruction stream.\n * @param at - Offset of the operand byte.\n * @param op - The opcode being executed.\n * @param role - What the operand is, for the truncation message.\n * @param poolSize - How many entries the pool holds.\n * @param poolName - The pool's name, for the message.\n * @returns An index known to be within the pool.\n */\nfunction poolIndex(\n    opcodes: Uint8Array,\n    at: number,\n    op: OpCode,\n    role: string,\n    poolSize: number,\n    poolName: string,\n): number {\n    const index = operandByte(opcodes, at, op, role);\n    if (index >= poolSize) {\n        throw malformedBytecode(\n            \"MALFORMED_BYTECODE_CONSTANT_INDEX\",\n            op,\n            `reads ${poolName} entry ${index}, which does not exist`,\n            `an index below ${poolSize}`,\n            `${index}`,\n            { index, poolSize, pool: poolName },\n        );\n    }\n    return index;\n}\n\n/**\n * Reads a string-pool entry through the bounds check above.\n *\n * The extra type check is not redundant with the bounds check: `strings` is an\n * ordinary array on a caller-supplied program, so it can be sparse or hold\n * something that is not a string at all.\n *\n * @param opcodes - The instruction stream.\n * @param at - Offset of the operand byte.\n * @param strings - The program's string pool.\n * @param op - The opcode being executed.\n * @param role - What the operand is, for the message.\n * @returns The pooled string.\n */\nfunction poolString(opcodes: Uint8Array, at: number, strings: string[], op: OpCode, role: string): string {\n    return pooledString(strings, operandByte(opcodes, at, op, role), op);\n}\n\n/**\n * The same check for an index that has already been read.\n *\n * `map(f, ...)` and `reduce(f, ...)` name their function through the `ref`\n * operand they had to read first in order to know which arm to take.\n *\n * @param strings - The program's string pool.\n * @param index - The pool index.\n * @param op - The opcode being executed.\n * @returns The pooled string.\n */\nfunction pooledString(strings: string[], index: number, op: OpCode): string {\n    const text = strings[index];\n    if (typeof text !== \"string\") {\n        throw malformedBytecode(\n            \"MALFORMED_BYTECODE_CONSTANT_INDEX\",\n            op,\n            `reads string-pool entry ${index}, which is ${index >= strings.length ? \"past the end of the pool\" : \"not a string\"}`,\n            `an index below ${strings.length}, holding a string`,\n            index >= strings.length ? `${index}` : typeof text,\n            { index, poolSize: strings.length, pool: \"string-pool\" },\n        );\n    }\n    return text;\n}\n\n/**\n * A unit or converter name taken off the value stack.\n *\n * Every one of these sites used to be a bare `safePop(stack).value as string`.\n * The cast is compile-time only, so any Value the stack happened to be holding\n * went straight through, and the next `.toLowerCase()`/`.indexOf()` threw. This\n * also stops a Uom being built around a non-string unit, which is what let a\n * malformed stream carry the problem forward into unrelated handlers and\n * builtins that all reasonably assume a unit is text.\n *\n * @param value - The popped operand.\n * @param site - The opcode being executed, or the VM-interface method doing\n *   the popping. See {@link BytecodeSite}.\n * @param role - What the string is, e.g. \"target unit name\". Left out by a\n *   caller that has nothing more specific to say than \"a string\", which is all\n *   `popString()` knows: its handler is the only thing that knows the role.\n * @returns The string.\n */\nfunction stringOperand(value: Value, site: BytecodeSite, role?: string): string {\n    if (typeof value.value !== \"string\") {\n        throw malformedBytecode(\n            \"MALFORMED_BYTECODE_OPERAND_TYPE\",\n            site,\n            `expected a ${role ?? \"string\"} on the stack`,\n            role ? `a string value holding the ${role}` : \"a string value\",\n            `a ${ValueType[value.type] ?? \"unknown\"} value`,\n            role ? { role, valueType: value.type } : { valueType: value.type },\n        );\n    }\n    return value.value;\n}\n\n/**\n * Refuses a `map`/`reduce` body kind the dispatch has no arm for.\n *\n * The three arms are 0 (an inline anonymous body), 1 (a builtin) and 2 (a\n * user-defined function). Anything else used to fall past all of them with\n * `program` still undefined and then recurse into `executeBytecode(undefined)`,\n * whose destructure threw before its own try/catch could see it.\n *\n * @param kind - The operand as read.\n * @param ref - The body reference beside it, for the message.\n * @param op - MAP_INVOKE or REDUCE_INVOKE.\n */\nfunction requireKnownBodyKind(kind: number, ref: number, op: OpCode): void {\n    if (kind !== 0 && kind !== 1 && kind !== 2) {\n        throw malformedBytecode(\n            \"MALFORMED_BYTECODE_BODY_KIND\",\n            op,\n            `has body kind ${kind}, which is not one this VM knows`,\n            \"0 (inline body), 1 (builtin function) or 2 (user-defined function)\",\n            `${kind}`,\n            { kind, ref },\n        );\n    }\n}\n\n/**\n * Turns a pooled string into a BigInt without letting V8's SyntaxError out.\n *\n * `BigInt(\"1.000\")` throws a raw `SyntaxError`, which arrived at the host as\n * UNEXPECTED_ERROR/INTERNAL. From the `./vm` surface the string is caller\n * input; from ordinary source it means the lexer put something in the pool that\n * is not an integer, which is a real defect but still not something to report\n * as an unexplained internal fault on the user's line.\n *\n * @param text - The pooled literal text.\n * @param op - The opcode being executed.\n * @returns The parsed BigInt.\n */\nfunction parseBigIntLiteral(text: string, op: OpCode): bigint {\n    try {\n        return BigInt(text);\n    } catch {\n        throw malformedBytecode(\n            \"MALFORMED_BYTECODE_BIGINT_LITERAL\",\n            op,\n            `cannot read \"${text}\" as a whole number`,\n            \"a string holding an integer, with no decimal point or separators\",\n            `\"${text}\"`,\n            { literal: text },\n        );\n    }\n}\n\n/**\n * Whether a program is runnable at all, checked before anything reads it.\n *\n * The destructure at the top of `executeBytecode()` sits outside its try/catch,\n * so `executeBytecode(undefined)` threw a raw TypeError at whoever called it.\n * That is reachable from inside the engine too: a `map`/`reduce` body whose\n * side-table entry is missing recurses with `program` undefined.\n *\n * Duck-typed rather than an `instanceof` check, because callers and tests\n * legitimately build programs with plain arrays rather than typed ones.\n *\n * @param bytecode - Whatever was passed in.\n * @returns A description of what is wrong, or `null` when it is runnable.\n */\nfunction unrunnableProgram(bytecode: unknown): string | null {\n    if (bytecode === null || typeof bytecode !== \"object\") {\n        return `expected a bytecode program, got ${bytecode === null ? \"null\" : typeof bytecode}`;\n    }\n    const candidate = bytecode as { opcodes?: unknown; numbers?: unknown; strings?: unknown };\n    if (typeof (candidate.opcodes as { length?: unknown } | undefined)?.length !== \"number\") {\n        return \"the program has no `opcodes` array\";\n    }\n    if (typeof (candidate.numbers as { length?: unknown } | undefined)?.length !== \"number\") {\n        return \"the program has no `numbers` pool\";\n    }\n    if (typeof (candidate.strings as { length?: unknown } | undefined)?.length !== \"number\") {\n        return \"the program has no `strings` pool\";\n    }\n    return null;\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 * Executes an algebra verb's expression argument with the verb's own named\n * unknown bound to itself, for `OpCode.BIND_UNKNOWN`.\n *\n * `der(x^2, x)` names x as the unknown it differentiates by, which declares\n * x bound for that expression: it has to read as the unknown even on a page\n * that also says `:x = 5`. This is the same shadowing a function's parameter\n * already gets (`getVar` reads the innermost call frame before the variable\n * store), reached the same way, with a frame. Without it the expression was\n * evaluated against the document's value first, so the verb was handed 25 and\n * `der(x^2, x)` answered 0, `solve(x^2-4=0, x)` reported no solution, and\n * `integral(x^2, x)` gave `25x`.\n *\n * The frame is copied from the enclosing one rather than started empty, so a\n * verb written inside a function or a map body still sees that body's own\n * parameters; only the named unknown is replaced.\n *\n * @param name - The unknown the verb named.\n * @param program - The expression argument, compiled on its own.\n * @returns The expression's value, with `name` free inside it.\n */\nfunction invokeWithBoundUnknown(\n    name: string,\n    program: BytecodeProgram,\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>(vm.getCallFrame());\n    frame.set(name, symbolicValue(varSymbolicNode(name)));\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        // Unreachable through the shipped grammar (the parselets refuse an\n        // async expression argument at parse time, see\n        // SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS), and stated as its own error\n        // rather than left to fall through as an accidental value.\n        throw ErrorFactory.execution(\n            \"SYMBOLIC_ASYNC_UNSUPPORTED\",\n            `an algebra verb's expression cannot call an async operation (weather, stocks, currency, ...)`,\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 measured quantity on the other side is the thing the proportion is\n        // OF, so the answer is that quantity scaled, exactly as it would be\n        // with the operands the other way round: \"10% + $5\" is $5.50, the same\n        // as \"$5 + 10%\". It used to fall through to the ordinary path, which\n        // added the bare fraction as though it were money and answered $5.10.\n        // Subtraction reads the same way round (\"10% - $5\" is $5 less a tenth,\n        // $4.50), which keeps the rule one rule rather than two.\n        if (r.type === ValueType.Uom && r.unit !== undefined) {\n            return scaleMoneyByPercent(r, r.unit, l.toNumber(), sign);\n        }\n        // Otherwise a percentage on the left keeps the result a percentage,\n        // because the thing being described is still a proportion. Only\n        // Number/Percentage make sense here; anything else (a date, a matrix)\n        // 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) {\n        // A scalar multiply scales a carried tolerance by the same factor, so a\n        // measurement keeps its uncertainty: \"(100 +/- 5) + 10%\" is \"110 +/- 5.5\",\n        // exactly what \"(100 +/- 5) * 1.1\" gives. Without this the tolerance was\n        // silently dropped.\n        const scaled = l.toNumber() * factor;\n        if (l.uncertainty !== undefined) return numberValueUncertain(scaled, Math.abs(l.uncertainty * factor));\n        return numberValue(scaled);\n    }\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. Money\n    // stays exact via the base-ten scaling factor.\n    if (l.type === ValueType.Uom && l.unit !== undefined) return scaleMoneyByPercent(l, l.unit, r.toNumber(), sign);\n    return null;\n}\n\n/**\n * `X * p%` and `p% of X` are a scalar multiply, so a tolerance on `X` scales by\n * the factor: `(100 +/- 5) * 10%` and `10% of (100 +/- 5)` are `10 ± 0.5`. Only\n * fires when one operand is a Percentage and the other is an uncertain Number, so\n * every plain `100 * 10%` and every non-percentage multiply keeps its own path.\n * (`of` compiles to `MUL`, so this covers both spellings.) Returns null\n * otherwise, exactly as {@link combinePercentage} does for `+`/`-`.\n */\nfunction multiplyPercentWithUncertainty(l: Value, r: Value): Value | null {\n    const pct = l.type === ValueType.Percentage ? l : r.type === ValueType.Percentage ? r : null;\n    if (pct === null) return null;\n    const other = pct === l ? r : l;\n    if (other.type !== ValueType.Number || other.uncertainty === undefined) return null;\n    const factor = pct.toNumber();\n    return numberValueUncertain(other.toNumber() * factor, Math.abs(other.uncertainty * factor));\n}\n\n/**\n * Money times a scalar is a scalar multiply, so like `$X + p%` it must stay exact\n * to the cent: `15% of $0.10` and `$0.10 * 15%` are `$0.015 -> $0.02`, not the\n * `$0.01` a bare double rounds down to, and the same for a computed factor with\n * no exact sidecar of its own, e.g. `50% of 1% of $3` (the inner `50% of 1%`\n * reduces to a bare `0.005`). Fires when one operand is a currency Uom and the\n * other a plain Number or a Percentage, routing through the same base-ten scaling\n * the `+`/`-` path uses, which recovers the factor from its shortest decimal (see\n * MoneyExact.ts). A rational scalar (`$3 * 2/7`) is left alone so the exact\n * fraction is kept rather than flattened to a decimal, and a non-currency Uom\n * (`10% of 5 kg`) and every other multiply keep their existing path. (`of`\n * compiles to `MUL`, so this covers the `of` spellings too.)\n */\nfunction multiplyMoneyByScalarExact(l: Value, r: Value): Value | null {\n    const money = l.type === ValueType.Uom ? l : r;\n    const scalar = l.type === ValueType.Uom ? r : l;\n    if (money.type !== ValueType.Uom || money.unit === undefined || !sharedCurrencyExchange.isCurrency(money.unit)) return null;\n    if (scalar.type !== ValueType.Number && scalar.type !== ValueType.Percentage) return null;\n    if (scalar.rational !== undefined) return null;\n    return scaleMoneyExact(money, scalar.toNumber(), money.unit);\n}\n\n/**\n * A division involving a Percentage and an uncertain Number carries the tolerance\n * that {@link uncertainOp} drops for a Percentage operand, in both arrangements:\n *\n *   (100 +/- 5) / 10%     1000 ± 50       X / p% = X/factor, spread scales by 1/factor\n *   10% / (2 +/- 0.1)     0.05 ± 0.0025   p% / (b ± e) = a/b, spread |a·e / b²|\n *\n * A zero divisor returns null so the general path surfaces the divide-by-zero,\n * and every other division keeps its own path.\n */\nfunction dividePercentWithUncertainty(l: Value, r: Value): Value | null {\n    // Uncertain Number over a Percentage divisor: a scalar divide by `factor`.\n    if (r.type === ValueType.Percentage && l.type === ValueType.Number && l.uncertainty !== undefined) {\n        const factor = r.toNumber();\n        if (factor === 0) return null;\n        return numberValueUncertain(l.toNumber() / factor, Math.abs(l.uncertainty / factor));\n    }\n    // Percentage over an uncertain Number divisor: the divisor's relative spread\n    // carries through the quotient (the dividend is exact, so only `b` varies).\n    if (l.type === ValueType.Percentage && r.type === ValueType.Number && r.uncertainty !== undefined) {\n        const b = r.toNumber();\n        if (b === 0) return null;\n        return numberValueUncertain(l.toNumber() / b, Math.abs((l.toNumber() * r.uncertainty) / (b * b)));\n    }\n    return null;\n}\n\n/** Extract milliseconds from a duration Value (UoM time unit or plain number).\n *  The linear half of {@link shiftDatetime}, and the whole of it for any unit\n *  shorter than a day. */\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 * Workdays in a year: 52.1775 weeks of five, rounded down.\n *\n * Only ever used to turn a limit configured in years into a number of steps\n * {@link addBusinessDays} may take, so being a day or two out across a century\n * is immaterial and no date is ever computed from it. Deliberately not the\n * unit table's workday<->day ratio, which exists for Rate arithmetic.\n */\nconst WORKDAYS_PER_YEAR = 260;\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 and the `N working days after/before/from <date>`\n * form (see this function's call sites below and `DATE_WORKDAY_OFFSET`).\n *\n * Skips public holidays too when the host has configured a calendar: the walk\n * asks `vm.isHoliday()` about each candidate day and lands only on a working\n * one. With no calendar `vm.isHoliday()` is always false, so this is weekends-\n * only, the honest default (see `constants/Configuration.ts`'s `date.holidays`\n * and `vm/BusinessDays.ts`). Same predicate every working-day form consults, so\n * `<date> + N workdays` and `N working days after <date>` can never disagree.\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 (and which days the host excludes),\n * so there's no fixed ratio like uom/UomConverter.ts's workday<->day RATE\n * conversion (that's a linear approximation acceptable for Rate math; actual\n * date arithmetic needs the real, exact answer).\n *\n * That walk is why this is the one date offset with a ceiling on it. Every\n * other one moves a Date field once and lets Date recompute (see\n * addCalendarDays() below), so `today + 100000 days` costs what one day\n * costs; here the cost IS the offset. The loop runs entirely inside a single\n * ADD opcode, so `vm.maxInstructions` is never consulted while it runs:\n * `today + 100000000 workdays` froze for 13.2 seconds and then answered\n * \"Invalid Date\", and `today + 1000000000000 workdays` never answered at all.\n * `date.maxOffsetYears`/`date.minOffsetYears` bound it, which is also the\n * first thing in the engine ever to read those two fields. The same bound,\n * expanded to calendar days, is handed to the walk as its step cap, so a\n * calendar that marks every day a holiday (nothing ever counts) is refused\n * rather than looping forever.\n *\n * @throws `DATE_OFFSET_LIMIT_EXCEEDED` for an offset outside the configured\n * range. Recoverable: it is a statement about this line, not about the\n * engine.\n */\nfunction addBusinessDays(epochMs: number, n: number, vm: VM): number {\n    const remaining = Math.trunc(Math.abs(n));\n    const direction = n >= 0 ? 1 : -1;\n    // Checked before the first step rather than counted during it, so a\n    // hopeless offset costs nothing at all. Working in workdays rather than\n    // converting the bound to days keeps the comparison exact for the number\n    // the user actually typed, and the ratio only has to be right to name a\n    // limit, not to compute a date.\n    const limitYears = direction > 0 ? vm.getMaxDateOffsetYears() : -vm.getMinDateOffsetYears();\n    const limitWorkdays = Math.floor(limitYears * WORKDAYS_PER_YEAR);\n    if (remaining > limitWorkdays) {\n        throw ErrorFactory.execution(\n            \"DATE_OFFSET_LIMIT_EXCEEDED\",\n            `A date offset of ${remaining.toLocaleString(\"en-US\")} workdays is about ${Math.round(remaining / WORKDAYS_PER_YEAR).toLocaleString(\"en-US\")} years, past the limit of ${limitYears} years for a workday offset`,\n            { requestedWorkdays: remaining, limitYears, limitWorkdays },\n        );\n    }\n    // Seven calendar days per workday is the floor of a week with only one\n    // working day in it, which no real calendar reaches, so a legitimate\n    // in-limit offset never trips this. A pathological all-holiday calendar\n    // does, and is reported as the same limit error rather than hanging.\n    const maxCalendarSteps = limitWorkdays * 7 + 7;\n    const landed = walkBusinessDays(epochMs, n, (ms) => vm.isHoliday(ms), maxCalendarSteps);\n    if (landed === null) {\n        throw ErrorFactory.execution(\n            \"DATE_OFFSET_LIMIT_EXCEEDED\",\n            `A working-day offset of ${remaining.toLocaleString(\"en-US\")} could not be reached within the ${limitYears}-year limit; the configured holiday calendar leaves too few working days`,\n            { requestedWorkdays: remaining, limitYears, maxCalendarSteps },\n        );\n    }\n    return landed;\n}\n\n/** Milliseconds in a day that contains no daylight-saving transition. */\nconst MS_PER_DAY = 86_400_000;\n\n/**\n * How many calendar months one of these units spans.\n *\n * The unit table gives a month and a year fixed lengths (2,592,000 and\n * 31,536,000 seconds, i.e. exactly 30 and 365 days). Those ratios are correct\n * for pure duration arithmetic, which is why they are left alone: `2 years in\n * days` genuinely is 730 days, and other code depends on that. They are not\n * correct for landing on a calendar date, because a real month is 28 to 31\n * days and a real year is 365 or 366, so no single ratio can put \"a year after\n * January 1 2024\" on January 1 2025 (linearly it lands on December 31 2024,\n * a day early, and drifts further with every year added).\n *\n * Every unit named here is therefore shifted with `setMonth()` instead, by\n * this many months. Everything not named here keeps whatever the table says.\n */\nconst CALENDAR_MONTHS_PER_UNIT: Record<string, number> = {\n    month: 1, months: 1, mo: 1,\n    year: 12, years: 12, yr: 12, y: 12, a: 12,\n    decade: 120, decades: 120, dec: 120,\n    century: 1200, centuries: 1200,\n    millennium: 12000, millennia: 12000,\n};\n\n/** Days in calendar month `monthIndex` (0-11) of `year`. Day zero of the\n *  following month is the last day of this one, which is also how the leap\n *  year rule gets applied without restating it. */\nfunction daysInMonth(year: number, monthIndex: number): number {\n    return new Date(year, monthIndex + 1, 0).getDate();\n}\n\n/**\n * Move `epochMs` by `days` calendar days, holding the local wall-clock time.\n *\n * Stepping the day field is the whole point, the same reason\n * addBusinessDays() above does it. A day is only 86,400,000 ms when no\n * daylight-saving transition falls inside it: the day a zone springs forward\n * is 23 hours long and the day it falls back is 25. Adding a flat 86,400,000\n * across either one lands an hour off, and an hour off a local midnight is a\n * different calendar day, so `2024-11-03 + 1 day` answered November 3 again\n * in Los Angeles and `26/10/2024 + 2 days` answered October 27 in London.\n * `setDate()` moves the field and lets Date recompute the offset, so the\n * answer is the day the user named in every zone.\n */\nfunction addCalendarDays(epochMs: number, days: number): number {\n    const whole = Math.trunc(days);\n    const date = new Date(epochMs);\n    date.setDate(date.getDate() + whole);\n    const shifted = date.getTime();\n    // A shift far enough out to leave the range a Date can represent gives an\n    // Invalid Date. Falling back to the linear arithmetic hands back the same\n    // out-of-range number as before rather than turning it into a NaN here.\n    if (Number.isNaN(shifted)) return epochMs + days * MS_PER_DAY;\n    // A fractional part is elapsed time, not a calendar step (\"1.5 days\" is a\n    // day and then twelve hours), so it is added as milliseconds.\n    return shifted + (days - whole) * MS_PER_DAY;\n}\n\n/**\n * Move `epochMs` by `months` calendar months, clamping to the end of the month\n * it lands in: January 31 plus a month is February 28, or February 29 in a leap\n * year, and never March.\n *\n * The clamp is why the day is parked on the 1st before the month field moves.\n * `setMonth()` on its own keeps the day number, so the 31st of a month whose\n * target has 30 days overflows into the month after it, which is how\n * `2024-01-31 + 1 month` answered March 1 and `2024-03-31 - 1 month` answered\n * March 1 as well. Clamping is what every calendar application does with this\n * case, and it is the only choice that keeps the month the user asked for.\n */\nfunction addCalendarMonths(epochMs: number, months: number): number {\n    const whole = Math.trunc(months);\n    const date = new Date(epochMs);\n    const dayOfMonth = date.getDate();\n    date.setDate(1);\n    date.setMonth(date.getMonth() + whole);\n    date.setDate(Math.min(dayOfMonth, daysInMonth(date.getFullYear(), date.getMonth())));\n    const shifted = date.getTime();\n    // A leftover fraction of a month names no calendar date of its own, so it\n    // falls back to the table's fixed-length month. Same overflow reasoning as\n    // addCalendarDays() above for the NaN case.\n    const monthMs = convertUnit(1, \"month\", \"ms\");\n    if (Number.isNaN(shifted)) return epochMs + months * monthMs;\n    return shifted + (months - whole) * monthMs;\n}\n\n/**\n * Move a Datetime by a duration: the operation behind `<date> + <duration>`\n * and `<date> - <duration>`, with `sign` +1 for ADD and -1 for SUB.\n *\n * Three kinds of duration, because they are three different questions:\n * - Workdays skip weekends, so they are neither a fixed span of milliseconds\n *   nor a plain calendar-day step (see addBusinessDays() above).\n * - Months and years are calendar fields, not lengths (see\n *   CALENDAR_MONTHS_PER_UNIT above).\n * - Days, weeks and fortnights are whole calendar days, so they step the day\n *   field and keep the wall-clock time (see addCalendarDays() above).\n *\n * Everything shorter than a day stays linear, and deliberately so: a duration\n * in hours is elapsed time. \"36 hours from now\" means 36 hours of clock\n * ticking, across a daylight-saving transition included, which is exactly what\n * adding milliseconds does.\n */\nfunction shiftDatetime(epochMs: number, duration: Value, sign: 1 | -1, vm: VM): number {\n    if (duration.type === ValueType.Uom && duration.unit !== undefined) {\n        const unit = duration.unit;\n        const amount = sign * duration.toNumber();\n\n        // `vm` is threaded in for this one branch: the workday walk is the\n        // only date offset whose cost grows with the offset, so it is the only\n        // one that needs a configured ceiling. See addBusinessDays().\n        if (isWorkdayUnit(unit)) return addBusinessDays(epochMs, amount, vm);\n\n        const monthsPerUnit = CALENDAR_MONTHS_PER_UNIT[unit];\n        if (monthsPerUnit !== undefined) return addCalendarMonths(epochMs, amount * monthsPerUnit);\n\n        // Measure first, for the reason extractDurationMs() gives below: a\n        // unit that is not a duration at all has to contribute nothing rather\n        // than be rescued by a lenient conversion.\n        if (getMeasure(unit) === \"time\") {\n            // Whether a unit is a whole number of days is read out of the unit\n            // table rather than listed here, so weeks and fortnights are\n            // covered by the same rule as days with nothing to keep in step by\n            // hand. Sub-day units fail the test and fall through to the linear\n            // path below, which is what they want.\n            let daysPerUnit = 0;\n            try { daysPerUnit = convertUnit(1, unit, \"day\"); } catch { /* Ignore */ }\n            if (Number.isInteger(daysPerUnit) && daysPerUnit >= 1) {\n                return addCalendarDays(epochMs, amount * daysPerUnit);\n            }\n        }\n    }\n    return epochMs + sign * extractDurationMs(duration);\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 * The answer a conversion gives when the two units measure different things.\n *\n * `UOM_CONVERT_TO` and `UOM_CONVERT_IN` used to push the input back unchanged\n * here, so \"5 kg in m\" displayed as \"5.00 kg\" and \"$100 in ZZZ\" as \"$100.00\":\n * not an error, not a conversion, the question repeated back as though it had\n * been answered at a rate of one. That is the failure mode this codebase\n * already refuses in `binaryOp` (vm/VMConversion.ts), where \"10 m + 5 kg\"\n * gives INCOMPATIBLE_UNITS rather than a bare 15, and the two paths now agree.\n *\n * Reached for a genuinely crossed pair (\"1 m3 in m2\"), for a currency against\n * a physical unit (\"$100 in kg\"), and for a code the lexer accepts that the\n * exchange does not consider money (\"$100 in HRK\"). All three are questions\n * with no answer, so all three say so.\n */\nfunction incompatibleConversionError(fromUnit: string, toUnit: string): Value {\n    // Name the two dimensions when both are known (\"a duration cannot be\n    // converted to a length\"). A compound rate or an unrecognised currency code\n    // has no single dimension to name, so it keeps the unit-naming fallback.\n    const named = describeConversionMismatch(fromUnit, toUnit);\n    return errorValue(\n        \"INCOMPATIBLE_UNITS\",\n        named ?? `Cannot convert ${fromUnit} to ${toUnit}: they do not measure the same thing`,\n    );\n}\n\n/**\n * How large an exact `^` on a BigInt base is allowed to grow, in bits.\n *\n * Not a precision limit, a safety one. Exponentiation is the one operator\n * where a short line of input asks for an unbounded amount of work: `2n ^\n * 1000000000` is a single instruction that would spend minutes building a\n * ~125MB integer, and this engine runs inside an editor, where that takes the\n * host down with it. The instruction budget (`getMaxInstructions()`) cannot\n * help, because this is one instruction.\n *\n * 65536 bits is a little under twenty thousand decimal digits, far past any\n * result a person reads and far short of anything that stalls.\n *\n * DECIDED (1.0.0, differential run 20260811): past the ceiling the operation is\n * REFUSED, where it used to fall through to the ordinary double path and answer\n * Infinity. Infinity is not the answer to `2n ^ 100000`; the answer is a\n * 30,103-digit integer this engine has chosen not to build, and those are\n * different facts. Reporting the second as the first discards the exactness the\n * `n` type exists for AND the fact that a limit was reached, which is the\n * failure mode (\"a confident magnitude that is not the real one\") that the rest\n * of this release removes everywhere else.\n *\n * It is also the line this codebase already draws between its two numeric\n * types, one operator over: `1 / 0` is Infinity and `1n / 0n` is refused,\n * because exact integer arithmetic does not hand back approximations (see\n * `bigIntDivisionByZero()` in vm/VMConversion.ts). The double spelling is\n * untouched, so `2 ^ 100000` is still Infinity, exactly as IEEE 754 says.\n */\nconst MAX_EXACT_POW_BITS = 65536;\n\n/**\n * How many bits `base ^ exponent` would occupy as an exact bigint, or `null`\n * when it has no exact bigint answer at all.\n *\n * Only a whole, non-negative exponent has one (there is no fractional bigint\n * and no reciprocal one); those cases return null and their caller keeps the\n * ordinary double path, which is the correct answer for them rather than a\n * fallback. The size is estimated from the base's magnitude as a double, which\n * is enough for a limit whose job is to reject the absurd: a base too large for\n * a double to hold is already past the limit.\n *\n * A magnitude of one or less is a special case for the same reason\n * {@link bigIntShift} special-cases zero: 0, 1 and -1 raised to anything at all\n * stay one bit wide, so `1n ^ 1000000` is exact, instant, and must not be\n * refused by an estimate that only looks at the exponent.\n */\nfunction exactPowBits(base: Value, exponent: number): number | null {\n    if (!Number.isInteger(exponent) || exponent < 0) return null;\n    if (exponent === 0) return 1;\n    const magnitude = Math.abs(base.toNumber());\n    if (magnitude <= 1) return 1;\n    const baseBits = magnitude <= 2 ? 1 : Math.log2(magnitude);\n    return baseBits * exponent;\n}\n\n/**\n * `base ** exponent` for bigints, by repeated squaring.\n *\n * Written out rather than using the `**` operator on purpose. TypeScript\n * downlevels `**` to `Math.pow()` for any target below ES2016, and the test\n * config compiles at ES6, so the operator form threw \"Cannot convert a BigInt\n * value to a number\" under the test runner while working in the shipped build:\n * a difference between what is tested and what ships, which is worse than the\n * loop. `symbolic/Complex.ts`'s `complexPow` does the same thing for the same\n * shape of reason.\n *\n * `exponent` must be non-negative; {@link exactPowBits} is the guard.\n */\nfunction bigIntPow(base: bigint, exponent: bigint): bigint {\n    let result = 1n;\n    let factor = base;\n    let remaining = exponent;\n    while (remaining > 0n) {\n        if (remaining % 2n === 1n) result *= factor;\n        remaining /= 2n;\n        // Skipped on the last pass, where squaring would only build a number\n        // twice the size of the answer and throw it away.\n        if (remaining > 0n) factor *= factor;\n    }\n    return result;\n}\n\n/**\n * How large an exact bigint SHIFT is allowed to grow, in bits.\n *\n * Deliberately the same number as {@link MAX_EXACT_POW_BITS}, and named\n * separately only so each operator's ceiling can be read where it is used.\n * `1n << k` and `2n ^ k` are the same number written two ways, so a ceiling on\n * one and none on the other is not a difference of opinion between operators,\n * it is a hole: `2n ^ 100000` was refused while `1n << 100000` built the exact\n * 30,103-digit integer it asks for, and `1n << 100000000` built a 12.5MB one\n * and then spent 8.5 seconds inside `formatValue()` rendering thirty million\n * characters of it.\n */\nconst MAX_EXACT_SHIFT_BITS = MAX_EXACT_POW_BITS;\n\n/**\n * How many bits a bigint occupies.\n *\n * The double path answers for anything a double can hold, where the exponent\n * IS the bit length. Past that `Number()` saturates to Infinity, so the length\n * comes off the hexadecimal form, which is linear in the size of the value.\n * (The decimal form is not, and turning a large bigint into decimal digits is\n * the exact cost this ceiling exists to prevent.)\n */\nfunction bigIntBitLength(value: bigint): number {\n    const magnitude = value < 0n ? -value : value;\n    if (magnitude === 0n) return 0;\n    const asDouble = Number(magnitude);\n    if (Number.isFinite(asDouble)) return Math.floor(Math.log2(asDouble)) + 1;\n    return magnitude.toString(16).length * 4;\n}\n\n/**\n * `l << r` (`direction` +1) or `l >> r` (-1) with a bigint operand, bounded by\n * {@link MAX_EXACT_SHIFT_BITS}.\n *\n * The right shift is guarded as well as the left, and not out of symmetry: a\n * bigint `>>` with a NEGATIVE count shifts the other way, so `1n >> -100000`\n * is the same unbounded growth spelled differently.\n *\n * Past the ceiling the shift is REFUSED, whichever operand made it a bigint\n * operation.\n *\n * DECIDED (1.0.0, differential run 20260811). The two spellings used to part\n * company here: a bigint on the LEFT fell through to `x * 2^n` as a double,\n * which for a number this size is Infinity, while a plain number on the left\n * (`1 << 100000n`, which reaches here because the bigint branch triggers on\n * EITHER operand) was refused by name, since JavaScript's 32-bit `<<` wraps its\n * count modulo 32 and would answer 1.\n *\n * `1n << 66000` is the case that settles it. It is a perfectly ordinary\n * 19,870-digit integer, and answering `Infinity` says two false things about\n * it: that it is beyond counting, and that nothing went wrong. The engine's own\n * reason for having an `n` type is that a double's approximation of a large\n * integer is not the integer, so approximating one as Infinity is that same\n * mistake at the largest possible scale. `^` now refuses at its ceiling for the\n * same reason (see {@link MAX_EXACT_POW_BITS}), which keeps `1n << k` and\n * `2n ^ k`, the same number written two ways, answering the same way at every\n * size.\n *\n * @throws `BIGINT_SHIFT_LIMIT_EXCEEDED` past the ceiling. Recoverable.\n */\nfunction bigIntShift(l: Value, r: Value, direction: 1 | -1): Value {\n    const value = toBigIntOperand(l);\n    const shift = toBigIntOperand(r);\n    // Zero shifted by anything is zero, and it costs nothing to say so, so it\n    // is answered rather than refused however absurd the count is.\n    if (value === 0n) return bigIntValue(0n);\n    // How many bits the result gains. Negative means it shrinks, which no\n    // ceiling has to care about. `Number()` on an absurd shift count saturates\n    // to Infinity, which fails the comparison below, which is the right answer.\n    const grownBits = direction * Number(shift);\n    if (grownBits <= 0 || bigIntBitLength(value) + grownBits <= MAX_EXACT_SHIFT_BITS) {\n        return bigIntValue(direction === 1 ? value << shift : value >> shift);\n    }\n    throw ErrorFactory.execution(\n        \"BIGINT_SHIFT_LIMIT_EXCEEDED\",\n        `Shifting by ${shift} would build an exact integer of about ${(bigIntBitLength(value) + grownBits).toLocaleString(\"en-US\")} bits, past the limit of ${MAX_EXACT_SHIFT_BITS.toLocaleString(\"en-US\")} bits`,\n        { shift: String(shift), limitBits: MAX_EXACT_SHIFT_BITS },\n    );\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 * Render an exact rational as a fraction: \"1/3\", \"5/2\", or a whole number as\n * itself (\"4\").\n *\n * The exact counterpart of {@link toFractionString}'s continued-fraction guess,\n * used when a value carries the rational it evaluates to. It is what makes\n * \"(1/1000003) as fraction\" read \"1/1000003\" rather than the \"0/1\" the float\n * approximation collapses to once the denominator passes its own ceiling.\n */\nfunction rationalToFractionString(r: Rational): string {\n    return r.d === 1n ? String(r.n) : `${r.n}/${r.d}`;\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    // An infinity or a NaN has no mantissa and no exponent, so splitting on\n    // \"e\" gave back one piece and the second was undefined: \"0/0 as sci\"\n    // rendered the string \"NaNeundefined\".\n    if (!Number.isFinite(n)) return String(n);\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    // Before the destructure, which is the point: `executeBytecode(undefined)`\n    // used to throw a raw TypeError from the destructure itself, outside the\n    // try/catch below, so a host calling this public export got an exception\n    // rather than the error arm this function documents. The internal caller\n    // that reaches here with nothing is a map/reduce body whose side-table\n    // entry is missing.\n    const unrunnable = unrunnableProgram(bytecode);\n    if (unrunnable) {\n        return {\n            type: 'error',\n            error: ErrorFactory.validation({\n                code: \"MALFORMED_BYTECODE_PROGRAM\",\n                message: `Malformed bytecode: ${unrunnable}`,\n                expected: \"a BytecodeProgram with opcodes, numbers and strings\",\n                found: unrunnable,\n                suggestion: MALFORMED_BYTECODE_SUGGESTION,\n            }),\n        };\n    }\n\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    // Makes this VM's allocation allowance current for the duration of this\n    // program, so that anything materialised beneath here charges it without\n    // the intervening frames having to pass it down. Only the OUTERMOST entry\n    // clears the tally: a reentrant call (a user-defined function, a map or\n    // reduce body) keeps spending the same allowance, which is what stops\n    // recursion from refreshing its own budget the way it can refresh\n    // `localInstructionCount`. Paired with `endEvaluation()` in the `finally`\n    // below, which is why a throw cannot leave a budget current.\n    beginEvaluation(vm);\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          // Read through safePop rather than `stack[stack.length - 1]`, which\n          // pushes `undefined` on an empty stack. A following HALT then popped\n          // that undefined and returned `{ type: 'value', value: undefined }`,\n          // a shape EvalResult declares impossible and every caller reads\n          // without checking. Found by the bytecode fuzzer on the two-opcode\n          // program `[DUP, HALT]`; the same underflow through any other opcode\n          // was already controlled, since they all pop through safePop.\n          const top = safePop(stack);\n          stack.push(top);\n          stack.push(top);\n          break;\n        }\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        // Every operand below goes through a checked read. An index past the\n        // end of a pool used to yield `undefined` and be pushed as a Value,\n        // which then failed somewhere else entirely: PUSH_BIGINT reached\n        // `BigInt(undefined)`, and an undefined string sat on the stack until\n        // a unit or converter name was read off it.\n        case OpCode.PUSH_NUMBER:\n          stack.push(numberValue(numbers[poolIndex(opcodes, ip++, op, \"constant-pool index\", numbers.length, \"number-pool\")]));\n          break;\n        case OpCode.PUSH_BIGINT:\n          stack.push(bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, \"constant-pool index\"), op)));\n          break;\n        case OpCode.PUSH_DECIMAL: {\n          // A decimal-point literal: the exact base-ten value rides in the\n          // `exact` sidecar, the nearest double stays in `value`, so this reads\n          // as an ordinary Number everywhere except where it meets money.\n          const dec = decimalFromLiteral(poolString(opcodes, ip++, strings, op, \"constant-pool index\"));\n          stack.push(numberValueExact(decimalToNumber(dec), dec));\n          break;\n        }\n        case OpCode.PUSH_HEX:\n          stack.push(hexValue(numbers[poolIndex(opcodes, ip++, op, \"constant-pool index\", numbers.length, \"number-pool\")]));\n          break;\n        case OpCode.PUSH_STRING:\n          stack.push(stringValue(poolString(opcodes, ip++, strings, op, \"constant-pool index\")));\n          break;\n        case OpCode.PUSH_BOOLEAN:\n          stack.push(boolValue(operandByte(opcodes, ip++, op, \"boolean operand\") === 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          // binaryOp() at the bottom of this chain propagates a faulted\n          // operand, but only the branches that reach it do. The Datetime and\n          // timecode branches above it do not: they read the other operand as\n          // a duration, and a duration read off an Error is zero, so `today +\n          // (5 kg to m)` answered today. See faultedOperand().\n          const addFault = faultedOperand(l, r);\n          if (addFault) { stack.push(addFault); break; }\n          // A carried uncertainty propagates in quadrature before anything else,\n          // so \"(10 +/- 1) + (20 +/- 2)\" is \"30 ± 2.24\". Gated on a sidecar\n          // being present, and checked ahead of the rational branch below so an\n          // uncertain operand is never folded into an exact fraction that would\n          // silently drop its tolerance. See uncertainOp().\n          if (l.uncertainty !== undefined || r.uncertainty !== undefined) {\n            const uncAdd = uncertainOp(l, r, \"add\");\n            if (uncAdd) { stack.push(uncAdd); break; }\n          }\n          // Fraction arithmetic stays exact when a rational already rides on an\n          // operand: \"1/3 + 1/3 + 1/3\" is exactly 1. The sidecar check gates it\n          // so this only ever PRESERVES a fraction, a plain integer sum never\n          // grows one and \"1e16 + 1 - 1e16\" stays the double it must be.\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const ratAdd = exactRationalOp(l, r, \"add\");\n            if (ratAdd) { stack.push(ratAdd); break; }\n          }\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 {\n              // Workdays, calendar months/years and whole calendar days each\n              // move a date differently. See shiftDatetime()'s doc comment.\n              stack.push(datetimeValue(shiftDatetime(l.toNumber(), r, 1, vm)));\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 if (r.type === ValueType.Datetime) {\n            // Addition commutes, so a date on the RIGHT is the same sum as a\n            // date on the left. Without this it fell through to binaryOp(),\n            // which reads both operands as bare numbers: \"1 day + 12-25-2023\"\n            // answered \"1,703,491,200,001 days\" and \"100 + 12-25-2023\"\n            // answered 1,703,491,200,100. Both are the date's epoch\n            // milliseconds wearing the wrong type, which is a confident wrong\n            // answer rather than a visible failure.\n            stack.push(datetimeValue(shiftDatetime(r.toNumber(), l, 1, vm)));\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          // Same reason as ADD above.\n          const subFault = faultedOperand(l, r);\n          if (subFault) { stack.push(subFault); break; }\n          // Uncertainty propagates before the fraction path, same reasoning as\n          // ADD: \"(10 +/- 1) - (20 +/- 2)\" is \"-10 ± 2.24\" (the spread of a\n          // difference combines in quadrature exactly as a sum's does).\n          if (l.uncertainty !== undefined || r.uncertainty !== undefined) {\n            const uncSub = uncertainOp(l, r, \"sub\");\n            if (uncSub) { stack.push(uncSub); break; }\n          }\n          // Preserve exact fractions, as ADD does above: \"5/6 - 1/6 - 1/6 - 1/6\n          // - 1/6 - 1/6\" is exactly 0, not the 1.6e-16 the doubles drift to.\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const ratSub = exactRationalOp(l, r, \"sub\");\n            if (ratSub) { stack.push(ratSub); break; }\n          }\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 {\n              // See the matching ADD case above, and shiftDatetime()'s own\n              // doc comment for why a day is not a fixed number of ms.\n              stack.push(datetimeValue(shiftDatetime(l.toNumber(), r, -1, vm)));\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 if (r.type === ValueType.Datetime) {\n            // Subtraction does not commute, so unlike ADD there is nothing to\n            // salvage here: taking a point in time away from a quantity that\n            // is not one has no meaning. ADD already refuses \"<date> +\n            // <date>\"; this is the same guard for the reversed operands, which\n            // had none, so \"100 - 12-25-2023\" answered -1,703,462,399,900,\n            // the date's epoch milliseconds leaking out as an ordinary number.\n            stack.push(errorValue(\n              \"INVALID_DATETIME_OP\",\n              \"Cannot subtract a datetime from a value that is not a datetime\",\n            ));\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          // A percentage scaling an uncertain number carries the tolerance, so\n          // \"(100 +/- 5) * 10%\" and \"10% of (100 +/- 5)\" are \"10 ± 0.5\". This sits\n          // ahead of uncertainOp, which declines for a Percentage operand.\n          const pctUnc = multiplyPercentWithUncertainty(l, r);\n          if (pctUnc) { stack.push(pctUnc); break; }\n          // Uncertainty first, so \"(12.3 +/- 0.5) * 4\" is \"49.2 ± 2.0\": a scalar\n          // multiply scales the spread by |k|, which the general quadrature rule\n          // gives when the plain operand is read as uncertainty 0. uncertainOp\n          // declines for a faulted or non-Number operand, so those keep their\n          // own paths below. See uncertainOp().\n          if (l.uncertainty !== undefined || r.uncertainty !== undefined) {\n            const uncMul = uncertainOp(l, r, \"mul\");\n            if (uncMul) { stack.push(uncMul); break; }\n          }\n          // Preserve exact fractions before the double fast path: \"2/7 * 14\" is\n          // exactly 4 and \"1/49 * 49\" exactly 1. Gated on a rational already\n          // being present, so a plain \"2 * 3\" pays only the two sidecar checks.\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const ratMul = exactRationalOp(l, r, \"mul\");\n            if (ratMul) { stack.push(ratMul); break; }\n          }\n          // Money times a scalar (a percentage, or a plain/computed number) stays\n          // exact to the cent, the same base-ten path as \"$X + p%\". After the\n          // rational check so \"$3 * 2/7\" keeps its exact fraction; ahead of\n          // binaryOp, which would read both as bare doubles and drop the sidecar,\n          // so \"50% of 1% of $3\" (a computed 0.005 factor) rounds like a till.\n          const moneyScalar = multiplyMoneyByScalarExact(l, r);\n          if (moneyScalar) { stack.push(moneyScalar); break; }\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            //\n            // Refused from the shapes BEFORE the multiply runs, because this is\n            // the one arithmetic result whose size is the PRODUCT of two\n            // separately legal operands: a 20,001x1 times a 1x20,001 is four\n            // hundred million cells from two matrices of twenty thousand, and\n            // that allocation aborted the process before any counter watching\n            // the result could have seen it. A check rather than a charge,\n            // since the result is charged once when `matrixValue()` builds it.\n            checkAllocation(matrixProductCells(l.value as MatrixData, r.value as MatrixData), \"matrix cells\");\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          // Dividing an uncertain number BY a percentage is a scalar divide, so\n          // it carries the tolerance: \"(100 +/- 5) / 10%\" is \"1000 ± 50\". This\n          // sits ahead of uncertainOp, which declines for a Percentage divisor.\n          const pctDivUnc = dividePercentWithUncertainty(l, r);\n          if (pctDivUnc) { stack.push(pctDivUnc); break; }\n          // Uncertainty first, ahead of both the Uom ratio and the exact-fraction\n          // paths below, so a carried tolerance is never dropped by either.\n          // uncertainOp declines unless both operands are plain Numbers, so\n          // \"$10 / 2\" and \"1/3\" are untouched. See uncertainOp().\n          if (l.uncertainty !== undefined || r.uncertainty !== undefined) {\n            const uncDiv = uncertainOp(l, r, \"div\");\n            if (uncDiv) { stack.push(uncDiv); break; }\n          }\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            // Integer division is the producer of exact fractions: \"1/3\" seeds\n            // the rational 1/3 that the rest of the system carries, so \"1/3 + 1/3\n            // + 1/3\" is exactly 1 and \"1/3 as fraction\" is exact. exactRationalOp\n            // declines for a non-integer operand, a bigint, or a zero divisor, so\n            // \"1.5 / 0.25\" and \"1/0\" keep the doubles binaryOp gives and \"100n /\n            // 3n\" stays exact integer division. The reduced result's nearest\n            // double equals the plain \"a / b\" quotient, so \"10 / 4\" is 2.5 and\n            // every existing division result is unchanged.\n            const ratDiv = exactRationalOp(l, r, \"div\");\n            if (ratDiv) { stack.push(ratDiv); break; }\n            // The bigint arm refuses a zero divisor rather than letting V8's\n            // own RangeError out. See bigIntDivisionByZero() for why this is\n            // an error while `1 / 0` is Infinity.\n            stack.push(binaryOp(l, r, (a, b) => a / b, (a, b) => { if (b === 0n) throw bigIntDivisionByZero(); return a / b; }, \"div\"));\n          }\n          break;\n        }\n        case OpCode.MOD: {\n          const r = safePop(stack), l = safePop(stack);\n          // Same zero case as DIV above, and refused the same way: a\n          // remainder is defined in terms of the quotient, so where one has\n          // no answer neither does the other.\n          stack.push(binaryOp(l, r, (a, b) => a % b, (a, b) => { if (b === 0n) throw bigIntDivisionByZero(); return 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(power(l.value as number, r.value as number)));\n            break;\n          }\n          // A Matrix operand means matrix exponentiation, which is repeated\n          // matrix multiplication and not the element-wise Math.pow the rest\n          // of this case does. Falling through was the same silent-zero shape\n          // the symbolic branch below documents: MatrixData.toNumber() is 0,\n          // so `[1,2;3,4]^2` answered 0 and `2^[1,2;3,4]` answered 1. `^T` and\n          // `^-1` never reach here, PrecedenceParser's caret-suffix rules take\n          // both at parse time, so every remaining shape that is not \"square\n          // matrix to a whole non-negative power\" is refused by name.\n          if (l.type === ValueType.Matrix || r.type === ValueType.Matrix) {\n            if (l.type !== ValueType.Matrix || r.type !== ValueType.Number) {\n              stack.push(errorValue(\n                \"MATRIX_POWER_UNSUPPORTED\",\n                `^: a matrix may only be the base, raised to a whole number (as in \"[1,2;3,4]^2\"); \"${ValueType[l.type]} ^ ${ValueType[r.type]}\" has no matrix reading.`,\n              ));\n              break;\n            }\n            // Checked against the whole repeated-squaring run rather than the\n            // answer alone, so a hopeless exponent is refused before the first\n            // multiplication instead of at whichever step happens to cross the\n            // line. See {@link matrixPowerCells}. Each intermediate matrix is\n            // still charged as `matrixValue()` builds it.\n            checkAllocation(matrixPowerCells(l.value as MatrixData, r.value as number), \"matrix cells\");\n            stack.push(matrixPower(l.value as MatrixData, 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          // A bigint operand raised to a whole power has an exact answer, and\n          // Math.pow does not give it: `2n ^ 100` came back as\n          // 1.2676506002282294e+30, a double's approximation of the very\n          // integer this type exists to hold. See exactPowBits() for when an\n          // exact answer exists at all, and for why there is a size limit.\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            const powBits = exactPowBits(l, r.toNumber());\n            if (powBits !== null) {\n              // Past the ceiling this refuses rather than handing the sum back\n              // to the double path, which would report a 30,103-digit integer\n              // as Infinity. See MAX_EXACT_POW_BITS for the decision.\n              if (powBits > MAX_EXACT_POW_BITS) {\n                throw ErrorFactory.execution(\n                  \"BIGINT_POW_LIMIT_EXCEEDED\",\n                  `That power would build an exact integer of about ${Math.round(powBits).toLocaleString(\"en-US\")} bits, past the limit of ${MAX_EXACT_POW_BITS.toLocaleString(\"en-US\")} bits`,\n                  { limitBits: MAX_EXACT_POW_BITS },\n                );\n              }\n              stack.push(bigIntValue(bigIntPow(toBigIntOperand(l), toBigIntOperand(r))));\n              break;\n            }\n            // A fractional or negative exponent has no bigint answer at all\n            // (`4n ^ 0.5` is 2 and `2n ^ -1` is 0.5), so those keep the double\n            // path below, which is their right answer rather than a fallback.\n          }\n          stack.push(numberValue(power(l.toNumber(), r.toNumber())));\n          break;\n        }\n        case OpCode.NEG: {\n          const v = safePop(stack);\n          // A negated fault is still a fault, and `-0` looks like an answer.\n          const negFault = faultedOperand(v);\n          if (negFault) { stack.push(negFault); break; }\n          if (v.type === ValueType.BigInt) stack.push(bigIntValue(-(v.value as bigint)));\n          // Negating money keeps it exact: \"-$0.10\" is exactly \"-$0.10\".\n          else if (v.type === ValueType.Uom && v.exact !== undefined) stack.push(uomValueExact(-v.toNumber(), v.unit!, decimalNegate(v.exact)));\n          else if (v.type === ValueType.Uom) stack.push(uomValue(-v.toNumber(), v.unit!));\n          // A negated percentage is still a percentage, for the same reason a\n          // negated Uom is still measured in the same unit. Without this\n          // branch `-10%` became the bare number -0.1, and every rule that\n          // reads a Percentage operand stopped seeing one: `200 + -10%`\n          // answered 199.9 (200 plus a tenth) instead of 180, `$300 + -15%`\n          // answered $299.85 instead of $255, and `-10%` displayed as \"-0.10\".\n          else if (v.type === ValueType.Percentage) stack.push(percentageValue(-v.toNumber()));\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          // Negating a fraction keeps it exact: \"-(1/3)\" carries the rational\n          // -1/3, so it still reads back exactly through \"as fraction\".\n          else if (v.type === ValueType.Number && v.rational !== undefined) stack.push(numberValueRational(-v.toNumber(), rationalNeg(v.rational)));\n          // Negating a decimal literal keeps its exact decimal, the same way\n          // money above does, so \"-1.005 to 2 dp\" rounds the exact -1.005 half\n          // away from zero to -1.01 rather than dropping to the drifted double\n          // (-1.00499...) the float path rounds toward zero.\n          else if (v.type === ValueType.Number && v.exact !== undefined) stack.push(numberValueExact(-v.toNumber(), decimalNegate(v.exact)));\n          else stack.push(numberValue(-v.toNumber()));\n          break;\n        }\n        case OpCode.POS: {\n          const v = safePop(stack);\n          const posFault = faultedOperand(v);\n          if (posFault) { stack.push(posFault); break; }\n          // Unary plus is a no-op, so money keeps its exact decimal too.\n          if (v.type === ValueType.Uom && v.exact !== undefined) stack.push(uomValueExact(v.toNumber(), v.unit!, v.exact));\n          else if (v.type === ValueType.Uom) stack.push(uomValue(v.toNumber(), v.unit!));\n          // Unary plus is a no-op, so it has to leave the type alone too.\n          else if (v.type === ValueType.Percentage) stack.push(percentageValue(v.toNumber()));\n          // A no-op keeps a fraction's exact rational, the same way it keeps\n          // money's exact decimal above.\n          else if (v.type === ValueType.Number && v.rational !== undefined) stack.push(numberValueRational(v.toNumber(), v.rational));\n          // And it keeps a decimal literal's exact decimal, so \"+1.005\" is still\n          // exactly 1.005 for a later \"to 2 dp\".\n          else if (v.type === ValueType.Number && v.exact !== undefined) stack.push(numberValueExact(v.toNumber(), v.exact));\n          else stack.push(numberValue(v.toNumber()));\n          break;\n        }\n        case OpCode.MAKE_UNCERTAIN: {\n          // `center ± spread`: the parselet pushed the center first, then the\n          // spread, so the spread pops first. A faulted operand propagates\n          // rather than being read as a zero center or spread.\n          const spread = safePop(stack), center = safePop(stack);\n          const uncFault = faultedOperand(center, spread);\n          if (uncFault) { stack.push(uncFault); break; }\n          // The center is the measured value, the spread its one-sigma tolerance.\n          // The spread is taken as a magnitude, so \"5 +/- -2\" reads the same as\n          // \"5 +/- 2\". Only a plain-number center carries an uncertainty (a unit\n          // or other typed center falls back to its bare magnitude, units with\n          // uncertainty are out of scope for this slice).\n          stack.push(numberValueUncertain(center.toNumber(), Math.abs(spread.toNumber())));\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §4  Bitwise  (OpCode 30–36)\n        //     None of these routes through binaryOp(), so each one carries\n        //     its own faulted-operand check for the reason that function\n        //     documents: a bit pattern read off an Error or a Pending is the\n        //     bit pattern of zero, and `(5 kg to m) & 1` answered 0 with\n        //     nothing to say it had not been asked a real question.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.LSHIFT: {\n          const r = safePop(stack), l = safePop(stack);\n          const shiftFault = faultedOperand(l, r);\n          if (shiftFault) { stack.push(shiftFault); break; }\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            // Bounded, unlike the plain-number path below, which cannot grow:\n            // a 32-bit shift is 32 bits whatever it is asked for. See\n            // bigIntShift().\n            stack.push(bigIntShift(l, r, 1));\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          const rshiftFault = faultedOperand(l, r);\n          if (rshiftFault) { stack.push(rshiftFault); break; }\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntShift(l, r, -1));\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          const urshiftFault = faultedOperand(l, r);\n          if (urshiftFault) { stack.push(urshiftFault); break; }\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          const andFault = faultedOperand(l, r);\n          if (andFault) { stack.push(andFault); break; }\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(toBigIntOperand(l) & toBigIntOperand(r)));\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          const orFault = faultedOperand(l, r);\n          if (orFault) { stack.push(orFault); break; }\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(toBigIntOperand(l) | toBigIntOperand(r)));\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          const xorFault = faultedOperand(l, r);\n          if (xorFault) { stack.push(xorFault); break; }\n          if (l.type === ValueType.BigInt || r.type === ValueType.BigInt) {\n            stack.push(bigIntValue(toBigIntOperand(l) ^ toBigIntOperand(r)));\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          const notFault = faultedOperand(v);\n          if (notFault) { stack.push(notFault); break; }\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        //     all six unify UoM operands before comparing them.\n        //\n        //     The four ordering opcodes used to skip that unification and\n        //     compare the bare magnitudes, so `1 km > 500 m` answered false\n        //     and `30 min < 1 hour` answered false as well. They now go\n        //     through compareUom() like EQ/NEQ, which also means they agree\n        //     with EQ about where the boundary between \"less\" and \"equal\"\n        //     falls: `equal` there is a tolerance rather than `===`, so a\n        //     pair EQ calls equal is one GT and LT both call false.\n        //\n        //     Two units that share no measure cannot be ordered at all, so\n        //     the four ordering opcodes answer with an error rather than a\n        //     boolean. EQ and NEQ still answer with a boolean, because\n        //     \"a kilogram is not a metre\" is a true statement about a pair\n        //     that cannot be converted, whereas \"a kilogram is less than a\n        //     metre\" is not a statement at all.\n        //\n        //     A faulted operand is the second case even for EQ and NEQ, and\n        //     all six propagate it. A kilogram is a quantity that is not a\n        //     metre; an Error is not a quantity, so there is nothing for it\n        //     to be equal to. Reading its number gave zero, which made\n        //     `(5 kg to m) == 0` answer true.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.EQ: {\n          const r = safePop(stack), l = safePop(stack);\n          const eqFault = faultedOperand(l, r);\n          if (eqFault) { stack.push(eqFault); break; }\n          // Equal fractions are equal on the value, not on whichever doubles\n          // they rounded to: \"1/49 * 49 == 1\" is true. Gated on a rational being\n          // present, so \"1 == 1\" keeps its double compare below.\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const cmp = compareRationalOperands(l, r);\n            if (cmp !== null) { stack.push(boolValue(cmp === 0)); break; }\n          }\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.BigInt || r.type === ValueType.BigInt) {\n            // Comparing through toNumber() rounds a bigint to the nearest\n            // double first, so two giants a single digit apart landed on the\n            // same double and this answered true. See compareBigIntOperands().\n            const cmp = compareBigIntOperands(l, r);\n            stack.push(boolValue(cmp === null ? l.toNumber() === r.toNumber() : cmp === 0));\n          } else if (l.type === ValueType.String && r.type === ValueType.String) {\n            // Two strings compare as strings. Through toNumber() every\n            // non-numeric string reads as 0, so `\"a\" == \"b\"` answered true.\n            stack.push(boolValue((l.value as string) === (r.value as string)));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { equal, sameMeasure } = compareUom(l, r);\n            stack.push(boolValue(sameMeasure && equal));\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 if (l.type === ValueType.Colour || r.type === ValueType.Colour) {\n            // A colour equals only another colour with the same canonical\n            // channels, so `#ff0000 == rgb(255,0,0)` is true regardless of\n            // format. A colour and a non-colour are never equal: NOT via\n            // toNumber() (0 for a colour), which would make `#000000 == 0` true,\n            // exactly the coercion fault this repo guards against.\n            if (l.type === ValueType.Colour && r.type === ValueType.Colour) {\n              const a = l.value as ColourData, b = r.value as ColourData;\n              stack.push(boolValue(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a));\n            } else {\n              stack.push(boolValue(false));\n            }\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          const neqFault = faultedOperand(l, r);\n          if (neqFault) { stack.push(neqFault); break; }\n          // The negation of EQ's rational branch, fraction for fraction.\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const cmp = compareRationalOperands(l, r);\n            if (cmp !== null) { stack.push(boolValue(cmp !== 0)); break; }\n          }\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.BigInt || r.type === ValueType.BigInt) {\n            // The negation of EQ's bigint branch above, digit for digit.\n            const cmp = compareBigIntOperands(l, r);\n            stack.push(boolValue(cmp === null ? l.toNumber() !== r.toNumber() : cmp !== 0));\n          } else if (l.type === ValueType.String && r.type === ValueType.String) {\n            stack.push(boolValue((l.value as string) !== (r.value as string)));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { equal, sameMeasure } = compareUom(l, r);\n            stack.push(boolValue(!sameMeasure || !equal));\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 if (l.type === ValueType.Colour || r.type === ValueType.Colour) {\n            // The negation of EQ's colour branch: two colours differ by channel,\n            // and a colour and a non-colour are always unequal.\n            if (l.type === ValueType.Colour && r.type === ValueType.Colour) {\n              const a = l.value as ColourData, b = r.value as ColourData;\n              stack.push(boolValue(!(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a)));\n            } else {\n              stack.push(boolValue(true));\n            }\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          const ltFault = faultedOperand(l, r);\n          if (ltFault) { stack.push(ltFault); break; }\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const cmp = compareRationalOperands(l, r);\n            if (cmp !== null) { stack.push(boolValue(cmp < 0)); break; }\n          }\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.BigInt || r.type === ValueType.BigInt) {\n            // Digit-exact, for the reason given on EQ's matching branch.\n            const cmp = compareBigIntOperands(l, r);\n            stack.push(boolValue(cmp === null ? l.toNumber() < r.toNumber() : cmp < 0));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, equal, sameMeasure } = compareUom(l, r);\n            stack.push(sameMeasure ? boolValue(!equal && lv < rv) : incomparableUnitsError(l, r));\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          const lteFault = faultedOperand(l, r);\n          if (lteFault) { stack.push(lteFault); break; }\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const cmp = compareRationalOperands(l, r);\n            if (cmp !== null) { stack.push(boolValue(cmp <= 0)); break; }\n          }\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.BigInt || r.type === ValueType.BigInt) {\n            const cmp = compareBigIntOperands(l, r);\n            stack.push(boolValue(cmp === null ? l.toNumber() <= r.toNumber() : cmp <= 0));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, equal, sameMeasure } = compareUom(l, r);\n            stack.push(sameMeasure ? boolValue(equal || lv <= rv) : incomparableUnitsError(l, r));\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          const gtFault = faultedOperand(l, r);\n          if (gtFault) { stack.push(gtFault); break; }\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const cmp = compareRationalOperands(l, r);\n            if (cmp !== null) { stack.push(boolValue(cmp > 0)); break; }\n          }\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.BigInt || r.type === ValueType.BigInt) {\n            const cmp = compareBigIntOperands(l, r);\n            stack.push(boolValue(cmp === null ? l.toNumber() > r.toNumber() : cmp > 0));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, equal, sameMeasure } = compareUom(l, r);\n            stack.push(sameMeasure ? boolValue(!equal && lv > rv) : incomparableUnitsError(l, r));\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          const gteFault = faultedOperand(l, r);\n          if (gteFault) { stack.push(gteFault); break; }\n          if (l.rational !== undefined || r.rational !== undefined) {\n            const cmp = compareRationalOperands(l, r);\n            if (cmp !== null) { stack.push(boolValue(cmp >= 0)); break; }\n          }\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.BigInt || r.type === ValueType.BigInt) {\n            const cmp = compareBigIntOperands(l, r);\n            stack.push(boolValue(cmp === null ? l.toNumber() >= r.toNumber() : cmp >= 0));\n          } else if (l.type === ValueType.Uom && r.type === ValueType.Uom) {\n            const { lv, rv, equal, sameMeasure } = compareUom(l, r);\n            stack.push(sameMeasure ? boolValue(equal || lv >= rv) : incomparableUnitsError(l, r));\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        //     Truthiness is read through isTruthy(), which reads a number,\n        //     which is zero for a fault, so a failed operand used to be\n        //     quietly false. Both operands are already evaluated by the time\n        //     either opcode runs (this VM has no branch opcodes), so there is\n        //     no short-circuit to preserve by ignoring the right-hand one.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.LOGICAL_AND: {\n          const r = safePop(stack), l = safePop(stack);\n          const andLogicFault = faultedOperand(l, r);\n          if (andLogicFault) { stack.push(andLogicFault); break; }\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          const orLogicFault = faultedOperand(l, r);\n          if (orLogicFault) { stack.push(orLogicFault); break; }\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          // Only the CONDITION is checked for a fault, unlike every other\n          // opcode here. Both arms are already evaluated, and the arm that is\n          // not chosen is not part of the answer: refusing `if 1 then 2 else\n          // (5 kg to m)` would report a failure the reader's own line never\n          // asked about. A faulted condition selects nothing, so it stands.\n          const conditionFault = faultedOperand(condition);\n          if (conditionFault) { stack.push(conditionFault); break; }\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 = operandByte(opcodes, ip++, op, \"plugin-function index\");\n          const argCount = operandByte(opcodes, ip++, op, \"argument count\");\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          // A plugin handler reads its arguments the same way a builtin does,\n          // and none of them can do anything useful with an argument that\n          // failed or has not arrived: the call would be made with a zero, or\n          // with a query built from one. Checked here rather than in each\n          // handler, for the same reason the arity check below lives at the\n          // dispatch point.\n          const pluginArgFault = faultedIn(args);\n          if (pluginArgFault) {\n            stack.push(pluginArgFault);\n          } else 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 = operandByte(opcodes, ip++, op, \"builtin-function index\");\n          const argCount = operandByte(opcodes, ip++, op, \"argument count\");\n          // Argument count first, before anything is popped. Every builtin\n          // indexes its args positionally with no length check of its own, so\n          // `sqrt()` used to reach `args[0].toNumber()` on an empty array and\n          // throw a raw TypeError that arrived at the host as an INTERNAL\n          // engine bug naming no function. This is the only place that knows\n          // both the index and the count; see vm/VMBuiltinArity.ts.\n          const arityError = builtinArityError(fnIdx, argCount);\n          if (arityError) throw arityError;\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          // The same argument as the symbolic routing below, for the operand\n          // type that has no reading at all rather than a non-numeric one:\n          // every implementation reads args[n].toNumber(), which is 0 for an\n          // Error and for a Pending, so `abs(5 kg to m)` answered 0 and\n          // `round(<a price still loading>)` answered 0 as well. One check\n          // here covers all ~90 of them; see faultedOperand() in vm/Value.ts.\n          const builtinArgFault = faultedIn(args);\n          if (builtinArgFault) { stack.push(builtinArgFault); break; }\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 = operandByte(opcodes, ip++, op, \"function-body index\");\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 name = poolString(opcodes, ip++, strings, op, \"function-name index\");\n          const argCount = operandByte(opcodes, ip++, op, \"argument count\");\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          // Two guards, because they bound two different numbers and each is\n          // blind to the other's case.\n          //\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          //\n          // chargeFunctionCall() bounds how MANY calls this evaluation makes\n          // rather than how deeply they nest, which the depth guard cannot\n          // see: `f(n)(v) = f(n-1)(v) + f(n-1)(v)` over twenty-two lines nests\n          // twenty-two deep and calls two million times, and killed the\n          // process. It is charged here rather than counted in the VM because\n          // the tally has to survive the reentrant call below, exactly like\n          // the allocation tally and unlike localInstructionCount.\n          chargeFunctionCall();\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 = poolString(opcodes, ip++, strings, op, \"variable-name index\");\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 = poolString(opcodes, ip++, strings, op, \"variable-name index\");\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 = poolString(opcodes, ip++, strings, op, \"variable-name index\");\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 = poolString(opcodes, ip++, strings, op, \"variable-name index\");\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        //     Every one of these restates a number in another notation, so a\n        //     faulted operand has nothing to restate and each propagates it\n        //     rather than converting the zero toNumber() reports. Without it\n        //     \"(5 kg to m) as hex\" answered 0x0 and \"as binary\" answered 0b0.\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.TO_NUMBER: {\n          const v = safePop(stack);\n          const toNumberFault = faultedOperand(v);\n          if (toNumberFault) { stack.push(toNumberFault); break; }\n          stack.push(numberValue(v.toNumber()));\n          break;\n        }\n        case OpCode.TO_HEX: {\n          const v = safePop(stack);\n          const toHexFault = faultedOperand(v);\n          if (toHexFault) { stack.push(toHexFault); break; }\n          // A colour already has a hex reading, so `#3366cc as rgb as hex` should\n          // round-trip rather than collapse through toNumber() (which is 0 for a\n          // colour). Re-tag its display format to hex, leaving channels intact.\n          if (v.type === ValueType.Colour) {\n            const c = v.value as ColourData;\n            stack.push(colourValue({ r: c.r, g: c.g, b: c.b, a: c.a, format: \"hex\" }));\n            break;\n          }\n          // A bigint keeps its bigint, exactly as ADD/SUB/MUL/DIV do:\n          // `12345678901234567890n as hex` rendered 0xAB54A98CEB1F0800 while\n          // the value ends 0AD2, because toNumber() rounded it first.\n          stack.push(hexValue(v.type === ValueType.BigInt ? (v.value as bigint) : v.toNumber()));\n          break;\n        }\n        case OpCode.TO_PERCENTAGE: {\n          const v = safePop(stack);\n          const toPercentageFault = faultedOperand(v);\n          if (toPercentageFault) { stack.push(toPercentageFault); break; }\n          stack.push(percentageValue(v.toNumber()));\n          break;\n        }\n        case OpCode.TO_FRACTION: {\n          const v = safePop(stack);\n          const toFractionFault = faultedOperand(v);\n          if (toFractionFault) { stack.push(toFractionFault); break; }\n          // A value carrying its exact rational renders that fraction exactly;\n          // everything else keeps the continued-fraction guess from the double,\n          // so \"0.75 as fraction\" is still \"3/4\".\n          stack.push(stringValue(v.rational !== undefined ? rationalToFractionString(v.rational) : toFractionString(v.toNumber())));\n          break;\n        }\n        case OpCode.TO_MULTIPLIER: {\n          const v = safePop(stack);\n          const toMultiplierFault = faultedOperand(v);\n          if (toMultiplierFault) { stack.push(toMultiplierFault); break; }\n          stack.push(stringValue(toMultiplierString(v)));\n          break;\n        }\n        case OpCode.TO_SCI: {\n          const v = safePop(stack);\n          const toSciFault = faultedOperand(v);\n          if (toSciFault) { stack.push(toSciFault); break; }\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          const toBinaryFault = faultedOperand(v);\n          if (toBinaryFault) { stack.push(toBinaryFault); break; }\n          stack.push(hexValue(v.type === ValueType.BigInt ? (v.value as bigint) : v.toNumber(), \"bin\"));\n          break;\n        }\n        case OpCode.TO_OCTAL: {\n          const v = safePop(stack);\n          const toOctalFault = faultedOperand(v);\n          if (toOctalFault) { stack.push(toOctalFault); break; }\n          stack.push(hexValue(v.type === ValueType.BigInt ? (v.value as bigint) : v.toNumber(), \"oct\"));\n          break;\n        }\n        case OpCode.CALL_AS_CONVERTER: {\n          const name = stringOperand(safePop(stack), op, \"converter name\").toLowerCase();\n          const value = safePop(stack);\n          // A registered converter is arbitrary host code reading the Value\n          // it is handed, so the fault is stopped before it gets there rather\n          // than inside each converter.\n          const converterFault = faultedOperand(value);\n          if (converterFault) { stack.push(converterFault); break; }\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 = stringOperand(safePop(stack), op, \"unit name\");\n          const operand = safePop(stack);\n          const faulted = faultedOperand(operand);\n          if (faulted) { stack.push(faulted); break; }\n          // Money keeps its exact decimal from here on. The amount either\n          // arrived as a decimal literal (exact sidecar already set) or is a\n          // whole number, either of which has an exact decimal; a fractional\n          // double amount (\"$sqrt(2)\") has none and stays an ordinary float\n          // Uom. Only currencies carry the sidecar, so every other unit (km,\n          // kg, ...) is unchanged.\n          const money = moneyExactMagnitude(operand, unit);\n          if (money) stack.push(uomValueExact(operand.toNumber(), unit, money));\n          else stack.push(uomValue(operand.toNumber(), unit));\n          break;\n        }\n        case OpCode.UOM_CONVERT_TO: {\n          const toUnit = stringOperand(safePop(stack), op, \"target unit name\");\n          const fromUnit = stringOperand(safePop(stack), op, \"source unit name\");\n          const operand = safePop(stack);\n          // The quantity being converted may already have failed, and a\n          // conversion is the one operator that made that invisible: it reads\n          // the operand's number, gets the zero Error and Pending report, and\n          // pushes it back wearing the unit the reader asked for. `5 kg to m\n          // to s` answered `0.00 s` and `60 km/h in m/s` answered `0.00 /s`,\n          // a plausible number in a unit with no numerator, with the failed\n          // first conversion nowhere on screen. `binaryOp` has refused this\n          // for `+` and `*` since it was written, which is why the same value\n          // carried its fault everywhere except through here.\n          const faulted = faultedOperand(operand);\n          if (faulted) { stack.push(faulted); break; }\n          const val = operand.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            // A rate or speed spelling (\"km/h\", \"m/s\", \"mph\") has no single\n            // measure, so the checks above cannot see it. \"100 km/h in mph\"\n            // and \"10 m/s in km/h\" reach conversion here, not through\n            // convertUnit(). A null means the pair really is incompatible.\n            const rate = convertRate(val, fromUnit, toUnit);\n            if (rate !== null) {\n              stack.push(uomValue(rate, toUnit));\n            } else {\n              stack.push(incompatibleConversionError(fromUnit, toUnit));\n            }\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 = stringOperand(safePop(stack), op, \"unit name\");\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 = stringOperand(safePop(stack), op, \"unit name\");\n          const operand = safePop(stack);\n          const faulted = faultedOperand(operand);\n          if (faulted) { stack.push(faulted); break; }\n          const { value, unit: bestUnit } = getBestUnit(operand.toNumber(), unit);\n          stack.push(uomValue(value, bestUnit));\n          break;\n        }\n        case OpCode.UOM_CONVERT_IN: {\n          const toUnit = stringOperand(safePop(stack), op, \"target unit name\");\n          const left = safePop(stack);\n          // See UOM_CONVERT_TO above. This is the spelling `5 kg to m to s`\n          // actually reaches, since the second conversion's source is an\n          // expression rather than a literal: an Error is not a Uom, so it\n          // fell into the else branch at the bottom and came back out as\n          // `uomValue(0, \"s\")`.\n          const faulted = faultedOperand(left);\n          if (faulted) { stack.push(faulted); break; }\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              // Rate or speed conversion, \"(120 km / 2 hours) in kph\". See the\n              // matching branch in UOM_CONVERT_TO above.\n              const rate = convertRate(val, fromUnit, toUnit);\n              if (rate !== null) {\n                stack.push(uomValue(rate, toUnit));\n              } else {\n                stack.push(incompatibleConversionError(fromUnit, toUnit));\n              }\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          const getValueFault = faultedOperand(v);\n          if (getValueFault) { stack.push(getValueFault); break; }\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          // \"60 km/h in m/s\" reaches here with a failed conversion as its\n          // numerator, and a rate built from one is the same silent zero the\n          // conversion opcodes had, wearing an even stranger unit: the\n          // numerator label comes off the operand's type, so an Error\n          // contributed no label at all and the answer displayed as\n          // \"0.00 /s\", a rate of nothing per second.\n          const rateDivFault = faultedOperand(numeratorVal, denominatorVal);\n          if (rateDivFault) { stack.push(rateDivFault); break; }\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          const rateMulFault = faultedOperand(rate, multiplier);\n          if (rateMulFault) { stack.push(rateMulFault); break; }\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 = stringOperand(safePop(stack), op, \"denominator unit name\");\n          const rate = safePop(stack);\n          const rateConvertFault = faultedOperand(rate);\n          if (rateConvertFault) { stack.push(rateConvertFault); break; }\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 minutesValue = safePop(stack);\n          const clockFault = faultedOperand(minutesValue);\n          if (clockFault) { stack.push(clockFault); break; }\n          const totalMinutes = minutesValue.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[poolIndex(opcodes, ip++, op, \"constant-pool index\", numbers.length, \"number-pool\")]));\n          break;\n        case OpCode.DATE_ADD: {\n          const durValue = safePop(stack), dtValue = safePop(stack);\n          // A duration read off a fault is zero, so the date came back\n          // unmoved: an answer that looks exactly like a correct one. Same\n          // reasoning as OpCode.ADD's own check.\n          const dateAddFault = faultedOperand(dtValue, durValue);\n          if (dateAddFault) { stack.push(dateAddFault); break; }\n          stack.push(datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, 1, vm)));\n          break;\n        }\n        case OpCode.DATE_SUB: {\n          const durValue = safePop(stack), dtValue = safePop(stack);\n          const dateSubFault = faultedOperand(dtValue, durValue);\n          if (dateSubFault) { stack.push(dateSubFault); break; }\n          stack.push(datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, -1, vm)));\n          break;\n        }\n        case OpCode.DATE_WORKDAY_OFFSET: {\n          // \"N working days after/before/from <date>\". One operand byte gives\n          // the direction: 0 forward (after/from), 1 backward (before). The\n          // anchor date is on top (WorkdayOffsetParselet compiles it last); the\n          // count is the left operand beneath it. Routed through the same\n          // addBusinessDays() as `<date> + N workdays`, so the two forms and\n          // the holiday calendar stay in lockstep.\n          const workdayDirection = operandByte(opcodes, ip++, op, \"workday offset direction\") === 1 ? -1 : 1;\n          const anchorValue = safePop(stack), countValue = safePop(stack);\n          const offsetFault = faultedOperand(countValue, anchorValue);\n          if (offsetFault) { stack.push(offsetFault); break; }\n          if (anchorValue.type !== ValueType.Datetime) {\n            stack.push(errorValue(\n              CoreErrorCodes.WORKDAY_OFFSET_EXPECTED_DATE,\n              `\"working days after/before/from\" expects a date to count from, got ${ValueType[anchorValue.type] ?? \"an unsupported value\"}`,\n            ));\n            break;\n          }\n          stack.push(datetimeValue(addBusinessDays(anchorValue.toNumber(), workdayDirection * countValue.toNumber(), vm)));\n          break;\n        }\n        case OpCode.DATE_WORKDAYS_BETWEEN: {\n          // \"working days between <date> and <date>\": the count of working days\n          // in the inclusive span, order-independent. Stack: [start, end], end\n          // on top (WorkdaysBetweenParselet compiles the second endpoint last).\n          const endValue = safePop(stack), startValue = safePop(stack);\n          const betweenFault = faultedOperand(startValue, endValue);\n          if (betweenFault) { stack.push(betweenFault); break; }\n          if (startValue.type !== ValueType.Datetime || endValue.type !== ValueType.Datetime) {\n            stack.push(errorValue(\n              CoreErrorCodes.WORKDAYS_BETWEEN_EXPECTED_DATES,\n              `\"working days between\" expects two dates, got ${ValueType[startValue.type] ?? \"an unsupported value\"} and ${ValueType[endValue.type] ?? \"an unsupported value\"}`,\n            ));\n            break;\n          }\n          // Bounded by the full configured offset range in calendar days, so a\n          // span of millennia is refused rather than walked a day at a time.\n          const spanLimitDays = Math.ceil((vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()) * 366);\n          const workdayCount = countBusinessDaysBetween(startValue.toNumber(), endValue.toNumber(), (ms) => vm.isHoliday(ms), spanLimitDays);\n          if (workdayCount === null) {\n            stack.push(errorValue(\n              CoreErrorCodes.WORKDAYS_BETWEEN_RANGE_TOO_LARGE,\n              `The two dates are more than ${vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()} years apart, past the working-day count's limit`,\n            ));\n            break;\n          }\n          stack.push(numberValue(workdayCount));\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 targetDayValue = safePop(stack);\n          const nowValue = safePop(stack);\n          const weekdayFault = faultedOperand(nowValue, targetDayValue);\n          if (weekdayFault) { stack.push(weekdayFault); break; }\n          const targetDay = targetDayValue.toNumber();\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          // Stepped as calendar days rather than added as milliseconds: a\n          // week that contains a daylight-saving transition is not 7 x\n          // 86,400,000 ms long, and being an hour out is enough to land on the\n          // day before or after the weekday that was asked for. See\n          // addCalendarDays() above.\n          stack.push(datetimeValue(addCalendarDays(now, op === OpCode.DATE_NEXT_WEEKDAY ? diffDays : -diffDays)));\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 = operandByte(opcodes, ip++, op, \"row count\");\n          const cols = operandByte(opcodes, ip++, op, \"column count\");\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 = checkedArray<MatrixEntry>(count, \"matrix cells\");\n          // A MatrixEntry is a number, a boolean or a symbolic node, so a\n          // faulted cell has nowhere to live inside the matrix and became a\n          // zero cell nothing could tell apart from a real one. The whole\n          // literal fails instead, the way one bad cell fails a map() (see\n          // MAP_INVOKE's own check).\n          let cellFault: Value | null = null;\n          for (let i = count - 1; i >= 0; i--) {\n            const cellVal = safePop(stack);\n            if (cellFault === null) cellFault = faultedOperand(cellVal);\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          if (cellFault) { stack.push(cellFault); break; }\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          // Pending as well as Error, here and in the three cases below: a\n          // value that has not arrived yet indexes no better than one that\n          // failed, and toNumber() reports zero for both. These checked only\n          // Error, so an index still loading read as cell 0.\n          const index1Fault = faultedOperand(matrixVal, indexVal);\n          if (index1Fault) { stack.push(index1Fault); 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          const index2Fault = faultedOperand(matrixVal, rowVal, colVal);\n          if (index2Fault) { stack.push(index2Fault); 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          const rangeFault = faultedOperand(minVal, maxVal);\n          if (rangeFault) { stack.push(rangeFault); 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          const sliceFault = faultedOperand(matrixVal, rowRangeVal, colRangeVal);\n          if (sliceFault) { stack.push(sliceFault); 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 = checkedArray<MatrixEntry>(newRows * newCols, \"matrix cells\");\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 = operandByte(opcodes, ip++, op, \"body kind\");\n          const ref = operandByte(opcodes, ip++, op, \"body reference\");\n          const collectionCount = operandByte(opcodes, ip++, op, \"collection count\");\n          requireKnownBodyKind(kind, ref, op);\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 = pooledString(strings, ref, op);\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], vm.getMaxCollectionSize());\n            if (!Array.isArray(resolved)) { mapEarlyError = resolved; break; }\n            // Charged after the fact, which is safe only because\n            // `maxCollectionSize` has already bounded this one expansion to\n            // something survivable. The tally is what stops the SECOND and\n            // third: individually legal collections are legal together, and\n            // nothing else counts them. Delete this line if\n            // `collectionToValues()` ever charges before expanding, which is\n            // the better place for it (it knows the length before it allocates)\n            // and would make this a double charge.\n            chargeAllocation(resolved.length, \"collection elements\");\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[] = checkedArray<MatrixEntry>(collectionLength, \"matrix cells\");\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            const resultFault = faultedOperand(resultVal);\n            if (resultFault) { mapError = resultFault; 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          // A mapped matrix keeps the shape it was given. `resultData` is\n          // filled in the same order `collectionToValues()` read the cells\n          // out, which for a Matrix is its own column-major storage order,\n          // so handing that array straight back with the source dimensions\n          // puts every result in the cell its input came from. Without this\n          // `map(x*2, [1,2;3,4])` answered a 1x4 row reading [2,6,4,8]: not\n          // just the wrong shape but the storage order leaking into what the\n          // user sees, since 6 is the image of 3, the cell BELOW 1. A Range\n          // (and a 1xN literal) is a row either way.\n          const firstCollection = rawCollections[0];\n          const sourceShape = firstCollection?.type === ValueType.Matrix ? (firstCollection.value as MatrixData) : undefined;\n          if (sourceShape && sourceShape.rows * sourceShape.cols === collectionLength) {\n            stack.push(matrixValue(sourceShape.rows, sourceShape.cols, resultData));\n          } else {\n            stack.push(matrixValue(1, collectionLength, resultData));\n          }\n          break;\n        }\n\n        case OpCode.REDUCE_INVOKE: {\n          const kind = operandByte(opcodes, ip++, op, \"body kind\");\n          const ref = operandByte(opcodes, ip++, op, \"body reference\");\n          const hasInitial = operandByte(opcodes, ip++, op, \"initial-value flag\");\n          requireKnownBodyKind(kind, ref, op);\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 = pooledString(strings, ref, op);\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, vm.getMaxCollectionSize());\n          if (!Array.isArray(cells)) { stack.push(cells); break; }\n          // Same post-charge, and the same note, as MAP_INVOKE above.\n          chargeAllocation(cells.length, \"collection elements\");\n\n          let acc: Value;\n          let startIdx: number;\n          if (initialVal !== undefined) {\n            const initialFault = faultedOperand(initialVal);\n            if (initialFault) { stack.push(initialFault); 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            const stepFault = faultedOperand(resultVal);\n            if (stepFault) { reduceError = stepFault; break; }\n            acc = resultVal;\n          }\n          if (reduceError) { stack.push(reduceError); break; }\n\n          stack.push(acc);\n          break;\n        }\n\n        // ═══════════════════════════════════════════════════════════════\n        // §12 Algebra verbs' bound unknown  (OpCode 159)\n        // ═══════════════════════════════════════════════════════════════\n        case OpCode.BIND_UNKNOWN: {\n          const ref = operandByte(opcodes, ip++, op, \"body reference\");\n          const def = anonymousBodies?.[ref];\n          if (!def) {\n            throw ErrorFactory.internal(\n              \"INTERNAL_MISSING_ANONYMOUS_BODY\",\n              `Internal error: BIND_UNKNOWN referenced missing anonymous body index ${ref}`,\n              { ref },\n            );\n          }\n          // `der(x^2, x)` names x as the unknown, so inside that expression x\n          // IS the unknown, whatever the document says elsewhere. Evaluated in\n          // a call frame binding the name to itself, the same mechanism that\n          // already makes a function's parameter shadow a document variable\n          // (see `getVar`, which reads the innermost frame first). Without it\n          // an earlier `:x = 5` turned `der(x^2, x)` into `der(25, x)`, and\n          // the answer 0 looked exactly like a correct one.\n          stack.push(invokeWithBoundUnknown(def.params[0], def.program, vm, pipeline, expression, context, !!symbolicTolerant));\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    } finally {\n        endEvaluation();\n    }\n}"]}