solve-engine 1.1.1 → 2.0.0

package/dist/chunk-AQNHHJMJ.cjs

@@ -1,261 +0,0 @@
-'use strict';
-
-var chunkAMOJYLG2_cjs = require('./chunk-AMOJYLG2.cjs');
-
-// src/lexer/units.ts
-var EXCLUDED_UNIT_SPELLINGS = /* @__PURE__ */ new Map([
-  ["in", "the IN keyword owns this word (the conversion operator). ConvertParselet and friends special-case the IN token type directly and trust its text as a unit name, so inches still convert"],
-  ["dec", "already a converter name, as in `255 as dec`"],
-  ["M", "the millions magnitude suffix, as in `2.5M`. Nautical miles are still spelled `nmi` and `NM`"],
-  // Claimed by a normalizer rule rather than by the keyword table, which is why
-  // scanning the locale keywords alone does not find it. Admitting `pm`
-  // (picometre) broke every clock time in the suite: `4pm` lexed as 4
-  // picometres. There is deliberately no entry for `am`: the table's SI
-  // prefixes stop at femto, so attometres do not exist and an exclusion would
-  // be dead weight. `UnitVocabularyCollisions.spec.ts` asserts that.
-  ["pm", "the meridiem marker, as in `4pm`. Picometres lose, and `picometre` still works"],
-  ["are", "the English verb, against a 100-square-metre unit almost nobody writes"],
-  ["ares", "the English verb in plural, same reasoning as `are` above"],
-  ["turn", "ordinary English, against a full-rotation angle unit also spelled in gradians"],
-  ["turns", "ordinary English in plural, same reasoning as `turn` above"],
-  ["grade", "ordinary English. The angle unit is also spelled `gon` and `grad`"],
-  ["grades", "ordinary English in plural, same reasoning as `grade` above"],
-  ["point", "ordinary English. The typographic point is also reachable as `pica`"],
-  ["points", "ordinary English in plural, same reasoning as `point` above"],
-  ["moment", "ordinary English, against an obscure medieval time unit of 90 seconds"],
-  ["moments", "ordinary English in plural, same reasoning as `moment` above"],
-  ["shake", "ordinary English, against an obscure physics unit of ten nanoseconds"],
-  ["shakes", "ordinary English in plural, same reasoning as `shake` above"]
-]);
-function isTokenizableSpelling(spelling) {
-  return /^[A-Za-z0-9_]+$/.test(spelling);
-}
-var GRANDFATHERED_SINGLE_CHARACTER_UNITS = /* @__PURE__ */ new Set([
-  "m",
-  "g",
-  "t",
-  "s",
-  "h",
-  "d",
-  "l",
-  "b",
-  "B",
-  "C",
-  "F",
-  "K",
-  "W"
-]);
-function isAdmissible(spelling) {
-  if (!isTokenizableSpelling(spelling)) return false;
-  if (EXCLUDED_UNIT_SPELLINGS.has(spelling)) return false;
-  if (spelling.length === 1) return GRANDFATHERED_SINGLE_CHARACTER_UNITS.has(spelling);
-  return true;
-}
-var CURRENCY_CODES = [
-  "USD",
-  "EUR",
-  "GBP",
-  "JPY",
-  "AUD",
-  "CAD",
-  "CHF",
-  "CNY",
-  "SEK",
-  "NOK",
-  "DKK",
-  "NZD",
-  "KRW",
-  "SGD",
-  "HKD",
-  "TWD",
-  "INR",
-  "BRL",
-  "ZAR",
-  "MXN",
-  "RUB",
-  "TRY",
-  "SAR",
-  "AED",
-  "ILS",
-  "PLN",
-  "CZK",
-  "HUF",
-  "THB",
-  "IDR",
-  "MYR",
-  "PHP",
-  "CLP",
-  "COP",
-  "ARS",
-  "NGN",
-  "EGP",
-  "PKR",
-  "BDT",
-  "VND",
-  "KES",
-  "XOF",
-  "XAF",
-  "MAD",
-  "QAR",
-  "KWD",
-  "OMR",
-  "BHD",
-  "JOD",
-  "LKR",
-  "MMK",
-  "UZS",
-  "KZT",
-  "RON",
-  "BGN",
-  "HRK",
-  "ISK",
-  "UAH",
-  "GEL",
-  "AZN",
-  "BTN",
-  "BND",
-  "BOB",
-  "BWP",
-  "BYN",
-  "BZD",
-  "CDF",
-  "CRC",
-  "CUP",
-  "DOP",
-  "DZD",
-  "ERN",
-  "ETB",
-  "FJD",
-  "FKP",
-  "GMD",
-  "GNF",
-  "GYD",
-  "HNL",
-  "HTG",
-  "JMD",
-  "KGZ",
-  "KHR",
-  "KMF",
-  "KYD",
-  "LAK",
-  "LBP",
-  "LRD",
-  "LSL",
-  "LYD",
-  "MDL",
-  "MGA",
-  "MKD",
-  "MNT",
-  "MOP",
-  "MRU",
-  "MUR",
-  "MVR",
-  "MWK",
-  "MZN",
-  "NAD",
-  "NIO",
-  "NPR",
-  "PGK",
-  "PYG",
-  "RSD",
-  "RWF",
-  "SBD",
-  "SCR",
-  "SDG",
-  "SHP",
-  "SLE",
-  "SOS",
-  "SRD",
-  "SSP",
-  "STN",
-  "SVC",
-  "SYP",
-  "SZL",
-  "TJS",
-  "TMT",
-  "TND",
-  "TOP",
-  "TTD",
-  "TZS",
-  "UGX",
-  "UYU",
-  "VEB",
-  "VUV",
-  "WST",
-  "XCD",
-  "XDR",
-  "XPF",
-  "YER",
-  "ZMW",
-  "ZWL",
-  "BTC",
-  "ETH",
-  "SOL",
-  "XRP",
-  "ADA",
-  "DOGE",
-  "DOT"
-];
-var CURRENCY_WORD_FORMS = [
-  "dollar",
-  "dollars",
-  "euro",
-  "euros",
-  "yen",
-  "ruble",
-  "rubles",
-  "rouble",
-  "roubles",
-  "won",
-  "rupee",
-  "rupees",
-  "yuan",
-  "renminbi",
-  "franc",
-  "francs",
-  "rand",
-  "krona",
-  "kronor",
-  "krone",
-  "kroner",
-  "real",
-  "reais",
-  "peso",
-  "pesos",
-  "shekel",
-  "shekels",
-  "lira",
-  "hryvnia",
-  "hryvnias",
-  "zloty",
-  "zlotys",
-  "forint",
-  "koruna",
-  "dirham",
-  "dirhams",
-  "riyal",
-  "riyals",
-  "rial",
-  "rials",
-  "ringgit",
-  "rupiah",
-  "baht",
-  "dong",
-  "naira"
-];
-var WORKDAY_UNITS = ["workday", "workdays"];
-var knownUnits = /* @__PURE__ */ new Set([
-  ...Object.keys(chunkAMOJYLG2_cjs.UNIT_TABLE).filter(isAdmissible),
-  ...Object.keys(chunkAMOJYLG2_cjs.EXTENDED_UNITS),
-  ...WORKDAY_UNITS,
-  ...CURRENCY_CODES,
-  ...CURRENCY_WORD_FORMS
-]);
-function isKnownUnit(text) {
-  return knownUnits.has(text);
-}
-
-exports.isKnownUnit = isKnownUnit;
-exports.knownUnits = knownUnits;
-//# sourceMappingURL=chunk-AQNHHJMJ.cjs.map
-//# sourceMappingURL=chunk-AQNHHJMJ.cjs.map

package/dist/chunk-B4HBEFTB.cjs

@@ -1,375 +0,0 @@
-'use strict';
-
-// src/errors/EngineError.ts
-var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
-  ErrorCategory2["PARSING"] = "PARSING";
-  ErrorCategory2["EXECUTION"] = "EXECUTION";
-  ErrorCategory2["VALIDATION"] = "VALIDATION";
-  ErrorCategory2["EXTERNAL"] = "EXTERNAL";
-  ErrorCategory2["INTERNAL"] = "INTERNAL";
-  ErrorCategory2["CONFIG"] = "CONFIG";
-  return ErrorCategory2;
-})(ErrorCategory || {});
-var EngineError = class _EngineError extends Error {
-  constructor(category, init) {
-    super(init.message);
-    this.name = "EngineError";
-    this.category = category;
-    this.code = init.code;
-    this.expected = init.expected;
-    this.found = init.found;
-    this.suggestion = init.suggestion;
-    this.recoverable = init.recoverable ?? true;
-    this.span = init.span;
-    this.context = init.context;
-    this.cause = init.cause;
-    this.timestamp = /* @__PURE__ */ new Date();
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _EngineError);
-    }
-  }
-  /** `!recoverable`. See `EngineErrorInit.recoverable`'s doc comment for what this actually gates (message framing/telemetry, not whether evaluation continues). */
-  isFatal() {
-    return !this.recoverable;
-  }
-  /** Walk `.cause` repeatedly, collecting the full chain (this error first). */
-  causeChain() {
-    const chain = [this];
-    let current = this.cause;
-    while (current !== void 0 && current !== null) {
-      chain.push(current);
-      current = current instanceof Error ? current.cause : void 0;
-    }
-    return chain;
-  }
-  /**
-   * Rust/Go-style multi-line renderer, the NEW thing a host/CLI/test
-   * reaches for when it wants the full, verbose picture, as distinct from
-   * `.message` (kept short and stable for existing assertions). Example:
-   *
-   * ```
-   * error[WEATHER_EXPECTED_CITY]: Expected a city name after "weather in"
-   *   expected: a city name
-   *   found: end of expression
-   *   suggestion: e.g. "weather in London"
-   * ```
-   */
-  format() {
-    const lines = [`error[${this.code}]: ${this.message}`];
-    if (this.expected) lines.push(`  expected: ${this.expected}`);
-    if (this.found) lines.push(`  found: ${this.found}`);
-    if (this.suggestion) lines.push(`  suggestion: ${this.suggestion}`);
-    return lines.join("\n");
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      category: this.category,
-      code: this.code,
-      message: this.message,
-      expected: this.expected,
-      found: this.found,
-      suggestion: this.suggestion,
-      recoverable: this.recoverable,
-      span: this.span,
-      context: this.context,
-      timestamp: this.timestamp.toISOString()
-    };
-  }
-};
-var ErrorFactory = class _ErrorFactory {
-  static build(category, defaultRecoverable, codeOrInit, message, context) {
-    const init = typeof codeOrInit === "string" ? { code: codeOrInit, message, context } : codeOrInit;
-    return new EngineError(category, { recoverable: defaultRecoverable, ...init });
-  }
-  static validation(codeOrInit, message, context) {
-    return _ErrorFactory.build("VALIDATION" /* VALIDATION */, true, codeOrInit, message, context);
-  }
-  static parsing(codeOrInit, message, context) {
-    return _ErrorFactory.build("PARSING" /* PARSING */, true, codeOrInit, message, context);
-  }
-  static execution(codeOrInit, message, context) {
-    return _ErrorFactory.build("EXECUTION" /* EXECUTION */, true, codeOrInit, message, context);
-  }
-  static external(codeOrInit, message, context) {
-    return _ErrorFactory.build("EXTERNAL" /* EXTERNAL */, true, codeOrInit, message, context);
-  }
-  static internal(codeOrInit, message, context) {
-    return _ErrorFactory.build("INTERNAL" /* INTERNAL */, true, codeOrInit, message, context);
-  }
-  static config(codeOrInit, message, context) {
-    return _ErrorFactory.build("CONFIG" /* CONFIG */, false, codeOrInit, message, context);
-  }
-};
-function normalizeUnknownError(error) {
-  if (error instanceof EngineError) return error;
-  if (error instanceof Error) {
-    return ErrorFactory.internal({
-      code: "UNEXPECTED_ERROR",
-      message: error.message,
-      context: { originalErrorName: error.name },
-      cause: error,
-      recoverable: true
-    });
-  }
-  return ErrorFactory.internal({
-    code: "UNKNOWN_ERROR",
-    message: "An unknown error occurred",
-    context: { error: String(error) },
-    recoverable: true
-  });
-}
-
-// src/errors/Result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-function isOk(r) {
-  return r.ok;
-}
-function isErr(r) {
-  return !r.ok;
-}
-function map(r, fn) {
-  return r.ok ? ok(fn(r.value)) : r;
-}
-function mapErr(r, fn) {
-  return r.ok ? r : err(fn(r.error));
-}
-function andThen(r, fn) {
-  return r.ok ? fn(r.value) : r;
-}
-function unwrapOr(r, fallback) {
-  return r.ok ? r.value : fallback;
-}
-function match(r, arms) {
-  return r.ok ? arms.ok(r.value) : arms.err(r.error);
-}
-function combine(results) {
-  const values = [];
-  for (const r of results) {
-    if (!r.ok) return r;
-    values.push(r.value);
-  }
-  return ok(values);
-}
-function throwIfErr(r) {
-  if (r.ok) return r.value;
-  throw r.error;
-}
-function tryCatch(fn, normalize = normalizeUnknownError) {
-  try {
-    return ok(fn());
-  } catch (e) {
-    return err(normalize(e));
-  }
-}
-async function tryCatchAsync(fn, normalize = normalizeUnknownError) {
-  try {
-    return ok(await fn());
-  } catch (e) {
-    return err(normalize(e));
-  }
-}
-
-// src/errors/ErrorCode.ts
-var CoreErrorCodes = {
-  // ── Parser (parser/PrecedenceParser.ts, parser/BytecodeBuilder.ts, parser/PhrasePattern.ts) ──
-  INVALID_NUMBER_LITERAL: "INVALID_NUMBER_LITERAL",
-  /** A `"` that never meets its closing partner (`lexer/ExpressionLexer.ts`'s `tokenizeString()`). Previously the tokenizer ran off the end of the input and returned what it had, so `"abc` lexed to an ordinary String and an unterminated literal was indistinguishable from a terminated one. */
-  UNTERMINATED_STRING: "UNTERMINATED_STRING",
-  NO_PREFIX_PARSELET: "NO_PREFIX_PARSELET",
-  UNEXPECTED_END_OF_INPUT: "UNEXPECTED_END_OF_INPUT",
-  UNEXPECTED_TOKEN_TYPE: "UNEXPECTED_TOKEN_TYPE",
-  NESTING_DEPTH_EXCEEDED: "NESTING_DEPTH_EXCEEDED",
-  UNEXPECTED_END: "UNEXPECTED_END",
-  UNEXPECTED_TRAILING_TOKEN: "UNEXPECTED_TRAILING_TOKEN",
-  PARSE_ERROR: "PARSE_ERROR",
-  TOO_MANY_NUMERIC_CONSTANTS: "TOO_MANY_NUMERIC_CONSTANTS",
-  TOO_MANY_STRING_CONSTANTS: "TOO_MANY_STRING_CONSTANTS",
-  NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE",
-  INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN",
-  PHRASE_KEYWORD_MISMATCH: "PHRASE_KEYWORD_MISMATCH",
-  /** User-defined-function definition parsing (`f(x, y) = ...`), an invalid token where a parameter name was expected. */
-  USER_FUNCTION_INVALID_PARAM_NAME: "USER_FUNCTION_INVALID_PARAM_NAME",
-  /** `f() = ...` with zero parameters, indistinguishable from a plain no-arg function call, so rejected at definition time. */
-  USER_FUNCTION_NO_PARAMS: "USER_FUNCTION_NO_PARAMS",
-  /** A user-defined function body calling an async plugin (weather/stocks/currency/...), rejected at definition time; v1 scope excludes async function bodies. */
-  FUNCTION_BODY_MUST_BE_SYNCHRONOUS: "FUNCTION_BODY_MUST_BE_SYNCHRONOUS",
-  /** `BytecodeBuilder`'s `userFunctionBodies` side-table exceeding its capacity. Same class as `TOO_MANY_NUMERIC_CONSTANTS`/`TOO_MANY_STRING_CONSTANTS` below. */
-  TOO_MANY_FUNCTION_DEFINITIONS: "TOO_MANY_FUNCTION_DEFINITIONS",
-  /** `BytecodeBuilder`'s `anonymousBodies` side-table (map/reduce inline transform bodies) exceeding its capacity. Same class as `TOO_MANY_FUNCTION_DEFINITIONS` above. */
-  TOO_MANY_ANONYMOUS_BODIES: "TOO_MANY_ANONYMOUS_BODIES",
-  // ── VM (vm/VM.ts, vm/OpRegistry.ts, vm/VMBuiltins.ts) ──
-  EVALUATION_ERROR: "EVALUATION_ERROR",
-  INSTRUCTION_LIMIT_EXCEEDED: "INSTRUCTION_LIMIT_EXCEEDED",
-  STACK_LIMIT_EXCEEDED: "STACK_LIMIT_EXCEEDED",
-  /** One evaluation asking for more elements (collection Values, matrix cells) than `vm.maxAllocatedElements` allows. The counter the two limits above cannot be: both are checked between opcodes, so neither can see what a single opcode allocates inside a loop of its own. See `vm/AllocationBudget.ts`. Recoverable, since it describes this expression rather than the engine. */
-  ALLOCATION_LIMIT_EXCEEDED: "ALLOCATION_LIMIT_EXCEEDED",
-  /** New this phase. See `VM.ts`'s `safePop()`: a stack-underflow (corrupted bytecode, a buggy plugin) is now a controlled EngineError instead of a raw TypeError. Category INTERNAL, since it is an engine or plugin fault rather than a typed line, but recoverable: it happened on one line and the engine is still usable. */
-  STACK_UNDERFLOW: "STACK_UNDERFLOW",
-  UNDEFINED_VARIABLE: "UNDEFINED_VARIABLE",
-  /** New this phase, the Tier-2/`LOAD_GLOBAL_VAR` hardening: a global variable read before its async preflight resolved, surfaced as a controlled error instead of pushing `undefined`. */
-  GLOBAL_VARIABLE_NOT_RESOLVED: "GLOBAL_VARIABLE_NOT_RESOLVED",
-  UNKNOWN_FUNCTION: "UNKNOWN_FUNCTION",
-  /** `unwrapEvalResult()`'s pending-when-expecting-value case, a caller-contract violation, not user-input. */
-  UNEXPECTED_PENDING_RESULT: "UNEXPECTED_PENDING_RESULT",
-  /** User-defined-function call/definition errors (`CALL_USER_FUNCTION`/`DEFINE_USER_FUNCTION` opcodes), calling a name with no matching definition, calling with the wrong argument count, and the deliberate v1 restriction that a function body can't itself contain async work. */
-  UNDEFINED_FUNCTION: "UNDEFINED_FUNCTION",
-  FUNCTION_ARITY_MISMATCH: "FUNCTION_ARITY_MISMATCH",
-  /** The same mistake against a BUILT-IN rather than a user-defined function (`sqrt()`, `atan2(1)`, `sqrt(1,2,3)`). Separate from `FUNCTION_ARITY_MISMATCH` above because the two are raised by different opcodes and a host may want to word them differently. Checked at the `CALL_BUILTIN` dispatch against `vm/VMBuiltinArity.ts`; recoverable, since it is a typo in the line, not an engine fault. */
-  BUILTIN_ARITY_MISMATCH: "BUILTIN_ARITY_MISMATCH",
-  USER_FUNCTION_ASYNC_UNSUPPORTED: "USER_FUNCTION_ASYNC_UNSUPPORTED",
-  /** A map/reduce transform body (inline expression or user-defined function) calling an async plugin. Same v1 scope restriction as `USER_FUNCTION_ASYNC_UNSUPPORTED` above, enforced both at parse time (`MAP_REDUCE_TRANSFORM_MUST_BE_SYNCHRONOUS`, packages/mapreduce/) and as a defense-in-depth runtime backstop here. */
-  MAP_REDUCE_ASYNC_UNSUPPORTED: "MAP_REDUCE_ASYNC_UNSUPPORTED",
-  /** An algebra verb's expression argument (`BIND_UNKNOWN`'s body) calling an async plugin. Same v1 scope restriction as the two above, and likewise refused at parse time first (`SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS`, packages/symbolic/). */
-  SYMBOLIC_ASYNC_UNSUPPORTED: "SYMBOLIC_ASYNC_UNSUPPORTED",
-  /** `explainLine()` asked to derive a line that resolves data asynchronously (a live-data or async-plugin line). A derivation is a sequence of settled intermediate values, which a pending result has none of, so the line is refused rather than explained with a hole in it. */
-  EXPLAIN_ASYNC_UNSUPPORTED: "EXPLAIN_ASYNC_UNSUPPORTED",
-  /** `pushCallFrame()`'s recursion guard, a nested `CALL_USER_FUNCTION` re-enters `executeBytecode()`, so `maxInstructions` alone can't catch e.g. `f(x) = f(x)`; this is the dedicated backstop. `recoverable: true` (the default for `.execution()`), ordinary user-written infinite recursion, not an engine bug; the guard exists precisely so it surfaces as a clear error instead of overflowing the native call stack uncatchably. */
-  FUNCTION_RECURSION_LIMIT_EXCEEDED: "FUNCTION_RECURSION_LIMIT_EXCEEDED",
-  /** The companion to the code above, and the half it could never see: how MANY user-defined-function calls one evaluation makes, rather than how deeply they nest. A twenty-two-line doubling chain nests twenty-two deep (legal) and makes two million calls (a fatal heap abort). Counted in `vm/AllocationBudget.ts`, because the tally has to survive `executeBytecode()` re-entering itself. Recoverable. */
-  FUNCTION_CALL_LIMIT_EXCEEDED: "FUNCTION_CALL_LIMIT_EXCEEDED",
-  /** A `<date> + N workdays` offset outside `date.maxOffsetYears`/`minOffsetYears`. Workdays are the one date offset that walks the calendar a day at a time, so the one whose cost is the offset; every other one moves a Date field once. Recoverable. */
-  DATE_OFFSET_LIMIT_EXCEEDED: "DATE_OFFSET_LIMIT_EXCEEDED",
-  /** The anchor of `N working days after/before/from <expr>` was not a date (e.g. `5 working days after 3`). The grammar guarantees the count is a number, so this only fires on the anchor. Emitted as a recoverable Error value, not thrown, matching the datetime package's other type guards. See `vm/VM.ts`'s `DATE_WORKDAY_OFFSET` case. */
-  WORKDAY_OFFSET_EXPECTED_DATE: "WORKDAY_OFFSET_EXPECTED_DATE",
-  /** An endpoint of `working days between <expr> and <expr>` was not a date. Recoverable Error value. See `vm/VM.ts`'s `DATE_WORKDAYS_BETWEEN` case. */
-  WORKDAYS_BETWEEN_EXPECTED_DATES: "WORKDAYS_BETWEEN_EXPECTED_DATES",
-  /** The two endpoints of `working days between <expr> and <expr>` are further apart than `date.maxOffsetYears`/`minOffsetYears` allow the count's calendar walk to run. Recoverable Error value, the between-count's equivalent of `DATE_OFFSET_LIMIT_EXCEEDED`. See `vm/VM.ts`'s `DATE_WORKDAYS_BETWEEN` case. */
-  WORKDAYS_BETWEEN_RANGE_TOO_LARGE: "WORKDAYS_BETWEEN_RANGE_TOO_LARGE",
-  /** A `<<`/`>>` with a bigint operand whose exact result would pass `MAX_EXACT_SHIFT_BITS`, whichever operand is the bigint. Both spellings refuse as of 1.0.0: a bigint on the left used to fall through to `x * 2^n` in doubles and report a 19,870-digit integer as Infinity. See `vm/VM.ts`'s `bigIntShift()`. Recoverable. */
-  BIGINT_SHIFT_LIMIT_EXCEEDED: "BIGINT_SHIFT_LIMIT_EXCEEDED",
-  /** The same ceiling for `^`, the operator it was written for: `2n ^ 100000` asks for the same 100,001-bit integer `1n << 100000` does, so the two spellings answer the same way. Also new in 1.0.0, and for the same reason: this used to fall through to the double path and answer Infinity. A fractional or negative exponent (`4n ^ 0.5`, `2n ^ -1`) has no exact answer to bound and still uses the double path. See `vm/VM.ts`'s `MAX_EXACT_POW_BITS`. Recoverable. */
-  BIGINT_POW_LIMIT_EXCEEDED: "BIGINT_POW_LIMIT_EXCEEDED",
-  /** An operand with no whole-number form (a fraction, an infinity, a NaN) meeting a bigint: `1n + 0.5`, `1n & 1.5`, `5n/pi`. `BigInt()` answers those with a raw RangeError, which the VM relabelled UNEXPECTED_ERROR, so a typo in the line was reported as an engine fault. Recoverable; see `vm/VMConversion.ts`'s `toBigIntOperand()`. */
-  BIGINT_INEXACT_OPERAND: "BIGINT_INEXACT_OPERAND",
-  /** `10n / 0n` and `10n mod 0n`. Deliberately NOT what `1 / 0` does, which is Infinity: a bigint division is exact integer division (`7n / 2n` is 3n), and integer division by zero has no answer, exactly as it has none in C, Java, Python or JavaScript's own BigInt. Previously V8's own RangeError, relabelled UNEXPECTED_ERROR. Recoverable; see `vm/VMConversion.ts`'s `bigIntDivisionByZero()`. */
-  BIGINT_DIVISION_BY_ZERO: "BIGINT_DIVISION_BY_ZERO",
-  /** `DEFINE_USER_FUNCTION`'s body-index lookup failing, a compiler/VM invariant violation (the opcode stream referenced a `userFunctionBodies` slot that doesn't exist), never a user-input error. */
-  INTERNAL_MISSING_FUNCTION_BODY: "INTERNAL_MISSING_FUNCTION_BODY",
-  /** `MAP_INVOKE`/`REDUCE_INVOKE`'s anonymous-body-index lookup failing. Same class as `INTERNAL_MISSING_FUNCTION_BODY` above, for the `anonymousBodies` side-table instead of `userFunctionBodies`. */
-  INTERNAL_MISSING_ANONYMOUS_BODY: "INTERNAL_MISSING_ANONYMOUS_BODY",
-  // ── Malformed bytecode on the public `./vm` surface (vm/VM.ts) ──
-  //
-  // `executeBytecode` is exported, so a bytecode program is caller input in
-  // the same sense an expression string is, and these five say so. They are
-  // VALIDATION rather than INTERNAL for exactly that reason: before they
-  // existed, every one of these cases reached a raw TypeError (`BigInt(undefined)`,
-  // `code.toUpperCase()` on a boolean, destructuring a program that was not
-  // there), which normalised to UNEXPECTED_ERROR and told the caller the
-  // engine was broken when their eleven bytes were. Reachable from ordinary
-  // source only through a compiler bug, which is why the messages name the
-  // opcode and the operand rather than the user's line.
-  /** An operand byte read past the end of the stream: the program ends in the middle of an instruction. */
-  MALFORMED_BYTECODE_TRUNCATED: "MALFORMED_BYTECODE_TRUNCATED",
-  /** A constant-pool operand indexing a `numbers`/`strings` entry that does not exist, or that is not of the pool's type. */
-  MALFORMED_BYTECODE_CONSTANT_INDEX: "MALFORMED_BYTECODE_CONSTANT_INDEX",
-  /** A unit or converter name read off the value stack that is not a string. Distinct from the pool case above: the operand is a Value another opcode pushed, not a pool entry. */
-  MALFORMED_BYTECODE_OPERAND_TYPE: "MALFORMED_BYTECODE_OPERAND_TYPE",
-  /** `MAP_INVOKE`/`REDUCE_INVOKE` carrying a body kind other than 0/1/2. Used to fall through every arm with no body and recurse into `executeBytecode(undefined)`. */
-  MALFORMED_BYTECODE_BODY_KIND: "MALFORMED_BYTECODE_BODY_KIND",
-  /** A `PUSH_BIGINT` pool entry that is not a whole number, e.g. `"1.000"`. `BigInt()` answers that with a raw SyntaxError. */
-  MALFORMED_BYTECODE_BIGINT_LITERAL: "MALFORMED_BYTECODE_BIGINT_LITERAL",
-  /** `executeBytecode()` called with something that is not a runnable program at all. Checked before the destructure that used to throw outside the function's own try/catch. */
-  MALFORMED_BYTECODE_PROGRAM: "MALFORMED_BYTECODE_PROGRAM",
-  // ── Symbolic algebra (symbolic/, vm/SymbolicOps.ts) ──
-  /** A coefficient grew past `RATIONAL_MAX_BITS`, e.g. repeated exact elimination multiplying denominators together. */
-  SYMBOLIC_RATIONAL_OVERFLOW: "SYMBOLIC_RATIONAL_OVERFLOW",
-  /** `NaN` or `±Infinity` reaching a symbolic expression, neither of which has an exact rational value. */
-  SYMBOLIC_NONFINITE_OPERAND: "SYMBOLIC_NONFINITE_OPERAND",
-  /** Division by an exactly-zero rational. Exact, unlike the double comparison it replaced, which could not distinguish a true zero from `5.551e-17`. */
-  SYMBOLIC_DIVISION_BY_ZERO: "SYMBOLIC_DIVISION_BY_ZERO",
-  /** A tree exceeding `SYMBOLIC_MAX_NODES` entering the simplifier. */
-  SYMBOLIC_NODE_LIMIT_EXCEEDED: "SYMBOLIC_NODE_LIMIT_EXCEEDED",
-  /** A builtin with no symbolic reading (`min`, `random`, the finance block, ...) applied to an expression still containing an unknown. Returned rather than computing against `toNumber()`'s placeholder zero. */
-  SYMBOLIC_UNSUPPORTED_FUNCTION: "SYMBOLIC_UNSUPPORTED_FUNCTION",
-  /** The rational-root search exceeding `FACTOR_MAX_ROOT_CANDIDATES`. The candidate set is the product of two divisor sets, so a highly-composite coefficient escapes quickly. */
-  SYMBOLIC_FACTOR_LIMIT_EXCEEDED: "SYMBOLIC_FACTOR_LIMIT_EXCEEDED",
-  /** An equation outside what the solver attempts: not a polynomial, above the degree ceiling, or non-linear in the unknown while another unknown is present. */
-  SYMBOLIC_SOLVE_UNSUPPORTED: "SYMBOLIC_SOLVE_UNSUPPORTED",
-  /** Some but not all of an equation's roots were found. Reported rather than returned, because a partial list of roots looks exactly like a complete one. */
-  SYMBOLIC_SOLVE_INCOMPLETE: "SYMBOLIC_SOLVE_INCOMPLETE",
-  /** `solve`'s second argument not being a bare name. */
-  SOLVE_REQUIRES_VARIABLE_NAME: "SOLVE_REQUIRES_VARIABLE_NAME",
-  /** A derivative order outside 0..`DERIVATIVE_MAX_ORDER`. */
-  SYMBOLIC_DERIVATIVE_ORDER_LIMIT: "SYMBOLIC_DERIVATIVE_ORDER_LIMIT",
-  /** An expression with no known elementary antiderivative. Reported rather than approximated, since a wrong integral is indistinguishable from a right one at the point of use. */
-  SYMBOLIC_INTEGRAL_UNSUPPORTED: "SYMBOLIC_INTEGRAL_UNSUPPORTED",
-  /** A Taylor degree outside 0..`TAYLOR_MAX_DEGREE`. */
-  SYMBOLIC_TAYLOR_DEGREE_LIMIT: "SYMBOLIC_TAYLOR_DEGREE_LIMIT",
-  /** A Taylor coefficient that does not reduce to an exact number at the expansion point. */
-  SYMBOLIC_TAYLOR_INEXACT: "SYMBOLIC_TAYLOR_INEXACT",
-  /** An algebra verb's variable-name argument not being a bare name. */
-  SYMBOLIC_REQUIRES_VARIABLE_NAME: "SYMBOLIC_REQUIRES_VARIABLE_NAME",
-  /** `jacobian` called with expressions containing no unknown to differentiate against. */
-  SYMBOLIC_JACOBIAN_NO_VARIABLES: "SYMBOLIC_JACOBIAN_NO_VARIABLES",
-  /** A finite number whose decimal form could not be read back, which the regex covering every `Number.prototype.toString` output should make unreachable. */
-  INTERNAL_RATIONAL_PARSE: "INTERNAL_RATIONAL_PARSE",
-  // ── Engine (engine/ExpressionEngine.ts, engine/ExpressionEngineSafety.ts, engine/AsyncResolutionBatcher.ts) ──
-  EXPRESSION_TOO_LONG: "EXPRESSION_TOO_LONG",
-  EXPRESSION_TOO_COMPLEX: "EXPRESSION_TOO_COMPLEX",
-  /** A document with more lines than `performance.maxDocumentLines`. The per-line limits above bound what one line may ask for and say nothing about how many lines there are; two hundred thousand of `1 + 1` exhausted the heap on the line records alone. Recoverable. */
-  DOCUMENT_TOO_LARGE: "DOCUMENT_TOO_LARGE",
-  NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED",
-  /** `"=>"` with nothing before it, needs an expression or variable name to solve/simplify. */
-  THEREFORE_REQUIRES_EXPRESSION: "THEREFORE_REQUIRES_EXPRESSION",
-  /** A `"=>"`-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies. */
-  THEREFORE_ASYNC_UNSUPPORTED: "THEREFORE_ASYNC_UNSUPPORTED",
-  /** Colon-separated numbers that are not a time any clock can show ("24:00", "9:60", "100:5"). Raised by the labeled-line fallback, which used to answer them with whatever stood after the colon. */
-  INVALID_TIME_LITERAL: "INVALID_TIME_LITERAL",
-  // ── Snapshot / restore (engine/EngineSnapshot.ts, engine/ExpressionEngine.ts) ──
-  /** `fromJSON()` handed an object that is not a snapshot at all, or whose serialised-shape version does not match this engine's reader. The versioning gate that refuses an incompatible snapshot clearly rather than restoring it wrongly. See `engine/EngineSnapshot.ts`'s `assertRestorable()`. */
-  SNAPSHOT_VERSION_MISMATCH: "SNAPSHOT_VERSION_MISMATCH",
-  /** A snapshot with the right envelope but internally inconsistent contents (an unrecognised number sentinel, an unknown value tag). Distinct from a version mismatch: the format is right, the payload is not. */
-  SNAPSHOT_MALFORMED: "SNAPSHOT_MALFORMED",
-  /** A value the v1 snapshot format cannot yet represent (a symbolic/algebra value, a symbolic matrix cell). Deferred to a follow-up; refused by name rather than dropped silently. */
-  SNAPSHOT_UNSUPPORTED_VALUE: "SNAPSHOT_UNSUPPORTED_VALUE",
-  // ── Config (constants/Configuration.ts) ──
-  CONFIG_PATH_NOT_FOUND: "CONFIG_PATH_NOT_FOUND",
-  INVALID_CONFIG_PATH: "INVALID_CONFIG_PATH",
-  CONFIG_SECTION_NOT_FOUND: "CONFIG_SECTION_NOT_FOUND",
-  CONFIG_PROPERTY_NOT_FOUND: "CONFIG_PROPERTY_NOT_FOUND",
-  // ── Package/lexer registration-time collisions (lexer/ExpressionLexer.ts) ──
-  PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION",
-  PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION",
-  PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION",
-  /** A package's declared `IEnginePackage.engineVersion` semver range doesn't satisfy the running engine's ENGINE_VERSION. See api/EngineVersionCompatibility.ts. */
-  PACKAGE_ENGINE_VERSION_MISMATCH: "PACKAGE_ENGINE_VERSION_MISMATCH",
-  /** A package's declared `IEnginePackage.engineVersion` isn't a parseable semver range at all (a typo in the package's own descriptor). */
-  PACKAGE_ENGINE_VERSION_INVALID_RANGE: "PACKAGE_ENGINE_VERSION_INVALID_RANGE",
-  /** `OpRegistry.allocateOpcode()`'s dynamic opcode pool (started at 201) exhausted, too many packages calling it. */
-  OPCODE_POOL_EXHAUSTED: "OPCODE_POOL_EXHAUSTED",
-  /** `VMBuiltins.allocatePluginFunctionIndex()`'s 0-255 index pool (a single opcode-stream byte) exhausted. */
-  PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED",
-  // ── vm/Value.ts caller-contract violations (check isRateUnit()/isTimecodeUnit() first) ──
-  INVALID_RATE_UNIT: "INVALID_RATE_UNIT",
-  INVALID_TIMECODE_UNIT: "INVALID_TIMECODE_UNIT",
-  // ── errors/EngineError.ts's own fallback normalization ──
-  UNEXPECTED_ERROR: "UNEXPECTED_ERROR",
-  UNKNOWN_ERROR: "UNKNOWN_ERROR"
-};
-
-exports.CoreErrorCodes = CoreErrorCodes;
-exports.EngineError = EngineError;
-exports.ErrorCategory = ErrorCategory;
-exports.ErrorFactory = ErrorFactory;
-exports.andThen = andThen;
-exports.combine = combine;
-exports.err = err;
-exports.isErr = isErr;
-exports.isOk = isOk;
-exports.map = map;
-exports.mapErr = mapErr;
-exports.match = match;
-exports.normalizeUnknownError = normalizeUnknownError;
-exports.ok = ok;
-exports.throwIfErr = throwIfErr;
-exports.tryCatch = tryCatch;
-exports.tryCatchAsync = tryCatchAsync;
-exports.unwrapOr = unwrapOr;
-//# sourceMappingURL=chunk-B4HBEFTB.cjs.map
-//# sourceMappingURL=chunk-B4HBEFTB.cjs.map