solve-engine 1.0.0-beta.7 → 1.0.0

package/dist/{chunk-BAMZT3GL.js → chunk-5WVP4YHP.js}

@@ -1,12 +1,12 @@
 import { DiagnosticEventType } from './chunk-G535KJEG.js';
-import { defaultEngineContext, builtinFunctions, asConverterRegistry, sharedGlobalVariableStore, SYMBOLIC_NATIVE_BUILTINS, symbolicBuiltin, unifyUom, symbolicNeg, symbolicPow, binaryOp } from './chunk-MVBEL57Q.js';
-import { sharedCurrencyExchange } from './chunk-UKPGSAZW.js';
-import { getOpCodeName } from './chunk-75JP4BZX.js';
-import { collectionToValues, matAt, inBounds, matrixEntryToValue, matIndex, rowMajorToColumnMajor, varNode, matrixCompare, matrixMultiply, CURRENCY_DISPLAY } from './chunk-CYFK5SY2.js';
-import { numberValue, isArenaActive, errorValue, matrixValue, rangeValue, datetimeValue, isRateUnit, splitRateUnit, rateValue, uomValue, stringValue, hexValue, percentageValue, persistentValue, symbolicValue, boolValue, bigIntValue, isTimecodeUnit, timecodeFps } from './chunk-BVAR5J2F.js';
-import { getMeasure, convertUnit, getBestUnit, getConvertiblePossibilities, isWorkdayUnit } from './chunk-WC5FFSHB.js';
-import { UNIT_TABLE } from './chunk-PCPX42KL.js';
-import { ErrorFactory, normalizeUnknownError } from './chunk-6RDSQURE.js';
+import { defaultEngineContext, builtinFunctions, asConverterRegistry, sharedGlobalVariableStore, SYMBOLIC_NATIVE_BUILTINS, symbolicBuiltin, compareBigIntOperands, compareUom, incomparableUnitsError, toBigIntOperand, symbolicNeg, power, symbolicPow, binaryOp, bigIntDivisionByZero, unifyUom } from './chunk-Y7FT4IQT.js';
+import { sharedCurrencyExchange } from './chunk-TMA4RCEN.js';
+import { getOpCodeName } from './chunk-UQ3UIZJC.js';
+import { collectionToValues, matAt, inBounds, matrixEntryToValue, matIndex, rowMajorToColumnMajor, varNode, matrixCompare, matrixPower, matrixMultiply, CURRENCY_DISPLAY } from './chunk-O3ANBHSA.js';
+import { numberValue, ValueType, isArenaActive, beginEvaluation, errorValue, chargeAllocation, faultedOperand, checkedArray, matrixValue, rangeValue, datetimeValue, isRateUnit, splitRateUnit, rateValue, uomValue, stringValue, hexValue, percentageValue, persistentValue, symbolicValue, chargeFunctionCall, faultedIn, boolValue, bigIntValue, checkAllocation, isTimecodeUnit, endEvaluation, timecodeFps } from './chunk-GQCOSXMG.js';
+import { getMeasure, convertUnit, getBestUnit, getConvertiblePossibilities, isWorkdayUnit } from './chunk-R3PY4G7J.js';
+import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
+import { ErrorFactory, normalizeUnknownError } from './chunk-3D7V24DG.js';
 
 // src/vm/DependencyGraph.ts
 var DependencyGraph = class {
@@ -330,8 +330,139 @@ var ScopeManager = class {
   }
 };
 
+// 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: 1 },
+  // 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 }
+};
+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, context = defaultEngineContext) {
+function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, maxCollectionSize = 1e5, maxAllocatedElements = 2e6, maxFunctionCalls = 1e4, maxDateOffsetYears = 100, minDateOffsetYears = -100, context = defaultEngineContext) {
   const stack = [];
   const variables = /* @__PURE__ */ new Map();
   let instructionCount = 0;
@@ -350,17 +481,51 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     getMaxStackDepth() {
       return maxStackDepth;
     },
+    getMaxCollectionSize() {
+      return maxCollectionSize;
+    },
+    getMaxAllocatedElements() {
+      return maxAllocatedElements;
+    },
+    getMaxFunctionCalls() {
+      return maxFunctionCalls;
+    },
+    getMaxDateOffsetYears() {
+      return maxDateOffsetYears;
+    },
+    getMinDateOffsetYears() {
+      return minDateOffsetYears;
+    },
     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 stack.pop().toNumber();
+      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 stack.pop().value;
+      return stringOperand(safePop(stack), "VM.popString()");
     },
     peek() {
       return stack[stack.length - 1];
@@ -392,6 +557,9 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     popCallFrame() {
       callFrames.pop();
     },
+    getCallFrame() {
+      return callFrames.length > 0 ? callFrames[callFrames.length - 1] : void 0;
+    },
     defineUserFunction(name, params, program) {
       userFunctions.set(name, { name, params, program });
     },
@@ -460,6 +628,17 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     }
   };
 }
+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({
@@ -472,6 +651,124 @@ function safePop(stack) {
   }
   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]);
@@ -493,6 +790,27 @@ function invokeFrameBody(params, program, args, vm, pipeline, expression, contex
   }
   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;
@@ -521,6 +839,9 @@ function moneyTimesQuantity(l, r) {
 }
 function combinePercentage(l, r, sign) {
   if (l.type === 5 /* Percentage */) {
+    if (r.type === 6 /* Uom */ && r.unit !== void 0) {
+      return uomValue(r.toNumber() * (1 + sign * l.toNumber()), r.unit);
+    }
     if (r.type !== 5 /* Percentage */ && r.type !== 0 /* Number */) return null;
     return percentageValue(l.toNumber() + sign * r.toNumber());
   }
@@ -543,10 +864,20 @@ function extractDurationMs(value) {
   }
   return value.toNumber();
 }
-function addBusinessDays(epochMs, n) {
-  const date = new Date(epochMs);
+var WORKDAYS_PER_YEAR = 260;
+function addBusinessDays(epochMs, n, vm) {
   let 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 date = new Date(epochMs);
   while (remaining > 0) {
     date.setDate(date.getDate() + direction);
     const day = date.getDay();
@@ -554,6 +885,67 @@ function addBusinessDays(epochMs, n) {
   }
   return date.getTime();
 }
+var MS_PER_DAY = 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_DAY;
+  return shifted + (days - whole) * MS_PER_DAY;
+}
+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 addBusinessDays(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)) {
@@ -579,6 +971,54 @@ function isTruthy(value) {
   if (value.type === 10 /* Boolean */) return value.value;
   return value.toNumber() !== 0;
 }
+function incompatibleConversionError(fromUnit, toUnit) {
+  return errorValue(
+    "INCOMPATIBLE_UNITS",
+    `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);
@@ -626,12 +1066,26 @@ function toMultiplierString(value) {
   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;
@@ -641,6 +1095,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
   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) {
@@ -678,9 +1133,12 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const result = safePop(stack);
           return { type: "value", value: hasArena ? persistentValue(result) : result };
         }
-        case 3 /* DUP */:
-          stack.push(stack[stack.length - 1]);
+        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);
@@ -690,20 +1148,25 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         // §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[opcodes[ip++]]));
+          stack.push(numberValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
         case 11 /* PUSH_BIGINT */:
-          stack.push(bigIntValue(BigInt(strings[opcodes[ip++]])));
+          stack.push(bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"), op)));
           break;
         case 12 /* PUSH_HEX */:
-          stack.push(hexValue(numbers[opcodes[ip++]]));
+          stack.push(hexValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
         case 13 /* PUSH_STRING */:
-          stack.push(stringValue(strings[opcodes[ip++]]));
+          stack.push(stringValue(poolString(opcodes, ip++, strings, op, "constant-pool index")));
           break;
         case 14 /* PUSH_BOOLEAN */:
-          stack.push(boolValue(opcodes[ip++] === 1));
+          stack.push(boolValue(operandByte(opcodes, ip++, op, "boolean operand") === 1));
           break;
         // ═══════════════════════════════════════════════════════════════
         // §3  Arithmetic  (OpCode 20–27)
@@ -712,6 +1175,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 20 /* ADD */: {
           const r = safePop(stack), l = safePop(stack);
+          const addFault = faultedOperand(l, r);
+          if (addFault) {
+            stack.push(addFault);
+            break;
+          }
           const pctAdd = combinePercentage(l, r, 1);
           const ratePeriodAdd = pctAdd === null ? unifyRatePeriods(l, r) : null;
           if (pctAdd !== null) {
@@ -725,13 +1193,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           } else if (l.type === 4 /* Datetime */) {
             if (r.type === 4 /* Datetime */) {
               stack.push(errorValue("INVALID_DATETIME_OP", "Cannot add two datetimes together"));
-            } else if (r.type === 6 /* Uom */ && isWorkdayUnit(r.unit)) {
-              stack.push(datetimeValue(addBusinessDays(l.toNumber(), r.toNumber())));
             } else {
-              stack.push(datetimeValue(l.toNumber() + extractDurationMs(r)));
+              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"));
           }
@@ -739,6 +1207,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 21 /* SUB */: {
           const r = safePop(stack), l = safePop(stack);
+          const subFault = faultedOperand(l, r);
+          if (subFault) {
+            stack.push(subFault);
+            break;
+          }
           const pctSub = combinePercentage(l, r, -1);
           const ratePeriodSub = pctSub === null ? unifyRatePeriods(l, r) : null;
           if (pctSub !== null) {
@@ -750,13 +1223,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           } else if (l.type === 4 /* Datetime */) {
             if (r.type === 4 /* Datetime */) {
               stack.push(uomValue(l.toNumber() - r.toNumber(), "ms"));
-            } else if (r.type === 6 /* Uom */ && isWorkdayUnit(r.unit)) {
-              stack.push(datetimeValue(addBusinessDays(l.toNumber(), -r.toNumber())));
             } else {
-              stack.push(datetimeValue(l.toNumber() - extractDurationMs(r)));
+              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"));
           }
@@ -767,6 +1243,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           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));
@@ -791,13 +1268,19 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
               stack.push(rateValue(lv / rv, l.unit, r.unit));
             }
           } else {
-            stack.push(binaryOp(l, r, (a, b) => a / b, (a, b) => a / b, "div"));
+            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) => a % b));
+          stack.push(binaryOp(l, r, (a, b) => a % b, (a, b) => {
+            if (b === 0n) throw bigIntDivisionByZero();
+            return a % b;
+          }));
           break;
         }
         case 25 /* EXP */: {
@@ -819,37 +1302,85 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             break;
           }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(numberValue(Math.pow(l.value, r.value)));
+            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;
           }
-          stack.push(numberValue(Math.pow(l.toNumber(), r.toNumber())));
+          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 */) 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 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 */) stack.push(uomValue(v.toNumber(), v.unit));
+          else if (v.type === 5 /* Percentage */) stack.push(percentageValue(v.toNumber()));
           else stack.push(numberValue(v.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(bigIntValue(BigInt(l.toNumber()) << BigInt(r.toNumber())));
+            stack.push(bigIntShift(l, r, 1));
           } else {
             stack.push(numberValue(l.toNumber() << r.toNumber()));
           }
@@ -857,8 +1388,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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(bigIntValue(BigInt(l.toNumber()) >> BigInt(r.toNumber())));
+            stack.push(bigIntShift(l, r, -1));
           } else {
             stack.push(numberValue(l.toNumber() >> r.toNumber()));
           }
@@ -866,13 +1402,23 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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(BigInt(l.toNumber()) & BigInt(r.toNumber())));
+            stack.push(bigIntValue(toBigIntOperand(l) & toBigIntOperand(r)));
           } else {
             stack.push(numberValue(l.toNumber() & r.toNumber()));
           }
@@ -880,8 +1426,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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(BigInt(l.toNumber()) | BigInt(r.toNumber())));
+            stack.push(bigIntValue(toBigIntOperand(l) | toBigIntOperand(r)));
           } else {
             stack.push(numberValue(l.toNumber() | r.toNumber()));
           }
@@ -889,8 +1440,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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(BigInt(l.toNumber()) ^ BigInt(r.toNumber())));
+            stack.push(bigIntValue(toBigIntOperand(l) ^ toBigIntOperand(r)));
           } else {
             stack.push(numberValue(l.toNumber() ^ r.toNumber()));
           }
@@ -898,6 +1454,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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;
@@ -905,15 +1466,46 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         // §4b Comparison  (OpCode 40–45)
         //     Numeric fast path when both operands are Number;
-        //     EQ/NEQ support UoM unification for same-measure comparison.
+        //     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.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 { lv, rv, sameMeasure } = unifyUom(l, r);
-            stack.push(boolValue(sameMeasure && lv === rv));
+            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 {
@@ -923,11 +1515,21 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 41 /* NEQ */: {
           const r = safePop(stack), l = safePop(stack);
+          const neqFault = faultedOperand(l, r);
+          if (neqFault) {
+            stack.push(neqFault);
+            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 { lv, rv, sameMeasure } = unifyUom(l, r);
-            stack.push(boolValue(!sameMeasure || lv !== rv));
+            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 {
@@ -937,8 +1539,19 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 42 /* LT */: {
           const r = safePop(stack), l = safePop(stack);
+          const ltFault = faultedOperand(l, r);
+          if (ltFault) {
+            stack.push(ltFault);
+            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 {
@@ -948,8 +1561,19 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 43 /* LTE */: {
           const r = safePop(stack), l = safePop(stack);
+          const lteFault = faultedOperand(l, r);
+          if (lteFault) {
+            stack.push(lteFault);
+            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 {
@@ -959,8 +1583,19 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 44 /* GT */: {
           const r = safePop(stack), l = safePop(stack);
+          const gtFault = faultedOperand(l, r);
+          if (gtFault) {
+            stack.push(gtFault);
+            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 {
@@ -970,8 +1605,19 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 45 /* GTE */: {
           const r = safePop(stack), l = safePop(stack);
+          const gteFault = faultedOperand(l, r);
+          if (gteFault) {
+            stack.push(gteFault);
+            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 {
@@ -981,14 +1627,30 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         // ═══════════════════════════════════════════════════════════════
         // §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;
         }
@@ -996,6 +1658,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           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;
         }
@@ -1003,13 +1670,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // §5  Functions  (OpCode 50–52)
         // ═══════════════════════════════════════════════════════════════
         case 50 /* CALL_PLUGIN */: {
-          const fnIdx = opcodes[ip++];
-          const argCount = opcodes[ip++];
+          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];
-          if (!fn) {
+          const pluginArgFault = faultedIn(args);
+          if (pluginArgFault) {
+            stack.push(pluginArgFault);
+          } else if (!fn) {
             stack.push(numberValue(0));
           } else {
             const result = fn(args, context);
@@ -1024,8 +1694,10 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           break;
         }
         case 51 /* CALL_BUILTIN */: {
-          const fnIdx = opcodes[ip++];
-          const argCount = opcodes[ip++];
+          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++) {
@@ -1033,6 +1705,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             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();
@@ -1042,7 +1719,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           break;
         }
         case 150 /* DEFINE_USER_FUNCTION */: {
-          const bodyIdx = opcodes[ip++];
+          const bodyIdx = operandByte(opcodes, ip++, op, "function-body index");
           const def = userFunctionBodies?.[bodyIdx];
           if (!def) {
             throw ErrorFactory.internal(
@@ -1055,9 +1732,8 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           break;
         }
         case 151 /* CALL_USER_FUNCTION */: {
-          const nameIdx = opcodes[ip++];
-          const argCount = opcodes[ip++];
-          const name = strings[nameIdx];
+          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();
@@ -1074,6 +1750,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           }
           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 {
@@ -1098,7 +1775,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // §6  Variables  (OpCode 60–63)
         // ═══════════════════════════════════════════════════════════════
         case 60 /* LOAD_VAR */: {
-          const varName = strings[opcodes[ip++]];
+          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
           const val = vm.getVar(varName);
           if (val !== void 0) {
             stack.push(val);
@@ -1115,13 +1792,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 61 /* STORE_VAR */: {
           const val = safePop(stack);
-          const varName = strings[opcodes[ip++]];
+          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 = strings[opcodes[ip++]];
+          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
           const globalValue = sharedGlobalVariableStore.get(varName);
           if (globalValue === void 0) {
             throw ErrorFactory.internal({
@@ -1137,41 +1814,75 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 63 /* STORE_GLOBAL_VAR */: {
           const val = safePop(stack);
-          const varName = strings[opcodes[ip++]];
+          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);
-          stack.push(hexValue(v.toNumber()));
+          const toHexFault = faultedOperand(v);
+          if (toHexFault) {
+            stack.push(toHexFault);
+            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(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;
         }
@@ -1179,17 +1890,32 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // `(255 as binary) + 1` has to be 256; as a string it was 1.
         case 143 /* TO_BINARY */: {
           const v = safePop(stack);
-          stack.push(hexValue(v.toNumber(), "bin"));
+          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);
-          stack.push(hexValue(v.toNumber(), "oct"));
+          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 = safePop(stack).value.toLowerCase();
+          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}"`));
@@ -1202,15 +1928,26 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // §8  UoM  (OpCode 80–84)
         // ═══════════════════════════════════════════════════════════════
         case 80 /* UOM_CONVERT */: {
-          const unit = safePop(stack).value;
-          const val = safePop(stack).toNumber();
-          stack.push(uomValue(val, unit));
+          const unit = stringOperand(safePop(stack), op, "unit name");
+          const operand = safePop(stack);
+          const faulted = faultedOperand(operand);
+          if (faulted) {
+            stack.push(faulted);
+            break;
+          }
+          stack.push(uomValue(operand.toNumber(), unit));
           break;
         }
         case 81 /* UOM_CONVERT_TO */: {
-          const toUnit = safePop(stack).value;
-          const fromUnit = safePop(stack).value;
-          const val = safePop(stack).toNumber();
+          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) {
@@ -1223,26 +1960,36 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
               stack.push(errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
             }
           } else {
-            stack.push(uomValue(val, fromUnit));
+            stack.push(incompatibleConversionError(fromUnit, toUnit));
           }
           break;
         }
         case 85 /* UOM_POSSIBILITIES */: {
-          const unit = safePop(stack).value;
+          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 = safePop(stack).value;
-          const val = safePop(stack).toNumber();
-          const { value, unit: bestUnit } = getBestUnit(val, unit);
+          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 = safePop(stack).value;
+          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();
@@ -1258,7 +2005,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
                 stack.push(errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
               }
             } else {
-              stack.push(left);
+              stack.push(incompatibleConversionError(fromUnit, toUnit));
             }
           } else {
             stack.push(uomValue(left.toNumber(), toUnit));
@@ -1267,6 +2014,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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;
         }
@@ -1277,6 +2029,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         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;
@@ -1288,6 +2045,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         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;
@@ -1300,8 +2062,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           break;
         }
         case 112 /* RATE_CONVERT */: {
-          const newDenominatorUnit = safePop(stack).value;
+          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;
@@ -1324,7 +2091,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // §8.7  Time, clock-time-of-day (OpCode 120)
         // ═══════════════════════════════════════════════════════════════
         case 120 /* CLOCK_TIME_TODAY */: {
-          const totalMinutes = safePop(stack).toNumber();
+          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);
@@ -1338,28 +2111,43 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           stack.push(datetimeValue(Date.now()));
           break;
         case 95 /* DATE_LITERAL */:
-          stack.push(datetimeValue(numbers[opcodes[ip++]]));
+          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);
-          stack.push(datetimeValue(dtValue.toNumber() + extractDurationMs(durValue)));
+          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);
-          stack.push(datetimeValue(dtValue.toNumber() - extractDurationMs(durValue)));
+          const dateSubFault = faultedOperand(dtValue, durValue);
+          if (dateSubFault) {
+            stack.push(dateSubFault);
+            break;
+          }
+          stack.push(datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, -1, vm)));
           break;
         }
         case 93 /* DATE_NEXT_WEEKDAY */:
         case 94 /* DATE_LAST_WEEKDAY */: {
-          const targetDay = safePop(stack).toNumber();
+          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;
-          const offsetMs = diffDays * 24 * 60 * 60 * 1e3;
-          stack.push(datetimeValue(op === 93 /* DATE_NEXT_WEEKDAY */ ? now + offsetMs : now - offsetMs));
+          stack.push(datetimeValue(addCalendarDays(now, op === 93 /* DATE_NEXT_WEEKDAY */ ? diffDays : -diffDays)));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -1371,25 +2159,28 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         //     column-major storage helpers.
         // ═══════════════════════════════════════════════════════════════
         case 152 /* MAT_NEW */: {
-          const rows = opcodes[ip++];
-          const cols = opcodes[ip++];
+          const rows = operandByte(opcodes, ip++, op, "row count");
+          const cols = operandByte(opcodes, ip++, op, "column count");
           const count = rows * cols;
-          const rowMajor = new Array(count);
+          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);
-          if (matrixVal.type === 13 /* Error */) {
-            stack.push(matrixVal);
-            break;
-          }
-          if (indexVal.type === 13 /* Error */) {
-            stack.push(indexVal);
+          const index1Fault = faultedOperand(matrixVal, indexVal);
+          if (index1Fault) {
+            stack.push(index1Fault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
@@ -1411,16 +2202,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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);
+          const index2Fault = faultedOperand(matrixVal, rowVal, colVal);
+          if (index2Fault) {
+            stack.push(index2Fault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
@@ -1443,12 +2227,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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);
+          const rangeFault = faultedOperand(minVal, maxVal);
+          if (rangeFault) {
+            stack.push(rangeFault);
             break;
           }
           if (minVal.type !== 0 /* Number */ || maxVal.type !== 0 /* Number */) {
@@ -1473,16 +2254,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         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);
+          const sliceFault = faultedOperand(matrixVal, rowRangeVal, colRangeVal);
+          if (sliceFault) {
+            stack.push(sliceFault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
@@ -1505,7 +2279,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           }
           const newRows = rowRange.max - rowRange.min + 1;
           const newCols = colRange.max - colRange.min + 1;
-          const data = new Array(newRows * newCols);
+          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);
@@ -1523,9 +2297,10 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         //     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 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 = [];
@@ -1542,7 +2317,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             paramNames = def.params;
             program = def.program;
           } else if (kind === 2) {
-            const name = strings[ref];
+            const name = pooledString(strings, ref, op);
             const fn = vm.getUserFunction(name);
             if (!fn) {
               stack.push(errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
@@ -1562,11 +2337,12 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const cellArrays = new Array(collectionCount);
           let mapEarlyError;
           for (let i = 0; i < collectionCount; i++) {
-            const resolved = collectionToValues(rawCollections[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) {
@@ -1582,14 +2358,15 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(mapEarlyError);
             break;
           }
-          const resultData = new Array(collectionLength);
+          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);
-            if (resultVal.type === 13 /* Error */) {
-              mapError = resultVal;
+            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();
@@ -1598,13 +2375,20 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(mapError);
             break;
           }
-          stack.push(matrixValue(1, collectionLength, resultData));
+          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 = opcodes[ip++];
-          const ref = opcodes[ip++];
-          const hasInitial = opcodes[ip++];
+          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 = [];
@@ -1621,7 +2405,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             paramNames = def.params;
             program = def.program;
           } else if (kind === 2) {
-            const name = strings[ref];
+            const name = pooledString(strings, ref, op);
             const fn = vm.getUserFunction(name);
             if (!fn) {
               stack.push(errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
@@ -1637,16 +2421,18 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             paramNames = fn.params;
             program = fn.program;
           }
-          const cells = collectionToValues(collectionVal);
+          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) {
-            if (initialVal.type === 13 /* Error */) {
-              stack.push(initialVal);
+            const initialFault = faultedOperand(initialVal);
+            if (initialFault) {
+              stack.push(initialFault);
               break;
             }
             acc = initialVal;
@@ -1663,8 +2449,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           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);
-            if (resultVal.type === 13 /* Error */) {
-              reduceError = resultVal;
+            const stepFault = faultedOperand(resultVal);
+            if (stepFault) {
+              reduceError = stepFault;
               break;
             }
             acc = resultVal;
@@ -1676,15 +2463,33 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           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-BAMZT3GL.js.map
-//# sourceMappingURL=chunk-BAMZT3GL.js.map
+//# sourceMappingURL=chunk-5WVP4YHP.js.map
+//# sourceMappingURL=chunk-5WVP4YHP.js.map