solve-engine 1.0.1 → 1.1.0

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

@@ -1,12 +1,12 @@
-import { DiagnosticEventType } from './chunk-G535KJEG.js';
-import { defaultEngineContext, builtinFunctions, asConverterRegistry, sharedGlobalVariableStore, SYMBOLIC_NATIVE_BUILTINS, symbolicBuiltin, compareBigIntOperands, compareUom, incomparableUnitsError, toBigIntOperand, symbolicNeg, power, symbolicPow, binaryOp, bigIntDivisionByZero, unifyUom } from './chunk-Y7FT4IQT.js';
-import { sharedCurrencyExchange } from './chunk-TMA4RCEN.js';
-import { getOpCodeName } from './chunk-UQ3UIZJC.js';
-import { collectionToValues, matAt, inBounds, matrixEntryToValue, matIndex, rowMajorToColumnMajor, varNode, matrixCompare, matrixPower, matrixMultiply, CURRENCY_DISPLAY } from './chunk-O3ANBHSA.js';
-import { numberValue, ValueType, isArenaActive, beginEvaluation, errorValue, chargeAllocation, faultedOperand, checkedArray, matrixValue, rangeValue, datetimeValue, isRateUnit, splitRateUnit, rateValue, uomValue, stringValue, hexValue, percentageValue, persistentValue, symbolicValue, chargeFunctionCall, faultedIn, boolValue, bigIntValue, checkAllocation, isTimecodeUnit, endEvaluation, timecodeFps } from './chunk-GQCOSXMG.js';
-import { getMeasure, convertUnit, getBestUnit, getConvertiblePossibilities, isWorkdayUnit } from './chunk-R3PY4G7J.js';
+import { DiagnosticEventType } from './chunk-CCBZZQAE.js';
+import { defaultEngineContext, builtinFunctions, moneyExactMagnitude, asConverterRegistry, sharedGlobalVariableStore, SYMBOLIC_NATIVE_BUILTINS, symbolicBuiltin, compareRationalOperands, compareBigIntOperands, compareUom, incomparableUnitsError, toBigIntOperand, symbolicNeg, power, symbolicPow, binaryOp, bigIntDivisionByZero, uncertainOp, unifyUom, exactRationalOp, describeConversionMismatch, scaleMoneyExact, scaleMoneyByPercent } from './chunk-NKW7LKYU.js';
+import { sharedCurrencyExchange } from './chunk-Z7XGGLI2.js';
+import { getOpCodeName } from './chunk-BLI4NIQY.js';
+import { collectionToValues, matAt, inBounds, matrixEntryToValue, matIndex, rowMajorToColumnMajor, varNode, matrixCompare, decimalNegate, rationalNeg, matrixPower, matrixMultiply, decimalFromLiteral, decimalToNumber, CURRENCY_DISPLAY } from './chunk-NNQ2TYDF.js';
+import { numberValue, ValueType, isArenaActive, beginEvaluation, errorValue, chargeAllocation, faultedOperand, checkedArray, matrixValue, rangeValue, datetimeValue, isRateUnit, splitRateUnit, rateValue, uomValue, stringValue, uomValueExact, hexValue, percentageValue, colourValue, persistentValue, symbolicValue, chargeFunctionCall, faultedIn, boolValue, bigIntValue, numberValueUncertain, numberValueRational, numberValueExact, checkAllocation, isTimecodeUnit, endEvaluation, timecodeFps } from './chunk-267JPOTF.js';
+import { getMeasure, convertUnit, convertRate, getBestUnit, getConvertiblePossibilities, isWorkdayUnit } from './chunk-MVTOCRV2.js';
 import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory, normalizeUnknownError } from './chunk-3D7V24DG.js';
+import { ErrorFactory, CoreErrorCodes, normalizeUnknownError } from './chunk-ERCOHGXD.js';
 
 // src/vm/DependencyGraph.ts
 var DependencyGraph = class {
@@ -330,6 +330,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 },
@@ -340,7 +381,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 },
@@ -462,7 +503,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 = defaultEngineContext) {
+function createVM(registry, maxStackDepth = 200, maxInstructions = 5e4, maxFunctionRecursionDepth = 50, maxCollectionSize = 1e5, maxAllocatedElements = 2e6, maxFunctionCalls = 1e4, maxDateOffsetYears = 100, minDateOffsetYears = -100, context = defaultEngineContext, holidayPredicate) {
   const stack = [];
   const variables = /* @__PURE__ */ new Map();
   let instructionCount = 0;
@@ -496,6 +537,12 @@ 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 numberValue(0);
@@ -569,6 +616,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 });
     },
@@ -840,15 +893,48 @@ function moneyTimesQuantity(l, r) {
 function combinePercentage(l, r, sign) {
   if (l.type === 5 /* Percentage */) {
     if (r.type === 6 /* Uom */ && r.unit !== void 0) {
-      return uomValue(r.toNumber() * (1 + sign * l.toNumber()), r.unit);
+      return scaleMoneyByPercent(r, r.unit, l.toNumber(), sign);
     }
     if (r.type !== 5 /* Percentage */ && r.type !== 0 /* Number */) return null;
     return percentageValue(l.toNumber() + sign * r.toNumber());
   }
   if (r.type !== 5 /* Percentage */) return null;
   const factor = 1 + sign * r.toNumber();
-  if (l.type === 0 /* Number */) return numberValue(l.toNumber() * factor);
-  if (l.type === 6 /* Uom */ && l.unit !== void 0) return uomValue(l.toNumber() * factor, l.unit);
+  if (l.type === 0 /* Number */) {
+    const scaled = l.toNumber() * factor;
+    if (l.uncertainty !== void 0) return numberValueUncertain(scaled, Math.abs(l.uncertainty * factor));
+    return numberValue(scaled);
+  }
+  if (l.type === 6 /* Uom */ && l.unit !== void 0) return scaleMoneyByPercent(l, l.unit, r.toNumber(), sign);
+  return null;
+}
+function multiplyPercentWithUncertainty(l, r) {
+  const pct = l.type === 5 /* Percentage */ ? l : r.type === 5 /* Percentage */ ? r : null;
+  if (pct === null) return null;
+  const other = pct === l ? r : l;
+  if (other.type !== 0 /* Number */ || other.uncertainty === void 0) return null;
+  const factor = pct.toNumber();
+  return numberValueUncertain(other.toNumber() * factor, Math.abs(other.uncertainty * factor));
+}
+function multiplyMoneyByScalarExact(l, r) {
+  const money = l.type === 6 /* Uom */ ? l : r;
+  const scalar = l.type === 6 /* Uom */ ? r : l;
+  if (money.type !== 6 /* Uom */ || money.unit === void 0 || !sharedCurrencyExchange.isCurrency(money.unit)) return null;
+  if (scalar.type !== 0 /* Number */ && scalar.type !== 5 /* Percentage */) return null;
+  if (scalar.rational !== void 0) return null;
+  return scaleMoneyExact(money, scalar.toNumber(), money.unit);
+}
+function dividePercentWithUncertainty(l, r) {
+  if (r.type === 5 /* Percentage */ && l.type === 0 /* Number */ && l.uncertainty !== void 0) {
+    const factor = r.toNumber();
+    if (factor === 0) return null;
+    return numberValueUncertain(l.toNumber() / factor, Math.abs(l.uncertainty / factor));
+  }
+  if (l.type === 5 /* Percentage */ && r.type === 0 /* Number */ && r.uncertainty !== void 0) {
+    const b = r.toNumber();
+    if (b === 0) return null;
+    return numberValueUncertain(l.toNumber() / b, Math.abs(l.toNumber() * r.uncertainty / (b * b)));
+  }
   return null;
 }
 function extractDurationMs(value) {
@@ -865,8 +951,8 @@ 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);
@@ -877,15 +963,18 @@ function addBusinessDays(epochMs, n, vm) {
       { 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 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,
@@ -911,8 +1000,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);
@@ -930,7 +1019,7 @@ function shiftDatetime(epochMs, duration, sign, vm) {
   if (duration.type === 6 /* Uom */ && duration.unit !== void 0) {
     const unit = duration.unit;
     const amount = sign * duration.toNumber();
-    if (isWorkdayUnit(unit)) return addBusinessDays(epochMs, amount, vm);
+    if (isWorkdayUnit(unit)) return addBusinessDays2(epochMs, amount, vm);
     const monthsPerUnit = CALENDAR_MONTHS_PER_UNIT[unit];
     if (monthsPerUnit !== void 0) return addCalendarMonths(epochMs, amount * monthsPerUnit);
     if (getMeasure(unit) === "time") {
@@ -972,9 +1061,10 @@ function isTruthy(value) {
   return value.toNumber() !== 0;
 }
 function incompatibleConversionError(fromUnit, toUnit) {
+  const named = describeConversionMismatch(fromUnit, toUnit);
   return 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;
@@ -1060,6 +1150,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;
@@ -1159,6 +1252,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         case 11 /* PUSH_BIGINT */:
           stack.push(bigIntValue(parseBigIntLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"), op)));
           break;
+        case 16 /* PUSH_DECIMAL */: {
+          const dec = decimalFromLiteral(poolString(opcodes, ip++, strings, op, "constant-pool index"));
+          stack.push(numberValueExact(decimalToNumber(dec), dec));
+          break;
+        }
         case 12 /* PUSH_HEX */:
           stack.push(hexValue(numbers[poolIndex(opcodes, ip++, op, "constant-pool index", numbers.length, "number-pool")]));
           break;
@@ -1180,6 +1278,20 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(addFault);
             break;
           }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncAdd = uncertainOp(l, r, "add");
+            if (uncAdd) {
+              stack.push(uncAdd);
+              break;
+            }
+          }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const ratAdd = exactRationalOp(l, r, "add");
+            if (ratAdd) {
+              stack.push(ratAdd);
+              break;
+            }
+          }
           const pctAdd = combinePercentage(l, r, 1);
           const ratePeriodAdd = pctAdd === null ? unifyRatePeriods(l, r) : null;
           if (pctAdd !== null) {
@@ -1212,6 +1324,20 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(subFault);
             break;
           }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncSub = uncertainOp(l, r, "sub");
+            if (uncSub) {
+              stack.push(uncSub);
+              break;
+            }
+          }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const ratSub = exactRationalOp(l, r, "sub");
+            if (ratSub) {
+              stack.push(ratSub);
+              break;
+            }
+          }
           const pctSub = combinePercentage(l, r, -1);
           const ratePeriodSub = pctSub === null ? unifyRatePeriods(l, r) : null;
           if (pctSub !== null) {
@@ -1240,6 +1366,30 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 22 /* MUL */: {
           const r = safePop(stack), l = safePop(stack);
+          const pctUnc = multiplyPercentWithUncertainty(l, r);
+          if (pctUnc) {
+            stack.push(pctUnc);
+            break;
+          }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncMul = uncertainOp(l, r, "mul");
+            if (uncMul) {
+              stack.push(uncMul);
+              break;
+            }
+          }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const ratMul = exactRationalOp(l, r, "mul");
+            if (ratMul) {
+              stack.push(ratMul);
+              break;
+            }
+          }
+          const moneyScalar = multiplyMoneyByScalarExact(l, r);
+          if (moneyScalar) {
+            stack.push(moneyScalar);
+            break;
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(numberValue(l.value * r.value));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
@@ -1258,6 +1408,18 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
         }
         case 23 /* DIV */: {
           const r = safePop(stack), l = safePop(stack);
+          const pctDivUnc = dividePercentWithUncertainty(l, r);
+          if (pctDivUnc) {
+            stack.push(pctDivUnc);
+            break;
+          }
+          if (l.uncertainty !== void 0 || r.uncertainty !== void 0) {
+            const uncDiv = uncertainOp(l, r, "div");
+            if (uncDiv) {
+              stack.push(uncDiv);
+              break;
+            }
+          }
           if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
             const { lv, rv, sameMeasure } = unifyUom(l, r);
             if (sameMeasure) {
@@ -1268,6 +1430,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
               stack.push(rateValue(lv / rv, l.unit, r.unit));
             }
           } else {
+            const ratDiv = exactRationalOp(l, r, "div");
+            if (ratDiv) {
+              stack.push(ratDiv);
+              break;
+            }
             stack.push(binaryOp(l, r, (a, b) => a / b, (a, b) => {
               if (b === 0n) throw bigIntDivisionByZero();
               return a / b;
@@ -1346,9 +1513,12 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             break;
           }
           if (v.type === 2 /* BigInt */) stack.push(bigIntValue(-v.value));
+          else if (v.type === 6 /* Uom */ && v.exact !== void 0) stack.push(uomValueExact(-v.toNumber(), v.unit, decimalNegate(v.exact)));
           else if (v.type === 6 /* Uom */) stack.push(uomValue(-v.toNumber(), v.unit));
           else if (v.type === 5 /* Percentage */) stack.push(percentageValue(-v.toNumber()));
           else if (v.type === 9 /* Symbolic */) stack.push(symbolicNeg(v));
+          else if (v.type === 0 /* Number */ && v.rational !== void 0) stack.push(numberValueRational(-v.toNumber(), rationalNeg(v.rational)));
+          else if (v.type === 0 /* Number */ && v.exact !== void 0) stack.push(numberValueExact(-v.toNumber(), decimalNegate(v.exact)));
           else stack.push(numberValue(-v.toNumber()));
           break;
         }
@@ -1359,11 +1529,24 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(posFault);
             break;
           }
-          if (v.type === 6 /* Uom */) stack.push(uomValue(v.toNumber(), v.unit));
+          if (v.type === 6 /* Uom */ && v.exact !== void 0) stack.push(uomValueExact(v.toNumber(), v.unit, v.exact));
+          else if (v.type === 6 /* Uom */) stack.push(uomValue(v.toNumber(), v.unit));
           else if (v.type === 5 /* Percentage */) stack.push(percentageValue(v.toNumber()));
+          else if (v.type === 0 /* Number */ && v.rational !== void 0) stack.push(numberValueRational(v.toNumber(), v.rational));
+          else if (v.type === 0 /* Number */ && v.exact !== void 0) stack.push(numberValueExact(v.toNumber(), v.exact));
           else stack.push(numberValue(v.toNumber()));
           break;
         }
+        case 28 /* MAKE_UNCERTAIN */: {
+          const spread = safePop(stack), center = safePop(stack);
+          const uncFault = faultedOperand(center, spread);
+          if (uncFault) {
+            stack.push(uncFault);
+            break;
+          }
+          stack.push(numberValueUncertain(center.toNumber(), Math.abs(spread.toNumber())));
+          break;
+        }
         // ═══════════════════════════════════════════════════════════════
         // §4  Bitwise  (OpCode 30–36)
         //     None of these routes through binaryOp(), so each one carries
@@ -1496,6 +1679,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(eqFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(boolValue(cmp === 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(boolValue(l.value === r.value));
           } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
@@ -1508,6 +1698,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(boolValue(sameMeasure && equal));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
             stack.push(matrixCompare(l.value, r.value, (a, b) => a === b));
+          } else if (l.type === 14 /* Colour */ || r.type === 14 /* Colour */) {
+            if (l.type === 14 /* Colour */ && r.type === 14 /* Colour */) {
+              const a = l.value, b = r.value;
+              stack.push(boolValue(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a));
+            } else {
+              stack.push(boolValue(false));
+            }
           } else {
             stack.push(boolValue(l.toNumber() === r.toNumber()));
           }
@@ -1520,6 +1717,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(neqFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(boolValue(cmp !== 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(boolValue(l.value !== r.value));
           } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
@@ -1532,6 +1736,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(boolValue(!sameMeasure || !equal));
           } else if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
             stack.push(matrixCompare(l.value, r.value, (a, b) => a !== b));
+          } else if (l.type === 14 /* Colour */ || r.type === 14 /* Colour */) {
+            if (l.type === 14 /* Colour */ && r.type === 14 /* Colour */) {
+              const a = l.value, b = r.value;
+              stack.push(boolValue(!(a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a)));
+            } else {
+              stack.push(boolValue(true));
+            }
           } else {
             stack.push(boolValue(l.toNumber() !== r.toNumber()));
           }
@@ -1544,6 +1755,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(ltFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(boolValue(cmp < 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(boolValue(l.value < r.value));
           } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
@@ -1566,6 +1784,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(lteFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(boolValue(cmp <= 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(boolValue(l.value <= r.value));
           } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
@@ -1588,6 +1813,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(gtFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(boolValue(cmp > 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(boolValue(l.value > r.value));
           } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
@@ -1610,6 +1842,13 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(gteFault);
             break;
           }
+          if (l.rational !== void 0 || r.rational !== void 0) {
+            const cmp = compareRationalOperands(l, r);
+            if (cmp !== null) {
+              stack.push(boolValue(cmp >= 0));
+              break;
+            }
+          }
           if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
             stack.push(boolValue(l.value >= r.value));
           } else if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
@@ -1843,6 +2082,11 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(toHexFault);
             break;
           }
+          if (v.type === 14 /* Colour */) {
+            const c = v.value;
+            stack.push(colourValue({ r: c.r, g: c.g, b: c.b, a: c.a, format: "hex" }));
+            break;
+          }
           stack.push(hexValue(v.type === 2 /* BigInt */ ? v.value : v.toNumber()));
           break;
         }
@@ -1863,7 +2107,7 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(toFractionFault);
             break;
           }
-          stack.push(stringValue(toFractionString(v.toNumber())));
+          stack.push(stringValue(v.rational !== void 0 ? rationalToFractionString(v.rational) : toFractionString(v.toNumber())));
           break;
         }
         case 141 /* TO_MULTIPLIER */: {
@@ -1935,7 +2179,9 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
             stack.push(faulted);
             break;
           }
-          stack.push(uomValue(operand.toNumber(), unit));
+          const money = moneyExactMagnitude(operand, unit);
+          if (money) stack.push(uomValueExact(operand.toNumber(), unit, money));
+          else stack.push(uomValue(operand.toNumber(), unit));
           break;
         }
         case 81 /* UOM_CONVERT_TO */: {
@@ -1960,7 +2206,12 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
               stack.push(errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
             }
           } else {
-            stack.push(incompatibleConversionError(fromUnit, toUnit));
+            const rate = convertRate(val, fromUnit, toUnit);
+            if (rate !== null) {
+              stack.push(uomValue(rate, toUnit));
+            } else {
+              stack.push(incompatibleConversionError(fromUnit, toUnit));
+            }
           }
           break;
         }
@@ -2005,7 +2256,12 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
                 stack.push(errorValue("CURRENCY_RATE_UNAVAILABLE", `No exchange rate available for ${fromUnit} to ${toUnit}`));
               }
             } else {
-              stack.push(incompatibleConversionError(fromUnit, toUnit));
+              const rate = convertRate(val, fromUnit, toUnit);
+              if (rate !== null) {
+                stack.push(uomValue(rate, toUnit));
+              } else {
+                stack.push(incompatibleConversionError(fromUnit, toUnit));
+              }
             }
           } else {
             stack.push(uomValue(left.toNumber(), toUnit));
@@ -2133,6 +2389,50 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
           stack.push(datetimeValue(shiftDatetime(dtValue.toNumber(), durValue, -1, vm)));
           break;
         }
+        case 96 /* DATE_WORKDAY_OFFSET */: {
+          const workdayDirection = operandByte(opcodes, ip++, op, "workday offset direction") === 1 ? -1 : 1;
+          const anchorValue = safePop(stack), countValue = safePop(stack);
+          const offsetFault = faultedOperand(countValue, anchorValue);
+          if (offsetFault) {
+            stack.push(offsetFault);
+            break;
+          }
+          if (anchorValue.type !== 4 /* Datetime */) {
+            stack.push(errorValue(
+              CoreErrorCodes.WORKDAY_OFFSET_EXPECTED_DATE,
+              `"working days after/before/from" expects a date to count from, got ${ValueType[anchorValue.type] ?? "an unsupported value"}`
+            ));
+            break;
+          }
+          stack.push(datetimeValue(addBusinessDays2(anchorValue.toNumber(), workdayDirection * countValue.toNumber(), vm)));
+          break;
+        }
+        case 97 /* DATE_WORKDAYS_BETWEEN */: {
+          const endValue = safePop(stack), startValue = safePop(stack);
+          const betweenFault = faultedOperand(startValue, endValue);
+          if (betweenFault) {
+            stack.push(betweenFault);
+            break;
+          }
+          if (startValue.type !== 4 /* Datetime */ || endValue.type !== 4 /* Datetime */) {
+            stack.push(errorValue(
+              CoreErrorCodes.WORKDAYS_BETWEEN_EXPECTED_DATES,
+              `"working days between" expects two dates, got ${ValueType[startValue.type] ?? "an unsupported value"} and ${ValueType[endValue.type] ?? "an unsupported value"}`
+            ));
+            break;
+          }
+          const spanLimitDays = Math.ceil((vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()) * 366);
+          const workdayCount = countBusinessDaysBetween(startValue.toNumber(), endValue.toNumber(), (ms) => vm.isHoliday(ms), spanLimitDays);
+          if (workdayCount === null) {
+            stack.push(errorValue(
+              CoreErrorCodes.WORKDAYS_BETWEEN_RANGE_TOO_LARGE,
+              `The two dates are more than ${vm.getMaxDateOffsetYears() - vm.getMinDateOffsetYears()} years apart, past the working-day count's limit`
+            ));
+            break;
+          }
+          stack.push(numberValue(workdayCount));
+          break;
+        }
         case 93 /* DATE_NEXT_WEEKDAY */:
         case 94 /* DATE_LAST_WEEKDAY */: {
           const targetDayValue = safePop(stack);
@@ -2491,5 +2791,5 @@ function executeBytecode(bytecode, vm, pipeline, expression, context, symbolicTo
 }
 
 export { DependencyGraph, ScopeManager, createVM, executeBytecode };
-//# sourceMappingURL=chunk-5WVP4YHP.js.map
-//# sourceMappingURL=chunk-5WVP4YHP.js.map
+//# sourceMappingURL=chunk-WXEHD6TT.js.map
+//# sourceMappingURL=chunk-WXEHD6TT.js.map