solve-engine 1.0.1 → 1.1.0

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

@@ -1,14 +1,14 @@
 'use strict';
 
-var chunk47LRVGOT_cjs = require('./chunk-47LRVGOT.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 chunkXA4CKRML_cjs = require('./chunk-XA4CKRML.cjs');
+var chunk7ZX6B7SY_cjs = require('./chunk-7ZX6B7SY.cjs');
+var chunkZVTWQLK4_cjs = require('./chunk-ZVTWQLK4.cjs');
+var chunkXIYYHA65_cjs = require('./chunk-XIYYHA65.cjs');
+var chunkHIQ5HSZL_cjs = require('./chunk-HIQ5HSZL.cjs');
+var chunk2TZKENDH_cjs = require('./chunk-2TZKENDH.cjs');
+var chunkEJ3ILXX6_cjs = require('./chunk-EJ3ILXX6.cjs');
 var chunkAMOJYLG2_cjs = require('./chunk-AMOJYLG2.cjs');
-var chunk5KMIY374_cjs = require('./chunk-5KMIY374.cjs');
+var chunkB4HBEFTB_cjs = require('./chunk-B4HBEFTB.cjs');
 
 // src/vm/DependencyGraph.ts
 var DependencyGraph = class {
@@ -332,6 +332,47 @@ var ScopeManager = class {
   }
 };
 
+// src/vm/BusinessDays.ts
+var MS_PER_DAY = 864e5;
+function isWeekend(epochMs) {
+  const day = new Date(epochMs).getDay();
+  return day === 0 || day === 6;
+}
+function isBusinessDay(epochMs, isHoliday) {
+  if (isWeekend(epochMs)) return false;
+  return isHoliday ? !isHoliday(epochMs) : true;
+}
+function startOfLocalDay(epochMs) {
+  const d = new Date(epochMs);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+function addBusinessDays(startMs, n, isHoliday, maxCalendarSteps) {
+  let remaining = Math.trunc(Math.abs(n));
+  const direction = n >= 0 ? 1 : -1;
+  const date = new Date(startMs);
+  let steps = 0;
+  while (remaining > 0) {
+    date.setDate(date.getDate() + direction);
+    steps++;
+    if (steps > maxCalendarSteps) return null;
+    if (isBusinessDay(date.getTime(), isHoliday)) remaining--;
+  }
+  return date.getTime();
+}
+function countBusinessDaysBetween(aMs, bMs, isHoliday, maxCalendarSteps) {
+  const startDay = startOfLocalDay(Math.min(aMs, bMs));
+  const endDay = startOfLocalDay(Math.max(aMs, bMs));
+  const spanDays = Math.round((endDay - startDay) / MS_PER_DAY);
+  if (spanDays > maxCalendarSteps) return null;
+  let count = 0;
+  const date = new Date(startDay);
+  for (let i = 0; i <= spanDays; i++) {
+    if (isBusinessDay(date.getTime(), isHoliday)) count++;
+    date.setDate(date.getDate() + 1);
+  }
+  return count;
+}
+
 // src/vm/VMBuiltinArity.ts
 var BUILTIN_ARITY = {
   0: { name: "sqrt", min: 1, max: 1 },
@@ -342,7 +383,7 @@ var BUILTIN_ARITY = {
   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 },
+  8: { name: "round", min: 1, max: 2 },
   // min/max compare as many operands as they are given.
   9: { name: "min", min: 1, max: Infinity },
   10: { name: "max", min: 1, max: Infinity },
@@ -456,7 +497,7 @@ 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(
+  return chunkB4HBEFTB_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 }
@@ -464,7 +505,7 @@ function builtinArityError(index, argCount) {
 }
 
 // src/vm/VM.ts
-function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, maxCollectionSize = 1e5, maxAllocatedElements = 2e6, maxFunctionCalls = 1e4, maxDateOffsetYears = 100, minDateOffsetYears = -100, context = chunk6WFMPTGB_cjs.defaultEngineContext) {
+function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, maxCollectionSize = 1e5, maxAllocatedElements = 2e6, maxFunctionCalls = 1e4, maxDateOffsetYears = 100, minDateOffsetYears = -100, context = chunk7ZX6B7SY_cjs.defaultEngineContext, holidayPredicate) {
   const stack = [];
   const variables = /* @__PURE__ */ new Map();
   let instructionCount = 0;
@@ -498,9 +539,15 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     getMinDateOffsetYears() {
       return minDateOffsetYears;
     },
+    // False whenever no calendar was configured, which is what makes
+    // unconfigured working-day arithmetic weekends-only. See
+    // vm/BusinessDays.ts, the only reader.
+    isHoliday(epochMs) {
+      return holidayPredicate ? holidayPredicate(epochMs) : false;
+    },
     pop() {
       if (stack.length === 0) {
-        return chunkJMXUNXQS_cjs.numberValue(0);
+        return chunk2TZKENDH_cjs.numberValue(0);
       }
       return stack.pop();
     },
@@ -548,7 +595,7 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     },
     pushCallFrame(frame) {
       if (callFrames.length >= maxFunctionRecursionDepth) {
-        throw chunk5KMIY374_cjs.ErrorFactory.execution(
+        throw chunkB4HBEFTB_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 }
@@ -571,6 +618,12 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     hasUserFunction(name) {
       return userFunctions.has(name);
     },
+    getVariableEntries() {
+      return Array.from(variables.entries());
+    },
+    getUserFunctionDefs() {
+      return Array.from(userFunctions.values());
+    },
     defineEquation(variable, factorNames, rhsProgram) {
       equations.set(variable, { variable, factorNames, rhsProgram });
     },
@@ -625,7 +678,7 @@ function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunct
     incrementInstructions(n) {
       instructionCount += n;
       if (instructionCount > maxInstructions) {
-        throw chunk5KMIY374_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
+        throw chunkB4HBEFTB_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
       }
     }
   };
@@ -643,7 +696,7 @@ function matrixPowerCells(m, exponent) {
 }
 function safePop(stack) {
   if (stack.length === 0) {
-    throw chunk5KMIY374_cjs.ErrorFactory.internal({
+    throw chunkB4HBEFTB_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",
@@ -655,11 +708,11 @@ function safePop(stack) {
 }
 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;
+  return typeof site === "number" ? chunkXIYYHA65_cjs.getOpCodeName(site) : site;
 }
 function malformedBytecode(code, site, problem, expected, found, context = {}) {
   const name = siteName(site);
-  return chunk5KMIY374_cjs.ErrorFactory.validation({
+  return chunkB4HBEFTB_cjs.ErrorFactory.validation({
     code,
     message: `Malformed bytecode: ${name} ${problem}`,
     expected,
@@ -723,7 +776,7 @@ function stringOperand(value, site, role) {
       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`,
+      `a ${chunk2TZKENDH_cjs.ValueType[value.type] ?? "unknown"} value`,
       role ? { role, valueType: value.type } : { valueType: value.type }
     );
   }
@@ -782,7 +835,7 @@ function invokeFrameBody(params, program, args, vm, pipeline, expression, contex
     vm.popCallFrame();
   }
   if (bodyResult.type === "pending") {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution(
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
       "MAP_REDUCE_ASYNC_UNSUPPORTED",
       `map/reduce transform bodies calling an async operation (weather, stocks, currency, ...) aren't supported`
     );
@@ -794,7 +847,7 @@ function invokeFrameBody(params, program, args, vm, pipeline, expression, contex
 }
 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)));
+  frame.set(name, chunk2TZKENDH_cjs.symbolicValue(chunkHIQ5HSZL_cjs.varNode(name)));
   vm.pushCallFrame(frame);
   let bodyResult;
   try {
@@ -803,7 +856,7 @@ function invokeWithBoundUnknown(name, program, vm, pipeline, expression, context
     vm.popCallFrame();
   }
   if (bodyResult.type === "pending") {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution(
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
       "SYMBOLIC_ASYNC_UNSUPPORTED",
       `an algebra verb's expression cannot call an async operation (weather, stocks, currency, ...)`
     );
@@ -834,31 +887,64 @@ 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 = chunkUM6BVY2S_cjs.CURRENCY_DISPLAY[leftUnit.toUpperCase()] !== void 0;
-  const rightIsMoney = chunkUM6BVY2S_cjs.CURRENCY_DISPLAY[rightUnit.toUpperCase()] !== void 0;
+  const leftIsMoney = chunkHIQ5HSZL_cjs.CURRENCY_DISPLAY[leftUnit.toUpperCase()] !== void 0;
+  const rightIsMoney = chunkHIQ5HSZL_cjs.CURRENCY_DISPLAY[rightUnit.toUpperCase()] !== void 0;
   if (leftIsMoney === rightIsMoney) return null;
-  return chunkJMXUNXQS_cjs.uomValue(l.toNumber() * r.toNumber(), leftIsMoney ? leftUnit : rightUnit);
+  return chunk2TZKENDH_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);
+      return chunk7ZX6B7SY_cjs.scaleMoneyByPercent(r, r.unit, l.toNumber(), sign);
     }
     if (r.type !== 5 /* Percentage */ && r.type !== 0 /* Number */) return null;
-    return chunkJMXUNXQS_cjs.percentageValue(l.toNumber() + sign * r.toNumber());
+    return chunk2TZKENDH_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 chunkJMXUNXQS_cjs.numberValue(l.toNumber() * factor);
-  if (l.type === 6 /* Uom */ && l.unit !== void 0) return chunkJMXUNXQS_cjs.uomValue(l.toNumber() * factor, l.unit);
+  if (l.type === 0 /* Number */) {
+    const scaled = l.toNumber() * factor;
+    if (l.uncertainty !== void 0) return chunk2TZKENDH_cjs.numberValueUncertain(scaled, Math.abs(l.uncertainty * factor));
+    return chunk2TZKENDH_cjs.numberValue(scaled);
+  }
+  if (l.type === 6 /* Uom */ && l.unit !== void 0) return chunk7ZX6B7SY_cjs.scaleMoneyByPercent(l, l.unit, r.toNumber(), sign);
+  return null;
+}
+function multiplyPercentWithUncertainty(l, r) {
+  const pct = l.type === 5 /* Percentage */ ? l : r.type === 5 /* Percentage */ ? r : null;
+  if (pct === null) return null;
+  const other = pct === l ? r : l;
+  if (other.type !== 0 /* Number */ || other.uncertainty === void 0) return null;
+  const factor = pct.toNumber();
+  return chunk2TZKENDH_cjs.numberValueUncertain(other.toNumber() * factor, Math.abs(other.uncertainty * factor));
+}
+function multiplyMoneyByScalarExact(l, r) {
+  const money = l.type === 6 /* Uom */ ? l : r;
+  const scalar = l.type === 6 /* Uom */ ? r : l;
+  if (money.type !== 6 /* Uom */ || money.unit === void 0 || !chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(money.unit)) return null;
+  if (scalar.type !== 0 /* Number */ && scalar.type !== 5 /* Percentage */) return null;
+  if (scalar.rational !== void 0) return null;
+  return chunk7ZX6B7SY_cjs.scaleMoneyExact(money, scalar.toNumber(), money.unit);
+}
+function dividePercentWithUncertainty(l, r) {
+  if (r.type === 5 /* Percentage */ && l.type === 0 /* Number */ && l.uncertainty !== void 0) {
+    const factor = r.toNumber();
+    if (factor === 0) return null;
+    return chunk2TZKENDH_cjs.numberValueUncertain(l.toNumber() / factor, Math.abs(l.uncertainty / factor));
+  }
+  if (l.type === 5 /* Percentage */ && r.type === 0 /* Number */ && r.uncertainty !== void 0) {
+    const b = r.toNumber();
+    if (b === 0) return null;
+    return chunk2TZKENDH_cjs.numberValueUncertain(l.toNumber() / b, Math.abs(l.toNumber() * r.uncertainty / (b * b)));
+  }
   return null;
 }
 function extractDurationMs(value) {
   if (value.type === 6 /* Uom */) {
     const unit = value.unit;
-    if (unit && chunkPFUESQTW_cjs.getMeasure(unit) === "time") {
+    if (unit && chunkEJ3ILXX6_cjs.getMeasure(unit) === "time") {
       try {
-        return chunkPFUESQTW_cjs.convertUnit(value.toNumber(), unit, "ms");
+        return chunkEJ3ILXX6_cjs.convertUnit(value.toNumber(), unit, "ms");
       } catch {
       }
     }
@@ -867,27 +953,30 @@ function extractDurationMs(value) {
   return value.toNumber();
 }
 var WORKDAYS_PER_YEAR = 260;
-function addBusinessDays(epochMs, n, vm) {
-  let remaining = Math.trunc(Math.abs(n));
+function addBusinessDays2(epochMs, n, vm) {
+  const remaining = Math.trunc(Math.abs(n));
   const direction = n >= 0 ? 1 : -1;
   const limitYears = direction > 0 ? vm.getMaxDateOffsetYears() : -vm.getMinDateOffsetYears();
   const limitWorkdays = Math.floor(limitYears * WORKDAYS_PER_YEAR);
   if (remaining > limitWorkdays) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution(
+    throw chunkB4HBEFTB_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();
-    if (day !== 0 && day !== 6) remaining--;
+  const maxCalendarSteps = limitWorkdays * 7 + 7;
+  const landed = addBusinessDays(epochMs, n, (ms) => vm.isHoliday(ms), maxCalendarSteps);
+  if (landed === null) {
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
+      "DATE_OFFSET_LIMIT_EXCEEDED",
+      `A working-day offset of ${remaining.toLocaleString("en-US")} could not be reached within the ${limitYears}-year limit; the configured holiday calendar leaves too few working days`,
+      { requestedWorkdays: remaining, limitYears, maxCalendarSteps }
+    );
   }
-  return date.getTime();
+  return landed;
 }
-var MS_PER_DAY = 864e5;
+var MS_PER_DAY2 = 864e5;
 var CALENDAR_MONTHS_PER_UNIT = {
   month: 1,
   months: 1,
@@ -913,8 +1002,8 @@ function addCalendarDays(epochMs, 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;
+  if (Number.isNaN(shifted)) return epochMs + days * MS_PER_DAY2;
+  return shifted + (days - whole) * MS_PER_DAY2;
 }
 function addCalendarMonths(epochMs, months) {
   const whole = Math.trunc(months);
@@ -924,7 +1013,7 @@ function addCalendarMonths(epochMs, months) {
   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");
+  const monthMs = chunkEJ3ILXX6_cjs.convertUnit(1, "month", "ms");
   if (Number.isNaN(shifted)) return epochMs + months * monthMs;
   return shifted + (months - whole) * monthMs;
 }
@@ -932,13 +1021,13 @@ 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);
+    if (chunkEJ3ILXX6_cjs.isWorkdayUnit(unit)) return addBusinessDays2(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") {
+    if (chunkEJ3ILXX6_cjs.getMeasure(unit) === "time") {
       let daysPerUnit = 0;
       try {
-        daysPerUnit = chunkPFUESQTW_cjs.convertUnit(1, unit, "day");
+        daysPerUnit = chunkEJ3ILXX6_cjs.convertUnit(1, unit, "day");
       } catch {
       }
       if (Number.isInteger(daysPerUnit) && daysPerUnit >= 1) {
@@ -949,34 +1038,35 @@ function shiftDatetime(epochMs, duration, sign, vm) {
   return epochMs + sign * extractDurationMs(duration);
 }
 function combineTimecode(tc, r, sign) {
-  const fps = chunkJMXUNXQS_cjs.timecodeFps(tc.unit);
-  if (r.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isTimecodeUnit(r.unit)) {
-    const rFps = chunkJMXUNXQS_cjs.timecodeFps(r.unit);
+  const fps = chunk2TZKENDH_cjs.timecodeFps(tc.unit);
+  if (r.type === 6 /* Uom */ && chunk2TZKENDH_cjs.isTimecodeUnit(r.unit)) {
+    const rFps = chunk2TZKENDH_cjs.timecodeFps(r.unit);
     if (rFps !== fps) {
-      return chunkJMXUNXQS_cjs.errorValue(
+      return chunk2TZKENDH_cjs.errorValue(
         "TIMECODE_FPS_MISMATCH",
         `Cannot combine timecodes at different frame rates (${fps} fps vs ${rFps} fps)`
       );
     }
-    return sign === 1 ? chunkJMXUNXQS_cjs.uomValue(tc.toNumber() + r.toNumber(), tc.unit) : chunkJMXUNXQS_cjs.uomValue(tc.toNumber() - r.toNumber(), "frames");
+    return sign === 1 ? chunk2TZKENDH_cjs.uomValue(tc.toNumber() + r.toNumber(), tc.unit) : chunk2TZKENDH_cjs.uomValue(tc.toNumber() - r.toNumber(), "frames");
   }
   if (r.type === 6 /* Uom */ && r.unit === "frames") {
-    return chunkJMXUNXQS_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
+    return chunk2TZKENDH_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), 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);
+  if (r.type === 6 /* Uom */ && r.unit && chunkEJ3ILXX6_cjs.getMeasure(r.unit) === "time") {
+    const seconds = chunkEJ3ILXX6_cjs.convertUnit(r.toNumber(), r.unit, "s");
+    return chunk2TZKENDH_cjs.uomValue(tc.toNumber() + sign * seconds * fps, tc.unit);
   }
-  return chunkJMXUNXQS_cjs.uomValue(tc.toNumber() + sign * r.toNumber(), tc.unit);
+  return chunk2TZKENDH_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(
+  const named = chunk7ZX6B7SY_cjs.describeConversionMismatch(fromUnit, toUnit);
+  return chunk2TZKENDH_cjs.errorValue(
     "INCOMPATIBLE_UNITS",
-    `Cannot convert ${fromUnit} to ${toUnit}: they do not measure the same thing`
+    named ?? `Cannot convert ${fromUnit} to ${toUnit}: they do not measure the same thing`
   );
 }
 var MAX_EXACT_POW_BITS = 65536;
@@ -1008,32 +1098,32 @@ function bigIntBitLength(value) {
   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 value = chunk7ZX6B7SY_cjs.toBigIntOperand(l);
+  const shift = chunk7ZX6B7SY_cjs.toBigIntOperand(r);
+  if (value === 0n) return chunk2TZKENDH_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);
+    return chunk2TZKENDH_cjs.bigIntValue(direction === 1 ? value << shift : value >> shift);
   }
-  throw chunk5KMIY374_cjs.ErrorFactory.execution(
+  throw chunkB4HBEFTB_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 } = chunkJMXUNXQS_cjs.splitRateUnit(rate.unit);
-  const rateMeasure = chunkPFUESQTW_cjs.getMeasure(denominator);
-  const multiplierMeasure = chunkPFUESQTW_cjs.getMeasure(multiplier.unit);
+  const { numerator, denominator } = chunk2TZKENDH_cjs.splitRateUnit(rate.unit);
+  const rateMeasure = chunkEJ3ILXX6_cjs.getMeasure(denominator);
+  const multiplierMeasure = chunkEJ3ILXX6_cjs.getMeasure(multiplier.unit);
   if (!rateMeasure || rateMeasure !== multiplierMeasure) {
-    return chunkJMXUNXQS_cjs.errorValue(
+    return chunk2TZKENDH_cjs.errorValue(
       "RATE_MUL_MEASURE_MISMATCH",
       `Cannot multiply a "${denominator}"-denominated rate by "${multiplier.unit}" \u2014 different measures`
     );
   }
-  const multiplierInDenominatorUnit = chunkPFUESQTW_cjs.convertUnit(multiplier.toNumber(), multiplier.unit, denominator);
+  const multiplierInDenominatorUnit = chunkEJ3ILXX6_cjs.convertUnit(multiplier.toNumber(), multiplier.unit, denominator);
   const total = rate.toNumber() * multiplierInDenominatorUnit;
-  return numerator ? chunkJMXUNXQS_cjs.uomValue(total, numerator) : chunkJMXUNXQS_cjs.numberValue(total);
+  return numerator ? chunk2TZKENDH_cjs.uomValue(total, numerator) : chunk2TZKENDH_cjs.numberValue(total);
 }
 function toFractionString(n) {
   if (Number.isNaN(n)) return "NaN";
@@ -1062,6 +1152,9 @@ function toFractionString(n) {
   const numerator = whole * k1 + h1;
   return `${negative ? "-" : ""}${numerator}/${k1}`;
 }
+function rationalToFractionString(r) {
+  return r.d === 1n ? String(r.n) : `${r.n}/${r.d}`;
+}
 function toMultiplierString(value) {
   const n = value.toNumber();
   const multiple = value.type === 5 /* Percentage */ ? 1 + n : n;
@@ -1079,7 +1172,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
   if (unrunnable) {
     return {
       type: "error",
-      error: chunk5KMIY374_cjs.ErrorFactory.validation({
+      error: chunkB4HBEFTB_cjs.ErrorFactory.validation({
         code: "MALFORMED_BYTECODE_PROGRAM",
         message: `Malformed bytecode: ${unrunnable}`,
         expected: "a BytecodeProgram with opcodes, numbers and strings",
@@ -1095,16 +1188,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
   const maxStackDepth = vm.getMaxStackDepth();
   const stack = vm.getStack();
   const shouldTrace = pipeline?.hasCollectors ?? false;
-  const hasArena = chunkJMXUNXQS_cjs.isArenaActive();
-  if (opcodes.length === 0) return { type: "value", value: chunkJMXUNXQS_cjs.numberValue(0) };
-  chunkJMXUNXQS_cjs.beginEvaluation(vm);
+  const hasArena = chunk2TZKENDH_cjs.isArenaActive();
+  if (opcodes.length === 0) return { type: "value", value: chunk2TZKENDH_cjs.numberValue(0) };
+  chunk2TZKENDH_cjs.beginEvaluation(vm);
   try {
     while (ip < opcodes.length) {
       if (++localInstructionCount > maxInstructions) {
-        throw chunk5KMIY374_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
+        throw chunkB4HBEFTB_cjs.ErrorFactory.execution("INSTRUCTION_LIMIT_EXCEEDED", `Execution exceeded maximum of ${maxInstructions} instructions`);
       }
       if (stack.length > maxStackDepth) {
-        throw chunk5KMIY374_cjs.ErrorFactory.execution("STACK_LIMIT_EXCEEDED", `Execution exceeded maximum stack depth of ${maxStackDepth}`);
+        throw chunkB4HBEFTB_cjs.ErrorFactory.execution("STACK_LIMIT_EXCEEDED", `Execution exceeded maximum stack depth of ${maxStackDepth}`);
       }
       const op = opcodes[ip++];
       if (shouldTrace) {
@@ -1114,11 +1207,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           unit: v.unit
         }));
         pipeline.fireVmStep({
-          type: chunk47LRVGOT_cjs.DiagnosticEventType.VmStep,
+          type: chunkXA4CKRML_cjs.DiagnosticEventType.VmStep,
           elapsedNs: 0,
           expression: expression ?? "",
           opcode: op,
-          opcodeName: chunk6KFYJ6TD_cjs.getOpCodeName(op),
+          opcodeName: chunkXIYYHA65_cjs.getOpCodeName(op),
           ip: ip - 1,
           stackDepth: stack.length,
           instructionNumber: localInstructionCount,
@@ -1133,7 +1226,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           break;
         case 1 /* HALT */: {
           const result = safePop(stack);
-          return { type: "value", value: hasArena ? chunkJMXUNXQS_cjs.persistentValue(result) : result };
+          return { type: "value", value: hasArena ? chunk2TZKENDH_cjs.persistentValue(result) : result };
         }
         case 3 /* DUP */: {
           const top = safePop(stack);
@@ -1156,19 +1249,24 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // `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(chunkJMXUNXQS_cjs.numberValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
+          stack.push(chunk2TZKENDH_cjs.numberValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
         case 11 /* PUSH_BIGINT */:
-          stack.push(chunkJMXUNXQS_cjs.bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"), op)));
+          stack.push(chunk2TZKENDH_cjs.bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"), op)));
           break;
+        case 16 /* PUSH_DECIMAL */: {
+          const dec = chunkHIQ5HSZL_cjs.decimalFromLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"));
+          stack.push(chunk2TZKENDH_cjs.numberValueExact(chunkHIQ5HSZL_cjs.decimalToNumber(dec), dec));
+          break;
+        }
         case 12 /* PUSH_HEX */:
-          stack.push(chunkJMXUNXQS_cjs.hexValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
+          stack.push(chunk2TZKENDH_cjs.hexValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
         case 13 /* PUSH_STRING */:
-          stack.push(chunkJMXUNXQS_cjs.stringValue(poolString(opcodes, ip++, strings, op, "constant-pool index")));
+          stack.push(chunk2TZKENDH_cjs.stringValue(poolString(opcodes, ip++, strings, op, "constant-pool index")));
           break;
         case 14 /* PUSH_BOOLEAN */:
-          stack.push(chunkJMXUNXQS_cjs.boolValue(operandByte(opcodes, ip++, op, "boolean operand") === 1));
+          stack.push(chunk2TZKENDH_cjs.boolValue(operandByte(opcodes, ip++, op, "boolean operand") === 1));
           break;
         // ═══════════════════════════════════════════════════════════════
         // §3  Arithmetic  (OpCode 20–27)
@@ -1177,101 +1275,170 @@ 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);
+          const addFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (addFault) {
             stack.push(addFault);
             break;
           }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncAdd = chunk7ZX6B7SY_cjs.uncertainOp(l, r, "add");
+            if (uncAdd) {
+              stack.push(uncAdd);
+              break;
+            }
+          }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const ratAdd = chunk7ZX6B7SY_cjs.exactRationalOp(l, r, "add");
+            if (ratAdd) {
+              stack.push(ratAdd);
+              break;
+            }
+          }
           const pctAdd = combinePercentage(l, r, 1);
           const ratePeriodAdd = pctAdd === null ? unifyRatePeriods(l, r) : null;
           if (pctAdd !== null) {
             stack.push(pctAdd);
           } else if (ratePeriodAdd !== null) {
-            stack.push(chunkJMXUNXQS_cjs.uomValue(ratePeriodAdd + r.toNumber(), r.unit));
+            stack.push(chunk2TZKENDH_cjs.uomValue(ratePeriodAdd + r.toNumber(), r.unit));
           } else if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.value + r.value));
+            stack.push(chunk2TZKENDH_cjs.numberValue(l.value + r.value));
           } else if (l.type === 10 /* Boolean */ && r.type === 10 /* Boolean */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value && r.value));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.value && r.value));
           } else if (l.type === 4 /* Datetime */) {
             if (r.type === 4 /* Datetime */) {
-              stack.push(chunkJMXUNXQS_cjs.errorValue("INVALID_DATETIME_OP", "Cannot add two datetimes together"));
+              stack.push(chunk2TZKENDH_cjs.errorValue("INVALID_DATETIME_OP", "Cannot add two datetimes together"));
             } else {
-              stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(l.toNumber(), r, 1, vm)));
+              stack.push(chunk2TZKENDH_cjs.datetimeValue(shiftDatetime(l.toNumber(), r, 1, vm)));
             }
-          } else if (l.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isTimecodeUnit(l.unit)) {
+          } else if (l.type === 6 /* Uom */ && chunk2TZKENDH_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)));
+            stack.push(chunk2TZKENDH_cjs.datetimeValue(shiftDatetime(r.toNumber(), l, 1, vm)));
           } else {
-            stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a + b, (a, b) => a + b, "add"));
+            stack.push(chunk7ZX6B7SY_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);
+          const subFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (subFault) {
             stack.push(subFault);
             break;
           }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncSub = chunk7ZX6B7SY_cjs.uncertainOp(l, r, "sub");
+            if (uncSub) {
+              stack.push(uncSub);
+              break;
+            }
+          }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const ratSub = chunk7ZX6B7SY_cjs.exactRationalOp(l, r, "sub");
+            if (ratSub) {
+              stack.push(ratSub);
+              break;
+            }
+          }
           const pctSub = combinePercentage(l, r, -1);
           const ratePeriodSub = pctSub === null ? unifyRatePeriods(l, r) : null;
           if (pctSub !== null) {
             stack.push(pctSub);
           } else if (ratePeriodSub !== null) {
-            stack.push(chunkJMXUNXQS_cjs.uomValue(ratePeriodSub - r.toNumber(), r.unit));
+            stack.push(chunk2TZKENDH_cjs.uomValue(ratePeriodSub - r.toNumber(), r.unit));
           } else if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.value - r.value));
+            stack.push(chunk2TZKENDH_cjs.numberValue(l.value - r.value));
           } else if (l.type === 4 /* Datetime */) {
             if (r.type === 4 /* Datetime */) {
-              stack.push(chunkJMXUNXQS_cjs.uomValue(l.toNumber() - r.toNumber(), "ms"));
+              stack.push(chunk2TZKENDH_cjs.uomValue(l.toNumber() - r.toNumber(), "ms"));
             } else {
-              stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(l.toNumber(), r, -1, vm)));
+              stack.push(chunk2TZKENDH_cjs.datetimeValue(shiftDatetime(l.toNumber(), r, -1, vm)));
             }
-          } else if (l.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isTimecodeUnit(l.unit)) {
+          } else if (l.type === 6 /* Uom */ && chunk2TZKENDH_cjs.isTimecodeUnit(l.unit)) {
             stack.push(combineTimecode(l, r, -1));
           } else if (r.type === 4 /* Datetime */) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue(
+            stack.push(chunk2TZKENDH_cjs.errorValue(
               "INVALID_DATETIME_OP",
               "Cannot subtract a datetime from a value that is not a datetime"
             ));
           } else {
-            stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a - b, (a, b) => a - b, "sub"));
+            stack.push(chunk7ZX6B7SY_cjs.binaryOp(l, r, (a, b) => a - b, (a, b) => a - b, "sub"));
           }
           break;
         }
         case 22 /* MUL */: {
           const r = safePop(stack), l = safePop(stack);
+          const pctUnc = multiplyPercentWithUncertainty(l, r);
+          if (pctUnc) {
+            stack.push(pctUnc);
+            break;
+          }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncMul = chunk7ZX6B7SY_cjs.uncertainOp(l, r, "mul");
+            if (uncMul) {
+              stack.push(uncMul);
+              break;
+            }
+          }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const ratMul = chunk7ZX6B7SY_cjs.exactRationalOp(l, r, "mul");
+            if (ratMul) {
+              stack.push(ratMul);
+              break;
+            }
+          }
+          const moneyScalar = multiplyMoneyByScalarExact(l, r);
+          if (moneyScalar) {
+            stack.push(moneyScalar);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.value * r.value));
+            stack.push(chunk2TZKENDH_cjs.numberValue(l.value * r.value));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            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) {
+            chunk2TZKENDH_cjs.checkAllocation(matrixProductCells(l.value, r.value), "matrix cells");
+            stack.push(chunkHIQ5HSZL_cjs.matrixMultiply(l.value, r.value));
+          } else if (l.type === 6 /* Uom */ && chunk2TZKENDH_cjs.isRateUnit(l.unit) && r.type === 6 /* Uom */ && r.unit) {
             stack.push(multiplyRateByMatchingUom(l, r));
-          } else if (r.type === 6 /* Uom */ && chunkJMXUNXQS_cjs.isRateUnit(r.unit) && l.type === 6 /* Uom */ && l.unit) {
+          } else if (r.type === 6 /* Uom */ && chunk2TZKENDH_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(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a * b, (a, b) => a * b, "mul"));
+            stack.push(chunk7ZX6B7SY_cjs.binaryOp(l, r, (a, b) => a * b, (a, b) => a * b, "mul"));
           }
           break;
         }
         case 23 /* DIV */: {
           const r = safePop(stack), l = safePop(stack);
+          const pctDivUnc = dividePercentWithUncertainty(l, r);
+          if (pctDivUnc) {
+            stack.push(pctDivUnc);
+            break;
+          }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncDiv = chunk7ZX6B7SY_cjs.uncertainOp(l, r, "div");
+            if (uncDiv) {
+              stack.push(uncDiv);
+              break;
+            }
+          }
           if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { lv, rv, sameMeasure } = chunk6WFMPTGB_cjs.unifyUom(l, r);
+            const { lv, rv, sameMeasure } = chunk7ZX6B7SY_cjs.unifyUom(l, r);
             if (sameMeasure) {
-              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}`));
+              stack.push(chunk2TZKENDH_cjs.numberValue(lv / rv));
+            } else if (chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(l.unit) && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(r.unit)) {
+              stack.push(chunk2TZKENDH_cjs.errorValue("INCOMPATIBLE_UNITS", `Cannot combine incompatible units: ${l.unit} and ${r.unit}`));
             } else {
-              stack.push(chunkJMXUNXQS_cjs.rateValue(lv / rv, l.unit, r.unit));
+              stack.push(chunk2TZKENDH_cjs.rateValue(lv / rv, l.unit, r.unit));
             }
           } else {
-            stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a / b, (a, b) => {
-              if (b === 0n) throw chunk6WFMPTGB_cjs.bigIntDivisionByZero();
+            const ratDiv = chunk7ZX6B7SY_cjs.exactRationalOp(l, r, "div");
+            if (ratDiv) {
+              stack.push(ratDiv);
+              break;
+            }
+            stack.push(chunk7ZX6B7SY_cjs.binaryOp(l, r, (a, b) => a / b, (a, b) => {
+              if (b === 0n) throw chunk7ZX6B7SY_cjs.bigIntDivisionByZero();
               return a / b;
             }, "div"));
           }
@@ -1279,8 +1446,8 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 24 /* MOD */: {
           const r = safePop(stack), l = safePop(stack);
-          stack.push(chunk6WFMPTGB_cjs.binaryOp(l, r, (a, b) => a % b, (a, b) => {
-            if (b === 0n) throw chunk6WFMPTGB_cjs.bigIntDivisionByZero();
+          stack.push(chunk7ZX6B7SY_cjs.binaryOp(l, r, (a, b) => a % b, (a, b) => {
+            if (b === 0n) throw chunk7ZX6B7SY_cjs.bigIntDivisionByZero();
             return a % b;
           }));
           break;
@@ -1304,66 +1471,82 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             break;
           }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(chunk6WFMPTGB_cjs.power(l.value, r.value)));
+            stack.push(chunk2TZKENDH_cjs.numberValue(chunk7ZX6B7SY_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(
+              stack.push(chunk2TZKENDH_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.`
+                `^: a matrix may only be the base, raised to a whole number (as in "[1,2;3,4]^2"); "${chunk2TZKENDH_cjs.ValueType[l.type]} ^ ${chunk2TZKENDH_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));
+            chunk2TZKENDH_cjs.checkAllocation(matrixPowerCells(l.value, r.value), "matrix cells");
+            stack.push(chunkHIQ5HSZL_cjs.matrixPower(l.value, r.value));
             break;
           }
           if (l.type === 9 /* Symbolic */ || r.type === 9 /* Symbolic */) {
-            stack.push(chunk6WFMPTGB_cjs.symbolicPow(l, r));
+            stack.push(chunk7ZX6B7SY_cjs.symbolicPow(l, r));
             break;
           }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
             const powBits = exactPowBits(l, r.toNumber());
             if (powBits !== null) {
               if (powBits > MAX_EXACT_POW_BITS) {
-                throw chunk5KMIY374_cjs.ErrorFactory.execution(
+                throw chunkB4HBEFTB_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))));
+              stack.push(chunk2TZKENDH_cjs.bigIntValue(bigIntPow(chunk7ZX6B7SY_cjs.toBigIntOperand(l), chunk7ZX6B7SY_cjs.toBigIntOperand(r))));
               break;
             }
           }
-          stack.push(chunkJMXUNXQS_cjs.numberValue(chunk6WFMPTGB_cjs.power(l.toNumber(), r.toNumber())));
+          stack.push(chunk2TZKENDH_cjs.numberValue(chunk7ZX6B7SY_cjs.power(l.toNumber(), r.toNumber())));
           break;
         }
         case 26 /* NEG */: {
           const v = safePop(stack);
-          const negFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const negFault = chunk2TZKENDH_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()));
+          if (v.type === 2 /* BigInt */) stack.push(chunk2TZKENDH_cjs.bigIntValue(-v.value));
+          else if (v.type === 6 /* Uom */ && v.exact !== void 0) stack.push(chunk2TZKENDH_cjs.uomValueExact(-v.toNumber(), v.unit, chunkHIQ5HSZL_cjs.decimalNegate(v.exact)));
+          else if (v.type === 6 /* Uom */) stack.push(chunk2TZKENDH_cjs.uomValue(-v.toNumber(), v.unit));
+          else if (v.type === 5 /* Percentage */) stack.push(chunk2TZKENDH_cjs.percentageValue(-v.toNumber()));
+          else if (v.type === 9 /* Symbolic */) stack.push(chunk7ZX6B7SY_cjs.symbolicNeg(v));
+          else if (v.type === 0 /* Number */ && v.rational !== void 0) stack.push(chunk2TZKENDH_cjs.numberValueRational(-v.toNumber(), chunkHIQ5HSZL_cjs.rationalNeg(v.rational)));
+          else if (v.type === 0 /* Number */ && v.exact !== void 0) stack.push(chunk2TZKENDH_cjs.numberValueExact(-v.toNumber(), chunkHIQ5HSZL_cjs.decimalNegate(v.exact)));
+          else stack.push(chunk2TZKENDH_cjs.numberValue(-v.toNumber()));
           break;
         }
         case 27 /* POS */: {
           const v = safePop(stack);
-          const posFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const posFault = chunk2TZKENDH_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()));
+          if (v.type === 6 /* Uom */ && v.exact !== void 0) stack.push(chunk2TZKENDH_cjs.uomValueExact(v.toNumber(), v.unit, v.exact));
+          else if (v.type === 6 /* Uom */) stack.push(chunk2TZKENDH_cjs.uomValue(v.toNumber(), v.unit));
+          else if (v.type === 5 /* Percentage */) stack.push(chunk2TZKENDH_cjs.percentageValue(v.toNumber()));
+          else if (v.type === 0 /* Number */ && v.rational !== void 0) stack.push(chunk2TZKENDH_cjs.numberValueRational(v.toNumber(), v.rational));
+          else if (v.type === 0 /* Number */ && v.exact !== void 0) stack.push(chunk2TZKENDH_cjs.numberValueExact(v.toNumber(), v.exact));
+          else stack.push(chunk2TZKENDH_cjs.numberValue(v.toNumber()));
+          break;
+        }
+        case 28 /* MAKE_UNCERTAIN */: {
+          const spread = safePop(stack), center = safePop(stack);
+          const uncFault = chunk2TZKENDH_cjs.faultedOperand(center, spread);
+          if (uncFault) {
+            stack.push(uncFault);
+            break;
+          }
+          stack.push(chunk2TZKENDH_cjs.numberValueUncertain(center.toNumber(), Math.abs(spread.toNumber())));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -1376,7 +1559,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 30 /* LSHIFT */: {
           const r = safePop(stack), l = safePop(stack);
-          const shiftFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const shiftFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (shiftFault) {
             stack.push(shiftFault);
             break;
@@ -1384,13 +1567,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
             stack.push(bigIntShift(l, r, 1));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() << r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.numberValue(l.toNumber() << r.toNumber()));
           }
           break;
         }
         case 31 /* RSHIFT */: {
           const r = safePop(stack), l = safePop(stack);
-          const rshiftFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const rshiftFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (rshiftFault) {
             stack.push(rshiftFault);
             break;
@@ -1398,71 +1581,71 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
             stack.push(bigIntShift(l, r, -1));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() >> r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.numberValue(l.toNumber() >> r.toNumber()));
           }
           break;
         }
         case 32 /* URSHIFT */: {
           const r = safePop(stack), l = safePop(stack);
-          const urshiftFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const urshiftFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (urshiftFault) {
             stack.push(urshiftFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() >>> r.toNumber()));
+          stack.push(chunk2TZKENDH_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);
+          const andFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (andFault) {
             stack.push(andFault);
             break;
           }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkJMXUNXQS_cjs.bigIntValue(chunk6WFMPTGB_cjs.toBigIntOperand(l) & chunk6WFMPTGB_cjs.toBigIntOperand(r)));
+            stack.push(chunk2TZKENDH_cjs.bigIntValue(chunk7ZX6B7SY_cjs.toBigIntOperand(l) & chunk7ZX6B7SY_cjs.toBigIntOperand(r)));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() & r.toNumber()));
+            stack.push(chunk2TZKENDH_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);
+          const orFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (orFault) {
             stack.push(orFault);
             break;
           }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkJMXUNXQS_cjs.bigIntValue(chunk6WFMPTGB_cjs.toBigIntOperand(l) | chunk6WFMPTGB_cjs.toBigIntOperand(r)));
+            stack.push(chunk2TZKENDH_cjs.bigIntValue(chunk7ZX6B7SY_cjs.toBigIntOperand(l) | chunk7ZX6B7SY_cjs.toBigIntOperand(r)));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() | r.toNumber()));
+            stack.push(chunk2TZKENDH_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);
+          const xorFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (xorFault) {
             stack.push(xorFault);
             break;
           }
           if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-            stack.push(chunkJMXUNXQS_cjs.bigIntValue(chunk6WFMPTGB_cjs.toBigIntOperand(l) ^ chunk6WFMPTGB_cjs.toBigIntOperand(r)));
+            stack.push(chunk2TZKENDH_cjs.bigIntValue(chunk7ZX6B7SY_cjs.toBigIntOperand(l) ^ chunk7ZX6B7SY_cjs.toBigIntOperand(r)));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(l.toNumber() ^ r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.numberValue(l.toNumber() ^ r.toNumber()));
           }
           break;
         }
         case 36 /* BIT_NOT */: {
           const v = safePop(stack);
-          const notFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const notFault = chunk2TZKENDH_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()));
+          if (v.type === 2 /* BigInt */) stack.push(chunk2TZKENDH_cjs.bigIntValue(~v.value));
+          else stack.push(chunk2TZKENDH_cjs.numberValue(~v.toNumber()));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -1493,137 +1676,193 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 40 /* EQ */: {
           const r = safePop(stack), l = safePop(stack);
-          const eqFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const eqFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (eqFault) {
             stack.push(eqFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = chunk7ZX6B7SY_cjs.compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(chunk2TZKENDH_cjs.boolValue(cmp === 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value === r.value));
+            stack.push(chunk2TZKENDH_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));
+            const cmp = chunk7ZX6B7SY_cjs.compareBigIntOperands(l, r);
+            stack.push(chunk2TZKENDH_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));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.value === r.value));
           } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
-            stack.push(chunkJMXUNXQS_cjs.boolValue(sameMeasure && equal));
+            const { equal, sameMeasure } = chunk7ZX6B7SY_cjs.compareUom(l, r);
+            stack.push(chunk2TZKENDH_cjs.boolValue(sameMeasure && equal));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a === b));
+            stack.push(chunkHIQ5HSZL_cjs.matrixCompare(l.value, r.value, (a, b) => a === b));
+          } else if (l.type === 14 /* Colour */ || r.type === 14 /* Colour */) {
+            if (l.type === 14 /* Colour */ && r.type === 14 /* Colour */) {
+              const a = l.value, b = r.value;
+              stack.push(chunk2TZKENDH_cjs.boolValue(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a));
+            } else {
+              stack.push(chunk2TZKENDH_cjs.boolValue(false));
+            }
           } else {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() === r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.toNumber() === r.toNumber()));
           }
           break;
         }
         case 41 /* NEQ */: {
           const r = safePop(stack), l = safePop(stack);
-          const neqFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const neqFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (neqFault) {
             stack.push(neqFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = chunk7ZX6B7SY_cjs.compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(chunk2TZKENDH_cjs.boolValue(cmp !== 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value !== r.value));
+            stack.push(chunk2TZKENDH_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));
+            const cmp = chunk7ZX6B7SY_cjs.compareBigIntOperands(l, r);
+            stack.push(chunk2TZKENDH_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));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.value !== r.value));
           } else if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-            const { equal, sameMeasure } = chunk6WFMPTGB_cjs.compareUom(l, r);
-            stack.push(chunkJMXUNXQS_cjs.boolValue(!sameMeasure || !equal));
+            const { equal, sameMeasure } = chunk7ZX6B7SY_cjs.compareUom(l, r);
+            stack.push(chunk2TZKENDH_cjs.boolValue(!sameMeasure || !equal));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a !== b));
+            stack.push(chunkHIQ5HSZL_cjs.matrixCompare(l.value, r.value, (a, b) => a !== b));
+          } else if (l.type === 14 /* Colour */ || r.type === 14 /* Colour */) {
+            if (l.type === 14 /* Colour */ && r.type === 14 /* Colour */) {
+              const a = l.value, b = r.value;
+              stack.push(chunk2TZKENDH_cjs.boolValue(!(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a)));
+            } else {
+              stack.push(chunk2TZKENDH_cjs.boolValue(true));
+            }
           } else {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() !== r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.toNumber() !== r.toNumber()));
           }
           break;
         }
         case 42 /* LT */: {
           const r = safePop(stack), l = safePop(stack);
-          const ltFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const ltFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (ltFault) {
             stack.push(ltFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = chunk7ZX6B7SY_cjs.compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(chunk2TZKENDH_cjs.boolValue(cmp < 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value < r.value));
+            stack.push(chunk2TZKENDH_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));
+            const cmp = chunk7ZX6B7SY_cjs.compareBigIntOperands(l, r);
+            stack.push(chunk2TZKENDH_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));
+            const { lv, rv, equal, sameMeasure } = chunk7ZX6B7SY_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunk2TZKENDH_cjs.boolValue(!equal && lv < rv) : chunk7ZX6B7SY_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a < b));
+            stack.push(chunkHIQ5HSZL_cjs.matrixCompare(l.value, r.value, (a, b) => a < b));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() < r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.toNumber() < r.toNumber()));
           }
           break;
         }
         case 43 /* LTE */: {
           const r = safePop(stack), l = safePop(stack);
-          const lteFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const lteFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (lteFault) {
             stack.push(lteFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = chunk7ZX6B7SY_cjs.compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(chunk2TZKENDH_cjs.boolValue(cmp <= 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value <= r.value));
+            stack.push(chunk2TZKENDH_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));
+            const cmp = chunk7ZX6B7SY_cjs.compareBigIntOperands(l, r);
+            stack.push(chunk2TZKENDH_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));
+            const { lv, rv, equal, sameMeasure } = chunk7ZX6B7SY_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunk2TZKENDH_cjs.boolValue(equal || lv <= rv) : chunk7ZX6B7SY_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a <= b));
+            stack.push(chunkHIQ5HSZL_cjs.matrixCompare(l.value, r.value, (a, b) => a <= b));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() <= r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.toNumber() <= r.toNumber()));
           }
           break;
         }
         case 44 /* GT */: {
           const r = safePop(stack), l = safePop(stack);
-          const gtFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const gtFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (gtFault) {
             stack.push(gtFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = chunk7ZX6B7SY_cjs.compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(chunk2TZKENDH_cjs.boolValue(cmp > 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value > r.value));
+            stack.push(chunk2TZKENDH_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));
+            const cmp = chunk7ZX6B7SY_cjs.compareBigIntOperands(l, r);
+            stack.push(chunk2TZKENDH_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));
+            const { lv, rv, equal, sameMeasure } = chunk7ZX6B7SY_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunk2TZKENDH_cjs.boolValue(!equal && lv > rv) : chunk7ZX6B7SY_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a > b));
+            stack.push(chunkHIQ5HSZL_cjs.matrixCompare(l.value, r.value, (a, b) => a > b));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() > r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.toNumber() > r.toNumber()));
           }
           break;
         }
         case 45 /* GTE */: {
           const r = safePop(stack), l = safePop(stack);
-          const gteFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const gteFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (gteFault) {
             stack.push(gteFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = chunk7ZX6B7SY_cjs.compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(chunk2TZKENDH_cjs.boolValue(cmp >= 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.value >= r.value));
+            stack.push(chunk2TZKENDH_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));
+            const cmp = chunk7ZX6B7SY_cjs.compareBigIntOperands(l, r);
+            stack.push(chunk2TZKENDH_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));
+            const { lv, rv, equal, sameMeasure } = chunk7ZX6B7SY_cjs.compareUom(l, r);
+            stack.push(sameMeasure ? chunk2TZKENDH_cjs.boolValue(equal || lv >= rv) : chunk7ZX6B7SY_cjs.incomparableUnitsError(l, r));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-            stack.push(chunkUM6BVY2S_cjs.matrixCompare(l.value, r.value, (a, b) => a >= b));
+            stack.push(chunkHIQ5HSZL_cjs.matrixCompare(l.value, r.value, (a, b) => a >= b));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.boolValue(l.toNumber() >= r.toNumber()));
+            stack.push(chunk2TZKENDH_cjs.boolValue(l.toNumber() >= r.toNumber()));
           }
           break;
         }
@@ -1638,29 +1877,29 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 130 /* LOGICAL_AND */: {
           const r = safePop(stack), l = safePop(stack);
-          const andLogicFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const andLogicFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (andLogicFault) {
             stack.push(andLogicFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.boolValue(isTruthy(l) && isTruthy(r)));
+          stack.push(chunk2TZKENDH_cjs.boolValue(isTruthy(l) && isTruthy(r)));
           break;
         }
         case 131 /* LOGICAL_OR */: {
           const r = safePop(stack), l = safePop(stack);
-          const orLogicFault = chunkJMXUNXQS_cjs.faultedOperand(l, r);
+          const orLogicFault = chunk2TZKENDH_cjs.faultedOperand(l, r);
           if (orLogicFault) {
             stack.push(orLogicFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.boolValue(isTruthy(l) || isTruthy(r)));
+          stack.push(chunk2TZKENDH_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);
+          const conditionFault = chunk2TZKENDH_cjs.faultedOperand(condition);
           if (conditionFault) {
             stack.push(conditionFault);
             break;
@@ -1678,11 +1917,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           for (let i = 0; i < argCount; i++) args.push(safePop(stack));
           args.reverse();
           const fn = vm.context.pluginFunctions[fnIdx];
-          const pluginArgFault = chunkJMXUNXQS_cjs.faultedIn(args);
+          const pluginArgFault = chunk2TZKENDH_cjs.faultedIn(args);
           if (pluginArgFault) {
             stack.push(pluginArgFault);
           } else if (!fn) {
-            stack.push(chunkJMXUNXQS_cjs.numberValue(0));
+            stack.push(chunk2TZKENDH_cjs.numberValue(0));
           } else {
             const result = fn(args, context);
             if (result instanceof Promise) {
@@ -1707,16 +1946,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             if (arg.type === 9 /* Symbolic */) sawSymbolic = true;
             args.push(arg);
           }
-          const builtinArgFault = chunkJMXUNXQS_cjs.faultedIn(args);
+          const builtinArgFault = chunk2TZKENDH_cjs.faultedIn(args);
           if (builtinArgFault) {
             stack.push(builtinArgFault);
             break;
           }
-          const fn = chunk6WFMPTGB_cjs.builtinFunctions[fnIdx];
+          const fn = chunk7ZX6B7SY_cjs.builtinFunctions[fnIdx];
           if (fn) {
             const ordered = args.reverse();
-            const routeSymbolically = sawSymbolic && !chunk6WFMPTGB_cjs.SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);
-            stack.push(routeSymbolically ? chunk6WFMPTGB_cjs.symbolicBuiltin(fnIdx, ordered) : fn(ordered));
+            const routeSymbolically = sawSymbolic && !chunk7ZX6B7SY_cjs.SYMBOLIC_NATIVE_BUILTINS.has(fnIdx);
+            stack.push(routeSymbolically ? chunk7ZX6B7SY_cjs.symbolicBuiltin(fnIdx, ordered) : fn(ordered));
           }
           break;
         }
@@ -1724,7 +1963,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const bodyIdx = operandByte(opcodes, ip++, op, "function-body index");
           const def = userFunctionBodies?.[bodyIdx];
           if (!def) {
-            throw chunk5KMIY374_cjs.ErrorFactory.internal(
+            throw chunkB4HBEFTB_cjs.ErrorFactory.internal(
               "INTERNAL_MISSING_FUNCTION_BODY",
               `Internal error: DEFINE_USER_FUNCTION referenced missing body index ${bodyIdx}`,
               { bodyIdx }
@@ -1741,10 +1980,10 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           args.reverse();
           const fn = vm.getUserFunction(name);
           if (!fn) {
-            throw chunk5KMIY374_cjs.ErrorFactory.execution("UNDEFINED_FUNCTION", `Undefined function: ${name}`, { name });
+            throw chunkB4HBEFTB_cjs.ErrorFactory.execution("UNDEFINED_FUNCTION", `Undefined function: ${name}`, { name });
           }
           if (argCount !== fn.params.length) {
-            throw chunk5KMIY374_cjs.ErrorFactory.execution(
+            throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
               "FUNCTION_ARITY_MISMATCH",
               `${name} expects ${fn.params.length} argument(s) but got ${argCount}`,
               { name, expected: fn.params.length, actual: argCount }
@@ -1752,7 +1991,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();
+          chunk2TZKENDH_cjs.chargeFunctionCall();
           vm.pushCallFrame(frame);
           let bodyResult;
           try {
@@ -1761,7 +2000,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             vm.popCallFrame();
           }
           if (bodyResult.type === "pending") {
-            throw chunk5KMIY374_cjs.ErrorFactory.execution(
+            throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
               "USER_FUNCTION_ASYNC_UNSUPPORTED",
               `${name}: user-defined functions with async bodies (weather, stocks, currency, ...) aren't supported`,
               { name }
@@ -1782,9 +2021,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (val !== void 0) {
             stack.push(val);
           } else if (symbolicTolerant) {
-            stack.push(chunkJMXUNXQS_cjs.symbolicValue(chunkUM6BVY2S_cjs.varNode(varName)));
+            stack.push(chunk2TZKENDH_cjs.symbolicValue(chunkHIQ5HSZL_cjs.varNode(varName)));
           } else {
-            throw chunk5KMIY374_cjs.ErrorFactory.execution(
+            throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
               "UNDEFINED_VARIABLE",
               `Undefined variable: ${varName}`,
               { varName }
@@ -1795,15 +2034,15 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         case 61 /* STORE_VAR */: {
           const val = safePop(stack);
           const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          vm.setVar(varName, hasArena ? chunkJMXUNXQS_cjs.persistentValue(val) : val);
+          vm.setVar(varName, hasArena ? chunk2TZKENDH_cjs.persistentValue(val) : val);
           stack.push(val);
           break;
         }
         case 62 /* LOAD_GLOBAL_VAR */: {
           const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          const globalValue = chunk6WFMPTGB_cjs.sharedGlobalVariableStore.get(varName);
+          const globalValue = chunk7ZX6B7SY_cjs.sharedGlobalVariableStore.get(varName);
           if (globalValue === void 0) {
-            throw chunk5KMIY374_cjs.ErrorFactory.internal({
+            throw chunkB4HBEFTB_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)`,
@@ -1817,7 +2056,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         case 63 /* STORE_GLOBAL_VAR */: {
           const val = safePop(stack);
           const varName = poolString(opcodes, ip++, strings, op, "variable-name index");
-          chunk6WFMPTGB_cjs.sharedGlobalVariableStore.set(varName, hasArena ? chunkJMXUNXQS_cjs.persistentValue(val) : val);
+          chunk7ZX6B7SY_cjs.sharedGlobalVariableStore.set(varName, hasArena ? chunk2TZKENDH_cjs.persistentValue(val) : val);
           stack.push(val);
           break;
         }
@@ -1830,97 +2069,102 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 70 /* TO_NUMBER */: {
           const v = safePop(stack);
-          const toNumberFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toNumberFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toNumberFault) {
             stack.push(toNumberFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.numberValue(v.toNumber()));
+          stack.push(chunk2TZKENDH_cjs.numberValue(v.toNumber()));
           break;
         }
         case 71 /* TO_HEX */: {
           const v = safePop(stack);
-          const toHexFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toHexFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toHexFault) {
             stack.push(toHexFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber()));
+          if (v.type === 14 /* Colour */) {
+            const c = v.value;
+            stack.push(chunk2TZKENDH_cjs.colourValue({ r: c.r, g: c.g, b: c.b, a: c.a, format: "hex" }));
+            break;
+          }
+          stack.push(chunk2TZKENDH_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber()));
           break;
         }
         case 74 /* TO_PERCENTAGE */: {
           const v = safePop(stack);
-          const toPercentageFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toPercentageFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toPercentageFault) {
             stack.push(toPercentageFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.percentageValue(v.toNumber()));
+          stack.push(chunk2TZKENDH_cjs.percentageValue(v.toNumber()));
           break;
         }
         case 140 /* TO_FRACTION */: {
           const v = safePop(stack);
-          const toFractionFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toFractionFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toFractionFault) {
             stack.push(toFractionFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.stringValue(toFractionString(v.toNumber())));
+          stack.push(chunk2TZKENDH_cjs.stringValue(v.rational !== void 0 ? rationalToFractionString(v.rational) : toFractionString(v.toNumber())));
           break;
         }
         case 141 /* TO_MULTIPLIER */: {
           const v = safePop(stack);
-          const toMultiplierFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toMultiplierFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toMultiplierFault) {
             stack.push(toMultiplierFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.stringValue(toMultiplierString(v)));
+          stack.push(chunk2TZKENDH_cjs.stringValue(toMultiplierString(v)));
           break;
         }
         case 142 /* TO_SCI */: {
           const v = safePop(stack);
-          const toSciFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toSciFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toSciFault) {
             stack.push(toSciFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.stringValue(toScientificString(v.toNumber())));
+          stack.push(chunk2TZKENDH_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);
-          const toBinaryFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toBinaryFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toBinaryFault) {
             stack.push(toBinaryFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "bin"));
+          stack.push(chunk2TZKENDH_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "bin"));
           break;
         }
         case 144 /* TO_OCTAL */: {
           const v = safePop(stack);
-          const toOctalFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const toOctalFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (toOctalFault) {
             stack.push(toOctalFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "oct"));
+          stack.push(chunk2TZKENDH_cjs.hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber(), "oct"));
           break;
         }
         case 145 /* CALL_AS_CONVERTER */: {
           const name = stringOperand(safePop(stack), op, "converter name").toLowerCase();
           const value = safePop(stack);
-          const converterFault = chunkJMXUNXQS_cjs.faultedOperand(value);
+          const converterFault = chunk2TZKENDH_cjs.faultedOperand(value);
           if (converterFault) {
             stack.push(converterFault);
             break;
           }
-          const converter = chunk6WFMPTGB_cjs.asConverterRegistry.get(name);
+          const converter = chunk7ZX6B7SY_cjs.asConverterRegistry.get(name);
           if (!converter) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue("UNKNOWN_AS_CONVERTER", `Unknown converter "as ${name}"`));
+            stack.push(chunk2TZKENDH_cjs.errorValue("UNKNOWN_AS_CONVERTER", `Unknown converter "as ${name}"`));
           } else {
             stack.push(converter(value));
           }
@@ -1932,62 +2176,69 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         case 80 /* UOM_CONVERT */: {
           const unit = stringOperand(safePop(stack), op, "unit name");
           const operand = safePop(stack);
-          const faulted = chunkJMXUNXQS_cjs.faultedOperand(operand);
+          const faulted = chunk2TZKENDH_cjs.faultedOperand(operand);
           if (faulted) {
             stack.push(faulted);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.uomValue(operand.toNumber(), unit));
+          const money = chunk7ZX6B7SY_cjs.moneyExactMagnitude(operand, unit);
+          if (money) stack.push(chunk2TZKENDH_cjs.uomValueExact(operand.toNumber(), unit, money));
+          else stack.push(chunk2TZKENDH_cjs.uomValue(operand.toNumber(), unit));
           break;
         }
         case 81 /* UOM_CONVERT_TO */: {
           const toUnit = stringOperand(safePop(stack), op, "target unit name");
           const fromUnit = stringOperand(safePop(stack), op, "source unit name");
           const operand = safePop(stack);
-          const faulted = chunkJMXUNXQS_cjs.faultedOperand(operand);
+          const faulted = chunk2TZKENDH_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));
+          const measure = chunkEJ3ILXX6_cjs.getMeasure(fromUnit);
+          const isCurrency = chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(toUnit);
+          if (measure && chunkEJ3ILXX6_cjs.getMeasure(toUnit) === measure) {
+            stack.push(chunk2TZKENDH_cjs.uomValue(chunkEJ3ILXX6_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
           } else if (isCurrency) {
-            const converted = chunkA2N2GFCG_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
+            const converted = chunkZVTWQLK4_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
             if (converted !== null) {
-              stack.push(chunkJMXUNXQS_cjs.uomValue(converted, toUnit));
+              stack.push(chunk2TZKENDH_cjs.uomValue(converted, toUnit));
             } else {
-              stack.push(chunkJMXUNXQS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
+              stack.push(chunk2TZKENDH_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
             }
           } else {
-            stack.push(incompatibleConversionError(fromUnit, toUnit));
+            const rate = chunkEJ3ILXX6_cjs.convertRate(val, fromUnit, toUnit);
+            if (rate !== null) {
+              stack.push(chunk2TZKENDH_cjs.uomValue(rate, toUnit));
+            } else {
+              stack.push(incompatibleConversionError(fromUnit, toUnit));
+            }
           }
           break;
         }
         case 85 /* UOM_POSSIBILITIES */: {
           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}"`));
+          const possibilities = chunkEJ3ILXX6_cjs.getConvertiblePossibilities(unit);
+          stack.push(chunk2TZKENDH_cjs.stringValue(possibilities.length > 0 ? possibilities.join(", ") : `No known units for "${unit}"`));
           break;
         }
         case 83 /* UOM_BEST */: {
           const unit = stringOperand(safePop(stack), op, "unit name");
           const operand = safePop(stack);
-          const faulted = chunkJMXUNXQS_cjs.faultedOperand(operand);
+          const faulted = chunk2TZKENDH_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));
+          const { value, unit: bestUnit } = chunkEJ3ILXX6_cjs.getBestUnit(operand.toNumber(), unit);
+          stack.push(chunk2TZKENDH_cjs.uomValue(value, bestUnit));
           break;
         }
         case 84 /* UOM_CONVERT_IN */: {
           const toUnit = stringOperand(safePop(stack), op, "target unit name");
           const left = safePop(stack);
-          const faulted = chunkJMXUNXQS_cjs.faultedOperand(left);
+          const faulted = chunk2TZKENDH_cjs.faultedOperand(left);
           if (faulted) {
             stack.push(faulted);
             break;
@@ -1995,33 +2246,38 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (left.type === 6 /* Uom */) {
             const fromUnit = left.unit;
             const val = left.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));
+            const measure = chunkEJ3ILXX6_cjs.getMeasure(fromUnit);
+            const isCurrency = chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(fromUnit) && chunkZVTWQLK4_cjs.sharedCurrencyExchange.isCurrency(toUnit);
+            if (measure && chunkEJ3ILXX6_cjs.getMeasure(toUnit) === measure) {
+              stack.push(chunk2TZKENDH_cjs.uomValue(chunkEJ3ILXX6_cjs.convertUnit(val, fromUnit, toUnit), toUnit));
             } else if (isCurrency) {
-              const converted = chunkA2N2GFCG_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
+              const converted = chunkZVTWQLK4_cjs.sharedCurrencyExchange.convertSync(val, fromUnit, toUnit);
               if (converted !== null) {
-                stack.push(chunkJMXUNXQS_cjs.uomValue(converted, toUnit));
+                stack.push(chunk2TZKENDH_cjs.uomValue(converted, toUnit));
               } else {
-                stack.push(chunkJMXUNXQS_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
+                stack.push(chunk2TZKENDH_cjs.errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
               }
             } else {
-              stack.push(incompatibleConversionError(fromUnit, toUnit));
+              const rate = chunkEJ3ILXX6_cjs.convertRate(val, fromUnit, toUnit);
+              if (rate !== null) {
+                stack.push(chunk2TZKENDH_cjs.uomValue(rate, toUnit));
+              } else {
+                stack.push(incompatibleConversionError(fromUnit, toUnit));
+              }
             }
           } else {
-            stack.push(chunkJMXUNXQS_cjs.uomValue(left.toNumber(), toUnit));
+            stack.push(chunk2TZKENDH_cjs.uomValue(left.toNumber(), toUnit));
           }
           break;
         }
         case 82 /* UOM_GET_VALUE */: {
           const v = safePop(stack);
-          const getValueFault = chunkJMXUNXQS_cjs.faultedOperand(v);
+          const getValueFault = chunk2TZKENDH_cjs.faultedOperand(v);
           if (getValueFault) {
             stack.push(getValueFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.numberValue(v.toNumber()));
+          stack.push(chunk2TZKENDH_cjs.numberValue(v.toNumber()));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -2031,33 +2287,33 @@ 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);
+          const rateDivFault = chunk2TZKENDH_cjs.faultedOperand(numeratorVal, denominatorVal);
           if (rateDivFault) {
             stack.push(rateDivFault);
             break;
           }
           if (denominatorVal.type !== 6 /* Uom */ || !denominatorVal.unit) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue("RATE_MISSING_DENOMINATOR_UNIT", 'Cannot build a rate: the right-hand side of "/" has no unit'));
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_cjs.rateValue(numeratorVal.toNumber() / denominatorVal.toNumber(), numeratorUnit, denominatorVal.unit));
+          stack.push(chunk2TZKENDH_cjs.rateValue(numeratorVal.toNumber() / denominatorVal.toNumber(), numeratorUnit, denominatorVal.unit));
           break;
         }
         case 111 /* RATE_MUL */: {
           const multiplier = safePop(stack);
           const rate = safePop(stack);
-          const rateMulFault = chunkJMXUNXQS_cjs.faultedOperand(rate, multiplier);
+          const rateMulFault = chunk2TZKENDH_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")'));
+          if (rate.type !== 6 /* Uom */ || !chunk2TZKENDH_cjs.isRateUnit(rate.unit)) {
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_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(chunk2TZKENDH_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));
@@ -2066,27 +2322,27 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         case 112 /* RATE_CONVERT */: {
           const newDenominatorUnit = stringOperand(safePop(stack), op, "denominator unit name");
           const rate = safePop(stack);
-          const rateConvertFault = chunkJMXUNXQS_cjs.faultedOperand(rate);
+          const rateConvertFault = chunk2TZKENDH_cjs.faultedOperand(rate);
           if (rateConvertFault) {
             stack.push(rateConvertFault);
             break;
           }
-          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"));
+          if (rate.type !== 6 /* Uom */ || !chunk2TZKENDH_cjs.isRateUnit(rate.unit)) {
+            stack.push(chunk2TZKENDH_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);
+          const { numerator, denominator } = chunk2TZKENDH_cjs.splitRateUnit(rate.unit);
+          const rateMeasure = chunkEJ3ILXX6_cjs.getMeasure(denominator);
+          const targetMeasure = chunkEJ3ILXX6_cjs.getMeasure(newDenominatorUnit);
           if (!rateMeasure || rateMeasure !== targetMeasure) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue(
+            stack.push(chunk2TZKENDH_cjs.errorValue(
               "RATE_CONVERT_MEASURE_MISMATCH",
               `Cannot convert a "${denominator}"-denominated rate to "${newDenominatorUnit}" \u2014 different measures`
             ));
             break;
           }
-          const factor = chunkPFUESQTW_cjs.convertUnit(1, newDenominatorUnit, denominator);
-          stack.push(chunkJMXUNXQS_cjs.rateValue(rate.toNumber() * factor, numerator, newDenominatorUnit));
+          const factor = chunkEJ3ILXX6_cjs.convertUnit(1, newDenominatorUnit, denominator);
+          stack.push(chunk2TZKENDH_cjs.rateValue(rate.toNumber() * factor, numerator, newDenominatorUnit));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -2094,7 +2350,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         // ═══════════════════════════════════════════════════════════════
         case 120 /* CLOCK_TIME_TODAY */: {
           const minutesValue = safePop(stack);
-          const clockFault = chunkJMXUNXQS_cjs.faultedOperand(minutesValue);
+          const clockFault = chunk2TZKENDH_cjs.faultedOperand(minutesValue);
           if (clockFault) {
             stack.push(clockFault);
             break;
@@ -2103,43 +2359,87 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const now = /* @__PURE__ */ new Date();
           const anchored = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
           anchored.setMinutes(totalMinutes);
-          stack.push(chunkJMXUNXQS_cjs.datetimeValue(anchored.getTime()));
+          stack.push(chunk2TZKENDH_cjs.datetimeValue(anchored.getTime()));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
         // §9  Datetime  (OpCode 90–93)
         // ═══════════════════════════════════════════════════════════════
         case 90 /* DATE_NOW */:
-          stack.push(chunkJMXUNXQS_cjs.datetimeValue(Date.now()));
+          stack.push(chunk2TZKENDH_cjs.datetimeValue(Date.now()));
           break;
         case 95 /* DATE_LITERAL */:
-          stack.push(chunkJMXUNXQS_cjs.datetimeValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
+          stack.push(chunk2TZKENDH_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);
-          const dateAddFault = chunkJMXUNXQS_cjs.faultedOperand(dtValue, durValue);
+          const dateAddFault = chunk2TZKENDH_cjs.faultedOperand(dtValue, durValue);
           if (dateAddFault) {
             stack.push(dateAddFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, 1, vm)));
+          stack.push(chunk2TZKENDH_cjs.datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, 1, vm)));
           break;
         }
         case 92 /* DATE_SUB */: {
           const durValue = safePop(stack), dtValue = safePop(stack);
-          const dateSubFault = chunkJMXUNXQS_cjs.faultedOperand(dtValue, durValue);
+          const dateSubFault = chunk2TZKENDH_cjs.faultedOperand(dtValue, durValue);
           if (dateSubFault) {
             stack.push(dateSubFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, -1, vm)));
+          stack.push(chunk2TZKENDH_cjs.datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, -1, vm)));
+          break;
+        }
+        case 96 /* DATE_WORKDAY_OFFSET */: {
+          const workdayDirection = operandByte(opcodes, ip++, op, "workday offset direction") === 1 ? -1 : 1;
+          const anchorValue = safePop(stack), countValue = safePop(stack);
+          const offsetFault = chunk2TZKENDH_cjs.faultedOperand(countValue, anchorValue);
+          if (offsetFault) {
+            stack.push(offsetFault);
+            break;
+          }
+          if (anchorValue.type !== 4 /* Datetime */) {
+            stack.push(chunk2TZKENDH_cjs.errorValue(
+              chunkB4HBEFTB_cjs.CoreErrorCodes.WORKDAY_OFFSET_EXPECTED_DATE,
+              `"working days after/before/from" expects a date to count from, got ${chunk2TZKENDH_cjs.ValueType[anchorValue.type] ?? "an unsupported value"}`
+            ));
+            break;
+          }
+          stack.push(chunk2TZKENDH_cjs.datetimeValue(addBusinessDays2(anchorValue.toNumber(), workdayDirection * countValue.toNumber(), vm)));
+          break;
+        }
+        case 97 /* DATE_WORKDAYS_BETWEEN */: {
+          const endValue = safePop(stack), startValue = safePop(stack);
+          const betweenFault = chunk2TZKENDH_cjs.faultedOperand(startValue, endValue);
+          if (betweenFault) {
+            stack.push(betweenFault);
+            break;
+          }
+          if (startValue.type !== 4 /* Datetime */ || endValue.type !== 4 /* Datetime */) {
+            stack.push(chunk2TZKENDH_cjs.errorValue(
+              chunkB4HBEFTB_cjs.CoreErrorCodes.WORKDAYS_BETWEEN_EXPECTED_DATES,
+              `"working days between" expects two dates, got ${chunk2TZKENDH_cjs.ValueType[startValue.type] ?? "an unsupported value"} and ${chunk2TZKENDH_cjs.ValueType[endValue.type] ?? "an unsupported value"}`
+            ));
+            break;
+          }
+          const spanLimitDays = Math.ceil((vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()) * 366);
+          const workdayCount = countBusinessDaysBetween(startValue.toNumber(), endValue.toNumber(), (ms) => vm.isHoliday(ms), spanLimitDays);
+          if (workdayCount === null) {
+            stack.push(chunk2TZKENDH_cjs.errorValue(
+              chunkB4HBEFTB_cjs.CoreErrorCodes.WORKDAYS_BETWEEN_RANGE_TOO_LARGE,
+              `The two dates are more than ${vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()} years apart, past the working-day count's limit`
+            ));
+            break;
+          }
+          stack.push(chunk2TZKENDH_cjs.numberValue(workdayCount));
           break;
         }
         case 93 /* DATE_NEXT_WEEKDAY */:
         case 94 /* DATE_LAST_WEEKDAY */: {
           const targetDayValue = safePop(stack);
           const nowValue = safePop(stack);
-          const weekdayFault = chunkJMXUNXQS_cjs.faultedOperand(nowValue, targetDayValue);
+          const weekdayFault = chunk2TZKENDH_cjs.faultedOperand(nowValue, targetDayValue);
           if (weekdayFault) {
             stack.push(weekdayFault);
             break;
@@ -2149,7 +2449,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const currentDay = new Date(now).getDay();
           let diffDays = op === 93 /* DATE_NEXT_WEEKDAY */ ? (targetDay - currentDay + 7) % 7 : (currentDay - targetDay + 7) % 7;
           if (diffDays === 0) diffDays = 7;
-          stack.push(chunkJMXUNXQS_cjs.datetimeValue(addCalendarDays(now, op === 93 /* DATE_NEXT_WEEKDAY */ ? diffDays : -diffDays)));
+          stack.push(chunk2TZKENDH_cjs.datetimeValue(addCalendarDays(now, op === 93 /* DATE_NEXT_WEEKDAY */ ? diffDays : -diffDays)));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -2164,116 +2464,116 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const rows = operandByte(opcodes, ip++, op, "row count");
           const cols = operandByte(opcodes, ip++, op, "column count");
           const count = rows * cols;
-          const rowMajor = chunkJMXUNXQS_cjs.checkedArray(count, "matrix cells");
+          const rowMajor = chunk2TZKENDH_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);
+            if (cellFault === null) cellFault = chunk2TZKENDH_cjs.faultedOperand(cellVal);
             rowMajor[i] = cellVal.type === 10 /* Boolean */ ? cellVal.value : cellVal.type === 9 /* Symbolic */ ? cellVal.value : cellVal.toNumber();
           }
           if (cellFault) {
             stack.push(cellFault);
             break;
           }
-          stack.push(chunkJMXUNXQS_cjs.matrixValue(rows, cols, chunkUM6BVY2S_cjs.rowMajorToColumnMajor(rows, cols, rowMajor)));
+          stack.push(chunk2TZKENDH_cjs.matrixValue(rows, cols, chunkHIQ5HSZL_cjs.rowMajorToColumnMajor(rows, cols, rowMajor)));
           break;
         }
         case 153 /* MAT_INDEX1 */: {
           const indexVal = safePop(stack), matrixVal = safePop(stack);
-          const index1Fault = chunkJMXUNXQS_cjs.faultedOperand(matrixVal, indexVal);
+          const index1Fault = chunk2TZKENDH_cjs.faultedOperand(matrixVal, indexVal);
           if (index1Fault) {
             stack.push(index1Fault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot index a non-matrix value with "[...]".`));
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_cjs.errorValue(
+            stack.push(chunk2TZKENDH_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 = chunkUM6BVY2S_cjs.matIndex(m, index);
-          stack.push(chunkUM6BVY2S_cjs.matrixEntryToValue(cell));
+          const cell = chunkHIQ5HSZL_cjs.matIndex(m, index);
+          stack.push(chunkHIQ5HSZL_cjs.matrixEntryToValue(cell));
           break;
         }
         case 154 /* MAT_INDEX2 */: {
           const colVal = safePop(stack), rowVal = safePop(stack), matrixVal = safePop(stack);
-          const index2Fault = chunkJMXUNXQS_cjs.faultedOperand(matrixVal, rowVal, colVal);
+          const index2Fault = chunk2TZKENDH_cjs.faultedOperand(matrixVal, rowVal, colVal);
           if (index2Fault) {
             stack.push(index2Fault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot index a non-matrix value with "[...]".`));
+            stack.push(chunk2TZKENDH_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 (!chunkUM6BVY2S_cjs.inBounds(m, row, col)) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue(
+          if (!chunkHIQ5HSZL_cjs.inBounds(m, row, col)) {
+            stack.push(chunk2TZKENDH_cjs.errorValue(
               "MATRIX_INDEX_OUT_OF_BOUNDS",
               `[${row}, ${col}] is out of bounds for a ${m.rows}x${m.cols} matrix.`
             ));
             break;
           }
-          const cell = chunkUM6BVY2S_cjs.matAt(m, row, col);
-          stack.push(chunkUM6BVY2S_cjs.matrixEntryToValue(cell));
+          const cell = chunkHIQ5HSZL_cjs.matAt(m, row, col);
+          stack.push(chunkHIQ5HSZL_cjs.matrixEntryToValue(cell));
           break;
         }
         case 156 /* RANGE_NEW */: {
           const maxVal = safePop(stack), minVal = safePop(stack);
-          const rangeFault = chunkJMXUNXQS_cjs.faultedOperand(minVal, maxVal);
+          const rangeFault = chunk2TZKENDH_cjs.faultedOperand(minVal, maxVal);
           if (rangeFault) {
             stack.push(rangeFault);
             break;
           }
           if (minVal.type !== 0 /* Number */ || maxVal.type !== 0 /* Number */) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue("INVALID_RANGE_BOUND", `A range's bounds must be plain numbers (e.g. "0:3").`));
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_cjs.errorValue("NON_INTEGER_RANGE_BOUND", `A range's bounds must be whole numbers, got "${min}:${max}".`));
+            stack.push(chunk2TZKENDH_cjs.errorValue("NON_INTEGER_RANGE_BOUND", `A range's bounds must be whole numbers, got "${min}:${max}".`));
             break;
           }
           if (min > max) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue(
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_cjs.rangeValue(min, max));
+          stack.push(chunk2TZKENDH_cjs.rangeValue(min, max));
           break;
         }
         case 155 /* MAT_SLICE */: {
           const colRangeVal = safePop(stack), rowRangeVal = safePop(stack), matrixVal = safePop(stack);
-          const sliceFault = chunkJMXUNXQS_cjs.faultedOperand(matrixVal, rowRangeVal, colRangeVal);
+          const sliceFault = chunk2TZKENDH_cjs.faultedOperand(matrixVal, rowRangeVal, colRangeVal);
           if (sliceFault) {
             stack.push(sliceFault);
             break;
           }
           if (matrixVal.type !== 7 /* Matrix */) {
-            stack.push(chunkJMXUNXQS_cjs.errorValue("MATRIX_INDEX_NOT_A_MATRIX", `Cannot slice a non-matrix value with "[...]".`));
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_cjs.errorValue("INVALID_MATRIX_SLICE_BOUND", `Matrix slicing needs range bounds (e.g. "a[0:1, 1:2]").`));
+            stack.push(chunk2TZKENDH_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(chunkJMXUNXQS_cjs.errorValue(
+            stack.push(chunk2TZKENDH_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.`
             ));
@@ -2281,13 +2581,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 = chunkJMXUNXQS_cjs.checkedArray(newRows * newCols, "matrix cells");
+          const data = chunk2TZKENDH_cjs.checkedArray(newRows * newCols, "matrix cells");
           for (let r = 0; r < newRows; r++) {
             for (let c = 0; c < newCols; c++) {
-              data[r + c * newRows] = chunkUM6BVY2S_cjs.matAt(m, rowRange.min + r, colRange.min + c);
+              data[r + c * newRows] = chunkHIQ5HSZL_cjs.matAt(m, rowRange.min + r, colRange.min + c);
             }
           }
-          stack.push(chunkJMXUNXQS_cjs.matrixValue(newRows, newCols, data));
+          stack.push(chunk2TZKENDH_cjs.matrixValue(newRows, newCols, data));
           break;
         }
         // ═══════════════════════════════════════════════════════════════
@@ -2310,7 +2610,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (kind === 0) {
             const def = anonymousBodies?.[ref];
             if (!def) {
-              throw chunk5KMIY374_cjs.ErrorFactory.internal(
+              throw chunkB4HBEFTB_cjs.ErrorFactory.internal(
                 "INTERNAL_MISSING_ANONYMOUS_BODY",
                 `Internal error: MAP_INVOKE referenced missing anonymous body index ${ref}`,
                 { ref }
@@ -2322,11 +2622,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             const name = pooledString(strings, ref, op);
             const fn = vm.getUserFunction(name);
             if (!fn) {
-              stack.push(chunkJMXUNXQS_cjs.errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
+              stack.push(chunk2TZKENDH_cjs.errorValue("UNDEFINED_FUNCTION", `map: undefined function "${name}"`));
               break;
             }
             if (fn.params.length !== collectionCount) {
-              stack.push(chunkJMXUNXQS_cjs.errorValue(
+              stack.push(chunk2TZKENDH_cjs.errorValue(
                 "FUNCTION_ARITY_MISMATCH",
                 `map: "${name}" expects ${fn.params.length} argument(s) but ${collectionCount} collection(s) were given`
               ));
@@ -2339,16 +2639,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 = chunkUM6BVY2S_cjs.collectionToValues(rawCollections[i], vm.getMaxCollectionSize());
+            const resolved = chunkHIQ5HSZL_cjs.collectionToValues(rawCollections[i], vm.getMaxCollectionSize());
             if (!Array.isArray(resolved)) {
               mapEarlyError = resolved;
               break;
             }
-            chunkJMXUNXQS_cjs.chargeAllocation(resolved.length, "collection elements");
+            chunk2TZKENDH_cjs.chargeAllocation(resolved.length, "collection elements");
             if (collectionLength === -1) {
               collectionLength = resolved.length;
             } else if (resolved.length !== collectionLength) {
-              mapEarlyError = chunkJMXUNXQS_cjs.errorValue(
+              mapEarlyError = chunk2TZKENDH_cjs.errorValue(
                 "MAP_COLLECTION_LENGTH_MISMATCH",
                 `map: all collections must have the same length (got ${collectionLength} and ${resolved.length}).`
               );
@@ -2360,13 +2660,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(mapEarlyError);
             break;
           }
-          const resultData = chunkJMXUNXQS_cjs.checkedArray(collectionLength, "matrix cells");
+          const resultData = chunk2TZKENDH_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 ? 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);
+            const resultVal = kind === 1 ? chunk7ZX6B7SY_cjs.builtinFunctions[ref]?.(args) ?? chunk2TZKENDH_cjs.errorValue("UNKNOWN_BUILTIN_FUNCTION", `map: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
+            const resultFault = chunk2TZKENDH_cjs.faultedOperand(resultVal);
             if (resultFault) {
               mapError = resultFault;
               break;
@@ -2380,9 +2680,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           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));
+            stack.push(chunk2TZKENDH_cjs.matrixValue(sourceShape.rows, sourceShape.cols, resultData));
           } else {
-            stack.push(chunkJMXUNXQS_cjs.matrixValue(1, collectionLength, resultData));
+            stack.push(chunk2TZKENDH_cjs.matrixValue(1, collectionLength, resultData));
           }
           break;
         }
@@ -2398,7 +2698,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           if (kind === 0) {
             const def = anonymousBodies?.[ref];
             if (!def) {
-              throw chunk5KMIY374_cjs.ErrorFactory.internal(
+              throw chunkB4HBEFTB_cjs.ErrorFactory.internal(
                 "INTERNAL_MISSING_ANONYMOUS_BODY",
                 `Internal error: REDUCE_INVOKE referenced missing anonymous body index ${ref}`,
                 { ref }
@@ -2410,11 +2710,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             const name = pooledString(strings, ref, op);
             const fn = vm.getUserFunction(name);
             if (!fn) {
-              stack.push(chunkJMXUNXQS_cjs.errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
+              stack.push(chunk2TZKENDH_cjs.errorValue("UNDEFINED_FUNCTION", `reduce: undefined function "${name}"`));
               break;
             }
             if (fn.params.length !== 2) {
-              stack.push(chunkJMXUNXQS_cjs.errorValue(
+              stack.push(chunk2TZKENDH_cjs.errorValue(
                 "FUNCTION_ARITY_MISMATCH",
                 `reduce: "${name}" must take exactly 2 arguments (accumulator, element), got ${fn.params.length}`
               ));
@@ -2423,16 +2723,16 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             paramNames = fn.params;
             program = fn.program;
           }
-          const cells = chunkUM6BVY2S_cjs.collectionToValues(collectionVal, vm.getMaxCollectionSize());
+          const cells = chunkHIQ5HSZL_cjs.collectionToValues(collectionVal, vm.getMaxCollectionSize());
           if (!Array.isArray(cells)) {
             stack.push(cells);
             break;
           }
-          chunkJMXUNXQS_cjs.chargeAllocation(cells.length, "collection elements");
+          chunk2TZKENDH_cjs.chargeAllocation(cells.length, "collection elements");
           let acc;
           let startIdx;
           if (initialVal !== void 0) {
-            const initialFault = chunkJMXUNXQS_cjs.faultedOperand(initialVal);
+            const initialFault = chunk2TZKENDH_cjs.faultedOperand(initialVal);
             if (initialFault) {
               stack.push(initialFault);
               break;
@@ -2441,7 +2741,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             startIdx = 0;
           } else {
             if (cells.length === 0) {
-              stack.push(chunkJMXUNXQS_cjs.errorValue("REDUCE_EMPTY_COLLECTION", `reduce: cannot reduce an empty collection without an initial value.`));
+              stack.push(chunk2TZKENDH_cjs.errorValue("REDUCE_EMPTY_COLLECTION", `reduce: cannot reduce an empty collection without an initial value.`));
               break;
             }
             acc = cells[0];
@@ -2450,8 +2750,8 @@ 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 ? 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);
+            const resultVal = kind === 1 ? chunk7ZX6B7SY_cjs.builtinFunctions[ref]?.(args) ?? chunk2TZKENDH_cjs.errorValue("UNKNOWN_BUILTIN_FUNCTION", `reduce: unknown builtin function index ${ref}`) : invokeFrameBody(paramNames, program, args, vm, pipeline, expression, context, !!symbolicTolerant);
+            const stepFault = chunk2TZKENDH_cjs.faultedOperand(resultVal);
             if (stepFault) {
               reduceError = stepFault;
               break;
@@ -2472,7 +2772,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           const ref = operandByte(opcodes, ip++, op, "body reference");
           const def = anonymousBodies?.[ref];
           if (!def) {
-            throw chunk5KMIY374_cjs.ErrorFactory.internal(
+            throw chunkB4HBEFTB_cjs.ErrorFactory.internal(
               "INTERNAL_MISSING_ANONYMOUS_BODY",
               `Internal error: BIND_UNKNOWN referenced missing anonymous body index ${ref}`,
               { ref }
@@ -2484,11 +2784,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
       }
     }
     const fallback = safePop(stack);
-    return { type: "value", value: hasArena ? chunkJMXUNXQS_cjs.persistentValue(fallback) : fallback };
+    return { type: "value", value: hasArena ? chunk2TZKENDH_cjs.persistentValue(fallback) : fallback };
   } catch (e) {
-    return { type: "error", error: chunk5KMIY374_cjs.normalizeUnknownError(e) };
+    return { type: "error", error: chunkB4HBEFTB_cjs.normalizeUnknownError(e) };
   } finally {
-    chunkJMXUNXQS_cjs.endEvaluation();
+    chunk2TZKENDH_cjs.endEvaluation();
   }
 }
 
@@ -2496,5 +2796,5 @@ exports.DependencyGraph = DependencyGraph;
 exports.ScopeManager = ScopeManager;
 exports.createVM = createVM;
 exports.executeBytecode = executeBytecode;
-//# sourceMappingURL=chunk-HDP7VK3C.cjs.map
-//# sourceMappingURL=chunk-HDP7VK3C.cjs.map
+//# sourceMappingURL=chunk-SRGQ72IR.cjs.map
+//# sourceMappingURL=chunk-SRGQ72IR.cjs.map