solve-engine 1.0.0-beta.7 → 1.0.0

package/dist/{chunk-QDMPOAI7.cjs → chunk-HDP7VK3C.cjs}

@@ -1,14 +1,14 @@
 'use strict';
 
 var chunk47LRVGOT_cjs = require('./chunk-47LRVGOT.cjs');
-var chunkBXKJLM5R_cjs = require('./chunk-BXKJLM5R.cjs');
-var chunk2MV4HBKC_cjs = require('./chunk-2MV4HBKC.cjs');
-var chunkMZOVP3WI_cjs = require('./chunk-MZOVP3WI.cjs');
-var chunk4CVLFLOB_cjs = require('./chunk-4CVLFLOB.cjs');
-var chunkOC6LTXYS_cjs = require('./chunk-OC6LTXYS.cjs');
-var chunkNJTXJ5AG_cjs = require('./chunk-NJTXJ5AG.cjs');
-var chunkMBNQVDVC_cjs = require('./chunk-MBNQVDVC.cjs');
-var chunkM4N5GA5Z_cjs = require('./chunk-M4N5GA5Z.cjs');
+var chunk6WFMPTGB_cjs = require('./chunk-6WFMPTGB.cjs');
+var chunkA2N2GFCG_cjs = require('./chunk-A2N2GFCG.cjs');
+var chunk6KFYJ6TD_cjs = require('./chunk-6KFYJ6TD.cjs');
+var chunkUM6BVY2S_cjs = require('./chunk-UM6BVY2S.cjs');
+var chunkJMXUNXQS_cjs = require('./chunk-JMXUNXQS.cjs');
+var chunkPFUESQTW_cjs = require('./chunk-PFUESQTW.cjs');
+var chunkAMOJYLG2_cjs = require('./chunk-AMOJYLG2.cjs');
+var chunk5KMIY374_cjs = require('./chunk-5KMIY374.cjs');
 
 // src/vm/DependencyGraph.ts
 var DependencyGraph = class {
@@ -332,8 +332,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 chunk5KMIY374_cjs.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 = chunkBXKJLM5R_cjs.defaultEngineContext) {
+function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, maxCollectionSize = 1e5, maxAllocatedElements = 2e6, maxFunctionCalls = 1e4, maxDateOffsetYears = 100, minDateOffsetYears = -100, context = chunk6WFMPTGB_cjs.defaultEngineContext) {
   const stack = [];
   const variables = /* @__PURE__ */ new Map();
   let instructionCount = 0;
@@ -352,17 +483,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 chunkOC6LTXYS_cjs.numberValue(0);
+        return chunkJMXUNXQS_cjs.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];
@@ -383,7 +548,7 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     },
     pushCallFrame(frame) {
       if (callFrames.length >= maxFunctionRecursionDepth) {
-        throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+        throw chunk5KMIY374_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 }
@@ -394,6 +559,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 });
     },
@@ -457,14 +625,25 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     incrementInstructions(n) {
       instructionCount += n;
       if (instructionCount > maxInstructions) {
-        throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
+        throw chunk5KMIY374_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
       }
     }
   };
 }
+function matrixProductCells(l, r) {
+  if (l.rows === 1 && l.cols === 1) return r.data.length;
+  if (r.rows === 1 && r.cols === 1) return l.data.length;
+  if (l.cols !== r.rows) return 0;
+  return l.rows * r.cols;
+}
+function matrixPowerCells(m, exponent) {
+  if (!Number.isInteger(exponent) || exponent < 0) return 0;
+  const cells = m.rows * m.cols;
+  return cells * (1 + (exponent < 2 ? 1 : 2 * Math.floor(Math.log2(exponent))));
+}
 function safePop(stack) {
   if (stack.length === 0) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.internal({
+    throw chunk5KMIY374_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",
@@ -474,6 +653,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" ? chunk6KFYJ6TD_cjs.getOpCodeName(site) : site;
+}
+function malformedBytecode(code, site, problem, expected, found, context = {}) {
+  const name = siteName(site);
+  return chunk5KMIY374_cjs.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 ${chunkJMXUNXQS_cjs.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]);
@@ -485,7 +782,7 @@ function invokeFrameBody(params, program, args, vm, pipeline, expression, contex
     vm.popCallFrame();
   }
   if (bodyResult.type === "pending") {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+    throw chunk5KMIY374_cjs.ErrorFactory.execution(
       "MAP_REDUCE_ASYNC_UNSUPPORTED",
       `map/reduce transform bodies calling an async operation (weather, stocks, currency, ...) aren't supported`
     );
@@ -495,6 +792,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, chunkJMXUNXQS_cjs.symbolicValue(chunkUM6BVY2S_cjs.varNode(name)));
+  vm.pushCallFrame(frame);
+  let bodyResult;
+  try {
+    bodyResult = executeBytecode(program, vm, pipeline, expression, context, symbolicTolerant);
+  } finally {
+    vm.popCallFrame();
+  }
+  if (bodyResult.type === "pending") {
+    throw chunk5KMIY374_cjs.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;
@@ -504,8 +822,8 @@ function unifyRatePeriods(l, r) {
   const rightSlash = rightUnit.indexOf("/");
   if (leftSlash < 0 || rightSlash < 0) return null;
   if (leftUnit.slice(0, leftSlash) !== rightUnit.slice(0, rightSlash)) return null;
-  const leftPeriod = chunkMBNQVDVC_cjs.UNIT_TABLE[leftUnit.slice(leftSlash + 1).toLowerCase()];
-  const rightPeriod = chunkMBNQVDVC_cjs.UNIT_TABLE[rightUnit.slice(rightSlash + 1).toLowerCase()];
+  const leftPeriod = chunkAMOJYLG2_cjs.UNIT_TABLE[leftUnit.slice(leftSlash + 1).toLowerCase()];
+  const rightPeriod = chunkAMOJYLG2_cjs.UNIT_TABLE[rightUnit.slice(rightSlash + 1).toLowerCase()];
   if (leftPeriod === void 0 || rightPeriod === void 0) return null;
   if (leftPeriod[0] !== rightPeriod[0]) return null;
   return l.toNumber() * (rightPeriod[1] / leftPeriod[1]);
@@ -516,28 +834,31 @@ function moneyTimesQuantity(l, r) {
   const rightUnit = r.unit;
   if (leftUnit === void 0 || rightUnit === void 0) return null;
   if (leftUnit.includes("/") || rightUnit.includes("/")) return null;
-  const leftIsMoney = chunk4CVLFLOB_cjs.CURRENCY_DISPLAY[leftUnit.toUpperCase()] !== void 0;
-  const rightIsMoney = chunk4CVLFLOB_cjs.CURRENCY_DISPLAY[rightUnit.toUpperCase()] !== void 0;
+  const leftIsMoney = chunkUM6BVY2S_cjs.CURRENCY_DISPLAY[leftUnit.toUpperCase()] !== void 0;
+  const rightIsMoney = chunkUM6BVY2S_cjs.CURRENCY_DISPLAY[rightUnit.toUpperCase()] !== void 0;
   if (leftIsMoney === rightIsMoney) return null;
-  return chunkOC6LTXYS_cjs.uomValue(l.toNumber() * r.toNumber(), leftIsMoney ? leftUnit : rightUnit);
+  return chunkJMXUNXQS_cjs.uomValue(l.toNumber() * r.toNumber(), leftIsMoney ? leftUnit : rightUnit);
 }
 function combinePercentage(l, r, sign) {
   if (l.type === 5 /* Percentage */) {
+    if (r.type === 6 /* Uom */ && r.unit !== void 0) {
+      return chunkJMXUNXQS_cjs.uomValue(r.toNumber() * (1 + sign * l.toNumber()), r.unit);
+    }
     if (r.type !== 5 /* Percentage */ && r.type !== 0 /* Number */) return null;
-    return chunkOC6LTXYS_cjs.percentageValue(l.toNumber() + sign * r.toNumber());
+    return chunkJMXUNXQS_cjs.percentageValue(l.toNumber() + sign * r.toNumber());
   }
   if (r.type !== 5 /* Percentage */) return null;
   const factor = 1 + sign * r.toNumber();
-  if (l.type === 0 /* Number */) return chunkOC6LTXYS_cjs.numberValue(l.toNumber() * factor);
-  if (l.type === 6 /* Uom */ && l.unit !== void 0) return chunkOC6LTXYS_cjs.uomValue(l.toNumber() * factor, l.unit);
+  if (l.type === 0 /* Number */) return chunkJMXUNXQS_cjs.numberValue(l.toNumber() * factor);
+  if (l.type === 6 /* Uom */ && l.unit !== void 0) return chunkJMXUNXQS_cjs.uomValue(l.toNumber() * factor, l.unit);
   return null;
 }
 function extractDurationMs(value) {
   if (value.type === 6 /* Uom */) {
     const unit = value.unit;
-    if (unit && chunkNJTXJ5AG_cjs.getMeasure(unit) === "time") {
+    if (unit && chunkPFUESQTW_cjs.getMeasure(unit) === "time") {
       try {
-        return chunkNJTXJ5AG_cjs.convertUnit(value.toNumber(), unit, "ms");
+        return chunkPFUESQTW_cjs.convertUnit(value.toNumber(), unit, "ms");
       } catch {
       }
     }
@@ -545,10 +866,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 chunk5KMIY374_cjs.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();
@@ -556,44 +887,153 @@ 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 = chunkPFUESQTW_cjs.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 (chunkPFUESQTW_cjs.isWorkdayUnit(unit)) return addBusinessDays(epochMs, amount, vm);
+    const monthsPerUnit = CALENDAR_MONTHS_PER_UNIT[unit];
+    if (monthsPerUnit !== void 0) return addCalendarMonths(epochMs, amount * monthsPerUnit);
+    if (chunkPFUESQTW_cjs.getMeasure(unit) === "time") {
+      let daysPerUnit = 0;
+      try {
+        daysPerUnit = chunkPFUESQTW_cjs.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 = chunkOC6LTXYS_cjs.timecodeFps(tc.unit);
-  if (r.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isTimecodeUnit(r.unit)) {
-    const rFps = chunkOC6LTXYS_cjs.timecodeFps(r.unit);
+  const fps = chunkJMXUNXQS_cjs.timecodeFps(tc.unit);
+  if (r.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isTimecodeUnit(r.unit)) {
+    const rFps = chunkJMXUNXQS_cjs.timecodeFps(r.unit);
     if (rFps !== fps) {
-      return chunkOC6LTXYS_cjs.errorValue(
+      return chunkJMXUNXQS_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");
+    return sign === 1 ? chunkJMXUNXQS_cjs.uomValue(tc.toNumber() + r.toNumber(), tc.unit) : chunkJMXUNXQS_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);
+    return chunkJMXUNXQS_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
   }
-  if (r.type === 6 /* Uom */ && r.unit && chunkNJTXJ5AG_cjs.getMeasure(r.unit) === "time") {
-    const seconds = chunkNJTXJ5AG_cjs.convertUnit(r.toNumber(), r.unit, "s");
-    return chunkOC6LTXYS_cjs.uomValue(tc.toNumber() + sign * seconds * fps, tc.unit);
+  if (r.type === 6 /* Uom */ && r.unit && chunkPFUESQTW_cjs.getMeasure(r.unit) === "time") {
+    const seconds = chunkPFUESQTW_cjs.convertUnit(r.toNumber(), r.unit, "s");
+    return chunkJMXUNXQS_cjs.uomValue(tc.toNumber() + sign * seconds * fps, tc.unit);
   }
-  return chunkOC6LTXYS_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
+  return chunkJMXUNXQS_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 incompatibleConversionError(fromUnit, toUnit) {
+  return chunkJMXUNXQS_cjs.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 = chunk6WFMPTGB_cjs.toBigIntOperand(l);
+  const shift = chunk6WFMPTGB_cjs.toBigIntOperand(r);
+  if (value === 0n) return chunkJMXUNXQS_cjs.bigIntValue(0n);
+  const grownBits = direction * Number(shift);
+  if (grownBits <= 0 || bigIntBitLength(value) + grownBits <= MAX_EXACT_SHIFT_BITS) {
+    return chunkJMXUNXQS_cjs.bigIntValue(direction === 1 ? value << shift : value >> shift);
+  }
+  throw chunk5KMIY374_cjs.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 } = chunkOC6LTXYS_cjs.splitRateUnit(rate.unit);
-  const rateMeasure = chunkNJTXJ5AG_cjs.getMeasure(denominator);
-  const multiplierMeasure = chunkNJTXJ5AG_cjs.getMeasure(multiplier.unit);
+  const { numerator, denominator } = chunkJMXUNXQS_cjs.splitRateUnit(rate.unit);
+  const rateMeasure = chunkPFUESQTW_cjs.getMeasure(denominator);
+  const multiplierMeasure = chunkPFUESQTW_cjs.getMeasure(multiplier.unit);
   if (!rateMeasure || rateMeasure !== multiplierMeasure) {
-    return chunkOC6LTXYS_cjs.errorValue(
+    return chunkJMXUNXQS_cjs.errorValue(
       "RATE_MUL_MEASURE_MISMATCH",
       `Cannot multiply a "${denominator}"-denominated rate by "${multiplier.unit}" \u2014 different measures`
     );
   }
-  const multiplierInDenominatorUnit = chunkNJTXJ5AG_cjs.convertUnit(multiplier.toNumber(), multiplier.unit, denominator);
+  const multiplierInDenominatorUnit = chunkPFUESQTW_cjs.convertUnit(multiplier.toNumber(), multiplier.unit, denominator);
   const total = rate.toNumber() * multiplierInDenominatorUnit;
-  return numerator ? chunkOC6LTXYS_cjs.uomValue(total, numerator) : chunkOC6LTXYS_cjs.numberValue(total);
+  return numerator ? chunkJMXUNXQS_cjs.uomValue(total, numerator) : chunkJMXUNXQS_cjs.numberValue(total);
 }
 function toFractionString(n) {
   if (Number.isNaN(n)) return "NaN";
@@ -628,12 +1068,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: chunk5KMIY374_cjs.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,15 +1095,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
   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) };
+  const hasArena = chunkJMXUNXQS_cjs.isArenaActive();
+  if (opcodes.length === 0) return { type: "value", value: chunkJMXUNXQS_cjs.numberValue(0) };
+  chunkJMXUNXQS_cjs.beginEvaluation(vm);
   try {
     while (ip < opcodes.length) {
       if (++localInstructionCount > maxInstructions) {
-        throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
+        throw chunk5KMIY374_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}`);
+        throw chunk5KMIY374_cjs.ErrorFactory.execution("STACK_LIMIT_EXCEEDED", `Execution exceeded maximum stack depth of ${maxStackDepth}`);
       }
       const op = opcodes[ip++];
       if (shouldTrace) {
@@ -663,7 +1118,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           elapsedNs: 0,
           expression: expression ?? "",
           opcode: op,
-          opcodeName: chunkMZOVP3WI_cjs.getOpCodeName(op),
+          opcodeName: chunk6KFYJ6TD_cjs.getOpCodeName(op),
           ip: ip - 1,
           stackDepth: stack.length,
           instructionNumber: localInstructionCount,
@@ -678,11 +1133,14 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           break;
         case 1 /* HALT */: {
           const result = safePop(stack);
-          return { type: "value", value: hasArena ? chunkOC6LTXYS_cjs.persistentValue(result) : result };
+          return { type: "value", value: hasArena ? chunkJMXUNXQS_cjs.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);
@@ -692,20 +1150,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(chunkOC6LTXYS_cjs.numberValue(numbers[opcodes[ip++]]));
+          stack.push(chunkJMXUNXQS_cjs.numberValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
         case 11 /* PUSH_BIGINT */:
-          stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(strings[opcodes[ip++]])));
+          stack.push(chunkJMXUNXQS_cjs.bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"), op)));
           break;
         case 12 /* PUSH_HEX */:
-          stack.push(chunkOC6LTXYS_cjs.hexValue(numbers[opcodes[ip++]]));
+          stack.push(chunkJMXUNXQS_cjs.hexValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
         case 13 /* PUSH_STRING */:
-          stack.push(chunkOC6LTXYS_cjs.stringValue(strings[opcodes[ip++]]));
+          stack.push(chunkJMXUNXQS_cjs.stringValue(poolString(opcodes, ip++, strings, op, "constant-pool index")));
           break;
         case 14 /* PUSH_BOOLEAN */:
-          stack.push(chunkOC6LTXYS_cjs.boolValue(opcodes[ip++] === 1));
+          stack.push(chunkJMXUNXQS_cjs.boolValue(operandByte(opcodes, ip++, op, "boolean operand") === 1));
           break;
         // ═══════════════════════════════════════════════════════════════
         // §3  Arithmetic  (OpCode 20–27)
@@ -714,92 +1177,112 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 20 /* ADD */: {
           const r = safePop(stack), l = safePop(stack);
+          const addFault = chunkJMXUNXQS_cjs.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) {
             stack.push(pctAdd);
           } else if (ratePeriodAdd !== null) {
-            stack.push(chunkOC6LTXYS_cjs.uomValue(ratePeriodAdd + r.toNumber(), r.unit));
+            stack.push(chunkJMXUNXQS_cjs.uomValue(ratePeriodAdd + r.toNumber(), r.unit));
           } else if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.value + r.value));
+            stack.push(chunkJMXUNXQS_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));
+            stack.push(chunkJMXUNXQS_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 */ && chunkNJTXJ5AG_cjs.isWorkdayUnit(r.unit)) {
-              stack.push(chunkOC6LTXYS_cjs.datetimeValue(addBusinessDays(l.toNumber(), r.toNumber())));
+              stack.push(chunkJMXUNXQS_cjs.errorValue("INVALID_DATETIME_OP", "Cannot add two datetimes together"));
             } else {
-              stack.push(chunkOC6LTXYS_cjs.datetimeValue(l.toNumber() + extractDurationMs(r)));
+              stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(l.toNumber(), r, 1, vm)));
             }
-          } else if (l.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isTimecodeUnit(l.unit)) {
+          } else if (l.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isTimecodeUnit(l.unit)) {
             stack.push(combineTimecode(l, r, 1));
+          } else if (r.type === 4 /* Datetime */) {
+            stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(r.toNumber(), l, 1, vm)));
           } else {
-            stack.push(chunkBXKJLM5R_cjs.binaryOp(l, r, (a, b) => a + b, (a, b) => a + b, "add"));
+            stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a + b, (a, b) => a + b, "add"));
           }
           break;
         }
         case 21 /* SUB */: {
           const r = safePop(stack), l = safePop(stack);
+          const subFault = chunkJMXUNXQS_cjs.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) {
             stack.push(pctSub);
           } else if (ratePeriodSub !== null) {
-            stack.push(chunkOC6LTXYS_cjs.uomValue(ratePeriodSub - r.toNumber(), r.unit));
+            stack.push(chunkJMXUNXQS_cjs.uomValue(ratePeriodSub - r.toNumber(), r.unit));
           } else if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.value - r.value));
+            stack.push(chunkJMXUNXQS_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 */ && chunkNJTXJ5AG_cjs.isWorkdayUnit(r.unit)) {
-              stack.push(chunkOC6LTXYS_cjs.datetimeValue(addBusinessDays(l.toNumber(), -r.toNumber())));
+              stack.push(chunkJMXUNXQS_cjs.uomValue(l.toNumber() - r.toNumber(), "ms"));
             } else {
-              stack.push(chunkOC6LTXYS_cjs.datetimeValue(l.toNumber() - extractDurationMs(r)));
+              stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(l.toNumber(), r, -1, vm)));
             }
-          } else if (l.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isTimecodeUnit(l.unit)) {
+          } else if (l.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isTimecodeUnit(l.unit)) {
             stack.push(combineTimecode(l, r, -1));
+          } else if (r.type === 4 /* Datetime */) {
+            stack.push(chunkJMXUNXQS_cjs.errorValue(
+              "INVALID_DATETIME_OP",
+              "Cannot subtract a datetime from a value that is not a datetime"
+            ));
           } else {
-            stack.push(chunkBXKJLM5R_cjs.binaryOp(l, r, (a, b) => a - b, (a, b) => a - b, "sub"));
+            stack.push(chunk6WFMPTGB_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));
+            stack.push(chunkJMXUNXQS_cjs.numberValue(l.value * r.value));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixMultiply(l.value, r.value));
-          } else if (l.type === 6 /* Uom */ && chunkOC6LTXYS_cjs.isRateUnit(l.unit) && r.type === 6 /* Uom */ && r.unit) {
+            chunkJMXUNXQS_cjs.checkAllocation(matrixProductCells(l.value, r.value), "matrix cells");
+            stack.push(chunkUM6BVY2S_cjs.matrixMultiply(l.value, r.value));
+          } else if (l.type === 6 /* Uom */ && chunkJMXUNXQS_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) {
+          } else if (r.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isRateUnit(r.unit) && l.type === 6 /* Uom */ && l.unit) {
             stack.push(multiplyRateByMatchingUom(r, l));
           } else if (moneyTimesQuantity(l, r) !== null) {
             stack.push(moneyTimesQuantity(l, r));
           } else {
-            stack.push(chunkBXKJLM5R_cjs.binaryOp(l, r, (a, b) => a * b, (a, b) => a * b, "mul"));
+            stack.push(chunk6WFMPTGB_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 } = chunkBXKJLM5R_cjs.unifyUom(l, r);
+            const { lv, rv, sameMeasure } = chunk6WFMPTGB_cjs.unifyUom(l, r);
             if (sameMeasure) {
-              stack.push(chunkOC6LTXYS_cjs.numberValue(lv / rv));
-            } else if (chunk2MV4HBKC_cjs.sharedCurrencyExchange.isCurrency(l.unit) && chunk2MV4HBKC_cjs.sharedCurrencyExchange.isCurrency(r.unit)) {
-              stack.push(chunkOC6LTXYS_cjs.errorValue("INCOMPATIBLE_UNITS", `Cannot combine incompatible units: ${l.unit} and ${r.unit}`));
+              stack.push(chunkJMXUNXQS_cjs.numberValue(lv / rv));
+            } else if (chunkA2N2GFCG_cjs.sharedCurrencyExchange.isCurrency(l.unit) && chunkA2N2GFCG_cjs.sharedCurrencyExchange.isCurrency(r.unit)) {
+              stack.push(chunkJMXUNXQS_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));
+              stack.push(chunkJMXUNXQS_cjs.rateValue(lv / rv, l.unit, r.unit));
             }
           } else {
-            stack.push(chunkBXKJLM5R_cjs.binaryOp(l, r, (a, b) => a / b, (a, b) => a / b, "div"));
+            stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a / b, (a, b) => {
+              if (b === 0n) throw chunk6WFMPTGB_cjs.bigIntDivisionByZero();
+              return a / b;
+            }, "div"));
           }
           break;
         }
         case 24 /* MOD */: {
           const r = safePop(stack), l = safePop(stack);
-          stack.push(chunkBXKJLM5R_cjs.binaryOp(l, r, (a, b) => a % b, (a, b) => a % b));
+          stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a % b, (a, b) => {
+            if (b === 0n) throw chunk6WFMPTGB_cjs.bigIntDivisionByZero();
+            return a % b;
+          }));
           break;
         }
         case 25 /* EXP */: {
@@ -821,183 +1304,367 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             break;
           }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(Math.pow(l.value, r.value)));
+            stack.push(chunkJMXUNXQS_cjs.numberValue(chunk6WFMPTGB_cjs.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(chunkJMXUNXQS_cjs.errorValue(
+                "MATRIX_POWER_UNSUPPORTED",
+                `^: a matrix may only be the base, raised to a whole number (as in "[1,2;3,4]^2"); "${chunkJMXUNXQS_cjs.ValueType[l.type]} ^ ${chunkJMXUNXQS_cjs.ValueType[r.type]}" has no matrix reading.`
+              ));
+              break;
+            }
+            chunkJMXUNXQS_cjs.checkAllocation(matrixPowerCells(l.value, r.value), "matrix cells");
+            stack.push(chunkUM6BVY2S_cjs.matrixPower(l.value, r.value));
             break;
           }
           if (l.type === 9 /* Symbolic */ || r.type === 9 /* Symbolic */) {
-            stack.push(chunkBXKJLM5R_cjs.symbolicPow(l, r));
+            stack.push(chunk6WFMPTGB_cjs.symbolicPow(l, r));
             break;
           }
-          stack.push(chunkOC6LTXYS_cjs.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 chunk5KMIY374_cjs.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(chunkJMXUNXQS_cjs.bigIntValue(bigIntPow(chunk6WFMPTGB_cjs.toBigIntOperand(l), chunk6WFMPTGB_cjs.toBigIntOperand(r))));
+              break;
+            }
+          }
+          stack.push(chunkJMXUNXQS_cjs.numberValue(chunk6WFMPTGB_cjs.power(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(chunkBXKJLM5R_cjs.symbolicNeg(v));
-          else stack.push(chunkOC6LTXYS_cjs.numberValue(-v.toNumber()));
+          const negFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (negFault) {
+            stack.push(negFault);
+            break;
+          }
+          if (v.type === 2 /* BigInt */) stack.push(chunkJMXUNXQS_cjs.bigIntValue(-v.value));
+          else if (v.type === 6 /* Uom */) stack.push(chunkJMXUNXQS_cjs.uomValue(-v.toNumber(), v.unit));
+          else if (v.type === 5 /* Percentage */) stack.push(chunkJMXUNXQS_cjs.percentageValue(-v.toNumber()));
+          else if (v.type === 9 /* Symbolic */) stack.push(chunk6WFMPTGB_cjs.symbolicNeg(v));
+          else stack.push(chunkJMXUNXQS_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()));
+          const posFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (posFault) {
+            stack.push(posFault);
+            break;
+          }
+          if (v.type === 6 /* Uom */) stack.push(chunkJMXUNXQS_cjs.uomValue(v.toNumber(), v.unit));
+          else if (v.type === 5 /* Percentage */) stack.push(chunkJMXUNXQS_cjs.percentageValue(v.toNumber()));
+          else stack.push(chunkJMXUNXQS_cjs.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 = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (shiftFault) {
+            stack.push(shiftFault);
+            break;
+          }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) << BigInt(r.toNumber())));
+            stack.push(bigIntShift(l, r, 1));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() << r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() << r.toNumber()));
           }
           break;
         }
         case 31 /* RSHIFT */: {
           const r = safePop(stack), l = safePop(stack);
+          const rshiftFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (rshiftFault) {
+            stack.push(rshiftFault);
+            break;
+          }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) >> BigInt(r.toNumber())));
+            stack.push(bigIntShift(l, r, -1));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() >> r.toNumber()));
+            stack.push(chunkJMXUNXQS_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()));
+          const urshiftFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (urshiftFault) {
+            stack.push(urshiftFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() >>> r.toNumber()));
           break;
         }
         case 33 /* BIT_AND */: {
           const r = safePop(stack), l = safePop(stack);
+          const andFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (andFault) {
+            stack.push(andFault);
+            break;
+          }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) & BigInt(r.toNumber())));
+            stack.push(chunkJMXUNXQS_cjs.bigIntValue(chunk6WFMPTGB_cjs.toBigIntOperand(l) & chunk6WFMPTGB_cjs.toBigIntOperand(r)));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() & r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() & r.toNumber()));
           }
           break;
         }
         case 34 /* BIT_OR */: {
           const r = safePop(stack), l = safePop(stack);
+          const orFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (orFault) {
+            stack.push(orFault);
+            break;
+          }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) | BigInt(r.toNumber())));
+            stack.push(chunkJMXUNXQS_cjs.bigIntValue(chunk6WFMPTGB_cjs.toBigIntOperand(l) | chunk6WFMPTGB_cjs.toBigIntOperand(r)));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() | r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() | r.toNumber()));
           }
           break;
         }
         case 35 /* BIT_XOR */: {
           const r = safePop(stack), l = safePop(stack);
+          const xorFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (xorFault) {
+            stack.push(xorFault);
+            break;
+          }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkOC6LTXYS_cjs.bigIntValue(BigInt(l.toNumber()) ^ BigInt(r.toNumber())));
+            stack.push(chunkJMXUNXQS_cjs.bigIntValue(chunk6WFMPTGB_cjs.toBigIntOperand(l) ^ chunk6WFMPTGB_cjs.toBigIntOperand(r)));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(l.toNumber() ^ r.toNumber()));
+            stack.push(chunkJMXUNXQS_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()));
+          const notFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (notFault) {
+            stack.push(notFault);
+            break;
+          }
+          if (v.type === 2 /* BigInt */) stack.push(chunkJMXUNXQS_cjs.bigIntValue(~v.value));
+          else stack.push(chunkJMXUNXQS_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.
+        //     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 = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (eqFault) {
+            stack.push(eqFault);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value === r.value));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value === r.value));
+          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            const cmp = chunk6WFMPTGB_cjs.compareBigIntOperands(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(cmp === null ? l.toNumber() === r.toNumber() : cmp === 0));
+          } else if (l.type === 3 /* String */ && r.type === 3 /* String */) {
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value === r.value));
           } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, sameMeasure } = chunkBXKJLM5R_cjs.unifyUom(l, r);
-            stack.push(chunkOC6LTXYS_cjs.boolValue(sameMeasure && lv === rv));
+            const { equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(sameMeasure && equal));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixCompare(l.value, r.value, (a, b) => a === b));
+            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a === b));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() === r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() === r.toNumber()));
           }
           break;
         }
         case 41 /* NEQ */: {
           const r = safePop(stack), l = safePop(stack);
+          const neqFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (neqFault) {
+            stack.push(neqFault);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value !== r.value));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value !== r.value));
+          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            const cmp = chunk6WFMPTGB_cjs.compareBigIntOperands(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(cmp === null ? l.toNumber() !== r.toNumber() : cmp !== 0));
+          } else if (l.type === 3 /* String */ && r.type === 3 /* String */) {
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value !== r.value));
           } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, sameMeasure } = chunkBXKJLM5R_cjs.unifyUom(l, r);
-            stack.push(chunkOC6LTXYS_cjs.boolValue(!sameMeasure || lv !== rv));
+            const { equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(!sameMeasure || !equal));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixCompare(l.value, r.value, (a, b) => a !== b));
+            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a !== b));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() !== r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() !== r.toNumber()));
           }
           break;
         }
         case 42 /* LT */: {
           const r = safePop(stack), l = safePop(stack);
+          const ltFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (ltFault) {
+            stack.push(ltFault);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value < r.value));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value < r.value));
+          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            const cmp = chunk6WFMPTGB_cjs.compareBigIntOperands(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(cmp === null ? l.toNumber() < r.toNumber() : cmp < 0));
+          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunkJMXUNXQS_cjs.boolValue(!equal && lv < rv) : chunk6WFMPTGB_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixCompare(l.value, r.value, (a, b) => a < b));
+            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a < b));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() < r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() < r.toNumber()));
           }
           break;
         }
         case 43 /* LTE */: {
           const r = safePop(stack), l = safePop(stack);
+          const lteFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (lteFault) {
+            stack.push(lteFault);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value <= r.value));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value <= r.value));
+          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            const cmp = chunk6WFMPTGB_cjs.compareBigIntOperands(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(cmp === null ? l.toNumber() <= r.toNumber() : cmp <= 0));
+          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunkJMXUNXQS_cjs.boolValue(equal || lv <= rv) : chunk6WFMPTGB_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixCompare(l.value, r.value, (a, b) => a <= b));
+            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a <= b));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() <= r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() <= r.toNumber()));
           }
           break;
         }
         case 44 /* GT */: {
           const r = safePop(stack), l = safePop(stack);
+          const gtFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (gtFault) {
+            stack.push(gtFault);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value > r.value));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value > r.value));
+          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            const cmp = chunk6WFMPTGB_cjs.compareBigIntOperands(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(cmp === null ? l.toNumber() > r.toNumber() : cmp > 0));
+          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunkJMXUNXQS_cjs.boolValue(!equal && lv > rv) : chunk6WFMPTGB_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixCompare(l.value, r.value, (a, b) => a > b));
+            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a > b));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() > r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() > r.toNumber()));
           }
           break;
         }
         case 45 /* GTE */: {
           const r = safePop(stack), l = safePop(stack);
+          const gteFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (gteFault) {
+            stack.push(gteFault);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.value >= r.value));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value >= r.value));
+          } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
+            const cmp = chunk6WFMPTGB_cjs.compareBigIntOperands(l, r);
+            stack.push(chunkJMXUNXQS_cjs.boolValue(cmp === null ? l.toNumber() >= r.toNumber() : cmp >= 0));
+          } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
+            const { lv, rv, equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunkJMXUNXQS_cjs.boolValue(equal || lv >= rv) : chunk6WFMPTGB_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunk4CVLFLOB_cjs.matrixCompare(l.value, r.value, (a, b) => a >= b));
+            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a >= b));
           } else {
-            stack.push(chunkOC6LTXYS_cjs.boolValue(l.toNumber() >= r.toNumber()));
+            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() >= r.toNumber()));
           }
           break;
         }
         // ═══════════════════════════════════════════════════════════════
         // §4c Logical / conditional select  (OpCode 130–132)
+        //
+        //     Truthiness is read through isTruthy(), which reads a number,
+        //     which is zero for a fault, so a failed operand used to be
+        //     quietly false. Both operands are already evaluated by the time
+        //     either opcode runs (this VM has no branch opcodes), so there is
+        //     no short-circuit to preserve by ignoring the right-hand one.
         // ═══════════════════════════════════════════════════════════════
         case 130 /* LOGICAL_AND */: {
           const r = safePop(stack), l = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.boolValue(isTruthy(l) && isTruthy(r)));
+          const andLogicFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (andLogicFault) {
+            stack.push(andLogicFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_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)));
+          const orLogicFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          if (orLogicFault) {
+            stack.push(orLogicFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.boolValue(isTruthy(l) || isTruthy(r)));
           break;
         }
         case 132 /* SELECT */: {
           const elseVal = safePop(stack);
           const thenVal = safePop(stack);
           const condition = safePop(stack);
+          const conditionFault = chunkJMXUNXQS_cjs.faultedOperand(condition);
+          if (conditionFault) {
+            stack.push(conditionFault);
+            break;
+          }
           stack.push(isTruthy(condition) ? thenVal : elseVal);
           break;
         }
@@ -1005,14 +1672,17 @@ 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) {
-            stack.push(chunkOC6LTXYS_cjs.numberValue(0));
+          const pluginArgFault = chunkJMXUNXQS_cjs.faultedIn(args);
+          if (pluginArgFault) {
+            stack.push(pluginArgFault);
+          } else if (!fn) {
+            stack.push(chunkJMXUNXQS_cjs.numberValue(0));
           } else {
             const result = fn(args, context);
             if (result instanceof Promise) {
@@ -1026,8 +1696,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++) {
@@ -1035,19 +1707,24 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             if (arg.type === 9 /* Symbolic */) sawSymbolic = true;
             args.push(arg);
           }
-          const fn = chunkBXKJLM5R_cjs.builtinFunctions[fnIdx];
+          const builtinArgFault = chunkJMXUNXQS_cjs.faultedIn(args);
+          if (builtinArgFault) {
+            stack.push(builtinArgFault);
+            break;
+          }
+          const fn = chunk6WFMPTGB_cjs.builtinFunctions[fnIdx];
           if (fn) {
             const ordered = args.reverse();
-            const routeSymbolically = sawSymbolic && !chunkBXKJLM5R_cjs.SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);
-            stack.push(routeSymbolically ? chunkBXKJLM5R_cjs.symbolicBuiltin(fnIdx, ordered) : fn(ordered));
+            const routeSymbolically = sawSymbolic && !chunk6WFMPTGB_cjs.SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);
+            stack.push(routeSymbolically ? chunk6WFMPTGB_cjs.symbolicBuiltin(fnIdx, ordered) : fn(ordered));
           }
           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 chunkM4N5GA5Z_cjs.ErrorFactory.internal(
+            throw chunk5KMIY374_cjs.ErrorFactory.internal(
               "INTERNAL_MISSING_FUNCTION_BODY",
               `Internal error: DEFINE_USER_FUNCTION referenced missing body index ${bodyIdx}`,
               { bodyIdx }
@@ -1057,18 +1734,17 @@ 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();
           const fn = vm.getUserFunction(name);
           if (!fn) {
-            throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("UNDEFINED_FUNCTION", `Undefined function: ${name}`, { name });
+            throw chunk5KMIY374_cjs.ErrorFactory.execution("UNDEFINED_FUNCTION", `Undefined function: ${name}`, { name });
           }
           if (argCount !== fn.params.length) {
-            throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+            throw chunk5KMIY374_cjs.ErrorFactory.execution(
               "FUNCTION_ARITY_MISMATCH",
               `${name} expects ${fn.params.length} argument(s) but got ${argCount}`,
               { name, expected: fn.params.length, actual: argCount }
@@ -1076,6 +1752,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]);
+          chunkJMXUNXQS_cjs.chargeFunctionCall();
           vm.pushCallFrame(frame);
           let bodyResult;
           try {
@@ -1084,7 +1761,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             vm.popCallFrame();
           }
           if (bodyResult.type === "pending") {
-            throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+            throw chunk5KMIY374_cjs.ErrorFactory.execution(
               "USER_FUNCTION_ASYNC_UNSUPPORTED",
               `${name}: user-defined functions with async bodies (weather, stocks, currency, ...) aren't supported`,
               { name }
@@ -1100,14 +1777,14 @@ 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);
           } else if (symbolicTolerant) {
-            stack.push(chunkOC6LTXYS_cjs.symbolicValue(chunk4CVLFLOB_cjs.varNode(varName)));
+            stack.push(chunkJMXUNXQS_cjs.symbolicValue(chunkUM6BVY2S_cjs.varNode(varName)));
           } else {
-            throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+            throw chunk5KMIY374_cjs.ErrorFactory.execution(
               "UNDEFINED_VARIABLE",
               `Undefined variable: ${varName}`,
               { varName }
@@ -1117,16 +1794,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 61 /* STORE_VAR */: {
           const val = safePop(stack);
-          const varName = strings[opcodes[ip++]];
-          vm.setVar(varName, hasArena ? chunkOC6LTXYS_cjs.persistentValue(val) : val);
+          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
+          vm.setVar(varName, hasArena ? chunkJMXUNXQS_cjs.persistentValue(val) : val);
           stack.push(val);
           break;
         }
         case 62 /* LOAD_GLOBAL_VAR */: {
-          const varName = strings[opcodes[ip++]];
-          const globalValue = chunkBXKJLM5R_cjs.sharedGlobalVariableStore.get(varName);
+          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
+          const globalValue = chunk6WFMPTGB_cjs.sharedGlobalVariableStore.get(varName);
           if (globalValue === void 0) {
-            throw chunkM4N5GA5Z_cjs.ErrorFactory.internal({
+            throw chunk5KMIY374_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)`,
@@ -1139,62 +1816,111 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 63 /* STORE_GLOBAL_VAR */: {
           const val = safePop(stack);
-          const varName = strings[opcodes[ip++]];
-          chunkBXKJLM5R_cjs.sharedGlobalVariableStore.set(varName, hasArena ? chunkOC6LTXYS_cjs.persistentValue(val) : val);
+          const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
+          chunk6WFMPTGB_cjs.sharedGlobalVariableStore.set(varName, hasArena ? chunkJMXUNXQS_cjs.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);
-          stack.push(chunkOC6LTXYS_cjs.numberValue(v.toNumber()));
+          const toNumberFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toNumberFault) {
+            stack.push(toNumberFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.numberValue(v.toNumber()));
           break;
         }
         case 71 /* TO_HEX */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.hexValue(v.toNumber()));
+          const toHexFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toHexFault) {
+            stack.push(toHexFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber()));
           break;
         }
         case 74 /* TO_PERCENTAGE */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.percentageValue(v.toNumber()));
+          const toPercentageFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toPercentageFault) {
+            stack.push(toPercentageFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.percentageValue(v.toNumber()));
           break;
         }
         case 140 /* TO_FRACTION */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.stringValue(toFractionString(v.toNumber())));
+          const toFractionFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toFractionFault) {
+            stack.push(toFractionFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.stringValue(toFractionString(v.toNumber())));
           break;
         }
         case 141 /* TO_MULTIPLIER */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.stringValue(toMultiplierString(v)));
+          const toMultiplierFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toMultiplierFault) {
+            stack.push(toMultiplierFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.stringValue(toMultiplierString(v)));
           break;
         }
         case 142 /* TO_SCI */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.stringValue(toScientificString(v.toNumber())));
+          const toSciFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toSciFault) {
+            stack.push(toSciFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_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"));
+          const toBinaryFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toBinaryFault) {
+            stack.push(toBinaryFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "bin"));
           break;
         }
         case 144 /* TO_OCTAL */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.hexValue(v.toNumber(), "oct"));
+          const toOctalFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (toOctalFault) {
+            stack.push(toOctalFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.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 converter = chunkBXKJLM5R_cjs.asConverterRegistry.get(name);
+          const converterFault = chunkJMXUNXQS_cjs.faultedOperand(value);
+          if (converterFault) {
+            stack.push(converterFault);
+            break;
+          }
+          const converter = chunk6WFMPTGB_cjs.asConverterRegistry.get(name);
           if (!converter) {
-            stack.push(chunkOC6LTXYS_cjs.errorValue("UNKNOWN_AS_CONVERTER", `Unknown converter "as ${name}"`));
+            stack.push(chunkJMXUNXQS_cjs.errorValue("UNKNOWN_AS_CONVERTER", `Unknown converter "as ${name}"`));
           } else {
             stack.push(converter(value));
           }
@@ -1204,72 +1930,98 @@ 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(chunkOC6LTXYS_cjs.uomValue(val, unit));
+          const unit = stringOperand(safePop(stack), op, "unit name");
+          const operand = safePop(stack);
+          const faulted = chunkJMXUNXQS_cjs.faultedOperand(operand);
+          if (faulted) {
+            stack.push(faulted);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.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 measure = chunkNJTXJ5AG_cjs.getMeasure(fromUnit);
-          const isCurrency = chunk2MV4HBKC_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunk2MV4HBKC_cjs.sharedCurrencyExchange.isCurrency(toUnit);
-          if (measure && chunkNJTXJ5AG_cjs.getMeasure(toUnit) === measure) {
-            stack.push(chunkOC6LTXYS_cjs.uomValue(chunkNJTXJ5AG_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
+          const toUnit = stringOperand(safePop(stack), op, "target unit name");
+          const fromUnit = stringOperand(safePop(stack), op, "source unit name");
+          const operand = safePop(stack);
+          const faulted = chunkJMXUNXQS_cjs.faultedOperand(operand);
+          if (faulted) {
+            stack.push(faulted);
+            break;
+          }
+          const val = operand.toNumber();
+          const measure = chunkPFUESQTW_cjs.getMeasure(fromUnit);
+          const isCurrency = chunkA2N2GFCG_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunkA2N2GFCG_cjs.sharedCurrencyExchange.isCurrency(toUnit);
+          if (measure && chunkPFUESQTW_cjs.getMeasure(toUnit) === measure) {
+            stack.push(chunkJMXUNXQS_cjs.uomValue(chunkPFUESQTW_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
           } else if (isCurrency) {
-            const converted = chunk2MV4HBKC_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
+            const converted = chunkA2N2GFCG_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
             if (converted !== null) {
-              stack.push(chunkOC6LTXYS_cjs.uomValue(converted, toUnit));
+              stack.push(chunkJMXUNXQS_cjs.uomValue(converted, toUnit));
             } else {
-              stack.push(chunkOC6LTXYS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
+              stack.push(chunkJMXUNXQS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
             }
           } else {
-            stack.push(chunkOC6LTXYS_cjs.uomValue(val, fromUnit));
+            stack.push(incompatibleConversionError(fromUnit, toUnit));
           }
           break;
         }
         case 85 /* UOM_POSSIBILITIES */: {
-          const unit = safePop(stack).value;
-          const possibilities = chunkNJTXJ5AG_cjs.getConvertiblePossibilities(unit);
-          stack.push(chunkOC6LTXYS_cjs.stringValue(possibilities.length > 0 ? possibilities.join(", ") : `No known units for "${unit}"`));
+          const unit = stringOperand(safePop(stack), op, "unit name");
+          const possibilities = chunkPFUESQTW_cjs.getConvertiblePossibilities(unit);
+          stack.push(chunkJMXUNXQS_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 } = chunkNJTXJ5AG_cjs.getBestUnit(val, unit);
-          stack.push(chunkOC6LTXYS_cjs.uomValue(value, bestUnit));
+          const unit = stringOperand(safePop(stack), op, "unit name");
+          const operand = safePop(stack);
+          const faulted = chunkJMXUNXQS_cjs.faultedOperand(operand);
+          if (faulted) {
+            stack.push(faulted);
+            break;
+          }
+          const { value, unit: bestUnit } = chunkPFUESQTW_cjs.getBestUnit(operand.toNumber(), unit);
+          stack.push(chunkJMXUNXQS_cjs.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 = chunkJMXUNXQS_cjs.faultedOperand(left);
+          if (faulted) {
+            stack.push(faulted);
+            break;
+          }
           if (left.type === 6 /* Uom */) {
             const fromUnit = left.unit;
             const val = left.toNumber();
-            const measure = chunkNJTXJ5AG_cjs.getMeasure(fromUnit);
-            const isCurrency = chunk2MV4HBKC_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunk2MV4HBKC_cjs.sharedCurrencyExchange.isCurrency(toUnit);
-            if (measure && chunkNJTXJ5AG_cjs.getMeasure(toUnit) === measure) {
-              stack.push(chunkOC6LTXYS_cjs.uomValue(chunkNJTXJ5AG_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
+            const measure = chunkPFUESQTW_cjs.getMeasure(fromUnit);
+            const isCurrency = chunkA2N2GFCG_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunkA2N2GFCG_cjs.sharedCurrencyExchange.isCurrency(toUnit);
+            if (measure && chunkPFUESQTW_cjs.getMeasure(toUnit) === measure) {
+              stack.push(chunkJMXUNXQS_cjs.uomValue(chunkPFUESQTW_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
             } else if (isCurrency) {
-              const converted = chunk2MV4HBKC_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
+              const converted = chunkA2N2GFCG_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
               if (converted !== null) {
-                stack.push(chunkOC6LTXYS_cjs.uomValue(converted, toUnit));
+                stack.push(chunkJMXUNXQS_cjs.uomValue(converted, toUnit));
               } else {
-                stack.push(chunkOC6LTXYS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
+                stack.push(chunkJMXUNXQS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
               }
             } else {
-              stack.push(left);
+              stack.push(incompatibleConversionError(fromUnit, toUnit));
             }
           } else {
-            stack.push(chunkOC6LTXYS_cjs.uomValue(left.toNumber(), toUnit));
+            stack.push(chunkJMXUNXQS_cjs.uomValue(left.toNumber(), toUnit));
           }
           break;
         }
         case 82 /* UOM_GET_VALUE */: {
           const v = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.numberValue(v.toNumber()));
+          const getValueFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          if (getValueFault) {
+            stack.push(getValueFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.numberValue(v.toNumber()));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -1279,89 +2031,125 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         case 110 /* RATE_DIV */: {
           const denominatorVal = safePop(stack);
           const numeratorVal = safePop(stack);
+          const rateDivFault = chunkJMXUNXQS_cjs.faultedOperand(numeratorVal, denominatorVal);
+          if (rateDivFault) {
+            stack.push(rateDivFault);
+            break;
+          }
           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'));
+            stack.push(chunkJMXUNXQS_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));
+          stack.push(chunkJMXUNXQS_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")'));
+          const rateMulFault = chunkJMXUNXQS_cjs.faultedOperand(rate, multiplier);
+          if (rateMulFault) {
+            stack.push(rateMulFault);
+            break;
+          }
+          if (rate.type !== 6 /* Uom */ || !chunkJMXUNXQS_cjs.isRateUnit(rate.unit)) {
+            stack.push(chunkJMXUNXQS_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"));
+            stack.push(chunkJMXUNXQS_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 newDenominatorUnit = stringOperand(safePop(stack), op, "denominator unit name");
           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"));
+          const rateConvertFault = chunkJMXUNXQS_cjs.faultedOperand(rate);
+          if (rateConvertFault) {
+            stack.push(rateConvertFault);
             break;
           }
-          const { numerator, denominator } = chunkOC6LTXYS_cjs.splitRateUnit(rate.unit);
-          const rateMeasure = chunkNJTXJ5AG_cjs.getMeasure(denominator);
-          const targetMeasure = chunkNJTXJ5AG_cjs.getMeasure(newDenominatorUnit);
+          if (rate.type !== 6 /* Uom */ || !chunkJMXUNXQS_cjs.isRateUnit(rate.unit)) {
+            stack.push(chunkJMXUNXQS_cjs.errorValue("RATE_CONVERT_NOT_A_RATE", "Cannot convert a non-rate value's denominator"));
+            break;
+          }
+          const { numerator, denominator } = chunkJMXUNXQS_cjs.splitRateUnit(rate.unit);
+          const rateMeasure = chunkPFUESQTW_cjs.getMeasure(denominator);
+          const targetMeasure = chunkPFUESQTW_cjs.getMeasure(newDenominatorUnit);
           if (!rateMeasure || rateMeasure !== targetMeasure) {
-            stack.push(chunkOC6LTXYS_cjs.errorValue(
+            stack.push(chunkJMXUNXQS_cjs.errorValue(
               "RATE_CONVERT_MEASURE_MISMATCH",
               `Cannot convert a "${denominator}"-denominated rate to "${newDenominatorUnit}" \u2014 different measures`
             ));
             break;
           }
-          const factor = chunkNJTXJ5AG_cjs.convertUnit(1, newDenominatorUnit, denominator);
-          stack.push(chunkOC6LTXYS_cjs.rateValue(rate.toNumber() * factor, numerator, newDenominatorUnit));
+          const factor = chunkPFUESQTW_cjs.convertUnit(1, newDenominatorUnit, denominator);
+          stack.push(chunkJMXUNXQS_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 minutesValue = safePop(stack);
+          const clockFault = chunkJMXUNXQS_cjs.faultedOperand(minutesValue);
+          if (clockFault) {
+            stack.push(clockFault);
+            break;
+          }
+          const totalMinutes = minutesValue.toNumber();
           const now = /* @__PURE__ */ new Date();
           const anchored = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
           anchored.setMinutes(totalMinutes);
-          stack.push(chunkOC6LTXYS_cjs.datetimeValue(anchored.getTime()));
+          stack.push(chunkJMXUNXQS_cjs.datetimeValue(anchored.getTime()));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
         // §9  Datetime  (OpCode 90–93)
         // ═══════════════════════════════════════════════════════════════
         case 90 /* DATE_NOW */:
-          stack.push(chunkOC6LTXYS_cjs.datetimeValue(Date.now()));
+          stack.push(chunkJMXUNXQS_cjs.datetimeValue(Date.now()));
           break;
         case 95 /* DATE_LITERAL */:
-          stack.push(chunkOC6LTXYS_cjs.datetimeValue(numbers[opcodes[ip++]]));
+          stack.push(chunkJMXUNXQS_cjs.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(chunkOC6LTXYS_cjs.datetimeValue(dtValue.toNumber() + extractDurationMs(durValue)));
+          const dateAddFault = chunkJMXUNXQS_cjs.faultedOperand(dtValue, durValue);
+          if (dateAddFault) {
+            stack.push(dateAddFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, 1, vm)));
           break;
         }
         case 92 /* DATE_SUB */: {
           const durValue = safePop(stack), dtValue = safePop(stack);
-          stack.push(chunkOC6LTXYS_cjs.datetimeValue(dtValue.toNumber() - extractDurationMs(durValue)));
+          const dateSubFault = chunkJMXUNXQS_cjs.faultedOperand(dtValue, durValue);
+          if (dateSubFault) {
+            stack.push(dateSubFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.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 = chunkJMXUNXQS_cjs.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(chunkOC6LTXYS_cjs.datetimeValue(op === 93 /* DATE_NEXT_WEEKDAY */ ? now + offsetMs : now - offsetMs));
+          stack.push(chunkJMXUNXQS_cjs.datetimeValue(addCalendarDays(now, op === 93 /* DATE_NEXT_WEEKDAY */ ? diffDays : -diffDays)));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -1373,133 +2161,119 @@ 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 = chunkJMXUNXQS_cjs.checkedArray(count, "matrix cells");
+          let cellFault = null;
           for (let i = count - 1; i >= 0; i--) {
             const cellVal = safePop(stack);
+            if (cellFault === null) cellFault = chunkJMXUNXQS_cjs.faultedOperand(cellVal);
             rowMajor[i] = cellVal.type === 10 /* Boolean */ ? cellVal.value : cellVal.type === 9 /* Symbolic */ ? cellVal.value : cellVal.toNumber();
           }
-          stack.push(chunkOC6LTXYS_cjs.matrixValue(rows, cols, chunk4CVLFLOB_cjs.rowMajorToColumnMajor(rows, cols, rowMajor)));
+          if (cellFault) {
+            stack.push(cellFault);
+            break;
+          }
+          stack.push(chunkJMXUNXQS_cjs.matrixValue(rows, cols, chunkUM6BVY2S_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);
+          const index1Fault = chunkJMXUNXQS_cjs.faultedOperand(matrixVal, indexVal);
+          if (index1Fault) {
+            stack.push(index1Fault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(chunkOC6LTXYS_cjs.errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot index a non-matrix value with "[...]".`));
+            stack.push(chunkJMXUNXQS_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(
+            stack.push(chunkJMXUNXQS_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 = chunk4CVLFLOB_cjs.matIndex(m, index);
-          stack.push(chunk4CVLFLOB_cjs.matrixEntryToValue(cell));
+          const cell = chunkUM6BVY2S_cjs.matIndex(m, index);
+          stack.push(chunkUM6BVY2S_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);
+          const index2Fault = chunkJMXUNXQS_cjs.faultedOperand(matrixVal, rowVal, colVal);
+          if (index2Fault) {
+            stack.push(index2Fault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(chunkOC6LTXYS_cjs.errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot index a non-matrix value with "[...]".`));
+            stack.push(chunkJMXUNXQS_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 (!chunk4CVLFLOB_cjs.inBounds(m, row, col)) {
-            stack.push(chunkOC6LTXYS_cjs.errorValue(
+          if (!chunkUM6BVY2S_cjs.inBounds(m, row, col)) {
+            stack.push(chunkJMXUNXQS_cjs.errorValue(
               "MATRIX_INDEX_OUT_OF_BOUNDS",
               `[${row}, ${col}] is out of bounds for a ${m.rows}x${m.cols} matrix.`
             ));
             break;
           }
-          const cell = chunk4CVLFLOB_cjs.matAt(m, row, col);
-          stack.push(chunk4CVLFLOB_cjs.matrixEntryToValue(cell));
+          const cell = chunkUM6BVY2S_cjs.matAt(m, row, col);
+          stack.push(chunkUM6BVY2S_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);
+          const rangeFault = chunkJMXUNXQS_cjs.faultedOperand(minVal, maxVal);
+          if (rangeFault) {
+            stack.push(rangeFault);
             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").`));
+            stack.push(chunkJMXUNXQS_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}".`));
+            stack.push(chunkJMXUNXQS_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(
+            stack.push(chunkJMXUNXQS_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));
+          stack.push(chunkJMXUNXQS_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);
+          const sliceFault = chunkJMXUNXQS_cjs.faultedOperand(matrixVal, rowRangeVal, colRangeVal);
+          if (sliceFault) {
+            stack.push(sliceFault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(chunkOC6LTXYS_cjs.errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot slice a non-matrix value with "[...]".`));
+            stack.push(chunkJMXUNXQS_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]").`));
+            stack.push(chunkJMXUNXQS_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(
+            stack.push(chunkJMXUNXQS_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.`
             ));
@@ -1507,13 +2281,13 @@ 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 = chunkJMXUNXQS_cjs.checkedArray(newRows * newCols, "matrix cells");
           for (let r = 0; r < newRows; r++) {
             for (let c = 0; c < newCols; c++) {
-              data[r + c * newRows] = chunk4CVLFLOB_cjs.matAt(m, rowRange.min + r, colRange.min + c);
+              data[r + c * newRows] = chunkUM6BVY2S_cjs.matAt(m, rowRange.min + r, colRange.min + c);
             }
           }
-          stack.push(chunkOC6LTXYS_cjs.matrixValue(newRows, newCols, data));
+          stack.push(chunkJMXUNXQS_cjs.matrixValue(newRows, newCols, data));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -1525,9 +2299,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 = [];
@@ -1535,7 +2310,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (kind === 0) {
             const def = anonymousBodies?.[ref];
             if (!def) {
-              throw chunkM4N5GA5Z_cjs.ErrorFactory.internal(
+              throw chunk5KMIY374_cjs.ErrorFactory.internal(
                 "INTERNAL_MISSING_ANONYMOUS_BODY",
                 `Internal error: MAP_INVOKE referenced missing anonymous body index ${ref}`,
                 { ref }
@@ -1544,14 +2319,14 @@ 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(chunkOC6LTXYS_cjs.errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
+              stack.push(chunkJMXUNXQS_cjs.errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
               break;
             }
             if (fn.params.length !== collectionCount) {
-              stack.push(chunkOC6LTXYS_cjs.errorValue(
+              stack.push(chunkJMXUNXQS_cjs.errorValue(
                 "FUNCTION_ARITY_MISMATCH",
                 `map: "${name}" expects ${fn.params.length} argument(s) but ${collectionCount} collection(s) were given`
               ));
@@ -1564,15 +2339,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const cellArrays = new Array(collectionCount);
           let mapEarlyError;
           for (let i = 0; i < collectionCount; i++) {
-            const resolved = chunk4CVLFLOB_cjs.collectionToValues(rawCollections[i]);
+            const resolved = chunkUM6BVY2S_cjs.collectionToValues(rawCollections[i], vm.getMaxCollectionSize());
             if (!Array.isArray(resolved)) {
               mapEarlyError = resolved;
               break;
             }
+            chunkJMXUNXQS_cjs.chargeAllocation(resolved.length, "collection elements");
             if (collectionLength === -1) {
               collectionLength = resolved.length;
             } else if (resolved.length !== collectionLength) {
-              mapEarlyError = chunkOC6LTXYS_cjs.errorValue(
+              mapEarlyError = chunkJMXUNXQS_cjs.errorValue(
                 "MAP_COLLECTION_LENGTH_MISMATCH",
                 `map: all collections must have the same length (got ${collectionLength} and ${resolved.length}).`
               );
@@ -1584,14 +2360,15 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(mapEarlyError);
             break;
           }
-          const resultData = new Array(collectionLength);
+          const resultData = chunkJMXUNXQS_cjs.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 ? chunkBXKJLM5R_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;
+            const resultVal = kind === 1 ? chunk6WFMPTGB_cjs.builtinFunctions[ref]?.(args) ?? chunkJMXUNXQS_cjs.errorValue("UNKNOWN_BUILTIN_FUNCTION", `map: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
+            const resultFault = chunkJMXUNXQS_cjs.faultedOperand(resultVal);
+            if (resultFault) {
+              mapError = resultFault;
               break;
             }
             resultData[i] = resultVal.type === 10 /* Boolean */ ? resultVal.value : resultVal.type === 9 /* Symbolic */ ? resultVal.value : resultVal.toNumber();
@@ -1600,13 +2377,20 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(mapError);
             break;
           }
-          stack.push(chunkOC6LTXYS_cjs.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(chunkJMXUNXQS_cjs.matrixValue(sourceShape.rows, sourceShape.cols, resultData));
+          } else {
+            stack.push(chunkJMXUNXQS_cjs.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 = [];
@@ -1614,7 +2398,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (kind === 0) {
             const def = anonymousBodies?.[ref];
             if (!def) {
-              throw chunkM4N5GA5Z_cjs.ErrorFactory.internal(
+              throw chunk5KMIY374_cjs.ErrorFactory.internal(
                 "INTERNAL_MISSING_ANONYMOUS_BODY",
                 `Internal error: REDUCE_INVOKE referenced missing anonymous body index ${ref}`,
                 { ref }
@@ -1623,14 +2407,14 @@ 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(chunkOC6LTXYS_cjs.errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
+              stack.push(chunkJMXUNXQS_cjs.errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
               break;
             }
             if (fn.params.length !== 2) {
-              stack.push(chunkOC6LTXYS_cjs.errorValue(
+              stack.push(chunkJMXUNXQS_cjs.errorValue(
                 "FUNCTION_ARITY_MISMATCH",
                 `reduce: "${name}" must take exactly 2 arguments (accumulator, element), got ${fn.params.length}`
               ));
@@ -1639,23 +2423,25 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             paramNames = fn.params;
             program = fn.program;
           }
-          const cells = chunk4CVLFLOB_cjs.collectionToValues(collectionVal);
+          const cells = chunkUM6BVY2S_cjs.collectionToValues(collectionVal, vm.getMaxCollectionSize());
           if (!Array.isArray(cells)) {
             stack.push(cells);
             break;
           }
+          chunkJMXUNXQS_cjs.chargeAllocation(cells.length, "collection elements");
           let acc;
           let startIdx;
           if (initialVal !== void 0) {
-            if (initialVal.type === 13 /* Error */) {
-              stack.push(initialVal);
+            const initialFault = chunkJMXUNXQS_cjs.faultedOperand(initialVal);
+            if (initialFault) {
+              stack.push(initialFault);
               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.`));
+              stack.push(chunkJMXUNXQS_cjs.errorValue("REDUCE_EMPTY_COLLECTION", `reduce: cannot reduce an empty collection without an initial value.`));
               break;
             }
             acc = cells[0];
@@ -1664,9 +2450,10 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           let reduceError;
           for (let i = startIdx; i < cells.length; i++) {
             const args = [acc, cells[i]];
-            const resultVal = kind === 1 ? chunkBXKJLM5R_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;
+            const resultVal = kind === 1 ? chunk6WFMPTGB_cjs.builtinFunctions[ref]?.(args) ?? chunkJMXUNXQS_cjs.errorValue("UNKNOWN_BUILTIN_FUNCTION", `reduce: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
+            const stepFault = chunkJMXUNXQS_cjs.faultedOperand(resultVal);
+            if (stepFault) {
+              reduceError = stepFault;
               break;
             }
             acc = resultVal;
@@ -1678,12 +2465,30 @@ 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 chunk5KMIY374_cjs.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 ? chunkOC6LTXYS_cjs.persistentValue(fallback) : fallback };
+    return { type: "value", value: hasArena ? chunkJMXUNXQS_cjs.persistentValue(fallback) : fallback };
   } catch (e) {
-    return { type: "error", error: chunkM4N5GA5Z_cjs.normalizeUnknownError(e) };
+    return { type: "error", error: chunk5KMIY374_cjs.normalizeUnknownError(e) };
+  } finally {
+    chunkJMXUNXQS_cjs.endEvaluation();
   }
 }
 
@@ -1691,5 +2496,5 @@ exports.DependencyGraph = DependencyGraph;
 exports.ScopeManager = ScopeManager;
 exports.createVM = createVM;
 exports.executeBytecode = executeBytecode;
-//# sourceMappingURL=chunk-QDMPOAI7.cjs.map
-//# sourceMappingURL=chunk-QDMPOAI7.cjs.map
+//# sourceMappingURL=chunk-HDP7VK3C.cjs.map
+//# sourceMappingURL=chunk-HDP7VK3C.cjs.map