solve-engine 1.2.0 → 2.0.0

package/dist/chunk-FE4RC37D.js

@@ -1,2801 +0,0 @@
-import { DiagnosticEventType } from './chunk-UF6JG5SG.js';
-import { defaultEngineContext, builtinFunctions, moneyExactMagnitude, asConverterRegistry, sharedGlobalVariableStore, SYMBOLIC_NATIVE_BUILTINS, symbolicBuiltin, compareRationalOperands, compareBigIntOperands, compareUom, incomparableUnitsError, toBigIntOperand, symbolicNeg, power, symbolicPow, binaryOp, bigIntDivisionByZero, uncertainOp, unifyUom, exactRationalOp, describeConversionMismatch, scaleMoneyExact, scaleMoneyByPercent } from './chunk-WMQRJTAO.js';
-import { sharedCurrencyExchange } from './chunk-BSPXMGIS.js';
-import { getOpCodeName } from './chunk-BLI4NIQY.js';
-import { collectionToValues, matAt, inBounds, matrixEntryToValue, matIndex, rowMajorToColumnMajor, varNode, matrixCompare, decimalNegate, rationalNeg, matrixPower, matrixMultiply, decimalFromLiteral, decimalToNumber, CURRENCY_DISPLAY } from './chunk-ZNFFTYWH.js';
-import { numberValue, ValueType, isArenaActive, beginEvaluation, errorValue, chargeAllocation, faultedOperand, checkedArray, matrixValue, rangeValue, datetimeValue, isRateUnit, splitRateUnit, rateValue, uomValue, stringValue, uomValueExact, hexValue, percentageValue, colourValue, persistentValue, symbolicValue, chargeFunctionCall, faultedIn, boolValue, bigIntValue, numberValueUncertain, numberValueRational, numberValueExact, checkAllocation, isTimecodeUnit, endEvaluation, timecodeFps } from './chunk-5EFKSKMA.js';
-import { getMeasure, convertUnit, convertRate, getBestUnit, getConvertiblePossibilities, isWorkdayUnit } from './chunk-MVTOCRV2.js';
-import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory, CoreErrorCodes, normalizeUnknownError } from './chunk-N7OA4WPJ.js';
-
-// src/vm/DependencyGraph.ts
-var DependencyGraph = class {
-  constructor() {
-    this.consumers = /* @__PURE__ */ new Map();
-    this.dependencies = /* @__PURE__ */ new Map();
-    this.writes = /* @__PURE__ */ new Map();
-    this.lineReads = /* @__PURE__ */ new Map();
-    // Data source dependencies: line number -> Set of query keys
-    this.dataSourceDependencies = /* @__PURE__ */ new Map();
-    // Reverse map: query key -> Set of line numbers
-    this.dataSourceConsumers = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Register a line's variable reads and writes in the dependency graph.
-   *
-   * If re-registering the same line (e.g., after editing), old consumer
-   * references are cleaned up first. Write-variables are removed from
-   * the consumer set so that redefinition breaks the old dependency chain.
-   *
-   * @param lineNumber - 1-based line number in the document
-   * @param reads - Variable names this line reads
-   * @param writes - Variable names this line writes (assigns to)
-   */
-  registerLine(lineNumber, reads, writes) {
-    const oldReads = this.lineReads.get(lineNumber);
-    if (oldReads) {
-      for (const oldRead of oldReads) {
-        const consumers = this.consumers.get(oldRead);
-        if (consumers) consumers.delete(lineNumber);
-      }
-    }
-    this.lineReads.set(lineNumber, new Set(reads));
-    for (const dep of reads) {
-      if (!this.consumers.has(dep)) this.consumers.set(dep, /* @__PURE__ */ new Set());
-      this.consumers.get(dep).add(lineNumber);
-    }
-    if (writes.length > 0) {
-      this.dependencies.set(lineNumber, new Set(reads));
-      this.writes.set(lineNumber, new Set(writes));
-      for (const write of writes) {
-        const prevConsumer = this.consumers.get(write);
-        if (prevConsumer) prevConsumer.delete(lineNumber);
-      }
-    }
-  }
-  /**
-   * Register a line's dependency on an external data source (e.g., currency rate, OSRS GE price).
-   *
-   * When the data source updates, {@link getAffectedLinesByDataSource} returns all lines
-   * that depend on this data, enabling targeted re-evaluation.
-   *
-   * @param lineNumber - 1-based line number in the document
-   * @param dataSourceId - Unique identifier for the data source (e.g., "currency", "osrs-ge")
-   * @param queryKey - Query key array identifying the specific data (e.g., ["USD", "EUR"])
-   */
-  registerLineDataSourceDependency(lineNumber, dataSourceId, queryKey) {
-    const queryKeyStr = JSON.stringify(queryKey);
-    const key = `${dataSourceId}:${queryKeyStr}`;
-    if (!this.dataSourceDependencies.has(lineNumber)) {
-      this.dataSourceDependencies.set(lineNumber, /* @__PURE__ */ new Set());
-    }
-    this.dataSourceDependencies.get(lineNumber).add(key);
-    if (!this.dataSourceConsumers.has(key)) {
-      this.dataSourceConsumers.set(key, /* @__PURE__ */ new Set());
-    }
-    this.dataSourceConsumers.get(key).add(lineNumber);
-  }
-  /**
-   * Find all lines affected by a changed variable via BFS through the consumer graph.
-   *
-   * When a variable is modified (e.g., `:x = 5` changes to `:x = 10`), this returns
-   * all lines that transitively depend on it, lines that read `x`, lines that read
-   * variables written by those lines, and so on.
-   *
-   * @param changedVariable - The variable name that changed
-   * @returns Set of line numbers that need re-evaluation
-   */
-  getAffectedLines(changedVariable) {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [changedVariable];
-    while (queue.length > 0) {
-      const varName = queue.pop();
-      const consumers = this.consumers.get(varName);
-      if (!consumers) continue;
-      for (const line of consumers) {
-        if (visited.has(line)) continue;
-        visited.add(line);
-        const lineWrites = this.writes.get(line);
-        if (lineWrites) {
-          for (const writtenVar of lineWrites) {
-            queue.push(writtenVar);
-          }
-        }
-      }
-    }
-    return visited;
-  }
-  /**
-   * Phase 1.4 DAG-walk optimization: return affected lines in dependency-safe
-   * topological order. Uses Kahn's algorithm (BFS-based) to ensure every line
-   * is evaluated AFTER all lines it depends on have been processed.
-   *
-   * This is more correct than ascending line-number sort, which fails when
-   * variable definitions and their consumers are not in document order.
-   *
-   * @returns Line numbers in topological order (producers before consumers).
-   */
-  getAffectedLinesInOrder(startVariable) {
-    const affected = this.getAffectedLines(startVariable);
-    if (affected.size === 0) return [];
-    const inDegree = /* @__PURE__ */ new Map();
-    const adjacency = /* @__PURE__ */ new Map();
-    for (const line of affected) {
-      if (!inDegree.has(line)) inDegree.set(line, 0);
-      if (!adjacency.has(line)) adjacency.set(line, []);
-    }
-    const producerOf = /* @__PURE__ */ new Map();
-    for (const line of affected) {
-      const lineWrites = this.writes.get(line);
-      if (lineWrites) {
-        for (const w of lineWrites) producerOf.set(w, line);
-      }
-    }
-    for (const line of affected) {
-      const reads = this.lineReads.get(line);
-      if (!reads) continue;
-      for (const readVar of reads) {
-        const producer = producerOf.get(readVar);
-        if (producer !== void 0 && producer !== line) {
-          adjacency.get(producer).push(line);
-          inDegree.set(line, (inDegree.get(line) ?? 0) + 1);
-        }
-      }
-    }
-    const queue = [];
-    for (const [line, degree] of inDegree) {
-      if (degree === 0) queue.push(line);
-    }
-    if (queue.length === 0 && affected.size > 0) {
-      const sorted = Array.from(affected).sort((a, b) => a - b);
-      queue.push(sorted[0]);
-    }
-    const ordered = [];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      ordered.push(current);
-      for (const downstream of adjacency.get(current) ?? []) {
-        const newDegree = (inDegree.get(downstream) ?? 1) - 1;
-        inDegree.set(downstream, newDegree);
-        if (newDegree === 0) queue.push(downstream);
-      }
-    }
-    if (ordered.length < affected.size) {
-      const orderedSet = new Set(ordered);
-      const remaining = Array.from(affected).filter((l) => !orderedSet.has(l)).sort((a, b) => a - b);
-      ordered.push(...remaining);
-    }
-    return ordered;
-  }
-  /**
-   * Find all lines affected by a data source update.
-   *
-   * When an async data source resolves (e.g., currency rate fetch completes),
-   * this returns all lines that depend on that specific data query.
-   *
-   * @param dataSourceId - The data source identifier
-   * @param queryKey - The query key that was updated
-   * @returns Set of line numbers that need re-evaluation
-   */
-  getAffectedLinesByDataSource(dataSourceId, queryKey) {
-    const queryKeyStr = JSON.stringify(queryKey);
-    const key = `${dataSourceId}:${queryKeyStr}`;
-    return this.dataSourceConsumers.get(key) ?? /* @__PURE__ */ new Set();
-  }
-  /**
-   * Remove a line from the dependency graph (e.g., when a line is deleted from the document).
-   *
-   * Cleans up all consumer references, write registrations, and data source dependencies
-   * for the removed line. O(k) where k is the number of variables the line reads.
-   *
-   * @param lineNumber - The line number being removed
-   */
-  removeLine(lineNumber) {
-    const reads = this.lineReads.get(lineNumber);
-    if (reads) {
-      for (const readVar of reads) {
-        const consumers = this.consumers.get(readVar);
-        if (consumers) consumers.delete(lineNumber);
-      }
-      this.lineReads.delete(lineNumber);
-    }
-    this.dependencies.delete(lineNumber);
-    this.writes.delete(lineNumber);
-    const dataSourceKeys = this.dataSourceDependencies.get(lineNumber);
-    if (dataSourceKeys) {
-      for (const key of dataSourceKeys) {
-        this.dataSourceConsumers.get(key)?.delete(lineNumber);
-      }
-      this.dataSourceDependencies.delete(lineNumber);
-    }
-  }
-  /**
-   * Get all line numbers that consume (read) a given variable.
-   *
-   * @param variable - The variable name
-   * @returns Set of line numbers that read this variable, or empty set if none
-   */
-  getConsumers(variable) {
-    return this.consumers.get(variable) ?? /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get all variables that a line depends on (reads).
-   *
-   * @param lineNumber - The line number to query
-   * @returns Set of variable names this line reads, or empty set if none
-   */
-  getDependencies(lineNumber) {
-    return this.dependencies.get(lineNumber) ?? /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get all variables that a line writes (assigns to).
-   *
-   * @param lineNumber - The line number to query
-   * @returns Set of variable names this line writes, or empty set if none
-   */
-  getWrites(lineNumber) {
-    return this.writes.get(lineNumber) ?? /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get a serializable snapshot of the entire dependency graph for diagnostics.
-   *
-   * Returns plain objects (not Maps/Sets) so consumers don't need to reach
-   * into private fields. Used by playground diagnostic tabs for DAG visualization.
-   */
-  getSnapshot() {
-    const consumers = {};
-    for (const [variable, lines] of this.consumers) {
-      consumers[variable] = Array.from(lines);
-    }
-    const writes = {};
-    for (const [line, vars] of this.writes) {
-      writes[line] = Array.from(vars);
-    }
-    const reads = {};
-    for (const [line, vars] of this.lineReads) {
-      reads[line] = Array.from(vars);
-    }
-    const dataSourceDeps = {};
-    for (const [line, keys] of this.dataSourceDependencies) {
-      dataSourceDeps[line] = Array.from(keys);
-    }
-    const dataSourceConsumers = {};
-    for (const [key, lines] of this.dataSourceConsumers) {
-      dataSourceConsumers[key] = Array.from(lines);
-    }
-    return { consumers, writes, reads, dataSourceDeps, dataSourceConsumers };
-  }
-  /** Clear all dependency graph state. Called on document switch or engine reset. */
-  clear() {
-    this.consumers.clear();
-    this.dependencies.clear();
-    this.writes.clear();
-    this.lineReads.clear();
-    this.dataSourceDependencies.clear();
-    this.dataSourceConsumers.clear();
-  }
-};
-
-// src/vm/ScopeManager.ts
-var ScopeManager = class {
-  constructor() {
-    this.definitions = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Record a variable definition at `lineNumber`. A variable may have
-   * multiple definitions across different lines (e.g. redefined further
-   * down a document), each call adds one, keeping the internal stack
-   * sorted by line so {@link read} can binary-scan for "most recent
-   * definition at or before" a given line.
-   */
-  write(variable, lineNumber, expr) {
-    if (!this.definitions.has(variable)) {
-      this.definitions.set(variable, []);
-    }
-    const stack = this.definitions.get(variable);
-    stack.push({ line: lineNumber, expr });
-    stack.sort((a, b) => a.line - b.line);
-  }
-  /**
-   * Look up a variable's value as seen from `readLine`: returns the result
-   * of the closest definition at or before `readLine`, not simply the most
-   * recently-written one, so a read on line 5 of a variable redefined on
-   * lines 2 and 10 sees line 2's value, not line 10's. Returns `undefined`
-   * if the variable has no definition at or before `readLine`.
-   */
-  read(variable, readLine) {
-    const stack = this.definitions.get(variable);
-    if (!stack) return void 0;
-    for (let i = stack.length - 1; i >= 0; i--) {
-      if (stack[i].line <= readLine) return stack[i].expr.lastResult;
-    }
-    return void 0;
-  }
-  /**
-   * Drop every definition of `variable` that comes strictly after
-   * `definitionLine`. Call this when a line is re-evaluated with a new
-   * definition, so stale later-line definitions from a previous edit don't
-   * linger and get returned by {@link read}.
-   */
-  invalidateDownstream(variable, definitionLine) {
-    const stack = this.definitions.get(variable);
-    if (!stack) return;
-    const idx = stack.findIndex((s) => s.line === definitionLine);
-    if (idx === -1) return;
-    stack.splice(idx + 1);
-  }
-  /** Remove every tracked variable definition, used when an engine/document is reset. */
-  clear() {
-    this.definitions.clear();
-  }
-};
-
-// src/vm/BusinessDays.ts
-var MS_PER_DAY = 864e5;
-function isWeekend(epochMs) {
-  const day = new Date(epochMs).getDay();
-  return day === 0 || day === 6;
-}
-function isBusinessDay(epochMs, isHoliday) {
-  if (isWeekend(epochMs)) return false;
-  return isHoliday ? !isHoliday(epochMs) : true;
-}
-function startOfLocalDay(epochMs) {
-  const d = new Date(epochMs);
-  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
-}
-function addBusinessDays(startMs, n, isHoliday, maxCalendarSteps) {
-  let remaining = Math.trunc(Math.abs(n));
-  const direction = n >= 0 ? 1 : -1;
-  const date = new Date(startMs);
-  let steps = 0;
-  while (remaining > 0) {
-    date.setDate(date.getDate() + direction);
-    steps++;
-    if (steps > maxCalendarSteps) return null;
-    if (isBusinessDay(date.getTime(), isHoliday)) remaining--;
-  }
-  return date.getTime();
-}
-function countBusinessDaysBetween(aMs, bMs, isHoliday, maxCalendarSteps) {
-  const startDay = startOfLocalDay(Math.min(aMs, bMs));
-  const endDay = startOfLocalDay(Math.max(aMs, bMs));
-  const spanDays = Math.round((endDay - startDay) / MS_PER_DAY);
-  if (spanDays > maxCalendarSteps) return null;
-  let count = 0;
-  const date = new Date(startDay);
-  for (let i = 0; i <= spanDays; i++) {
-    if (isBusinessDay(date.getTime(), isHoliday)) count++;
-    date.setDate(date.getDate() + 1);
-  }
-  return count;
-}
-
-// src/vm/VMBuiltinArity.ts
-var BUILTIN_ARITY = {
-  0: { name: "sqrt", min: 1, max: 1 },
-  1: { name: "abs", min: 1, max: 1 },
-  2: { name: "sin", min: 1, max: 1 },
-  3: { name: "cos", min: 1, max: 1 },
-  4: { name: "tan", min: 1, max: 1 },
-  5: { name: "log", min: 1, max: 1 },
-  6: { name: "ceil", min: 1, max: 1 },
-  7: { name: "floor", min: 1, max: 1 },
-  8: { name: "round", min: 1, max: 2 },
-  // min/max compare as many operands as they are given.
-  9: { name: "min", min: 1, max: Infinity },
-  10: { name: "max", min: 1, max: Infinity },
-  11: { name: "asin", min: 1, max: 1 },
-  12: { name: "acos", min: 1, max: 1 },
-  13: { name: "atan", min: 1, max: 1 },
-  14: { name: "atan2", min: 2, max: 2 },
-  15: { name: "sinh", min: 1, max: 1 },
-  16: { name: "cosh", min: 1, max: 1 },
-  17: { name: "tanh", min: 1, max: 1 },
-  18: { name: "asinh", min: 1, max: 1 },
-  19: { name: "acosh", min: 1, max: 1 },
-  20: { name: "atanh", min: 1, max: 1 },
-  21: { name: "cbrt", min: 1, max: 1 },
-  22: { name: "clz32", min: 1, max: 1 },
-  23: { name: "expm1", min: 1, max: 1 },
-  24: { name: "exp", min: 1, max: 1 },
-  25: { name: "fround", min: 1, max: 1 },
-  // hypot is the length of a vector with as many components as it is given.
-  26: { name: "hypot", min: 1, max: Infinity },
-  27: { name: "imul", min: 2, max: 2 },
-  28: { name: "log10", min: 1, max: 1 },
-  29: { name: "log1p", min: 1, max: 1 },
-  30: { name: "log2", min: 1, max: 1 },
-  31: { name: "pow", min: 2, max: 2 },
-  32: { name: "random", min: 0, max: 0 },
-  33: { name: "sign", min: 1, max: 1 },
-  34: { name: "trunc", min: 1, max: 1 },
-  35: { name: "degtorad", min: 1, max: 1 },
-  36: { name: "radtodeg", min: 1, max: 1 },
-  37: { name: "roll", min: 2, max: 2 },
-  38: { name: "gcd", min: 2, max: 2 },
-  39: { name: "lcm", min: 2, max: 2 },
-  40: { name: "permutation", min: 2, max: 2 },
-  41: { name: "combination", min: 2, max: 2 },
-  // The aggregates back "average of X, Y, Z" and friends, so they take a
-  // list. Their implementations already answer for an empty list rather
-  // than indexing into it, and the phrase parselets can emit an empty one,
-  // so the minimum stays 0 here instead of being tightened on the way past.
-  42: { name: "average", min: 0, max: Infinity },
-  43: { name: "median", min: 0, max: Infinity },
-  44: { name: "total", min: 0, max: Infinity },
-  45: { name: "count", min: 0, max: Infinity },
-  46: { name: "proportion", min: 3, max: 3 },
-  47: { name: "clamp", min: 3, max: 3 },
-  48: { name: "hex", min: 1, max: 1 },
-  49: { name: "bin", min: 1, max: 1 },
-  50: { name: "int", min: 1, max: 1 },
-  51: { name: "compoundInterest", min: 3, max: 3 },
-  52: { name: "interestEarned", min: 3, max: 3 },
-  53: { name: "compoundInterestRate", min: 3, max: 3 },
-  54: { name: "compoundInterestYears", min: 3, max: 3 },
-  55: { name: "loanRepayment", min: 4, max: 4 },
-  56: { name: "loanInterest", min: 4, max: 4 },
-  57: { name: "monthlyPayment", min: 3, max: 3 },
-  58: { name: "taxAdd", min: 2, max: 2 },
-  59: { name: "taxRemove", min: 2, max: 2 },
-  60: { name: "inflationAdjust", min: 3, max: 3 },
-  61: { name: "root", min: 2, max: 2 },
-  62: { name: "fact", min: 1, max: 1 },
-  63: { name: "transpose", min: 1, max: 1 },
-  64: { name: "det", min: 1, max: 1 },
-  65: { name: "inv", min: 1, max: 1 },
-  66: { name: "dot", min: 2, max: 2 },
-  67: { name: "expand", min: 1, max: 1 },
-  68: { name: "factor", min: 1, max: 1 },
-  // solve pushes the two sides of the equation and then the unknown's name.
-  69: { name: "solve", min: 3, max: 3 },
-  // der's order of differentiation is optional and defaults to 1.
-  70: { name: "der", min: 2, max: 3 },
-  71: { name: "integral", min: 2, max: 2 },
-  72: { name: "taylor", min: 4, max: 4 },
-  // jacobian differentiates however many functions it is handed.
-  73: { name: "jacobian", min: 1, max: Infinity },
-  74: { name: "imaginary", min: 1, max: 1 },
-  75: { name: "conj", min: 1, max: 1 },
-  76: { name: "re", min: 1, max: 1 },
-  77: { name: "im", min: 1, max: 1 },
-  78: { name: "cancel", min: 1, max: 1 },
-  79: { name: "apart", min: 1, max: 1 },
-  80: { name: "compoundInterestEvery", min: 4, max: 4 },
-  81: { name: "compoundInterestEarnedEvery", min: 4, max: 4 },
-  82: { name: "presentValue", min: 3, max: 3 },
-  83: { name: "roi", min: 2, max: 2 },
-  84: { name: "annualisedReturn", min: 3, max: 3 },
-  85: { name: "taxIn", min: 2, max: 2 },
-  86: { name: "taxOn", min: 2, max: 2 },
-  87: { name: "sind", min: 1, max: 1 },
-  88: { name: "cosd", min: 1, max: 1 },
-  89: { name: "tand", min: 1, max: 1 },
-  90: { name: "asind", min: 1, max: 1 },
-  91: { name: "acosd", min: 1, max: 1 },
-  92: { name: "atand", min: 1, max: 1 },
-  93: { name: "daysCount", min: 1, max: 1 },
-  94: { name: "asTwoUnits", min: 3, max: 3 },
-  95: { name: "makeRate", min: 2, max: 2 },
-  96: { name: "atRate", min: 2, max: 2 },
-  // Not reachable by name, only through `<value> to <n> dp`; see
-  // converters/parselets/RoundingParselets.ts.
-  97: { name: "roundToPlaces", min: 2, max: 2 },
-  98: { name: "splitEach", min: 2, max: 2 },
-  99: { name: "savingsGoalPayment", min: 3, max: 3 },
-  100: { name: "savingsGoalPeriods", min: 5, max: 5 }
-};
-function plural(count) {
-  return count === 1 ? "1 argument" : `${count} arguments`;
-}
-function expectation(arity) {
-  if (arity.max === Infinity) return `at least ${plural(arity.min)}`;
-  if (arity.min === arity.max) return plural(arity.min);
-  return `${arity.min} to ${plural(arity.max)}`;
-}
-function builtinArityError(index, argCount) {
-  const arity = BUILTIN_ARITY[index];
-  if (arity === void 0) return void 0;
-  if (argCount >= arity.min && argCount <= arity.max) return void 0;
-  return ErrorFactory.execution(
-    "BUILTIN_ARITY_MISMATCH",
-    `${arity.name}() takes ${expectation(arity)}, but was given ${argCount === 0 ? "none" : plural(argCount)}`,
-    { functionName: arity.name, expectedMin: arity.min, expectedMax: arity.max, actual: argCount }
-  );
-}
-
-// src/vm/VM.ts
-function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, maxCollectionSize = 1e5, maxAllocatedElements = 2e6, maxFunctionCalls = 1e4, maxDateOffsetYears = 100, minDateOffsetYears = -100, context = defaultEngineContext, holidayPredicate) {
-  const stack = [];
-  const variables = /* @__PURE__ */ new Map();
-  let instructionCount = 0;
-  let activeSignal;
-  let abortCurrent;
-  const callFrames = [];
-  const userFunctions = /* @__PURE__ */ new Map();
-  const equations = /* @__PURE__ */ new Map();
-  const scalarEquations = /* @__PURE__ */ new Map();
-  return {
-    push(v) {
-      if (stack.length < maxStackDepth) {
-        stack.push(v);
-      }
-    },
-    getMaxStackDepth() {
-      return maxStackDepth;
-    },
-    getMaxCollectionSize() {
-      return maxCollectionSize;
-    },
-    getMaxAllocatedElements() {
-      return maxAllocatedElements;
-    },
-    getMaxFunctionCalls() {
-      return maxFunctionCalls;
-    },
-    getMaxDateOffsetYears() {
-      return maxDateOffsetYears;
-    },
-    getMinDateOffsetYears() {
-      return minDateOffsetYears;
-    },
-    // False whenever no calendar was configured, which is what makes
-    // unconfigured working-day arithmetic weekends-only. See
-    // vm/BusinessDays.ts, the only reader.
-    isHoliday(epochMs) {
-      return holidayPredicate ? holidayPredicate(epochMs) : false;
-    },
-    pop() {
-      if (stack.length === 0) {
-        return numberValue(0);
-      }
-      return stack.pop();
-    },
-    /**
-     * Popped through `safePop()` for the same reason as `popString()` below.
-     * Only the underflow half applies here: `toNumber()` is a real method on
-     * every Value, so there was no cast to make a non-number look like one,
-     * and the `!` was the whole bug.
-     */
-    popNumber() {
-      return safePop(stack).toNumber();
-    },
-    /**
-     * Popped through the same two guards the dispatch loop below uses, and
-     * for the same reason: a package's opcode handler can disagree with its
-     * own bytecode exactly as this engine's compiler can disagree with
-     * hand-assembled input.
-     *
-     * This was `stack.pop()!.value as string`, which had neither guard. The
-     * `!` is compile-time only, so an empty stack reached `.value` and threw
-     * a raw TypeError; so is the cast, so any Value the stack happened to be
-     * holding was handed back as a "string" and threw in the handler's own
-     * code some lines later. Nothing in this repo calls this method, which is
-     * the only reason the fuzz corpus never found either.
-     */
-    popString() {
-      return stringOperand(safePop(stack), "VM.popString()");
-    },
-    peek() {
-      return stack[stack.length - 1];
-    },
-    getStack() {
-      return stack;
-    },
-    registry,
-    getVar(key) {
-      if (callFrames.length > 0) {
-        const frameValue = callFrames[callFrames.length - 1].get(key);
-        if (frameValue !== void 0) return frameValue;
-      }
-      return variables.get(key);
-    },
-    setVar(key, val) {
-      variables.set(key, val);
-    },
-    deleteVar(key) {
-      variables.delete(key);
-    },
-    pushCallFrame(frame) {
-      if (callFrames.length >= maxFunctionRecursionDepth) {
-        throw ErrorFactory.execution(
-          "FUNCTION_RECURSION_LIMIT_EXCEEDED",
-          `Function call nesting exceeded maximum depth of ${maxFunctionRecursionDepth} (possible infinite recursion, e.g. f(x) = f(x))`,
-          { maxFunctionRecursionDepth }
-        );
-      }
-      callFrames.push(frame);
-    },
-    popCallFrame() {
-      callFrames.pop();
-    },
-    getCallFrame() {
-      return callFrames.length > 0 ? callFrames[callFrames.length - 1] : void 0;
-    },
-    defineUserFunction(name, params, program) {
-      userFunctions.set(name, { name, params, program });
-    },
-    getUserFunction(name) {
-      return userFunctions.get(name);
-    },
-    hasUserFunction(name) {
-      return userFunctions.has(name);
-    },
-    getVariableEntries() {
-      return Array.from(variables.entries());
-    },
-    getUserFunctionDefs() {
-      return Array.from(userFunctions.values());
-    },
-    defineEquation(variable, factorNames, rhsProgram) {
-      equations.set(variable, { variable, factorNames, rhsProgram });
-    },
-    getEquation(variable) {
-      return equations.get(variable);
-    },
-    hasEquation(variable) {
-      return equations.has(variable);
-    },
-    defineScalarEquation(variable, lhsProgram, rhsProgram) {
-      scalarEquations.set(variable, { variable, lhsProgram, rhsProgram });
-    },
-    getScalarEquation(variable) {
-      return scalarEquations.get(variable);
-    },
-    hasScalarEquation(variable) {
-      return scalarEquations.has(variable);
-    },
-    reset() {
-      stack.length = 0;
-      variables.clear();
-      callFrames.length = 0;
-      userFunctions.clear();
-      equations.clear();
-      scalarEquations.clear();
-      instructionCount = 0;
-      if (abortCurrent) {
-        abortCurrent();
-        abortCurrent = void 0;
-      }
-      activeSignal = void 0;
-    },
-    get activeSignal() {
-      return activeSignal;
-    },
-    set activeSignal(s) {
-      activeSignal = s;
-    },
-    get abortCurrent() {
-      return abortCurrent;
-    },
-    set abortCurrent(f) {
-      abortCurrent = f;
-    },
-    context,
-    getMaxInstructions() {
-      return maxInstructions;
-    },
-    getInstructionCount() {
-      return instructionCount;
-    },
-    incrementInstructions(n) {
-      instructionCount += n;
-      if (instructionCount > maxInstructions) {
-        throw ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
-      }
-    }
-  };
-}
-function matrixProductCells(l, r) {
-  if (l.rows === 1 && l.cols === 1) return r.data.length;
-  if (r.rows === 1 && r.cols === 1) return l.data.length;
-  if (l.cols !== r.rows) return 0;
-  return l.rows * r.cols;
-}
-function matrixPowerCells(m, exponent) {
-  if (!Number.isInteger(exponent) || exponent < 0) return 0;
-  const cells = m.rows * m.cols;
-  return cells * (1 + (exponent < 2 ? 1 : 2 * Math.floor(Math.log2(exponent))));
-}
-function safePop(stack) {
-  if (stack.length === 0) {
-    throw ErrorFactory.internal({
-      code: "STACK_UNDERFLOW",
-      message: "Stack underflow: an opcode expected a value on the stack but it was empty",
-      expected: "at least one value on the VM stack",
-      found: "an empty stack",
-      suggestion: "this indicates corrupted bytecode or a bug in a package's parselet (mismatched push/pop counts), not a user-input error"
-    });
-  }
-  return stack.pop();
-}
-var MALFORMED_BYTECODE_SUGGESTION = "bytecode is caller input on this entry point: rebuild the program with the engine's compiler, or fix the hand-assembled stream";
-function siteName(site) {
-  return typeof site === "number" ? getOpCodeName(site) : site;
-}
-function malformedBytecode(code, site, problem, expected, found, context = {}) {
-  const name = siteName(site);
-  return ErrorFactory.validation({
-    code,
-    message: `Malformed bytecode: ${name} ${problem}`,
-    expected,
-    found,
-    suggestion: MALFORMED_BYTECODE_SUGGESTION,
-    // A named site reports under `site` rather than borrowing `opcodeName`,
-    // so a host reading `opcode`/`opcodeName` never gets a method name
-    // where it expects an opcode, and never has to tell a missing opcode
-    // apart from opcode 0.
-    context: typeof site === "number" ? { opcode: site, opcodeName: name, ...context } : { site: name, ...context }
-  });
-}
-function operandByte(opcodes, at, op, role) {
-  if (at >= opcodes.length) {
-    throw malformedBytecode(
-      "MALFORMED_BYTECODE_TRUNCATED",
-      op,
-      `is missing its ${role}: the program ends mid-instruction`,
-      `an operand byte at offset ${at}`,
-      `a program only ${opcodes.length} byte(s) long`,
-      { offset: at, length: opcodes.length, role }
-    );
-  }
-  return opcodes[at];
-}
-function poolIndex(opcodes, at, op, role, poolSize, poolName) {
-  const index = operandByte(opcodes, at, op, role);
-  if (index >= poolSize) {
-    throw malformedBytecode(
-      "MALFORMED_BYTECODE_CONSTANT_INDEX",
-      op,
-      `reads ${poolName} entry ${index}, which does not exist`,
-      `an index below ${poolSize}`,
-      `${index}`,
-      { index, poolSize, pool: poolName }
-    );
-  }
-  return index;
-}
-function poolString(opcodes, at, strings, op, role) {
-  return pooledString(strings, operandByte(opcodes, at, op, role), op);
-}
-function pooledString(strings, index, op) {
-  const text = strings[index];
-  if (typeof text !== "string") {
-    throw malformedBytecode(
-      "MALFORMED_BYTECODE_CONSTANT_INDEX",
-      op,
-      `reads string-pool entry ${index}, which is ${index >= strings.length ? "past the end of the pool" : "not a string"}`,
-      `an index below ${strings.length}, holding a string`,
-      index >= strings.length ? `${index}` : typeof text,
-      { index, poolSize: strings.length, pool: "string-pool" }
-    );
-  }
-  return text;
-}
-function stringOperand(value, site, role) {
-  if (typeof value.value !== "string") {
-    throw malformedBytecode(
-      "MALFORMED_BYTECODE_OPERAND_TYPE",
-      site,
-      `expected a ${role ?? "string"} on the stack`,
-      role ? `a string value holding the ${role}` : "a string value",
-      `a ${ValueType[value.type] ?? "unknown"} value`,
-      role ? { role, valueType: value.type } : { valueType: value.type }
-    );
-  }
-  return value.value;
-}
-function requireKnownBodyKind(kind, ref, op) {
-  if (kind !== 0 && kind !== 1 && kind !== 2) {
-    throw malformedBytecode(
-      "MALFORMED_BYTECODE_BODY_KIND",
-      op,
-      `has body kind ${kind}, which is not one this VM knows`,
-      "0 (inline body), 1 (builtin function) or 2 (user-defined function)",
-      `${kind}`,
-      { kind, ref }
-    );
-  }
-}
-function parseBigIntLiteral(text, op) {
-  try {
-    return BigInt(text);
-  } catch {
-    throw malformedBytecode(
-      "MALFORMED_BYTECODE_BIGINT_LITERAL",
-      op,
-      `cannot read "${text}" as a whole number`,
-      "a string holding an integer, with no decimal point or separators",
-      `"${text}"`,
-      { literal: text }
-    );
-  }
-}
-function unrunnableProgram(bytecode) {
-  if (bytecode === null || typeof bytecode !== "object") {
-    return `expected a bytecode program, got ${bytecode === null ? "null" : typeof bytecode}`;
-  }
-  const candidate = bytecode;
-  if (typeof candidate.opcodes?.length !== "number") {
-    return "the program has no `opcodes` array";
-  }
-  if (typeof candidate.numbers?.length !== "number") {
-    return "the program has no `numbers` pool";
-  }
-  if (typeof candidate.strings?.length !== "number") {
-    return "the program has no `strings` pool";
-  }
-  return null;
-}
-function invokeFrameBody(params, program, args, vm, pipeline, expression, context, symbolicTolerant) {
-  const frame = /* @__PURE__ */ new Map();
-  for (let i = 0; i < params.length; i++) frame.set(params[i], args[i]);
-  vm.pushCallFrame(frame);
-  let bodyResult;
-  try {
-    bodyResult = executeBytecode(program, vm, pipeline, expression, context, symbolicTolerant);
-  } finally {
-    vm.popCallFrame();
-  }
-  if (bodyResult.type === "pending") {
-    throw ErrorFactory.execution(
-      "MAP_REDUCE_ASYNC_UNSUPPORTED",
-      `map/reduce transform bodies calling an async operation (weather, stocks, currency, ...) aren't supported`
-    );
-  }
-  if (bodyResult.type === "error") {
-    throw bodyResult.error;
-  }
-  return bodyResult.value;
-}
-function invokeWithBoundUnknown(name, program, vm, pipeline, expression, context, symbolicTolerant) {
-  const frame = new Map(vm.getCallFrame());
-  frame.set(name, symbolicValue(varNode(name)));
-  vm.pushCallFrame(frame);
-  let bodyResult;
-  try {
-    bodyResult = executeBytecode(program, vm, pipeline, expression, context, symbolicTolerant);
-  } finally {
-    vm.popCallFrame();
-  }
-  if (bodyResult.type === "pending") {
-    throw ErrorFactory.execution(
-      "SYMBOLIC_ASYNC_UNSUPPORTED",
-      `an algebra verb's expression cannot call an async operation (weather, stocks, currency, ...)`
-    );
-  }
-  if (bodyResult.type === "error") {
-    throw bodyResult.error;
-  }
-  return bodyResult.value;
-}
-function unifyRatePeriods(l, r) {
-  if (l.type !== 6 /* Uom */ || r.type !== 6 /* Uom */) return null;
-  const leftUnit = l.unit;
-  const rightUnit = r.unit;
-  if (leftUnit === void 0 || rightUnit === void 0) return null;
-  const leftSlash = leftUnit.indexOf("/");
-  const rightSlash = rightUnit.indexOf("/");
-  if (leftSlash < 0 || rightSlash < 0) return null;
-  if (leftUnit.slice(0, leftSlash) !== rightUnit.slice(0, rightSlash)) return null;
-  const leftPeriod = UNIT_TABLE[leftUnit.slice(leftSlash + 1).toLowerCase()];
-  const rightPeriod = UNIT_TABLE[rightUnit.slice(rightSlash + 1).toLowerCase()];
-  if (leftPeriod === void 0 || rightPeriod === void 0) return null;
-  if (leftPeriod[0] !== rightPeriod[0]) return null;
-  return l.toNumber() * (rightPeriod[1] / leftPeriod[1]);
-}
-function moneyTimesQuantity(l, r) {
-  if (l.type !== 6 /* Uom */ || r.type !== 6 /* Uom */) return null;
-  const leftUnit = l.unit;
-  const rightUnit = r.unit;
-  if (leftUnit === void 0 || rightUnit === void 0) return null;
-  if (leftUnit.includes("/") || rightUnit.includes("/")) return null;
-  const leftIsMoney = CURRENCY_DISPLAY[leftUnit.toUpperCase()] !== void 0;
-  const rightIsMoney = CURRENCY_DISPLAY[rightUnit.toUpperCase()] !== void 0;
-  if (leftIsMoney === rightIsMoney) return null;
-  return uomValue(l.toNumber() * r.toNumber(), leftIsMoney ? leftUnit : rightUnit);
-}
-function combinePercentage(l, r, sign) {
-  if (l.type === 5 /* Percentage */) {
-    if (r.type === 6 /* Uom */ && r.unit !== void 0) {
-      return scaleMoneyByPercent(r, r.unit, l.toNumber(), sign);
-    }
-    if (r.type !== 5 /* Percentage */ && r.type !== 0 /* Number */) return null;
-    return percentageValue(l.toNumber() + sign * r.toNumber());
-  }
-  if (r.type !== 5 /* Percentage */) return null;
-  const factor = 1 + sign * r.toNumber();
-  if (l.type === 0 /* Number */) {
-    const scaled = l.toNumber() * factor;
-    if (l.uncertainty !== void 0) return numberValueUncertain(scaled, Math.abs(l.uncertainty * factor));
-    return numberValue(scaled);
-  }
-  if (l.type === 6 /* Uom */ && l.unit !== void 0) return scaleMoneyByPercent(l, l.unit, r.toNumber(), sign);
-  return null;
-}
-function multiplyPercentWithUncertainty(l, r) {
-  const pct = l.type === 5 /* Percentage */ ? l : r.type === 5 /* Percentage */ ? r : null;
-  if (pct === null) return null;
-  const other = pct === l ? r : l;
-  if (other.type !== 0 /* Number */ || other.uncertainty === void 0) return null;
-  const factor = pct.toNumber();
-  return numberValueUncertain(other.toNumber() * factor, Math.abs(other.uncertainty * factor));
-}
-function multiplyMoneyByScalarExact(l, r) {
-  const money = l.type === 6 /* Uom */ ? l : r;
-  const scalar = l.type === 6 /* Uom */ ? r : l;
-  if (money.type !== 6 /* Uom */ || money.unit === void 0 || !sharedCurrencyExchange.isCurrency(money.unit)) return null;
-  if (scalar.type !== 0 /* Number */ && scalar.type !== 5 /* Percentage */) return null;
-  if (scalar.rational !== void 0) return null;
-  return scaleMoneyExact(money, scalar.toNumber(), money.unit);
-}
-function dividePercentWithUncertainty(l, r) {
-  if (r.type === 5 /* Percentage */ && l.type === 0 /* Number */ && l.uncertainty !== void 0) {
-    const factor = r.toNumber();
-    if (factor === 0) return null;
-    return numberValueUncertain(l.toNumber() / factor, Math.abs(l.uncertainty / factor));
-  }
-  if (l.type === 5 /* Percentage */ && r.type === 0 /* Number */ && r.uncertainty !== void 0) {
-    const b = r.toNumber();
-    if (b === 0) return null;
-    return numberValueUncertain(l.toNumber() / b, Math.abs(l.toNumber() * r.uncertainty / (b * b)));
-  }
-  return null;
-}
-function extractDurationMs(value) {
-  if (value.type === 6 /* Uom */) {
-    const unit = value.unit;
-    if (unit && getMeasure(unit) === "time") {
-      try {
-        return convertUnit(value.toNumber(), unit, "ms");
-      } catch {
-      }
-    }
-    return 0;
-  }
-  return value.toNumber();
-}
-var WORKDAYS_PER_YEAR = 260;
-function addBusinessDays2(epochMs, n, vm) {
-  const remaining = Math.trunc(Math.abs(n));
-  const direction = n >= 0 ? 1 : -1;
-  const limitYears = direction > 0 ? vm.getMaxDateOffsetYears() : -vm.getMinDateOffsetYears();
-  const limitWorkdays = Math.floor(limitYears * WORKDAYS_PER_YEAR);
-  if (remaining > limitWorkdays) {
-    throw ErrorFactory.execution(
-      "DATE_OFFSET_LIMIT_EXCEEDED",
-      `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`,
-      { requestedWorkdays: remaining, limitYears, limitWorkdays }
-    );
-  }
-  const maxCalendarSteps = limitWorkdays * 7 + 7;
-  const landed = addBusinessDays(epochMs, n, (ms) => vm.isHoliday(ms), maxCalendarSteps);
-  if (landed === null) {
-    throw ErrorFactory.execution(
-      "DATE_OFFSET_LIMIT_EXCEEDED",
-      `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`,
-      { requestedWorkdays: remaining, limitYears, maxCalendarSteps }
-    );
-  }
-  return landed;
-}
-var MS_PER_DAY2 = 864e5;
-var CALENDAR_MONTHS_PER_UNIT = {
-  month: 1,
-  months: 1,
-  mo: 1,
-  year: 12,
-  years: 12,
-  yr: 12,
-  y: 12,
-  a: 12,
-  decade: 120,
-  decades: 120,
-  dec: 120,
-  century: 1200,
-  centuries: 1200,
-  millennium: 12e3,
-  millennia: 12e3
-};
-function daysInMonth(year, monthIndex) {
-  return new Date(year, monthIndex + 1, 0).getDate();
-}
-function addCalendarDays(epochMs, days) {
-  const whole = Math.trunc(days);
-  const date = new Date(epochMs);
-  date.setDate(date.getDate() + whole);
-  const shifted = date.getTime();
-  if (Number.isNaN(shifted)) return epochMs + days * MS_PER_DAY2;
-  return shifted + (days - whole) * MS_PER_DAY2;
-}
-function addCalendarMonths(epochMs, months) {
-  const whole = Math.trunc(months);
-  const date = new Date(epochMs);
-  const dayOfMonth = date.getDate();
-  date.setDate(1);
-  date.setMonth(date.getMonth() + whole);
-  date.setDate(Math.min(dayOfMonth, daysInMonth(date.getFullYear(), date.getMonth())));
-  const shifted = date.getTime();
-  const monthMs = convertUnit(1, "month", "ms");
-  if (Number.isNaN(shifted)) return epochMs + months * monthMs;
-  return shifted + (months - whole) * monthMs;
-}
-function shiftDatetime(epochMs, duration, sign, vm) {
-  if (duration.type === 6 /* Uom */ && duration.unit !== void 0) {
-    const unit = duration.unit;
-    const amount = sign * duration.toNumber();
-    if (isWorkdayUnit(unit)) return addBusinessDays2(epochMs, amount, vm);
-    const monthsPerUnit = CALENDAR_MONTHS_PER_UNIT[unit];
-    if (monthsPerUnit !== void 0) return addCalendarMonths(epochMs, amount * monthsPerUnit);
-    if (getMeasure(unit) === "time") {
-      let daysPerUnit = 0;
-      try {
-        daysPerUnit = convertUnit(1, unit, "day");
-      } catch {
-      }
-      if (Number.isInteger(daysPerUnit) && daysPerUnit >= 1) {
-        return addCalendarDays(epochMs, amount * daysPerUnit);
-      }
-    }
-  }
-  return epochMs + sign * extractDurationMs(duration);
-}
-function combineTimecode(tc, r, sign) {
-  const fps = timecodeFps(tc.unit);
-  if (r.type === 6 /* Uom */ && isTimecodeUnit(r.unit)) {
-    const rFps = timecodeFps(r.unit);
-    if (rFps !== fps) {
-      return errorValue(
-        "TIMECODE_FPS_MISMATCH",
-        `Cannot combine timecodes at different frame rates (${fps} fps vs ${rFps} fps)`
-      );
-    }
-    return sign === 1 ? uomValue(tc.toNumber() + r.toNumber(), tc.unit) : uomValue(tc.toNumber() - r.toNumber(), "frames");
-  }
-  if (r.type === 6 /* Uom */ && r.unit === "frames") {
-    return uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
-  }
-  if (r.type === 6 /* Uom */ && r.unit && getMeasure(r.unit) === "time") {
-    const seconds = convertUnit(r.toNumber(), r.unit, "s");
-    return uomValue(tc.toNumber() + sign * seconds * fps, tc.unit);
-  }
-  return uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
-}
-function isTruthy(value) {
-  if (value.type === 10 /* Boolean */) return value.value;
-  return value.toNumber() !== 0;
-}
-function incompatibleConversionError(fromUnit, toUnit) {
-  const named = describeConversionMismatch(fromUnit, toUnit);
-  return errorValue(
-    "INCOMPATIBLE_UNITS",
-    named ?? `Cannot convert ${fromUnit} to ${toUnit}: they do not measure the same thing`
-  );
-}
-var MAX_EXACT_POW_BITS = 65536;
-function exactPowBits(base, exponent) {
-  if (!Number.isInteger(exponent) || exponent < 0) return null;
-  if (exponent === 0) return 1;
-  const magnitude = Math.abs(base.toNumber());
-  if (magnitude <= 1) return 1;
-  const baseBits = magnitude <= 2 ? 1 : Math.log2(magnitude);
-  return baseBits * exponent;
-}
-function bigIntPow(base, exponent) {
-  let result = 1n;
-  let factor = base;
-  let remaining = exponent;
-  while (remaining > 0n) {
-    if (remaining % 2n === 1n) result *= factor;
-    remaining /= 2n;
-    if (remaining > 0n) factor *= factor;
-  }
-  return result;
-}
-var MAX_EXACT_SHIFT_BITS = MAX_EXACT_POW_BITS;
-function bigIntBitLength(value) {
-  const magnitude = value < 0n ? -value : value;
-  if (magnitude === 0n) return 0;
-  const asDouble = Number(magnitude);
-  if (Number.isFinite(asDouble)) return Math.floor(Math.log2(asDouble)) + 1;
-  return magnitude.toString(16).length * 4;
-}
-function bigIntShift(l, r, direction) {
-  const value = toBigIntOperand(l);
-  const shift = toBigIntOperand(r);
-  if (value === 0n) return bigIntValue(0n);
-  const grownBits = direction * Number(shift);
-  if (grownBits <= 0 || bigIntBitLength(value) + grownBits <= MAX_EXACT_SHIFT_BITS) {
-    return bigIntValue(direction === 1 ? value << shift : value >> shift);
-  }
-  throw ErrorFactory.execution(
-    "BIGINT_SHIFT_LIMIT_EXCEEDED",
-    `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`,
-    { shift: String(shift), limitBits: MAX_EXACT_SHIFT_BITS }
-  );
-}
-function multiplyRateByMatchingUom(rate, multiplier) {
-  const { numerator, denominator } = splitRateUnit(rate.unit);
-  const rateMeasure = getMeasure(denominator);
-  const multiplierMeasure = getMeasure(multiplier.unit);
-  if (!rateMeasure || rateMeasure !== multiplierMeasure) {
-    return errorValue(
-      "RATE_MUL_MEASURE_MISMATCH",
-      `Cannot multiply a "${denominator}"-denominated rate by "${multiplier.unit}" \u2014 different measures`
-    );
-  }
-  const multiplierInDenominatorUnit = convertUnit(multiplier.toNumber(), multiplier.unit, denominator);
-  const total = rate.toNumber() * multiplierInDenominatorUnit;
-  return numerator ? uomValue(total, numerator) : numberValue(total);
-}
-function toFractionString(n) {
-  if (Number.isNaN(n)) return "NaN";
-  if (!isFinite(n)) return n > 0 ? "Infinity" : "-Infinity";
-  const negative = n < 0;
-  const abs = Math.abs(n);
-  const whole = Math.floor(abs);
-  const frac = abs - whole;
-  if (frac < 1e-9) return `${negative ? "-" : ""}${whole}`;
-  let h0 = 0, h1 = 1, k0 = 1, k1 = 0;
-  let b = frac;
-  const maxDenominator = 1e6;
-  for (let i = 0; i < 30; i++) {
-    const a = Math.floor(b + 1e-9);
-    const h2 = a * h1 + h0, k2 = a * k1 + k0;
-    if (k2 > maxDenominator) break;
-    h0 = h1;
-    h1 = h2;
-    k0 = k1;
-    k1 = k2;
-    if (Math.abs(frac - h1 / k1) < 1e-9) break;
-    const rem = b - a;
-    if (rem < 1e-9) break;
-    b = 1 / rem;
-  }
-  const numerator = whole * k1 + h1;
-  return `${negative ? "-" : ""}${numerator}/${k1}`;
-}
-function rationalToFractionString(r) {
-  return r.d === 1n ? String(r.n) : `${r.n}/${r.d}`;
-}
-function toMultiplierString(value) {
-  const n = value.toNumber();
-  const multiple = value.type === 5 /* Percentage */ ? 1 + n : n;
-  return `${Math.round(multiple * 1e6) / 1e6}x`;
-}
-function toScientificString(n) {
-  if (!Number.isFinite(n)) return String(n);
-  if (n === 0) return "0e+0";
-  const [mantissa, exponent] = n.toExponential().split("e");
-  const trimmed = mantissa.includes(".") ? mantissa.replace(/0+$/, "").replace(/\.$/, "") : mantissa;
-  return `${trimmed}e${exponent}`;
-}
-function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTolerant) {
-  const unrunnable = unrunnableProgram(bytecode);
-  if (unrunnable) {
-    return {
-      type: "error",
-      error: ErrorFactory.validation({
-        code: "MALFORMED_BYTECODE_PROGRAM",
-        message: `Malformed bytecode: ${unrunnable}`,
-        expected: "a BytecodeProgram with opcodes, numbers and strings",
-        found: unrunnable,
-        suggestion: MALFORMED_BYTECODE_SUGGESTION
-      })
-    };
-  }
-  const { opcodes, numbers, strings, userFunctionBodies, anonymousBodies } = bytecode;
-  let ip = 0;
-  let localInstructionCount = 0;
-  const maxInstructions = vm.getMaxInstructions();
-  const maxStackDepth = vm.getMaxStackDepth();
-  const stack = vm.getStack();
-  const shouldTrace = pipeline?.hasCollectors ?? false;
-  const hasArena = isArenaActive();
-  if (opcodes.length === 0) return { type: "value", value: numberValue(0) };
-  beginEvaluation(vm);
-  try {
-    while (ip < opcodes.length) {
-      if (++localInstructionCount > maxInstructions) {
-        throw ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
-      }
-      if (stack.length > maxStackDepth) {
-        throw ErrorFactory.execution("STACK_LIMIT_EXCEEDED", `Execution exceeded maximum stack depth of ${maxStackDepth}`);
-      }
-      const op = opcodes[ip++];
-      if (shouldTrace) {
-        const stackSnapshot = stack.map((v) => ({
-          type: v.type,
-          value: v.value,
-          unit: v.unit
-        }));
-        pipeline.fireVmStep({
-          type: DiagnosticEventType.VmStep,
-          elapsedNs: 0,
-          expression: expression ?? "",
-          opcode: op,
-          opcodeName: getOpCodeName(op),
-          ip: ip - 1,
-          stackDepth: stack.length,
-          instructionNumber: localInstructionCount,
-          stack: stackSnapshot
-        });
-      }
-      switch (op) {
-        // ═══════════════════════════════════════════════════════════════
-        // §1  Stack operations  (OpCode 0–3)
-        // ═══════════════════════════════════════════════════════════════
-        case 0 /* NOP */:
-          break;
-        case 1 /* HALT */: {
-          const result = safePop(stack);
-          return { type: "value", value: hasArena ? persistentValue(result) : result };
-        }
-        case 3 /* DUP */: {
-          const top = safePop(stack);
-          stack.push(top);
-          stack.push(top);
-          break;
-        }
-        case 2 /* SWAP */: {
-          const a = safePop(stack), b = safePop(stack);
-          stack.push(a);
-          stack.push(b);
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §2  Push literals  (OpCode 10–15)
-        // ═══════════════════════════════════════════════════════════════
-        // Every operand below goes through a checked read. An index past the
-        // end of a pool used to yield `undefined` and be pushed as a Value,
-        // which then failed somewhere else entirely: PUSH_BIGINT reached
-        // `BigInt(undefined)`, and an undefined string sat on the stack until
-        // a unit or converter name was read off it.
-        case 10 /* PUSH_NUMBER */:
-          stack.push(numberValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
-          break;
-        case 11 /* PUSH_BIGINT */:
-          stack.push(bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"), op)));
-          break;
-        case 16 /* PUSH_DECIMAL */: {
-          const dec = decimalFromLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"));
-          stack.push(numberValueExact(decimalToNumber(dec), dec));
-          break;
-        }
-        case 12 /* PUSH_HEX */:
-          stack.push(hexValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
-          break;
-        case 13 /* PUSH_STRING */:
-          stack.push(stringValue(poolString(opcodes, ip++, strings, op, "constant-pool index")));
-          break;
-        case 14 /* PUSH_BOOLEAN */:
-          stack.push(boolValue(operandByte(opcodes, ip++, op, "boolean operand") === 1));
-          break;
-        // ═══════════════════════════════════════════════════════════════
-        // §3  Arithmetic  (OpCode 20–27)
-        //     Binary ops (ADD/SUB/MUL/DIV/MOD/EXP) have inlined numeric
-        //     fast paths; unary ops (NEG/POS) handle BigInt and UoM.
-        // ═══════════════════════════════════════════════════════════════
-        case 20 /* ADD */: {
-          const r = safePop(stack), l = safePop(stack);
-          const addFault = faultedOperand(l, r);
-          if (addFault) {
-            stack.push(addFault);
-            break;
-          }
-          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
-            const uncAdd = uncertainOp(l, r, "add");
-            if (uncAdd) {
-              stack.push(uncAdd);
-              break;
-            }
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const ratAdd = exactRationalOp(l, r, "add");
-            if (ratAdd) {
-              stack.push(ratAdd);
-              break;
-            }
-          }
-          const pctAdd = combinePercentage(l, r, 1);
-          const ratePeriodAdd = pctAdd === null ? unifyRatePeriods(l, r) : null;
-          if (pctAdd !== null) {
-            stack.push(pctAdd);
-          } else if (ratePeriodAdd !== null) {
-            stack.push(uomValue(ratePeriodAdd + r.toNumber(), r.unit));
-          } else if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(numberValue(l.value + r.value));
-          } else if (l.type === 10 /* Boolean */ && r.type === 10 /* Boolean */) {
-            stack.push(boolValue(l.value && r.value));
-          } else if (l.type === 4 /* Datetime */) {
-            if (r.type === 4 /* Datetime */) {
-              stack.push(errorValue("INVALID_DATETIME_OP", "Cannot add two datetimes together"));
-            } else {
-              stack.push(datetimeValue(shiftDatetime(l.toNumber(), r, 1, vm)));
-            }
-          } else if (l.type === 6 /* Uom */ && isTimecodeUnit(l.unit)) {
-            stack.push(combineTimecode(l, r, 1));
-          } else if (r.type === 4 /* Datetime */) {
-            stack.push(datetimeValue(shiftDatetime(r.toNumber(), l, 1, vm)));
-          } else {
-            stack.push(binaryOp(l, r, (a, b) => a + b, (a, b) => a + b, "add"));
-          }
-          break;
-        }
-        case 21 /* SUB */: {
-          const r = safePop(stack), l = safePop(stack);
-          const subFault = faultedOperand(l, r);
-          if (subFault) {
-            stack.push(subFault);
-            break;
-          }
-          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
-            const uncSub = uncertainOp(l, r, "sub");
-            if (uncSub) {
-              stack.push(uncSub);
-              break;
-            }
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const ratSub = exactRationalOp(l, r, "sub");
-            if (ratSub) {
-              stack.push(ratSub);
-              break;
-            }
-          }
-          const pctSub = combinePercentage(l, r, -1);
-          const ratePeriodSub = pctSub === null ? unifyRatePeriods(l, r) : null;
-          if (pctSub !== null) {
-            stack.push(pctSub);
-          } else if (ratePeriodSub !== null) {
-            stack.push(uomValue(ratePeriodSub - r.toNumber(), r.unit));
-          } else if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(numberValue(l.value - r.value));
-          } else if (l.type === 4 /* Datetime */) {
-            if (r.type === 4 /* Datetime */) {
-              stack.push(uomValue(l.toNumber() - r.toNumber(), "ms"));
-            } else {
-              stack.push(datetimeValue(shiftDatetime(l.toNumber(), r, -1, vm)));
-            }
-          } else if (l.type === 6 /* Uom */ && isTimecodeUnit(l.unit)) {
-            stack.push(combineTimecode(l, r, -1));
-          } else if (r.type === 4 /* Datetime */) {
-            stack.push(errorValue(
-              "INVALID_DATETIME_OP",
-              "Cannot subtract a datetime from a value that is not a datetime"
-            ));
-          } else {
-            stack.push(binaryOp(l, r, (a, b) => a - b, (a, b) => a - b, "sub"));
-          }
-          break;
-        }
-        case 22 /* MUL */: {
-          const r = safePop(stack), l = safePop(stack);
-          const pctUnc = multiplyPercentWithUncertainty(l, r);
-          if (pctUnc) {
-            stack.push(pctUnc);
-            break;
-          }
-          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
-            const uncMul = uncertainOp(l, r, "mul");
-            if (uncMul) {
-              stack.push(uncMul);
-              break;
-            }
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const ratMul = exactRationalOp(l, r, "mul");
-            if (ratMul) {
-              stack.push(ratMul);
-              break;
-            }
-          }
-          const moneyScalar = multiplyMoneyByScalarExact(l, r);
-          if (moneyScalar) {
-            stack.push(moneyScalar);
-            break;
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(numberValue(l.value * r.value));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            checkAllocation(matrixProductCells(l.value, r.value), "matrix cells");
-            stack.push(matrixMultiply(l.value, r.value));
-          } else if (l.type === 6 /* Uom */ && isRateUnit(l.unit) && r.type === 6 /* Uom */ && r.unit) {
-            stack.push(multiplyRateByMatchingUom(l, r));
-          } else if (r.type === 6 /* Uom */ && isRateUnit(r.unit) && l.type === 6 /* Uom */ && l.unit) {
-            stack.push(multiplyRateByMatchingUom(r, l));
-          } else if (moneyTimesQuantity(l, r) !== null) {
-            stack.push(moneyTimesQuantity(l, r));
-          } else {
-            stack.push(binaryOp(l, r, (a, b) => a * b, (a, b) => a * b, "mul"));
-          }
-          break;
-        }
-        case 23 /* DIV */: {
-          const r = safePop(stack), l = safePop(stack);
-          const pctDivUnc = dividePercentWithUncertainty(l, r);
-          if (pctDivUnc) {
-            stack.push(pctDivUnc);
-            break;
-          }
-          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
-            const uncDiv = uncertainOp(l, r, "div");
-            if (uncDiv) {
-              stack.push(uncDiv);
-              break;
-            }
-          }
-          if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, sameMeasure } = unifyUom(l, r);
-            if (sameMeasure) {
-              stack.push(numberValue(lv / rv));
-            } else if (sharedCurrencyExchange.isCurrency(l.unit) && sharedCurrencyExchange.isCurrency(r.unit)) {
-              stack.push(errorValue("INCOMPATIBLE_UNITS", `Cannot combine incompatible units: ${l.unit} and ${r.unit}`));
-            } else {
-              stack.push(rateValue(lv / rv, l.unit, r.unit));
-            }
-          } else {
-            const ratDiv = exactRationalOp(l, r, "div");
-            if (ratDiv) {
-              stack.push(ratDiv);
-              break;
-            }
-            stack.push(binaryOp(l, r, (a, b) => a / b, (a, b) => {
-              if (b === 0n) throw bigIntDivisionByZero();
-              return a / b;
-            }, "div"));
-          }
-          break;
-        }
-        case 24 /* MOD */: {
-          const r = safePop(stack), l = safePop(stack);
-          stack.push(binaryOp(l, r, (a, b) => a % b, (a, b) => {
-            if (b === 0n) throw bigIntDivisionByZero();
-            return a % b;
-          }));
-          break;
-        }
-        case 25 /* EXP */: {
-          const r = safePop(stack), l = safePop(stack);
-          if (l.type === 13 /* Error */) {
-            stack.push(l);
-            break;
-          }
-          if (r.type === 13 /* Error */) {
-            stack.push(r);
-            break;
-          }
-          if (l.type === 12 /* Pending */) {
-            stack.push(l);
-            break;
-          }
-          if (r.type === 12 /* Pending */) {
-            stack.push(r);
-            break;
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(numberValue(power(l.value, r.value)));
-            break;
-          }
-          if (l.type === 7 /* Matrix */ || r.type === 7 /* Matrix */) {
-            if (l.type !== 7 /* Matrix */ || r.type !== 0 /* Number */) {
-              stack.push(errorValue(
-                "MATRIX_POWER_UNSUPPORTED",
-                `^: 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.`
-              ));
-              break;
-            }
-            checkAllocation(matrixPowerCells(l.value, r.value), "matrix cells");
-            stack.push(matrixPower(l.value, r.value));
-            break;
-          }
-          if (l.type === 9 /* Symbolic */ || r.type === 9 /* Symbolic */) {
-            stack.push(symbolicPow(l, r));
-            break;
-          }
-          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const powBits = exactPowBits(l, r.toNumber());
-            if (powBits !== null) {
-              if (powBits > MAX_EXACT_POW_BITS) {
-                throw ErrorFactory.execution(
-                  "BIGINT_POW_LIMIT_EXCEEDED",
-                  `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`,
-                  { limitBits: MAX_EXACT_POW_BITS }
-                );
-              }
-              stack.push(bigIntValue(bigIntPow(toBigIntOperand(l), toBigIntOperand(r))));
-              break;
-            }
-          }
-          stack.push(numberValue(power(l.toNumber(), r.toNumber())));
-          break;
-        }
-        case 26 /* NEG */: {
-          const v = safePop(stack);
-          const negFault = faultedOperand(v);
-          if (negFault) {
-            stack.push(negFault);
-            break;
-          }
-          if (v.type === 2 /* BigInt */) stack.push(bigIntValue(-v.value));
-          else if (v.type === 6 /* Uom */ && v.exact !== void 0) stack.push(uomValueExact(-v.toNumber(), v.unit, decimalNegate(v.exact)));
-          else if (v.type === 6 /* Uom */) stack.push(uomValue(-v.toNumber(), v.unit));
-          else if (v.type === 5 /* Percentage */) stack.push(percentageValue(-v.toNumber()));
-          else if (v.type === 9 /* Symbolic */) stack.push(symbolicNeg(v));
-          else if (v.type === 0 /* Number */ && v.rational !== void 0) stack.push(numberValueRational(-v.toNumber(), rationalNeg(v.rational)));
-          else if (v.type === 0 /* Number */ && v.exact !== void 0) stack.push(numberValueExact(-v.toNumber(), decimalNegate(v.exact)));
-          else stack.push(numberValue(-v.toNumber()));
-          break;
-        }
-        case 27 /* POS */: {
-          const v = safePop(stack);
-          const posFault = faultedOperand(v);
-          if (posFault) {
-            stack.push(posFault);
-            break;
-          }
-          if (v.type === 6 /* Uom */ && v.exact !== void 0) stack.push(uomValueExact(v.toNumber(), v.unit, v.exact));
-          else if (v.type === 6 /* Uom */) stack.push(uomValue(v.toNumber(), v.unit));
-          else if (v.type === 5 /* Percentage */) stack.push(percentageValue(v.toNumber()));
-          else if (v.type === 0 /* Number */ && v.rational !== void 0) stack.push(numberValueRational(v.toNumber(), v.rational));
-          else if (v.type === 0 /* Number */ && v.exact !== void 0) stack.push(numberValueExact(v.toNumber(), v.exact));
-          else stack.push(numberValue(v.toNumber()));
-          break;
-        }
-        case 28 /* MAKE_UNCERTAIN */: {
-          const spread = safePop(stack), center = safePop(stack);
-          const uncFault = faultedOperand(center, spread);
-          if (uncFault) {
-            stack.push(uncFault);
-            break;
-          }
-          stack.push(numberValueUncertain(center.toNumber(), Math.abs(spread.toNumber())));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §4  Bitwise  (OpCode 30–36)
-        //     None of these routes through binaryOp(), so each one carries
-        //     its own faulted-operand check for the reason that function
-        //     documents: a bit pattern read off an Error or a Pending is the
-        //     bit pattern of zero, and `(5 kg to m) & 1` answered 0 with
-        //     nothing to say it had not been asked a real question.
-        // ═══════════════════════════════════════════════════════════════
-        case 30 /* LSHIFT */: {
-          const r = safePop(stack), l = safePop(stack);
-          const shiftFault = faultedOperand(l, r);
-          if (shiftFault) {
-            stack.push(shiftFault);
-            break;
-          }
-          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(bigIntShift(l, r, 1));
-          } else {
-            stack.push(numberValue(l.toNumber() << r.toNumber()));
-          }
-          break;
-        }
-        case 31 /* RSHIFT */: {
-          const r = safePop(stack), l = safePop(stack);
-          const rshiftFault = faultedOperand(l, r);
-          if (rshiftFault) {
-            stack.push(rshiftFault);
-            break;
-          }
-          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(bigIntShift(l, r, -1));
-          } else {
-            stack.push(numberValue(l.toNumber() >> r.toNumber()));
-          }
-          break;
-        }
-        case 32 /* URSHIFT */: {
-          const r = safePop(stack), l = safePop(stack);
-          const urshiftFault = faultedOperand(l, r);
-          if (urshiftFault) {
-            stack.push(urshiftFault);
-            break;
-          }
-          stack.push(numberValue(l.toNumber() >>> r.toNumber()));
-          break;
-        }
-        case 33 /* BIT_AND */: {
-          const r = safePop(stack), l = safePop(stack);
-          const andFault = faultedOperand(l, r);
-          if (andFault) {
-            stack.push(andFault);
-            break;
-          }
-          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(bigIntValue(toBigIntOperand(l) & toBigIntOperand(r)));
-          } else {
-            stack.push(numberValue(l.toNumber() & r.toNumber()));
-          }
-          break;
-        }
-        case 34 /* BIT_OR */: {
-          const r = safePop(stack), l = safePop(stack);
-          const orFault = faultedOperand(l, r);
-          if (orFault) {
-            stack.push(orFault);
-            break;
-          }
-          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(bigIntValue(toBigIntOperand(l) | toBigIntOperand(r)));
-          } else {
-            stack.push(numberValue(l.toNumber() | r.toNumber()));
-          }
-          break;
-        }
-        case 35 /* BIT_XOR */: {
-          const r = safePop(stack), l = safePop(stack);
-          const xorFault = faultedOperand(l, r);
-          if (xorFault) {
-            stack.push(xorFault);
-            break;
-          }
-          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(bigIntValue(toBigIntOperand(l) ^ toBigIntOperand(r)));
-          } else {
-            stack.push(numberValue(l.toNumber() ^ r.toNumber()));
-          }
-          break;
-        }
-        case 36 /* BIT_NOT */: {
-          const v = safePop(stack);
-          const notFault = faultedOperand(v);
-          if (notFault) {
-            stack.push(notFault);
-            break;
-          }
-          if (v.type === 2 /* BigInt */) stack.push(bigIntValue(~v.value));
-          else stack.push(numberValue(~v.toNumber()));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §4b Comparison  (OpCode 40–45)
-        //     Numeric fast path when both operands are Number;
-        //     all six unify UoM operands before comparing them.
-        //
-        //     The four ordering opcodes used to skip that unification and
-        //     compare the bare magnitudes, so `1 km > 500 m` answered false
-        //     and `30 min < 1 hour` answered false as well. They now go
-        //     through compareUom() like EQ/NEQ, which also means they agree
-        //     with EQ about where the boundary between "less" and "equal"
-        //     falls: `equal` there is a tolerance rather than `===`, so a
-        //     pair EQ calls equal is one GT and LT both call false.
-        //
-        //     Two units that share no measure cannot be ordered at all, so
-        //     the four ordering opcodes answer with an error rather than a
-        //     boolean. EQ and NEQ still answer with a boolean, because
-        //     "a kilogram is not a metre" is a true statement about a pair
-        //     that cannot be converted, whereas "a kilogram is less than a
-        //     metre" is not a statement at all.
-        //
-        //     A faulted operand is the second case even for EQ and NEQ, and
-        //     all six propagate it. A kilogram is a quantity that is not a
-        //     metre; an Error is not a quantity, so there is nothing for it
-        //     to be equal to. Reading its number gave zero, which made
-        //     `(5 kg to m) == 0` answer true.
-        // ═══════════════════════════════════════════════════════════════
-        case 40 /* EQ */: {
-          const r = safePop(stack), l = safePop(stack);
-          const eqFault = faultedOperand(l, r);
-          if (eqFault) {
-            stack.push(eqFault);
-            break;
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const cmp = compareRationalOperands(l, r);
-            if (cmp !== null) {
-              stack.push(boolValue(cmp === 0));
-              break;
-            }
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(boolValue(l.value === r.value));
-          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const cmp = compareBigIntOperands(l, r);
-            stack.push(boolValue(cmp === null ? l.toNumber() === r.toNumber() : cmp === 0));
-          } else if (l.type === 3 /* String */ && r.type === 3 /* String */) {
-            stack.push(boolValue(l.value === r.value));
-          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { equal, sameMeasure } = compareUom(l, r);
-            stack.push(boolValue(sameMeasure && equal));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(matrixCompare(l.value, r.value, (a, b) => a === b));
-          } else if (l.type === 14 /* Colour */ || r.type === 14 /* Colour */) {
-            if (l.type === 14 /* Colour */ && r.type === 14 /* Colour */) {
-              const a = l.value, b = r.value;
-              stack.push(boolValue(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a));
-            } else {
-              stack.push(boolValue(false));
-            }
-          } else {
-            stack.push(boolValue(l.toNumber() === r.toNumber()));
-          }
-          break;
-        }
-        case 41 /* NEQ */: {
-          const r = safePop(stack), l = safePop(stack);
-          const neqFault = faultedOperand(l, r);
-          if (neqFault) {
-            stack.push(neqFault);
-            break;
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const cmp = compareRationalOperands(l, r);
-            if (cmp !== null) {
-              stack.push(boolValue(cmp !== 0));
-              break;
-            }
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(boolValue(l.value !== r.value));
-          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const cmp = compareBigIntOperands(l, r);
-            stack.push(boolValue(cmp === null ? l.toNumber() !== r.toNumber() : cmp !== 0));
-          } else if (l.type === 3 /* String */ && r.type === 3 /* String */) {
-            stack.push(boolValue(l.value !== r.value));
-          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { equal, sameMeasure } = compareUom(l, r);
-            stack.push(boolValue(!sameMeasure || !equal));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(matrixCompare(l.value, r.value, (a, b) => a !== b));
-          } else if (l.type === 14 /* Colour */ || r.type === 14 /* Colour */) {
-            if (l.type === 14 /* Colour */ && r.type === 14 /* Colour */) {
-              const a = l.value, b = r.value;
-              stack.push(boolValue(!(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a)));
-            } else {
-              stack.push(boolValue(true));
-            }
-          } else {
-            stack.push(boolValue(l.toNumber() !== r.toNumber()));
-          }
-          break;
-        }
-        case 42 /* LT */: {
-          const r = safePop(stack), l = safePop(stack);
-          const ltFault = faultedOperand(l, r);
-          if (ltFault) {
-            stack.push(ltFault);
-            break;
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const cmp = compareRationalOperands(l, r);
-            if (cmp !== null) {
-              stack.push(boolValue(cmp < 0));
-              break;
-            }
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(boolValue(l.value < r.value));
-          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const cmp = compareBigIntOperands(l, r);
-            stack.push(boolValue(cmp === null ? l.toNumber() < r.toNumber() : cmp < 0));
-          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, equal, sameMeasure } = compareUom(l, r);
-            stack.push(sameMeasure ? boolValue(!equal && lv < rv) : incomparableUnitsError(l, r));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(matrixCompare(l.value, r.value, (a, b) => a < b));
-          } else {
-            stack.push(boolValue(l.toNumber() < r.toNumber()));
-          }
-          break;
-        }
-        case 43 /* LTE */: {
-          const r = safePop(stack), l = safePop(stack);
-          const lteFault = faultedOperand(l, r);
-          if (lteFault) {
-            stack.push(lteFault);
-            break;
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const cmp = compareRationalOperands(l, r);
-            if (cmp !== null) {
-              stack.push(boolValue(cmp <= 0));
-              break;
-            }
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(boolValue(l.value <= r.value));
-          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const cmp = compareBigIntOperands(l, r);
-            stack.push(boolValue(cmp === null ? l.toNumber() <= r.toNumber() : cmp <= 0));
-          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, equal, sameMeasure } = compareUom(l, r);
-            stack.push(sameMeasure ? boolValue(equal || lv <= rv) : incomparableUnitsError(l, r));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(matrixCompare(l.value, r.value, (a, b) => a <= b));
-          } else {
-            stack.push(boolValue(l.toNumber() <= r.toNumber()));
-          }
-          break;
-        }
-        case 44 /* GT */: {
-          const r = safePop(stack), l = safePop(stack);
-          const gtFault = faultedOperand(l, r);
-          if (gtFault) {
-            stack.push(gtFault);
-            break;
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const cmp = compareRationalOperands(l, r);
-            if (cmp !== null) {
-              stack.push(boolValue(cmp > 0));
-              break;
-            }
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(boolValue(l.value > r.value));
-          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const cmp = compareBigIntOperands(l, r);
-            stack.push(boolValue(cmp === null ? l.toNumber() > r.toNumber() : cmp > 0));
-          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, equal, sameMeasure } = compareUom(l, r);
-            stack.push(sameMeasure ? boolValue(!equal && lv > rv) : incomparableUnitsError(l, r));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(matrixCompare(l.value, r.value, (a, b) => a > b));
-          } else {
-            stack.push(boolValue(l.toNumber() > r.toNumber()));
-          }
-          break;
-        }
-        case 45 /* GTE */: {
-          const r = safePop(stack), l = safePop(stack);
-          const gteFault = faultedOperand(l, r);
-          if (gteFault) {
-            stack.push(gteFault);
-            break;
-          }
-          if (l.rational !== void 0 || r.rational !== void 0) {
-            const cmp = compareRationalOperands(l, r);
-            if (cmp !== null) {
-              stack.push(boolValue(cmp >= 0));
-              break;
-            }
-          }
-          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(boolValue(l.value >= r.value));
-          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            const cmp = compareBigIntOperands(l, r);
-            stack.push(boolValue(cmp === null ? l.toNumber() >= r.toNumber() : cmp >= 0));
-          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, equal, sameMeasure } = compareUom(l, r);
-            stack.push(sameMeasure ? boolValue(equal || lv >= rv) : incomparableUnitsError(l, r));
-          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(matrixCompare(l.value, r.value, (a, b) => a >= b));
-          } else {
-            stack.push(boolValue(l.toNumber() >= r.toNumber()));
-          }
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §4c Logical / conditional select  (OpCode 130–132)
-        //
-        //     Truthiness is read through isTruthy(), which reads a number,
-        //     which is zero for a fault, so a failed operand used to be
-        //     quietly false. Both operands are already evaluated by the time
-        //     either opcode runs (this VM has no branch opcodes), so there is
-        //     no short-circuit to preserve by ignoring the right-hand one.
-        // ═══════════════════════════════════════════════════════════════
-        case 130 /* LOGICAL_AND */: {
-          const r = safePop(stack), l = safePop(stack);
-          const andLogicFault = faultedOperand(l, r);
-          if (andLogicFault) {
-            stack.push(andLogicFault);
-            break;
-          }
-          stack.push(boolValue(isTruthy(l) && isTruthy(r)));
-          break;
-        }
-        case 131 /* LOGICAL_OR */: {
-          const r = safePop(stack), l = safePop(stack);
-          const orLogicFault = faultedOperand(l, r);
-          if (orLogicFault) {
-            stack.push(orLogicFault);
-            break;
-          }
-          stack.push(boolValue(isTruthy(l) || isTruthy(r)));
-          break;
-        }
-        case 132 /* SELECT */: {
-          const elseVal = safePop(stack);
-          const thenVal = safePop(stack);
-          const condition = safePop(stack);
-          const conditionFault = faultedOperand(condition);
-          if (conditionFault) {
-            stack.push(conditionFault);
-            break;
-          }
-          stack.push(isTruthy(condition) ? thenVal : elseVal);
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §5  Functions  (OpCode 50–52)
-        // ═══════════════════════════════════════════════════════════════
-        case 50 /* CALL_PLUGIN */: {
-          const fnIdx = operandByte(opcodes, ip++, op, "plugin-function index");
-          const argCount = operandByte(opcodes, ip++, op, "argument count");
-          const args = [];
-          for (let i = 0; i < argCount; i++) args.push(safePop(stack));
-          args.reverse();
-          const fn = vm.context.pluginFunctions[fnIdx];
-          const pluginArgFault = faultedIn(args);
-          if (pluginArgFault) {
-            stack.push(pluginArgFault);
-          } else if (!fn) {
-            stack.push(numberValue(0));
-          } else {
-            const result = fn(args, context);
-            if (result instanceof Promise) {
-              const cacheKey = `plugin:${fnIdx}:${args.map((a) => String(a.value ?? "")).join("|")}`;
-              const signal = vm.activeSignal;
-              const packageId = vm.context.pluginFunctionOwners[fnIdx] ?? "";
-              return { type: "pending", queryKey: cacheKey, resolver: result, packageId, signal };
-            }
-            stack.push(result);
-          }
-          break;
-        }
-        case 51 /* CALL_BUILTIN */: {
-          const fnIdx = operandByte(opcodes, ip++, op, "builtin-function index");
-          const argCount = operandByte(opcodes, ip++, op, "argument count");
-          const arityError = builtinArityError(fnIdx, argCount);
-          if (arityError) throw arityError;
-          const args = [];
-          let sawSymbolic = false;
-          for (let i = 0; i < argCount; i++) {
-            const arg = safePop(stack);
-            if (arg.type === 9 /* Symbolic */) sawSymbolic = true;
-            args.push(arg);
-          }
-          const builtinArgFault = faultedIn(args);
-          if (builtinArgFault) {
-            stack.push(builtinArgFault);
-            break;
-          }
-          const fn = builtinFunctions[fnIdx];
-          if (fn) {
-            const ordered = args.reverse();
-            const routeSymbolically = sawSymbolic && !SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);
-            stack.push(routeSymbolically ? symbolicBuiltin(fnIdx, ordered) : fn(ordered));
-          }
-          break;
-        }
-        case 150 /* DEFINE_USER_FUNCTION */: {
-          const bodyIdx = operandByte(opcodes, ip++, op, "function-body index");
-          const def = userFunctionBodies?.[bodyIdx];
-          if (!def) {
-            throw ErrorFactory.internal(
-              "INTERNAL_MISSING_FUNCTION_BODY",
-              `Internal error: DEFINE_USER_FUNCTION referenced missing body index ${bodyIdx}`,
-              { bodyIdx }
-            );
-          }
-          vm.defineUserFunction(def.name, def.params, def.program);
-          break;
-        }
-        case 151 /* CALL_USER_FUNCTION */: {
-          const name = poolString(opcodes, ip++, strings, op, "function-name index");
-          const argCount = operandByte(opcodes, ip++, op, "argument count");
-          const args = [];
-          for (let i = 0; i < argCount; i++) args.push(safePop(stack));
-          args.reverse();
-          const fn = vm.getUserFunction(name);
-          if (!fn) {
-            throw ErrorFactory.execution("UNDEFINED_FUNCTION", `Undefined function: ${name}`, { name });
-          }
-          if (argCount !== fn.params.length) {
-            throw ErrorFactory.execution(
-              "FUNCTION_ARITY_MISMATCH",
-              `${name} expects ${fn.params.length} argument(s) but got ${argCount}`,
-              { name, expected: fn.params.length, actual: argCount }
-            );
-          }
-          const frame = /* @__PURE__ */ new Map();
-          for (let i = 0; i < fn.params.length; i++) frame.set(fn.params[i], args[i]);
-          chargeFunctionCall();
-          vm.pushCallFrame(frame);
-          let bodyResult;
-          try {
-            bodyResult = executeBytecode(fn.program, vm, pipeline, expression, context);
-          } finally {
-            vm.popCallFrame();
-          }
-          if (bodyResult.type === "pending") {
-            throw ErrorFactory.execution(
-              "USER_FUNCTION_ASYNC_UNSUPPORTED",
-              `${name}: user-defined functions with async bodies (weather, stocks, currency, ...) aren't supported`,
-              { name }
-            );
-          }
-          if (bodyResult.type === "error") {
-            throw bodyResult.error;
-          }
-          stack.push(bodyResult.value);
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §6  Variables  (OpCode 60–63)
-        // ═══════════════════════════════════════════════════════════════
-        case 60 /* LOAD_VAR */: {
-          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          const val = vm.getVar(varName);
-          if (val !== void 0) {
-            stack.push(val);
-          } else if (symbolicTolerant) {
-            stack.push(symbolicValue(varNode(varName)));
-          } else {
-            throw ErrorFactory.execution(
-              "UNDEFINED_VARIABLE",
-              `Undefined variable: ${varName}`,
-              { varName }
-            );
-          }
-          break;
-        }
-        case 61 /* STORE_VAR */: {
-          const val = safePop(stack);
-          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          vm.setVar(varName, hasArena ? persistentValue(val) : val);
-          stack.push(val);
-          break;
-        }
-        case 62 /* LOAD_GLOBAL_VAR */: {
-          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          const globalValue = sharedGlobalVariableStore.get(varName);
-          if (globalValue === void 0) {
-            throw ErrorFactory.internal({
-              code: "GLOBAL_VARIABLE_NOT_RESOLVED",
-              message: `Global variable "${varName}" was read before it resolved`,
-              expected: `global variable "${varName}" to already be resolved (async preflight should guarantee this)`,
-              found: "no value in the global variable store",
-              context: { varName }
-            });
-          }
-          stack.push(globalValue);
-          break;
-        }
-        case 63 /* STORE_GLOBAL_VAR */: {
-          const val = safePop(stack);
-          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          sharedGlobalVariableStore.set(varName, hasArena ? persistentValue(val) : val);
-          stack.push(val);
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §7  Type conversions  (OpCode 70–74, 140–145)
-        //     Every one of these restates a number in another notation, so a
-        //     faulted operand has nothing to restate and each propagates it
-        //     rather than converting the zero toNumber() reports. Without it
-        //     "(5 kg to m) as hex" answered 0x0 and "as binary" answered 0b0.
-        // ═══════════════════════════════════════════════════════════════
-        case 70 /* TO_NUMBER */: {
-          const v = safePop(stack);
-          const toNumberFault = faultedOperand(v);
-          if (toNumberFault) {
-            stack.push(toNumberFault);
-            break;
-          }
-          stack.push(numberValue(v.toNumber()));
-          break;
-        }
-        case 71 /* TO_HEX */: {
-          const v = safePop(stack);
-          const toHexFault = faultedOperand(v);
-          if (toHexFault) {
-            stack.push(toHexFault);
-            break;
-          }
-          if (v.type === 14 /* Colour */) {
-            const c = v.value;
-            stack.push(colourValue({ r: c.r, g: c.g, b: c.b, a: c.a, format: "hex" }));
-            break;
-          }
-          stack.push(hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber()));
-          break;
-        }
-        case 74 /* TO_PERCENTAGE */: {
-          const v = safePop(stack);
-          const toPercentageFault = faultedOperand(v);
-          if (toPercentageFault) {
-            stack.push(toPercentageFault);
-            break;
-          }
-          stack.push(percentageValue(v.toNumber()));
-          break;
-        }
-        case 140 /* TO_FRACTION */: {
-          const v = safePop(stack);
-          const toFractionFault = faultedOperand(v);
-          if (toFractionFault) {
-            stack.push(toFractionFault);
-            break;
-          }
-          stack.push(stringValue(v.rational !== void 0 ? rationalToFractionString(v.rational) : toFractionString(v.toNumber())));
-          break;
-        }
-        case 141 /* TO_MULTIPLIER */: {
-          const v = safePop(stack);
-          const toMultiplierFault = faultedOperand(v);
-          if (toMultiplierFault) {
-            stack.push(toMultiplierFault);
-            break;
-          }
-          stack.push(stringValue(toMultiplierString(v)));
-          break;
-        }
-        case 142 /* TO_SCI */: {
-          const v = safePop(stack);
-          const toSciFault = faultedOperand(v);
-          if (toSciFault) {
-            stack.push(toSciFault);
-            break;
-          }
-          stack.push(stringValue(toScientificString(v.toNumber())));
-          break;
-        }
-        // Numeric, like TO_HEX above. A base is a way of writing a number, so
-        // `(255 as binary) + 1` has to be 256; as a string it was 1.
-        case 143 /* TO_BINARY */: {
-          const v = safePop(stack);
-          const toBinaryFault = faultedOperand(v);
-          if (toBinaryFault) {
-            stack.push(toBinaryFault);
-            break;
-          }
-          stack.push(hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "bin"));
-          break;
-        }
-        case 144 /* TO_OCTAL */: {
-          const v = safePop(stack);
-          const toOctalFault = faultedOperand(v);
-          if (toOctalFault) {
-            stack.push(toOctalFault);
-            break;
-          }
-          stack.push(hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "oct"));
-          break;
-        }
-        case 145 /* CALL_AS_CONVERTER */: {
-          const name = stringOperand(safePop(stack), op, "converter name").toLowerCase();
-          const value = safePop(stack);
-          const converterFault = faultedOperand(value);
-          if (converterFault) {
-            stack.push(converterFault);
-            break;
-          }
-          const converter = asConverterRegistry.get(name);
-          if (!converter) {
-            stack.push(errorValue("UNKNOWN_AS_CONVERTER", `Unknown converter "as ${name}"`));
-          } else {
-            stack.push(converter(value));
-          }
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §8  UoM  (OpCode 80–84)
-        // ═══════════════════════════════════════════════════════════════
-        case 80 /* UOM_CONVERT */: {
-          const unit = stringOperand(safePop(stack), op, "unit name");
-          const operand = safePop(stack);
-          const faulted = faultedOperand(operand);
-          if (faulted) {
-            stack.push(faulted);
-            break;
-          }
-          const money = moneyExactMagnitude(operand, unit);
-          if (money) stack.push(uomValueExact(operand.toNumber(), unit, money));
-          else stack.push(uomValue(operand.toNumber(), unit));
-          break;
-        }
-        case 81 /* UOM_CONVERT_TO */: {
-          const toUnit = stringOperand(safePop(stack), op, "target unit name");
-          const fromUnit = stringOperand(safePop(stack), op, "source unit name");
-          const operand = safePop(stack);
-          const faulted = faultedOperand(operand);
-          if (faulted) {
-            stack.push(faulted);
-            break;
-          }
-          const val = operand.toNumber();
-          const measure = getMeasure(fromUnit);
-          const isCurrency = sharedCurrencyExchange.isCurrency(fromUnit) && sharedCurrencyExchange.isCurrency(toUnit);
-          if (measure && getMeasure(toUnit) === measure) {
-            stack.push(uomValue(convertUnit(val, fromUnit, toUnit), toUnit));
-          } else if (isCurrency) {
-            const converted = sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
-            if (converted !== null) {
-              stack.push(uomValue(converted, toUnit));
-            } else {
-              stack.push(errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
-            }
-          } else {
-            const rate = convertRate(val, fromUnit, toUnit);
-            if (rate !== null) {
-              stack.push(uomValue(rate, toUnit));
-            } else {
-              stack.push(incompatibleConversionError(fromUnit, toUnit));
-            }
-          }
-          break;
-        }
-        case 85 /* UOM_POSSIBILITIES */: {
-          const unit = stringOperand(safePop(stack), op, "unit name");
-          const possibilities = getConvertiblePossibilities(unit);
-          stack.push(stringValue(possibilities.length > 0 ? possibilities.join(", ") : `No known units for "${unit}"`));
-          break;
-        }
-        case 83 /* UOM_BEST */: {
-          const unit = stringOperand(safePop(stack), op, "unit name");
-          const operand = safePop(stack);
-          const faulted = faultedOperand(operand);
-          if (faulted) {
-            stack.push(faulted);
-            break;
-          }
-          const { value, unit: bestUnit } = getBestUnit(operand.toNumber(), unit);
-          stack.push(uomValue(value, bestUnit));
-          break;
-        }
-        case 84 /* UOM_CONVERT_IN */: {
-          const toUnit = stringOperand(safePop(stack), op, "target unit name");
-          const left = safePop(stack);
-          const faulted = faultedOperand(left);
-          if (faulted) {
-            stack.push(faulted);
-            break;
-          }
-          if (left.type === 6 /* Uom */) {
-            const fromUnit = left.unit;
-            const val = left.toNumber();
-            const measure = getMeasure(fromUnit);
-            const isCurrency = sharedCurrencyExchange.isCurrency(fromUnit) && sharedCurrencyExchange.isCurrency(toUnit);
-            if (measure && getMeasure(toUnit) === measure) {
-              stack.push(uomValue(convertUnit(val, fromUnit, toUnit), toUnit));
-            } else if (isCurrency) {
-              const converted = sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
-              if (converted !== null) {
-                stack.push(uomValue(converted, toUnit));
-              } else {
-                stack.push(errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
-              }
-            } else {
-              const rate = convertRate(val, fromUnit, toUnit);
-              if (rate !== null) {
-                stack.push(uomValue(rate, toUnit));
-              } else {
-                stack.push(incompatibleConversionError(fromUnit, toUnit));
-              }
-            }
-          } else {
-            stack.push(uomValue(left.toNumber(), toUnit));
-          }
-          break;
-        }
-        case 82 /* UOM_GET_VALUE */: {
-          const v = safePop(stack);
-          const getValueFault = faultedOperand(v);
-          if (getValueFault) {
-            stack.push(getValueFault);
-            break;
-          }
-          stack.push(numberValue(v.toNumber()));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §8.5  Rate, "quantity per unit of something" (OpCode 110–112)
-        //       See vm/Value.ts's rateValue()/isRateUnit()/splitRateUnit().
-        // ═══════════════════════════════════════════════════════════════
-        case 110 /* RATE_DIV */: {
-          const denominatorVal = safePop(stack);
-          const numeratorVal = safePop(stack);
-          const rateDivFault = faultedOperand(numeratorVal, denominatorVal);
-          if (rateDivFault) {
-            stack.push(rateDivFault);
-            break;
-          }
-          if (denominatorVal.type !== 6 /* Uom */ || !denominatorVal.unit) {
-            stack.push(errorValue("RATE_MISSING_DENOMINATOR_UNIT", 'Cannot build a rate: the right-hand side of "/" has no unit'));
-            break;
-          }
-          const numeratorUnit = numeratorVal.type === 6 /* Uom */ ? numeratorVal.unit ?? "" : "";
-          stack.push(rateValue(numeratorVal.toNumber() / denominatorVal.toNumber(), numeratorUnit, denominatorVal.unit));
-          break;
-        }
-        case 111 /* RATE_MUL */: {
-          const multiplier = safePop(stack);
-          const rate = safePop(stack);
-          const rateMulFault = faultedOperand(rate, multiplier);
-          if (rateMulFault) {
-            stack.push(rateMulFault);
-            break;
-          }
-          if (rate.type !== 6 /* Uom */ || !isRateUnit(rate.unit)) {
-            stack.push(errorValue("RATE_MUL_LEFT_NOT_A_RATE", 'Left-hand side of a rate multiplication must be a rate (e.g. "$50/week")'));
-            break;
-          }
-          if (multiplier.type !== 6 /* Uom */ || !multiplier.unit) {
-            stack.push(errorValue("RATE_MUL_RIGHT_MISSING_UNIT", "Right-hand side of a rate multiplication must have a unit matching the rate's denominator"));
-            break;
-          }
-          stack.push(multiplyRateByMatchingUom(rate, multiplier));
-          break;
-        }
-        case 112 /* RATE_CONVERT */: {
-          const newDenominatorUnit = stringOperand(safePop(stack), op, "denominator unit name");
-          const rate = safePop(stack);
-          const rateConvertFault = faultedOperand(rate);
-          if (rateConvertFault) {
-            stack.push(rateConvertFault);
-            break;
-          }
-          if (rate.type !== 6 /* Uom */ || !isRateUnit(rate.unit)) {
-            stack.push(errorValue("RATE_CONVERT_NOT_A_RATE", "Cannot convert a non-rate value's denominator"));
-            break;
-          }
-          const { numerator, denominator } = splitRateUnit(rate.unit);
-          const rateMeasure = getMeasure(denominator);
-          const targetMeasure = getMeasure(newDenominatorUnit);
-          if (!rateMeasure || rateMeasure !== targetMeasure) {
-            stack.push(errorValue(
-              "RATE_CONVERT_MEASURE_MISMATCH",
-              `Cannot convert a "${denominator}"-denominated rate to "${newDenominatorUnit}" \u2014 different measures`
-            ));
-            break;
-          }
-          const factor = convertUnit(1, newDenominatorUnit, denominator);
-          stack.push(rateValue(rate.toNumber() * factor, numerator, newDenominatorUnit));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §8.7  Time, clock-time-of-day (OpCode 120)
-        // ═══════════════════════════════════════════════════════════════
-        case 120 /* CLOCK_TIME_TODAY */: {
-          const minutesValue = safePop(stack);
-          const clockFault = faultedOperand(minutesValue);
-          if (clockFault) {
-            stack.push(clockFault);
-            break;
-          }
-          const totalMinutes = minutesValue.toNumber();
-          const now = /* @__PURE__ */ new Date();
-          const anchored = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
-          anchored.setMinutes(totalMinutes);
-          stack.push(datetimeValue(anchored.getTime()));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §9  Datetime  (OpCode 90–93)
-        // ═══════════════════════════════════════════════════════════════
-        case 90 /* DATE_NOW */:
-          stack.push(datetimeValue(Date.now()));
-          break;
-        case 95 /* DATE_LITERAL */:
-          stack.push(datetimeValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
-          break;
-        case 91 /* DATE_ADD */: {
-          const durValue = safePop(stack), dtValue = safePop(stack);
-          const dateAddFault = faultedOperand(dtValue, durValue);
-          if (dateAddFault) {
-            stack.push(dateAddFault);
-            break;
-          }
-          stack.push(datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, 1, vm)));
-          break;
-        }
-        case 92 /* DATE_SUB */: {
-          const durValue = safePop(stack), dtValue = safePop(stack);
-          const dateSubFault = faultedOperand(dtValue, durValue);
-          if (dateSubFault) {
-            stack.push(dateSubFault);
-            break;
-          }
-          stack.push(datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, -1, vm)));
-          break;
-        }
-        case 96 /* DATE_WORKDAY_OFFSET */: {
-          const workdayDirection = operandByte(opcodes, ip++, op, "workday offset direction") === 1 ? -1 : 1;
-          const anchorValue = safePop(stack), countValue = safePop(stack);
-          const offsetFault = faultedOperand(countValue, anchorValue);
-          if (offsetFault) {
-            stack.push(offsetFault);
-            break;
-          }
-          if (anchorValue.type !== 4 /* Datetime */) {
-            stack.push(errorValue(
-              CoreErrorCodes.WORKDAY_OFFSET_EXPECTED_DATE,
-              `"working days after/before/from" expects a date to count from, got ${ValueType[anchorValue.type] ?? "an unsupported value"}`
-            ));
-            break;
-          }
-          stack.push(datetimeValue(addBusinessDays2(anchorValue.toNumber(), workdayDirection * countValue.toNumber(), vm)));
-          break;
-        }
-        case 97 /* DATE_WORKDAYS_BETWEEN */: {
-          const endValue = safePop(stack), startValue = safePop(stack);
-          const betweenFault = faultedOperand(startValue, endValue);
-          if (betweenFault) {
-            stack.push(betweenFault);
-            break;
-          }
-          if (startValue.type !== 4 /* Datetime */ || endValue.type !== 4 /* Datetime */) {
-            stack.push(errorValue(
-              CoreErrorCodes.WORKDAYS_BETWEEN_EXPECTED_DATES,
-              `"working days between" expects two dates, got ${ValueType[startValue.type] ?? "an unsupported value"} and ${ValueType[endValue.type] ?? "an unsupported value"}`
-            ));
-            break;
-          }
-          const spanLimitDays = Math.ceil((vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()) * 366);
-          const workdayCount = countBusinessDaysBetween(startValue.toNumber(), endValue.toNumber(), (ms) => vm.isHoliday(ms), spanLimitDays);
-          if (workdayCount === null) {
-            stack.push(errorValue(
-              CoreErrorCodes.WORKDAYS_BETWEEN_RANGE_TOO_LARGE,
-              `The two dates are more than ${vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()} years apart, past the working-day count's limit`
-            ));
-            break;
-          }
-          stack.push(numberValue(workdayCount));
-          break;
-        }
-        case 93 /* DATE_NEXT_WEEKDAY */:
-        case 94 /* DATE_LAST_WEEKDAY */: {
-          const targetDayValue = safePop(stack);
-          const nowValue = safePop(stack);
-          const weekdayFault = faultedOperand(nowValue, targetDayValue);
-          if (weekdayFault) {
-            stack.push(weekdayFault);
-            break;
-          }
-          const targetDay = targetDayValue.toNumber();
-          const now = nowValue.toNumber();
-          const currentDay = new Date(now).getDay();
-          let diffDays = op === 93 /* DATE_NEXT_WEEKDAY */ ? (targetDay - currentDay + 7) % 7 : (currentDay - targetDay + 7) % 7;
-          if (diffDays === 0) diffDays = 7;
-          stack.push(datetimeValue(addCalendarDays(now, op === 93 /* DATE_NEXT_WEEKDAY */ ? diffDays : -diffDays)));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §10 Matrix  (OpCode 152+, see parser/OpCode.ts's Matrix band)
-        //     Replaces the old ARR_* vector-only opcodes (100-107), which
-        //     were never emitted by any registered parselet in production
-        //     confirmed dead code, deleted outright rather than repurposed.
-        //     See vm/Value.ts's MatrixData and vm/MatrixOps.ts's shared
-        //     column-major storage helpers.
-        // ═══════════════════════════════════════════════════════════════
-        case 152 /* MAT_NEW */: {
-          const rows = operandByte(opcodes, ip++, op, "row count");
-          const cols = operandByte(opcodes, ip++, op, "column count");
-          const count = rows * cols;
-          const rowMajor = checkedArray(count, "matrix cells");
-          let cellFault = null;
-          for (let i = count - 1; i >= 0; i--) {
-            const cellVal = safePop(stack);
-            if (cellFault === null) cellFault = faultedOperand(cellVal);
-            rowMajor[i] = cellVal.type === 10 /* Boolean */ ? cellVal.value : cellVal.type === 9 /* Symbolic */ ? cellVal.value : cellVal.toNumber();
-          }
-          if (cellFault) {
-            stack.push(cellFault);
-            break;
-          }
-          stack.push(matrixValue(rows, cols, rowMajorToColumnMajor(rows, cols, rowMajor)));
-          break;
-        }
-        case 153 /* MAT_INDEX1 */: {
-          const indexVal = safePop(stack), matrixVal = safePop(stack);
-          const index1Fault = faultedOperand(matrixVal, indexVal);
-          if (index1Fault) {
-            stack.push(index1Fault);
-            break;
-          }
-          if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot index a non-matrix value with "[...]".`));
-            break;
-          }
-          const m = matrixVal.value;
-          const index = Math.trunc(indexVal.toNumber());
-          if (index < 0 || index >= m.data.length) {
-            stack.push(errorValue(
-              "MATRIX_INDEX_OUT_OF_BOUNDS",
-              `Index ${index} is out of bounds for a ${m.rows}x${m.cols} matrix (valid range: 0-${m.data.length - 1}).`
-            ));
-            break;
-          }
-          const cell = matIndex(m, index);
-          stack.push(matrixEntryToValue(cell));
-          break;
-        }
-        case 154 /* MAT_INDEX2 */: {
-          const colVal = safePop(stack), rowVal = safePop(stack), matrixVal = safePop(stack);
-          const index2Fault = faultedOperand(matrixVal, rowVal, colVal);
-          if (index2Fault) {
-            stack.push(index2Fault);
-            break;
-          }
-          if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot index a non-matrix value with "[...]".`));
-            break;
-          }
-          const m = matrixVal.value;
-          const row = Math.trunc(rowVal.toNumber());
-          const col = Math.trunc(colVal.toNumber());
-          if (!inBounds(m, row, col)) {
-            stack.push(errorValue(
-              "MATRIX_INDEX_OUT_OF_BOUNDS",
-              `[${row}, ${col}] is out of bounds for a ${m.rows}x${m.cols} matrix.`
-            ));
-            break;
-          }
-          const cell = matAt(m, row, col);
-          stack.push(matrixEntryToValue(cell));
-          break;
-        }
-        case 156 /* RANGE_NEW */: {
-          const maxVal = safePop(stack), minVal = safePop(stack);
-          const rangeFault = faultedOperand(minVal, maxVal);
-          if (rangeFault) {
-            stack.push(rangeFault);
-            break;
-          }
-          if (minVal.type !== 0 /* Number */ || maxVal.type !== 0 /* Number */) {
-            stack.push(errorValue("INVALID_RANGE_BOUND", `A range's bounds must be plain numbers (e.g. "0:3").`));
-            break;
-          }
-          const min = minVal.value;
-          const max = maxVal.value;
-          if (!Number.isInteger(min) || !Number.isInteger(max)) {
-            stack.push(errorValue("NON_INTEGER_RANGE_BOUND", `A range's bounds must be whole numbers, got "${min}:${max}".`));
-            break;
-          }
-          if (min > max) {
-            stack.push(errorValue(
-              "DESCENDING_RANGE",
-              `A range's min (${min}) cannot be greater than its max (${max}) \u2014 did you mean "${max}:${min}"?`
-            ));
-            break;
-          }
-          stack.push(rangeValue(min, max));
-          break;
-        }
-        case 155 /* MAT_SLICE */: {
-          const colRangeVal = safePop(stack), rowRangeVal = safePop(stack), matrixVal = safePop(stack);
-          const sliceFault = faultedOperand(matrixVal, rowRangeVal, colRangeVal);
-          if (sliceFault) {
-            stack.push(sliceFault);
-            break;
-          }
-          if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot slice a non-matrix value with "[...]".`));
-            break;
-          }
-          if (rowRangeVal.type !== 8 /* Range */ || colRangeVal.type !== 8 /* Range */) {
-            stack.push(errorValue("INVALID_MATRIX_SLICE_BOUND", `Matrix slicing needs range bounds (e.g. "a[0:1, 1:2]").`));
-            break;
-          }
-          const m = matrixVal.value;
-          const rowRange = rowRangeVal.value;
-          const colRange = colRangeVal.value;
-          if (rowRange.min < 0 || rowRange.max >= m.rows || colRange.min < 0 || colRange.max >= m.cols) {
-            stack.push(errorValue(
-              "MATRIX_INDEX_OUT_OF_BOUNDS",
-              `Slice [${rowRange.min}:${rowRange.max}, ${colRange.min}:${colRange.max}] is out of bounds for a ${m.rows}x${m.cols} matrix.`
-            ));
-            break;
-          }
-          const newRows = rowRange.max - rowRange.min + 1;
-          const newCols = colRange.max - colRange.min + 1;
-          const data = checkedArray(newRows * newCols, "matrix cells");
-          for (let r = 0; r < newRows; r++) {
-            for (let c = 0; c < newCols; c++) {
-              data[r + c * newRows] = matAt(m, rowRange.min + r, colRange.min + c);
-            }
-          }
-          stack.push(matrixValue(newRows, newCols, data));
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §11 map/reduce  (OpCode 157-158, see parser/OpCode.ts's Matrix
-        //     band). See packages/mapreduce/ for the parselets that decide
-        //     `kind` (0=inline anonymous body, 1=builtin function,
-        //     2=user-defined function) at parse time, and
-        //     `BytecodeBuilder.ts`'s AnonymousBodyDef doc comment for why
-        //     kind-0 bodies are a SEPARATE side-table from userFunctionBodies.
-        // ═══════════════════════════════════════════════════════════════
-        case 157 /* MAP_INVOKE */: {
-          const kind = operandByte(opcodes, ip++, op, "body kind");
-          const ref = operandByte(opcodes, ip++, op, "body reference");
-          const collectionCount = operandByte(opcodes, ip++, op, "collection count");
-          requireKnownBodyKind(kind, ref, op);
-          const rawCollections = new Array(collectionCount);
-          for (let i = collectionCount - 1; i >= 0; i--) rawCollections[i] = safePop(stack);
-          let paramNames = [];
-          let program;
-          if (kind === 0) {
-            const def = anonymousBodies?.[ref];
-            if (!def) {
-              throw ErrorFactory.internal(
-                "INTERNAL_MISSING_ANONYMOUS_BODY",
-                `Internal error: MAP_INVOKE referenced missing anonymous body index ${ref}`,
-                { ref }
-              );
-            }
-            paramNames = def.params;
-            program = def.program;
-          } else if (kind === 2) {
-            const name = pooledString(strings, ref, op);
-            const fn = vm.getUserFunction(name);
-            if (!fn) {
-              stack.push(errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
-              break;
-            }
-            if (fn.params.length !== collectionCount) {
-              stack.push(errorValue(
-                "FUNCTION_ARITY_MISMATCH",
-                `map: "${name}" expects ${fn.params.length} argument(s) but ${collectionCount} collection(s) were given`
-              ));
-              break;
-            }
-            paramNames = fn.params;
-            program = fn.program;
-          }
-          let collectionLength = -1;
-          const cellArrays = new Array(collectionCount);
-          let mapEarlyError;
-          for (let i = 0; i < collectionCount; i++) {
-            const resolved = collectionToValues(rawCollections[i], vm.getMaxCollectionSize());
-            if (!Array.isArray(resolved)) {
-              mapEarlyError = resolved;
-              break;
-            }
-            chargeAllocation(resolved.length, "collection elements");
-            if (collectionLength === -1) {
-              collectionLength = resolved.length;
-            } else if (resolved.length !== collectionLength) {
-              mapEarlyError = errorValue(
-                "MAP_COLLECTION_LENGTH_MISMATCH",
-                `map: all collections must have the same length (got ${collectionLength} and ${resolved.length}).`
-              );
-              break;
-            }
-            cellArrays[i] = resolved;
-          }
-          if (mapEarlyError) {
-            stack.push(mapEarlyError);
-            break;
-          }
-          const resultData = checkedArray(collectionLength, "matrix cells");
-          let mapError;
-          for (let i = 0; i < collectionLength; i++) {
-            const args = new Array(collectionCount);
-            for (let j = 0; j < collectionCount; j++) args[j] = cellArrays[j][i];
-            const resultVal = kind === 1 ? builtinFunctions[ref]?.(args) ?? errorValue("UNKNOWN_BUILTIN_FUNCTION", `map: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
-            const resultFault = faultedOperand(resultVal);
-            if (resultFault) {
-              mapError = resultFault;
-              break;
-            }
-            resultData[i] = resultVal.type === 10 /* Boolean */ ? resultVal.value : resultVal.type === 9 /* Symbolic */ ? resultVal.value : resultVal.toNumber();
-          }
-          if (mapError) {
-            stack.push(mapError);
-            break;
-          }
-          const firstCollection = rawCollections[0];
-          const sourceShape = firstCollection?.type === 7 /* Matrix */ ? firstCollection.value : void 0;
-          if (sourceShape && sourceShape.rows * sourceShape.cols === collectionLength) {
-            stack.push(matrixValue(sourceShape.rows, sourceShape.cols, resultData));
-          } else {
-            stack.push(matrixValue(1, collectionLength, resultData));
-          }
-          break;
-        }
-        case 158 /* REDUCE_INVOKE */: {
-          const kind = operandByte(opcodes, ip++, op, "body kind");
-          const ref = operandByte(opcodes, ip++, op, "body reference");
-          const hasInitial = operandByte(opcodes, ip++, op, "initial-value flag");
-          requireKnownBodyKind(kind, ref, op);
-          const initialVal = hasInitial ? safePop(stack) : void 0;
-          const collectionVal = safePop(stack);
-          let paramNames = [];
-          let program;
-          if (kind === 0) {
-            const def = anonymousBodies?.[ref];
-            if (!def) {
-              throw ErrorFactory.internal(
-                "INTERNAL_MISSING_ANONYMOUS_BODY",
-                `Internal error: REDUCE_INVOKE referenced missing anonymous body index ${ref}`,
-                { ref }
-              );
-            }
-            paramNames = def.params;
-            program = def.program;
-          } else if (kind === 2) {
-            const name = pooledString(strings, ref, op);
-            const fn = vm.getUserFunction(name);
-            if (!fn) {
-              stack.push(errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
-              break;
-            }
-            if (fn.params.length !== 2) {
-              stack.push(errorValue(
-                "FUNCTION_ARITY_MISMATCH",
-                `reduce: "${name}" must take exactly 2 arguments (accumulator, element), got ${fn.params.length}`
-              ));
-              break;
-            }
-            paramNames = fn.params;
-            program = fn.program;
-          }
-          const cells = collectionToValues(collectionVal, vm.getMaxCollectionSize());
-          if (!Array.isArray(cells)) {
-            stack.push(cells);
-            break;
-          }
-          chargeAllocation(cells.length, "collection elements");
-          let acc;
-          let startIdx;
-          if (initialVal !== void 0) {
-            const initialFault = faultedOperand(initialVal);
-            if (initialFault) {
-              stack.push(initialFault);
-              break;
-            }
-            acc = initialVal;
-            startIdx = 0;
-          } else {
-            if (cells.length === 0) {
-              stack.push(errorValue("REDUCE_EMPTY_COLLECTION", `reduce: cannot reduce an empty collection without an initial value.`));
-              break;
-            }
-            acc = cells[0];
-            startIdx = 1;
-          }
-          let reduceError;
-          for (let i = startIdx; i < cells.length; i++) {
-            const args = [acc, cells[i]];
-            const resultVal = kind === 1 ? builtinFunctions[ref]?.(args) ?? errorValue("UNKNOWN_BUILTIN_FUNCTION", `reduce: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
-            const stepFault = faultedOperand(resultVal);
-            if (stepFault) {
-              reduceError = stepFault;
-              break;
-            }
-            acc = resultVal;
-          }
-          if (reduceError) {
-            stack.push(reduceError);
-            break;
-          }
-          stack.push(acc);
-          break;
-        }
-        // ═══════════════════════════════════════════════════════════════
-        // §12 Algebra verbs' bound unknown  (OpCode 159)
-        // ═══════════════════════════════════════════════════════════════
-        case 159 /* BIND_UNKNOWN */: {
-          const ref = operandByte(opcodes, ip++, op, "body reference");
-          const def = anonymousBodies?.[ref];
-          if (!def) {
-            throw ErrorFactory.internal(
-              "INTERNAL_MISSING_ANONYMOUS_BODY",
-              `Internal error: BIND_UNKNOWN referenced missing anonymous body index ${ref}`,
-              { ref }
-            );
-          }
-          stack.push(invokeWithBoundUnknown(def.params[0], def.program, vm, pipeline, expression, context, !!symbolicTolerant));
-          break;
-        }
-      }
-    }
-    const fallback = safePop(stack);
-    return { type: "value", value: hasArena ? persistentValue(fallback) : fallback };
-  } catch (e) {
-    return { type: "error", error: normalizeUnknownError(e) };
-  } finally {
-    endEvaluation();
-  }
-}
-
-export { DependencyGraph, ScopeManager, createVM, executeBytecode };
-//# sourceMappingURL=chunk-FE4RC37D.js.map
-//# sourceMappingURL=chunk-FE4RC37D.js.map