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

package/dist/chunk-6NTVRDQV.cjs

@@ -0,0 +1,1642 @@
+'use strict';
+
+var chunk47LRVGOT_cjs = require('./chunk-47LRVGOT.cjs');
+var chunkJ73SJHR3_cjs = require('./chunk-J73SJHR3.cjs');
+var chunkXJCMXB2E_cjs = require('./chunk-XJCMXB2E.cjs');
+var chunkMZOVP3WI_cjs = require('./chunk-MZOVP3WI.cjs');
+var chunkHTXVVJRA_cjs = require('./chunk-HTXVVJRA.cjs');
+var chunkOC6LTXYS_cjs = require('./chunk-OC6LTXYS.cjs');
+var chunkQNJ4ACRT_cjs = require('./chunk-QNJ4ACRT.cjs');
+var chunkM4N5GA5Z_cjs = require('./chunk-M4N5GA5Z.cjs');
+
+// 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/VM.ts
+function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, context = chunkJ73SJHR3_cjs.defaultEngineContext) {
+  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;
+    },
+    pop() {
+      if (stack.length === 0) {
+        return chunkOC6LTXYS_cjs.numberValue(0);
+      }
+      return stack.pop();
+    },
+    popNumber() {
+      return stack.pop().toNumber();
+    },
+    popString() {
+      return stack.pop().value;
+    },
+    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);
+    },
+    pushCallFrame(frame) {
+      if (callFrames.length >= maxFunctionRecursionDepth) {
+        throw chunkM4N5GA5Z_cjs.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();
+    },
+    defineUserFunction(name, params, program) {
+      userFunctions.set(name, { name, params, program });
+    },
+    getUserFunction(name) {
+      return userFunctions.get(name);
+    },
+    hasUserFunction(name) {
+      return userFunctions.has(name);
+    },
+    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 chunkM4N5GA5Z_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
+      }
+    }
+  };
+}
+function safePop(stack) {
+  if (stack.length === 0) {
+    throw chunkM4N5GA5Z_cjs.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();
+}
+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 chunkM4N5GA5Z_cjs.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 extractDurationMs(value) {
+  if (value.type === 6 /* Uom */) {
+    const unit = value.unit;
+    if (unit && chunkQNJ4ACRT_cjs.getMeasure(unit) === "time") {
+      try {
+        return chunkQNJ4ACRT_cjs.convertUnit(value.toNumber(), unit, "ms");
+      } catch {
+      }
+    }
+    return 0;
+  }
+  return value.toNumber();
+}
+function addBusinessDays(epochMs, n) {
+  const date = new Date(epochMs);
+  let remaining = Math.trunc(Math.abs(n));
+  const direction = n >= 0 ? 1 : -1;
+  while (remaining > 0) {
+    date.setDate(date.getDate() + direction);
+    const day = date.getDay();
+    if (day !== 0 && day !== 6) remaining--;
+  }
+  return date.getTime();
+}
+function combineTimecode(tc, r, sign) {
+  const fps = chunkOC6LTXYS_cjs.timecodeFps(tc.unit);
+  if (r.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isTimecodeUnit(r.unit)) {
+    const rFps = chunkOC6LTXYS_cjs.timecodeFps(r.unit);
+    if (rFps !== fps) {
+      return chunkOC6LTXYS_cjs.errorValue(
+        "TIMECODE_FPS_MISMATCH",
+        `Cannot combine timecodes at different frame rates (${fps} fps vs ${rFps} fps)`
+      );
+    }
+    return sign === 1 ? chunkOC6LTXYS_cjs.uomValue(tc.toNumber() + r.toNumber(), tc.unit) : chunkOC6LTXYS_cjs.uomValue(tc.toNumber() - r.toNumber(), "frames");
+  }
+  if (r.type === 6 /* Uom */ && r.unit === "frames") {
+    return chunkOC6LTXYS_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
+  }
+  if (r.type === 6 /* Uom */ && r.unit && chunkQNJ4ACRT_cjs.getMeasure(r.unit) === "time") {
+    const seconds = chunkQNJ4ACRT_cjs.convertUnit(r.toNumber(), r.unit, "s");
+    return chunkOC6LTXYS_cjs.uomValue(tc.toNumber() + sign * seconds * fps, tc.unit);
+  }
+  return chunkOC6LTXYS_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
+}
+function isTruthy(value) {
+  if (value.type === 10 /* Boolean */) return value.value;
+  return value.toNumber() !== 0;
+}
+function multiplyRateByMatchingUom(rate, multiplier) {
+  const { numerator, denominator } = chunkOC6LTXYS_cjs.splitRateUnit(rate.unit);
+  const rateMeasure = chunkQNJ4ACRT_cjs.getMeasure(denominator);
+  const multiplierMeasure = chunkQNJ4ACRT_cjs.getMeasure(multiplier.unit);
+  if (!rateMeasure || rateMeasure !== multiplierMeasure) {
+    return chunkOC6LTXYS_cjs.errorValue(
+      "RATE_MUL_MEASURE_MISMATCH",
+      `Cannot multiply a "${denominator}"-denominated rate by "${multiplier.unit}" \u2014 different measures`
+    );
+  }
+  const multiplierInDenominatorUnit = chunkQNJ4ACRT_cjs.convertUnit(multiplier.toNumber(), multiplier.unit, denominator);
+  const total = rate.toNumber() * multiplierInDenominatorUnit;
+  return numerator ? chunkOC6LTXYS_cjs.uomValue(total, numerator) : chunkOC6LTXYS_cjs.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 toMultiplierString(n) {
+  const multiplier = Math.round((1 + n) * 1e6) / 1e6;
+  return `${multiplier}x`;
+}
+function toScientificString(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 { 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 = chunkOC6LTXYS_cjs.isArenaActive();
+  if (opcodes.length === 0) return { type: "value", value: chunkOC6LTXYS_cjs.numberValue(0) };
+  try {
+    while (ip < opcodes.length) {
+      if (++localInstructionCount > maxInstructions) {
+        throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
+      }
+      if (stack.length > maxStackDepth) {
+        throw chunkM4N5GA5Z_cjs.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: chunk47LRVGOT_cjs.DiagnosticEventType.VmStep,
+          elapsedNs: 0,
+          expression: expression ?? "",
+          opcode: op,
+          opcodeName: chunkMZOVP3WI_cjs.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 ? chunkOC6LTXYS_cjs.persistentValue(result) : result };
+        }
+        case 3 /* DUP */:
+          stack.push(stack[stack.length - 1]);
+          break;
+        case 2 /* SWAP */: {
+          const a = safePop(stack), b = safePop(stack);
+          stack.push(a);
+          stack.push(b);
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §2  Push literals  (OpCode 10–15)
+        // ═══════════════════════════════════════════════════════════════
+        case 10 /* PUSH_NUMBER */:
+          stack.push(chunkOC6LTXYS_cjs.numberValue(numbers[opcodes[ip++]]));
+          break;
+        case 11 /* PUSH_BIGINT */:
+          stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(strings[opcodes[ip++]])));
+          break;
+        case 12 /* PUSH_HEX */:
+          stack.push(chunkOC6LTXYS_cjs.hexValue(numbers[opcodes[ip++]]));
+          break;
+        case 13 /* PUSH_STRING */:
+          stack.push(chunkOC6LTXYS_cjs.stringValue(strings[opcodes[ip++]]));
+          break;
+        case 14 /* PUSH_BOOLEAN */:
+          stack.push(chunkOC6LTXYS_cjs.boolValue(opcodes[ip++] === 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);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.value + r.value));
+          } else if (l.type === 10 /* Boolean */ && r.type === 10 /* Boolean */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value && r.value));
+          } else if (l.type === 4 /* Datetime */) {
+            if (r.type === 4 /* Datetime */) {
+              stack.push(chunkOC6LTXYS_cjs.errorValue("INVALID_DATETIME_OP", "Cannot add two datetimes together"));
+            } else if (r.type === 6 /* Uom */ && chunkQNJ4ACRT_cjs.isWorkdayUnit(r.unit)) {
+              stack.push(chunkOC6LTXYS_cjs.datetimeValue(addBusinessDays(l.toNumber(), r.toNumber())));
+            } else {
+              stack.push(chunkOC6LTXYS_cjs.datetimeValue(l.toNumber() + extractDurationMs(r)));
+            }
+          } else if (l.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isTimecodeUnit(l.unit)) {
+            stack.push(combineTimecode(l, r, 1));
+          } else {
+            stack.push(chunkJ73SJHR3_cjs.binaryOp(l, r, (a, b) => a + b, (a, b) => a + b, "add"));
+          }
+          break;
+        }
+        case 21 /* SUB */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.value - r.value));
+          } else if (l.type === 4 /* Datetime */) {
+            if (r.type === 4 /* Datetime */) {
+              stack.push(chunkOC6LTXYS_cjs.uomValue(l.toNumber() - r.toNumber(), "ms"));
+            } else if (r.type === 6 /* Uom */ && chunkQNJ4ACRT_cjs.isWorkdayUnit(r.unit)) {
+              stack.push(chunkOC6LTXYS_cjs.datetimeValue(addBusinessDays(l.toNumber(), -r.toNumber())));
+            } else {
+              stack.push(chunkOC6LTXYS_cjs.datetimeValue(l.toNumber() - extractDurationMs(r)));
+            }
+          } else if (l.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isTimecodeUnit(l.unit)) {
+            stack.push(combineTimecode(l, r, -1));
+          } else {
+            stack.push(chunkJ73SJHR3_cjs.binaryOp(l, r, (a, b) => a - b, (a, b) => a - b, "sub"));
+          }
+          break;
+        }
+        case 22 /* MUL */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.value * r.value));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixMultiply(l.value, r.value));
+          } else if (l.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isRateUnit(l.unit) && r.type === 6 /* Uom */ && r.unit) {
+            stack.push(multiplyRateByMatchingUom(l, r));
+          } else if (r.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isRateUnit(r.unit) && l.type === 6 /* Uom */ && l.unit) {
+            stack.push(multiplyRateByMatchingUom(r, l));
+          } else {
+            stack.push(chunkJ73SJHR3_cjs.binaryOp(l, r, (a, b) => a * b, (a, b) => a * b, "mul"));
+          }
+          break;
+        }
+        case 23 /* DIV */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, sameMeasure } = chunkJ73SJHR3_cjs.unifyUom(l, r);
+            if (sameMeasure) {
+              stack.push(chunkOC6LTXYS_cjs.numberValue(lv / rv));
+            } else if (chunkXJCMXB2E_cjs.sharedCurrencyExchange.isCurrency(l.unit) && chunkXJCMXB2E_cjs.sharedCurrencyExchange.isCurrency(r.unit)) {
+              stack.push(chunkOC6LTXYS_cjs.errorValue("INCOMPATIBLE_UNITS", `Cannot combine incompatible units: ${l.unit} and ${r.unit}`));
+            } else {
+              stack.push(chunkOC6LTXYS_cjs.rateValue(lv / rv, l.unit, r.unit));
+            }
+          } else {
+            stack.push(chunkJ73SJHR3_cjs.binaryOp(l, r, (a, b) => a / b, (a, b) => a / b, "div"));
+          }
+          break;
+        }
+        case 24 /* MOD */: {
+          const r = safePop(stack), l = safePop(stack);
+          stack.push(chunkJ73SJHR3_cjs.binaryOp(l, r, (a, b) => a % b, (a, b) => 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(chunkOC6LTXYS_cjs.numberValue(Math.pow(l.value, r.value)));
+            break;
+          }
+          if (l.type === 9 /* Symbolic */ || r.type === 9 /* Symbolic */) {
+            stack.push(chunkJ73SJHR3_cjs.symbolicPow(l, r));
+            break;
+          }
+          stack.push(chunkOC6LTXYS_cjs.numberValue(Math.pow(l.toNumber(), r.toNumber())));
+          break;
+        }
+        case 26 /* NEG */: {
+          const v = safePop(stack);
+          if (v.type === 2 /* BigInt */) stack.push(chunkOC6LTXYS_cjs.bigIntValue(-v.value));
+          else if (v.type === 6 /* Uom */) stack.push(chunkOC6LTXYS_cjs.uomValue(-v.toNumber(), v.unit));
+          else if (v.type === 9 /* Symbolic */) stack.push(chunkJ73SJHR3_cjs.symbolicNeg(v));
+          else stack.push(chunkOC6LTXYS_cjs.numberValue(-v.toNumber()));
+          break;
+        }
+        case 27 /* POS */: {
+          const v = safePop(stack);
+          if (v.type === 6 /* Uom */) stack.push(chunkOC6LTXYS_cjs.uomValue(v.toNumber(), v.unit));
+          else stack.push(chunkOC6LTXYS_cjs.numberValue(v.toNumber()));
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §4  Bitwise  (OpCode 30–36)
+        // ═══════════════════════════════════════════════════════════════
+        case 30 /* LSHIFT */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) << BigInt(r.toNumber())));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() << r.toNumber()));
+          }
+          break;
+        }
+        case 31 /* RSHIFT */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) >> BigInt(r.toNumber())));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() >> r.toNumber()));
+          }
+          break;
+        }
+        case 32 /* URSHIFT */: {
+          const r = safePop(stack), l = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() >>> r.toNumber()));
+          break;
+        }
+        case 33 /* BIT_AND */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) & BigInt(r.toNumber())));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() & r.toNumber()));
+          }
+          break;
+        }
+        case 34 /* BIT_OR */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) | BigInt(r.toNumber())));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() | r.toNumber()));
+          }
+          break;
+        }
+        case 35 /* BIT_XOR */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) ^ BigInt(r.toNumber())));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() ^ r.toNumber()));
+          }
+          break;
+        }
+        case 36 /* BIT_NOT */: {
+          const v = safePop(stack);
+          if (v.type === 2 /* BigInt */) stack.push(chunkOC6LTXYS_cjs.bigIntValue(~v.value));
+          else stack.push(chunkOC6LTXYS_cjs.numberValue(~v.toNumber()));
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §4b Comparison  (OpCode 40–45)
+        //     Numeric fast path when both operands are Number;
+        //     EQ/NEQ support UoM unification for same-measure comparison.
+        // ═══════════════════════════════════════════════════════════════
+        case 40 /* EQ */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value === r.value));
+          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, sameMeasure } = chunkJ73SJHR3_cjs.unifyUom(l, r);
+            stack.push(chunkOC6LTXYS_cjs.boolValue(sameMeasure && lv === rv));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixCompare(l.value, r.value, (a, b) => a === b));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() === r.toNumber()));
+          }
+          break;
+        }
+        case 41 /* NEQ */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value !== r.value));
+          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, sameMeasure } = chunkJ73SJHR3_cjs.unifyUom(l, r);
+            stack.push(chunkOC6LTXYS_cjs.boolValue(!sameMeasure || lv !== rv));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixCompare(l.value, r.value, (a, b) => a !== b));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() !== r.toNumber()));
+          }
+          break;
+        }
+        case 42 /* LT */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value < r.value));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixCompare(l.value, r.value, (a, b) => a < b));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() < r.toNumber()));
+          }
+          break;
+        }
+        case 43 /* LTE */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value <= r.value));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixCompare(l.value, r.value, (a, b) => a <= b));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() <= r.toNumber()));
+          }
+          break;
+        }
+        case 44 /* GT */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value > r.value));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixCompare(l.value, r.value, (a, b) => a > b));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() > r.toNumber()));
+          }
+          break;
+        }
+        case 45 /* GTE */: {
+          const r = safePop(stack), l = safePop(stack);
+          if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value >= r.value));
+          } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
+            stack.push(chunkHTXVVJRA_cjs.matrixCompare(l.value, r.value, (a, b) => a >= b));
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() >= r.toNumber()));
+          }
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §4c Logical / conditional select  (OpCode 130–132)
+        // ═══════════════════════════════════════════════════════════════
+        case 130 /* LOGICAL_AND */: {
+          const r = safePop(stack), l = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.boolValue(isTruthy(l) && isTruthy(r)));
+          break;
+        }
+        case 131 /* LOGICAL_OR */: {
+          const r = safePop(stack), l = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.boolValue(isTruthy(l) || isTruthy(r)));
+          break;
+        }
+        case 132 /* SELECT */: {
+          const elseVal = safePop(stack);
+          const thenVal = safePop(stack);
+          const condition = safePop(stack);
+          stack.push(isTruthy(condition) ? thenVal : elseVal);
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §5  Functions  (OpCode 50–52)
+        // ═══════════════════════════════════════════════════════════════
+        case 50 /* CALL_PLUGIN */: {
+          const fnIdx = opcodes[ip++];
+          const argCount = opcodes[ip++];
+          const args = [];
+          for (let i = 0; i < argCount; i++) args.push(safePop(stack));
+          args.reverse();
+          const fn = vm.context.pluginFunctions[fnIdx];
+          if (!fn) {
+            stack.push(chunkOC6LTXYS_cjs.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 = opcodes[ip++];
+          const argCount = opcodes[ip++];
+          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 fn = chunkJ73SJHR3_cjs.builtinFunctions[fnIdx];
+          if (fn) {
+            const ordered = args.reverse();
+            const routeSymbolically = sawSymbolic && !chunkJ73SJHR3_cjs.SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);
+            stack.push(routeSymbolically ? chunkJ73SJHR3_cjs.symbolicBuiltin(fnIdx, ordered) : fn(ordered));
+          }
+          break;
+        }
+        case 150 /* DEFINE_USER_FUNCTION */: {
+          const bodyIdx = opcodes[ip++];
+          const def = userFunctionBodies?.[bodyIdx];
+          if (!def) {
+            throw chunkM4N5GA5Z_cjs.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 nameIdx = opcodes[ip++];
+          const argCount = opcodes[ip++];
+          const name = strings[nameIdx];
+          const args = [];
+          for (let i = 0; i < argCount; i++) args.push(safePop(stack));
+          args.reverse();
+          const fn = vm.getUserFunction(name);
+          if (!fn) {
+            throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("UNDEFINED_FUNCTION", `Undefined function: ${name}`, { name });
+          }
+          if (argCount !== fn.params.length) {
+            throw chunkM4N5GA5Z_cjs.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]);
+          vm.pushCallFrame(frame);
+          let bodyResult;
+          try {
+            bodyResult = executeBytecode(fn.program, vm, pipeline, expression, context);
+          } finally {
+            vm.popCallFrame();
+          }
+          if (bodyResult.type === "pending") {
+            throw chunkM4N5GA5Z_cjs.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 = strings[opcodes[ip++]];
+          const val = vm.getVar(varName);
+          if (val !== void 0) {
+            stack.push(val);
+          } else if (symbolicTolerant) {
+            stack.push(chunkOC6LTXYS_cjs.symbolicValue(chunkHTXVVJRA_cjs.varNode(varName)));
+          } else {
+            throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+              "UNDEFINED_VARIABLE",
+              `Undefined variable: ${varName}`,
+              { varName }
+            );
+          }
+          break;
+        }
+        case 61 /* STORE_VAR */: {
+          const val = safePop(stack);
+          const varName = strings[opcodes[ip++]];
+          vm.setVar(varName, hasArena ? chunkOC6LTXYS_cjs.persistentValue(val) : val);
+          stack.push(val);
+          break;
+        }
+        case 62 /* LOAD_GLOBAL_VAR */: {
+          const varName = strings[opcodes[ip++]];
+          const globalValue = chunkJ73SJHR3_cjs.sharedGlobalVariableStore.get(varName);
+          if (globalValue === void 0) {
+            throw chunkM4N5GA5Z_cjs.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 = strings[opcodes[ip++]];
+          chunkJ73SJHR3_cjs.sharedGlobalVariableStore.set(varName, hasArena ? chunkOC6LTXYS_cjs.persistentValue(val) : val);
+          stack.push(val);
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §7  Type conversions  (OpCode 70–74, 140–145)
+        // ═══════════════════════════════════════════════════════════════
+        case 70 /* TO_NUMBER */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.numberValue(v.toNumber()));
+          break;
+        }
+        case 71 /* TO_HEX */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.hexValue(v.toNumber()));
+          break;
+        }
+        case 74 /* TO_PERCENTAGE */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.percentageValue(v.toNumber()));
+          break;
+        }
+        case 140 /* TO_FRACTION */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.stringValue(toFractionString(v.toNumber())));
+          break;
+        }
+        case 141 /* TO_MULTIPLIER */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.stringValue(toMultiplierString(v.toNumber())));
+          break;
+        }
+        case 142 /* TO_SCI */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.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);
+          stack.push(chunkOC6LTXYS_cjs.hexValue(v.toNumber(), "bin"));
+          break;
+        }
+        case 144 /* TO_OCTAL */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.hexValue(v.toNumber(), "oct"));
+          break;
+        }
+        case 145 /* CALL_AS_CONVERTER */: {
+          const name = safePop(stack).value.toLowerCase();
+          const value = safePop(stack);
+          const converter = chunkJ73SJHR3_cjs.asConverterRegistry.get(name);
+          if (!converter) {
+            stack.push(chunkOC6LTXYS_cjs.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 = safePop(stack).value;
+          const val = safePop(stack).toNumber();
+          stack.push(chunkOC6LTXYS_cjs.uomValue(val, unit));
+          break;
+        }
+        case 81 /* UOM_CONVERT_TO */: {
+          const toUnit = safePop(stack).value;
+          const fromUnit = safePop(stack).value;
+          const val = safePop(stack).toNumber();
+          const measure = chunkQNJ4ACRT_cjs.getMeasure(fromUnit);
+          const isCurrency = chunkXJCMXB2E_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunkXJCMXB2E_cjs.sharedCurrencyExchange.isCurrency(toUnit);
+          if (measure && chunkQNJ4ACRT_cjs.getMeasure(toUnit) === measure) {
+            stack.push(chunkOC6LTXYS_cjs.uomValue(chunkQNJ4ACRT_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
+          } else if (isCurrency) {
+            const converted = chunkXJCMXB2E_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
+            if (converted !== null) {
+              stack.push(chunkOC6LTXYS_cjs.uomValue(converted, toUnit));
+            } else {
+              stack.push(chunkOC6LTXYS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
+            }
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.uomValue(val, fromUnit));
+          }
+          break;
+        }
+        case 85 /* UOM_POSSIBILITIES */: {
+          const unit = safePop(stack).value;
+          const possibilities = chunkQNJ4ACRT_cjs.getConvertiblePossibilities(unit);
+          stack.push(chunkOC6LTXYS_cjs.stringValue(possibilities.length > 0 ? possibilities.join(", ") : `No known units for "${unit}"`));
+          break;
+        }
+        case 83 /* UOM_BEST */: {
+          const unit = safePop(stack).value;
+          const val = safePop(stack).toNumber();
+          const { value, unit: bestUnit } = chunkQNJ4ACRT_cjs.getBestUnit(val, unit);
+          stack.push(chunkOC6LTXYS_cjs.uomValue(value, bestUnit));
+          break;
+        }
+        case 84 /* UOM_CONVERT_IN */: {
+          const toUnit = safePop(stack).value;
+          const left = safePop(stack);
+          if (left.type === 6 /* Uom */) {
+            const fromUnit = left.unit;
+            const val = left.toNumber();
+            const measure = chunkQNJ4ACRT_cjs.getMeasure(fromUnit);
+            const isCurrency = chunkXJCMXB2E_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunkXJCMXB2E_cjs.sharedCurrencyExchange.isCurrency(toUnit);
+            if (measure && chunkQNJ4ACRT_cjs.getMeasure(toUnit) === measure) {
+              stack.push(chunkOC6LTXYS_cjs.uomValue(chunkQNJ4ACRT_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
+            } else if (isCurrency) {
+              const converted = chunkXJCMXB2E_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
+              if (converted !== null) {
+                stack.push(chunkOC6LTXYS_cjs.uomValue(converted, toUnit));
+              } else {
+                stack.push(chunkOC6LTXYS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
+              }
+            } else {
+              stack.push(left);
+            }
+          } else {
+            stack.push(chunkOC6LTXYS_cjs.uomValue(left.toNumber(), toUnit));
+          }
+          break;
+        }
+        case 82 /* UOM_GET_VALUE */: {
+          const v = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.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);
+          if (denominatorVal.type !== 6 /* Uom */ || !denominatorVal.unit) {
+            stack.push(chunkOC6LTXYS_cjs.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(chunkOC6LTXYS_cjs.rateValue(numeratorVal.toNumber() / denominatorVal.toNumber(), numeratorUnit, denominatorVal.unit));
+          break;
+        }
+        case 111 /* RATE_MUL */: {
+          const multiplier = safePop(stack);
+          const rate = safePop(stack);
+          if (rate.type !== 6 /* Uom */ || !chunkOC6LTXYS_cjs.isRateUnit(rate.unit)) {
+            stack.push(chunkOC6LTXYS_cjs.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(chunkOC6LTXYS_cjs.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 = safePop(stack).value;
+          const rate = safePop(stack);
+          if (rate.type !== 6 /* Uom */ || !chunkOC6LTXYS_cjs.isRateUnit(rate.unit)) {
+            stack.push(chunkOC6LTXYS_cjs.errorValue("RATE_CONVERT_NOT_A_RATE", "Cannot convert a non-rate value's denominator"));
+            break;
+          }
+          const { numerator, denominator } = chunkOC6LTXYS_cjs.splitRateUnit(rate.unit);
+          const rateMeasure = chunkQNJ4ACRT_cjs.getMeasure(denominator);
+          const targetMeasure = chunkQNJ4ACRT_cjs.getMeasure(newDenominatorUnit);
+          if (!rateMeasure || rateMeasure !== targetMeasure) {
+            stack.push(chunkOC6LTXYS_cjs.errorValue(
+              "RATE_CONVERT_MEASURE_MISMATCH",
+              `Cannot convert a "${denominator}"-denominated rate to "${newDenominatorUnit}" \u2014 different measures`
+            ));
+            break;
+          }
+          const factor = chunkQNJ4ACRT_cjs.convertUnit(1, newDenominatorUnit, denominator);
+          stack.push(chunkOC6LTXYS_cjs.rateValue(rate.toNumber() * factor, numerator, newDenominatorUnit));
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §8.7  Time, clock-time-of-day (OpCode 120)
+        // ═══════════════════════════════════════════════════════════════
+        case 120 /* CLOCK_TIME_TODAY */: {
+          const totalMinutes = safePop(stack).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(chunkOC6LTXYS_cjs.datetimeValue(anchored.getTime()));
+          break;
+        }
+        // ═══════════════════════════════════════════════════════════════
+        // §9  Datetime  (OpCode 90–93)
+        // ═══════════════════════════════════════════════════════════════
+        case 90 /* DATE_NOW */:
+          stack.push(chunkOC6LTXYS_cjs.datetimeValue(Date.now()));
+          break;
+        case 95 /* DATE_LITERAL */:
+          stack.push(chunkOC6LTXYS_cjs.datetimeValue(numbers[opcodes[ip++]]));
+          break;
+        case 91 /* DATE_ADD */: {
+          const durValue = safePop(stack), dtValue = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.datetimeValue(dtValue.toNumber() + extractDurationMs(durValue)));
+          break;
+        }
+        case 92 /* DATE_SUB */: {
+          const durValue = safePop(stack), dtValue = safePop(stack);
+          stack.push(chunkOC6LTXYS_cjs.datetimeValue(dtValue.toNumber() - extractDurationMs(durValue)));
+          break;
+        }
+        case 93 /* DATE_NEXT_WEEKDAY */:
+        case 94 /* DATE_LAST_WEEKDAY */: {
+          const targetDay = safePop(stack).toNumber();
+          const nowValue = safePop(stack);
+          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;
+          const offsetMs = diffDays * 24 * 60 * 60 * 1e3;
+          stack.push(chunkOC6LTXYS_cjs.datetimeValue(op === 93 /* DATE_NEXT_WEEKDAY */ ? now + offsetMs : now - offsetMs));
+          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 = opcodes[ip++];
+          const cols = opcodes[ip++];
+          const count = rows * cols;
+          const rowMajor = new Array(count);
+          for (let i = count - 1; i >= 0; i--) {
+            const cellVal = safePop(stack);
+            rowMajor[i] = cellVal.type === 10 /* Boolean */ ? cellVal.value : cellVal.type === 9 /* Symbolic */ ? cellVal.value : cellVal.toNumber();
+          }
+          stack.push(chunkOC6LTXYS_cjs.matrixValue(rows, cols, chunkHTXVVJRA_cjs.rowMajorToColumnMajor(rows, cols, rowMajor)));
+          break;
+        }
+        case 153 /* MAT_INDEX1 */: {
+          const indexVal = safePop(stack), matrixVal = safePop(stack);
+          if (matrixVal.type === 13 /* Error */) {
+            stack.push(matrixVal);
+            break;
+          }
+          if (indexVal.type === 13 /* Error */) {
+            stack.push(indexVal);
+            break;
+          }
+          if (matrixVal.type !== 7 /* Matrix */) {
+            stack.push(chunkOC6LTXYS_cjs.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(chunkOC6LTXYS_cjs.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 = chunkHTXVVJRA_cjs.matIndex(m, index);
+          stack.push(chunkHTXVVJRA_cjs.matrixEntryToValue(cell));
+          break;
+        }
+        case 154 /* MAT_INDEX2 */: {
+          const colVal = safePop(stack), rowVal = safePop(stack), matrixVal = safePop(stack);
+          if (matrixVal.type === 13 /* Error */) {
+            stack.push(matrixVal);
+            break;
+          }
+          if (rowVal.type === 13 /* Error */) {
+            stack.push(rowVal);
+            break;
+          }
+          if (colVal.type === 13 /* Error */) {
+            stack.push(colVal);
+            break;
+          }
+          if (matrixVal.type !== 7 /* Matrix */) {
+            stack.push(chunkOC6LTXYS_cjs.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 (!chunkHTXVVJRA_cjs.inBounds(m, row, col)) {
+            stack.push(chunkOC6LTXYS_cjs.errorValue(
+              "MATRIX_INDEX_OUT_OF_BOUNDS",
+              `[${row}, ${col}] is out of bounds for a ${m.rows}x${m.cols} matrix.`
+            ));
+            break;
+          }
+          const cell = chunkHTXVVJRA_cjs.matAt(m, row, col);
+          stack.push(chunkHTXVVJRA_cjs.matrixEntryToValue(cell));
+          break;
+        }
+        case 156 /* RANGE_NEW */: {
+          const maxVal = safePop(stack), minVal = safePop(stack);
+          if (minVal.type === 13 /* Error */) {
+            stack.push(minVal);
+            break;
+          }
+          if (maxVal.type === 13 /* Error */) {
+            stack.push(maxVal);
+            break;
+          }
+          if (minVal.type !== 0 /* Number */ || maxVal.type !== 0 /* Number */) {
+            stack.push(chunkOC6LTXYS_cjs.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(chunkOC6LTXYS_cjs.errorValue("NON_INTEGER_RANGE_BOUND", `A range's bounds must be whole numbers, got "${min}:${max}".`));
+            break;
+          }
+          if (min > max) {
+            stack.push(chunkOC6LTXYS_cjs.errorValue(
+              "DESCENDING_RANGE",
+              `A range's min (${min}) cannot be greater than its max (${max}) \u2014 did you mean "${max}:${min}"?`
+            ));
+            break;
+          }
+          stack.push(chunkOC6LTXYS_cjs.rangeValue(min, max));
+          break;
+        }
+        case 155 /* MAT_SLICE */: {
+          const colRangeVal = safePop(stack), rowRangeVal = safePop(stack), matrixVal = safePop(stack);
+          if (matrixVal.type === 13 /* Error */) {
+            stack.push(matrixVal);
+            break;
+          }
+          if (rowRangeVal.type === 13 /* Error */) {
+            stack.push(rowRangeVal);
+            break;
+          }
+          if (colRangeVal.type === 13 /* Error */) {
+            stack.push(colRangeVal);
+            break;
+          }
+          if (matrixVal.type !== 7 /* Matrix */) {
+            stack.push(chunkOC6LTXYS_cjs.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(chunkOC6LTXYS_cjs.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(chunkOC6LTXYS_cjs.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 = new Array(newRows * newCols);
+          for (let r = 0; r < newRows; r++) {
+            for (let c = 0; c < newCols; c++) {
+              data[r + c * newRows] = chunkHTXVVJRA_cjs.matAt(m, rowRange.min + r, colRange.min + c);
+            }
+          }
+          stack.push(chunkOC6LTXYS_cjs.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 = opcodes[ip++];
+          const ref = opcodes[ip++];
+          const collectionCount = opcodes[ip++];
+          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 chunkM4N5GA5Z_cjs.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 = strings[ref];
+            const fn = vm.getUserFunction(name);
+            if (!fn) {
+              stack.push(chunkOC6LTXYS_cjs.errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
+              break;
+            }
+            if (fn.params.length !== collectionCount) {
+              stack.push(chunkOC6LTXYS_cjs.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 = chunkHTXVVJRA_cjs.collectionToValues(rawCollections[i]);
+            if (!Array.isArray(resolved)) {
+              mapEarlyError = resolved;
+              break;
+            }
+            if (collectionLength === -1) {
+              collectionLength = resolved.length;
+            } else if (resolved.length !== collectionLength) {
+              mapEarlyError = chunkOC6LTXYS_cjs.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 = new Array(collectionLength);
+          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 ? chunkJ73SJHR3_cjs.builtinFunctions[ref]?.(args) ?? chunkOC6LTXYS_cjs.errorValue("UNKNOWN_BUILTIN_FUNCTION", `map: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
+            if (resultVal.type === 13 /* Error */) {
+              mapError = resultVal;
+              break;
+            }
+            resultData[i] = resultVal.type === 10 /* Boolean */ ? resultVal.value : resultVal.type === 9 /* Symbolic */ ? resultVal.value : resultVal.toNumber();
+          }
+          if (mapError) {
+            stack.push(mapError);
+            break;
+          }
+          stack.push(chunkOC6LTXYS_cjs.matrixValue(1, collectionLength, resultData));
+          break;
+        }
+        case 158 /* REDUCE_INVOKE */: {
+          const kind = opcodes[ip++];
+          const ref = opcodes[ip++];
+          const hasInitial = opcodes[ip++];
+          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 chunkM4N5GA5Z_cjs.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 = strings[ref];
+            const fn = vm.getUserFunction(name);
+            if (!fn) {
+              stack.push(chunkOC6LTXYS_cjs.errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
+              break;
+            }
+            if (fn.params.length !== 2) {
+              stack.push(chunkOC6LTXYS_cjs.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 = chunkHTXVVJRA_cjs.collectionToValues(collectionVal);
+          if (!Array.isArray(cells)) {
+            stack.push(cells);
+            break;
+          }
+          let acc;
+          let startIdx;
+          if (initialVal !== void 0) {
+            if (initialVal.type === 13 /* Error */) {
+              stack.push(initialVal);
+              break;
+            }
+            acc = initialVal;
+            startIdx = 0;
+          } else {
+            if (cells.length === 0) {
+              stack.push(chunkOC6LTXYS_cjs.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 ? chunkJ73SJHR3_cjs.builtinFunctions[ref]?.(args) ?? chunkOC6LTXYS_cjs.errorValue("UNKNOWN_BUILTIN_FUNCTION", `reduce: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
+            if (resultVal.type === 13 /* Error */) {
+              reduceError = resultVal;
+              break;
+            }
+            acc = resultVal;
+          }
+          if (reduceError) {
+            stack.push(reduceError);
+            break;
+          }
+          stack.push(acc);
+          break;
+        }
+      }
+    }
+    const fallback = safePop(stack);
+    return { type: "value", value: hasArena ? chunkOC6LTXYS_cjs.persistentValue(fallback) : fallback };
+  } catch (e) {
+    return { type: "error", error: chunkM4N5GA5Z_cjs.normalizeUnknownError(e) };
+  }
+}
+
+exports.DependencyGraph = DependencyGraph;
+exports.ScopeManager = ScopeManager;
+exports.createVM = createVM;
+exports.executeBytecode = executeBytecode;
+//# sourceMappingURL=chunk-6NTVRDQV.cjs.map
+//# sourceMappingURL=chunk-6NTVRDQV.cjs.map