solve-engine 1.2.0 → 2.0.0

package/dist/chunk-N7OA4WPJ.js

@@ -1,362 +0,0 @@
-// 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",
-  /** A compound assignment (`name += expr` / `name -= expr`) with nothing on the right, a line half-typed on the way to `total += 5`. */
-  COMPOUND_ASSIGN_REQUIRES_EXPRESSION: "COMPOUND_ASSIGN_REQUIRES_EXPRESSION",
-  /** A running total (`+= / -=`) whose right-hand side calls an async plugin (weather/stocks/currency). The same v1 scope restriction as the `"=>"` and user-function bodies. */
-  COMPOUND_ASSIGN_ASYNC_UNSUPPORTED: "COMPOUND_ASSIGN_ASYNC_UNSUPPORTED",
-  /** A savings-goal contribution period that is not one of daily/weekly/monthly/yearly (`how long to save $X at $Y <period>`). Names the accepted set. */
-  UNKNOWN_SAVINGS_PERIOD: "UNKNOWN_SAVINGS_PERIOD",
-  /** 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"
-};
-
-export { CoreErrorCodes, EngineError, ErrorCategory, ErrorFactory, andThen, combine, err, isErr, isOk, map, mapErr, match, normalizeUnknownError, ok, throwIfErr, tryCatch, tryCatchAsync, unwrapOr };
-//# sourceMappingURL=chunk-N7OA4WPJ.js.map
-//# sourceMappingURL=chunk-N7OA4WPJ.js.map

package/dist/chunk-N7OA4WPJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/errors/EngineError.ts","../src/errors/Result.ts","../src/errors/ErrorCode.ts"],"names":["ErrorCategory"],"mappings":";AA6BO,IAAK,aAAA,qBAAAA,cAAAA,KAAL;AAEL,EAAAA,eAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,eAAA,WAAA,CAAA,GAAY,WAAA;AAEZ,EAAAA,eAAA,YAAA,CAAA,GAAa,YAAA;AAEb,EAAAA,eAAA,UAAA,CAAA,GAAW,UAAA;AAEX,EAAAA,eAAA,UAAA,CAAA,GAAW,UAAA;AAEX,EAAAA,eAAA,QAAA,CAAA,GAAS,QAAA;AAZC,EAAA,OAAAA,cAAAA;AAAA,CAAA,EAAA,aAAA,IAAA,EAAA;AAmEL,IAAM,WAAA,GAAN,MAAM,YAAA,SAAoB,KAAA,CAAM;AAAA,EAsBrC,WAAA,CAAY,UAAyB,IAAA,EAAuB;AAC1D,IAAA,KAAA,CAAM,KAAK,OAAO,CAAA;AAClB,IAAA,IAAA,CAAK,IAAA,GAAO,aAAA;AACZ,IAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAChB,IAAA,IAAA,CAAK,OAAO,IAAA,CAAK,IAAA;AACjB,IAAA,IAAA,CAAK,WAAW,IAAA,CAAK,QAAA;AACrB,IAAA,IAAA,CAAK,QAAQ,IAAA,CAAK,KAAA;AAClB,IAAA,IAAA,CAAK,aAAa,IAAA,CAAK,UAAA;AACvB,IAAA,IAAA,CAAK,WAAA,GAAc,KAAK,WAAA,IAAe,IAAA;AACvC,IAAA,IAAA,CAAK,OAAO,IAAA,CAAK,IAAA;AACjB,IAAA,IAAA,CAAK,UAAU,IAAA,CAAK,OAAA;AACpB,IAAA,IAAA,CAAK,QAAQ,IAAA,CAAK,KAAA;AAClB,IAAA,IAAA,CAAK,SAAA,uBAAgB,IAAA,EAAK;AAC1B,IAAA,IAAI,MAAM,iBAAA,EAAmB;AAC3B,MAAA,KAAA,CAAM,iBAAA,CAAkB,MAAM,YAAW,CAAA;AAAA,IAC3C;AAAA,EACF;AAAA;AAAA,EAGA,OAAA,GAAmB;AACjB,IAAA,OAAO,CAAC,IAAA,CAAK,WAAA;AAAA,EACf;AAAA;AAAA,EAGA,UAAA,GAAwB;AACtB,IAAA,MAAM,KAAA,GAAmB,CAAC,IAAI,CAAA;AAC9B,IAAA,IAAI,UAAmB,IAAA,CAAK,KAAA;AAC5B,IAAA,OAAO,OAAA,KAAY,MAAA,IAAa,OAAA,KAAY,IAAA,EAAM;AAChD,MAAA,KAAA,CAAM,KAAK,OAAO,CAAA;AAClB,MAAA,OAAA,GAAU,OAAA,YAAmB,KAAA,GAAS,OAAA,CAAwC,KAAA,GAAQ,MAAA;AAAA,IACxF;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,MAAA,GAAiB;AACf,IAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,MAAA,EAAS,IAAA,CAAK,IAAI,CAAA,GAAA,EAAM,IAAA,CAAK,OAAO,CAAA,CAAE,CAAA;AACrD,IAAA,IAAI,KAAK,QAAA,EAAU,KAAA,CAAM,KAAK,CAAA,YAAA,EAAe,IAAA,CAAK,QAAQ,CAAA,CAAE,CAAA;AAC5D,IAAA,IAAI,KAAK,KAAA,EAAO,KAAA,CAAM,KAAK,CAAA,SAAA,EAAY,IAAA,CAAK,KAAK,CAAA,CAAE,CAAA;AACnD,IAAA,IAAI,KAAK,UAAA,EAAY,KAAA,CAAM,KAAK,CAAA,cAAA,EAAiB,IAAA,CAAK,UAAU,CAAA,CAAE,CAAA;AAClE,IAAA,OAAO,KAAA,CAAM,KAAK,IAAI,CAAA;AAAA,EACxB;AAAA,EAEA,MAAA,GAAkC;AAChC,IAAA,OAAO;AAAA,MACL,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,UAAU,IAAA,CAAK,QAAA;AAAA,MACf,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,SAAS,IAAA,CAAK,OAAA;AAAA,MACd,UAAU,IAAA,CAAK,QAAA;AAAA,MACf,OAAO,IAAA,CAAK,KAAA;AAAA,MACZ,YAAY,IAAA,CAAK,UAAA;AAAA,MACjB,aAAa,IAAA,CAAK,WAAA;AAAA,MAClB,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,SAAS,IAAA,CAAK,OAAA;AAAA,MACd,SAAA,EAAW,IAAA,CAAK,SAAA,CAAU,WAAA;AAAY,KACxC;AAAA,EACF;AACF;AAWO,IAAM,YAAA,GAAN,MAAM,aAAA,CAAa;AAAA,EACxB,OAAe,KAAA,CACb,QAAA,EACA,kBAAA,EACA,UAAA,EACA,SACA,OAAA,EACa;AACb,IAAA,MAAM,IAAA,GACJ,OAAO,UAAA,KAAe,QAAA,GAClB,EAAE,IAAA,EAAM,UAAA,EAAY,OAAA,EAAmB,OAAA,EAAQ,GAC/C,UAAA;AACN,IAAA,OAAO,IAAI,YAAY,QAAA,EAAU,EAAE,aAAa,kBAAA,EAAoB,GAAG,MAAM,CAAA;AAAA,EAC/E;AAAA,EAIA,OAAO,UAAA,CAAW,UAAA,EAAsC,OAAA,EAAkB,OAAA,EAAgD;AACxH,IAAA,OAAO,cAAa,KAAA,CAAM,YAAA,mBAA0B,IAAA,EAAM,UAAA,EAAY,SAAS,OAAO,CAAA;AAAA,EACxF;AAAA,EAIA,OAAO,OAAA,CAAQ,UAAA,EAAsC,OAAA,EAAkB,OAAA,EAAgD;AACrH,IAAA,OAAO,cAAa,KAAA,CAAM,SAAA,gBAAuB,IAAA,EAAM,UAAA,EAAY,SAAS,OAAO,CAAA;AAAA,EACrF;AAAA,EAIA,OAAO,SAAA,CAAU,UAAA,EAAsC,OAAA,EAAkB,OAAA,EAAgD;AACvH,IAAA,OAAO,cAAa,KAAA,CAAM,WAAA,kBAAyB,IAAA,EAAM,UAAA,EAAY,SAAS,OAAO,CAAA;AAAA,EACvF;AAAA,EAIA,OAAO,QAAA,CAAS,UAAA,EAAsC,OAAA,EAAkB,OAAA,EAAgD;AACtH,IAAA,OAAO,cAAa,KAAA,CAAM,UAAA,iBAAwB,IAAA,EAAM,UAAA,EAAY,SAAS,OAAO,CAAA;AAAA,EACtF;AAAA,EAkBA,OAAO,QAAA,CAAS,UAAA,EAAsC,OAAA,EAAkB,OAAA,EAAgD;AACtH,IAAA,OAAO,cAAa,KAAA,CAAM,UAAA,iBAAwB,IAAA,EAAM,UAAA,EAAY,SAAS,OAAO,CAAA;AAAA,EACtF;AAAA,EAKA,OAAO,MAAA,CAAO,UAAA,EAAsC,OAAA,EAAkB,OAAA,EAAgD;AACpH,IAAA,OAAO,cAAa,KAAA,CAAM,QAAA,eAAsB,KAAA,EAAO,UAAA,EAAY,SAAS,OAAO,CAAA;AAAA,EACrF;AACF;AAiCO,SAAS,sBAAsB,KAAA,EAA6B;AACjE,EAAA,IAAI,KAAA,YAAiB,aAAa,OAAO,KAAA;AACzC,EAAA,IAAI,iBAAiB,KAAA,EAAO;AAC1B,IAAA,OAAO,aAAa,QAAA,CAAS;AAAA,MAC3B,IAAA,EAAM,kBAAA;AAAA,MACN,SAAS,KAAA,CAAM,OAAA;AAAA,MACf,OAAA,EAAS,EAAE,iBAAA,EAAmB,KAAA,CAAM,IAAA,EAAK;AAAA,MACzC,KAAA,EAAO,KAAA;AAAA,MACP,WAAA,EAAa;AAAA,KACd,CAAA;AAAA,EACH;AACA,EAAA,OAAO,aAAa,QAAA,CAAS;AAAA,IAC3B,IAAA,EAAM,eAAA;AAAA,IACN,OAAA,EAAS,2BAAA;AAAA,IACT,OAAA,EAAS,EAAE,KAAA,EAAO,MAAA,CAAO,KAAK,CAAA,EAAE;AAAA,IAChC,WAAA,EAAa;AAAA,GACd,CAAA;AACH;;;AChSO,SAAS,GAAM,KAAA,EAA4B;AAChD,EAAA,OAAO,EAAE,EAAA,EAAI,IAAA,EAAM,KAAA,EAAM;AAC3B;AAGO,SAAS,IAAO,KAAA,EAA4B;AACjD,EAAA,OAAO,EAAE,EAAA,EAAI,KAAA,EAAO,KAAA,EAAM;AAC5B;AAQO,SAAS,KAAW,CAAA,EAA8C;AACvE,EAAA,OAAO,CAAA,CAAE,EAAA;AACX;AAQO,SAAS,MAAY,CAAA,EAA+C;AACzE,EAAA,OAAO,CAAC,CAAA,CAAE,EAAA;AACZ;AAGO,SAAS,GAAA,CAAa,GAAiB,EAAA,EAAmC;AAC/E,EAAA,OAAO,EAAE,EAAA,GAAK,EAAA,CAAG,GAAG,CAAA,CAAE,KAAK,CAAC,CAAA,GAAI,CAAA;AAClC;AAGO,SAAS,MAAA,CAAgB,GAAiB,EAAA,EAAmC;AAClF,EAAA,OAAO,EAAE,EAAA,GAAK,CAAA,GAAI,IAAI,EAAA,CAAG,CAAA,CAAE,KAAK,CAAC,CAAA;AACnC;AAGO,SAAS,OAAA,CAAiB,GAAiB,EAAA,EAA8C;AAC9F,EAAA,OAAO,CAAA,CAAE,EAAA,GAAK,EAAA,CAAG,CAAA,CAAE,KAAK,CAAA,GAAI,CAAA;AAC9B;AAGO,SAAS,QAAA,CAAe,GAAiB,QAAA,EAAgB;AAC9D,EAAA,OAAO,CAAA,CAAE,EAAA,GAAK,CAAA,CAAE,KAAA,GAAQ,QAAA;AAC1B;AAGO,SAAS,KAAA,CAAe,GAAiB,IAAA,EAAwD;AACtG,EAAA,OAAO,CAAA,CAAE,EAAA,GAAK,IAAA,CAAK,EAAA,CAAG,CAAA,CAAE,KAAK,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAA,CAAE,KAAK,CAAA;AACnD;AASO,SAAS,QACd,OAAA,EACc;AACd,EAAA,MAAM,SAAoB,EAAC;AAC3B,EAAA,KAAA,MAAW,KAAK,OAAA,EAA0C;AACxD,IAAA,IAAI,CAAC,CAAA,CAAE,EAAA,EAAI,OAAO,CAAA;AAClB,IAAA,MAAA,CAAO,IAAA,CAAK,EAAE,KAAK,CAAA;AAAA,EACrB;AACA,EAAA,OAAO,GAAG,MAAsB,CAAA;AAClC;AASO,SAAS,WAAiB,CAAA,EAAoB;AACnD,EAAA,IAAI,CAAA,CAAE,EAAA,EAAI,OAAO,CAAA,CAAE,KAAA;AACnB,EAAA,MAAM,CAAA,CAAE,KAAA;AACV;AASO,SAAS,QAAA,CACd,EAAA,EACA,SAAA,GAAyC,qBAAA,EACjB;AACxB,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,CAAG,IAAI,CAAA;AAAA,EAChB,SAAS,CAAA,EAAG;AACV,IAAA,OAAO,GAAA,CAAI,SAAA,CAAU,CAAC,CAAC,CAAA;AAAA,EACzB;AACF;AAGA,eAAsB,aAAA,CACpB,EAAA,EACA,SAAA,GAAyC,qBAAA,EACR;AACjC,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,CAAG,MAAM,EAAA,EAAI,CAAA;AAAA,EACtB,SAAS,CAAA,EAAG;AACV,IAAA,OAAO,GAAA,CAAI,SAAA,CAAU,CAAC,CAAC,CAAA;AAAA,EACzB;AACF;;;AC5GO,IAAM,cAAA,GAAiB;AAAA;AAAA,EAE5B,sBAAA,EAAwB,wBAAA;AAAA;AAAA,EAExB,mBAAA,EAAqB,qBAAA;AAAA,EACrB,kBAAA,EAAoB,oBAAA;AAAA,EACpB,uBAAA,EAAyB,yBAAA;AAAA,EACzB,qBAAA,EAAuB,uBAAA;AAAA,EACvB,sBAAA,EAAwB,wBAAA;AAAA,EACxB,cAAA,EAAgB,gBAAA;AAAA,EAChB,yBAAA,EAA2B,2BAAA;AAAA,EAC3B,WAAA,EAAa,aAAA;AAAA,EACb,0BAAA,EAA4B,4BAAA;AAAA,EAC5B,yBAAA,EAA2B,2BAAA;AAAA,EAC3B,8BAAA,EAAgC,gCAAA;AAAA,EAChC,sBAAA,EAAwB,wBAAA;AAAA,EACxB,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,gCAAA,EAAkC,kCAAA;AAAA;AAAA,EAElC,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,iCAAA,EAAmC,mCAAA;AAAA;AAAA,EAEnC,6BAAA,EAA+B,+BAAA;AAAA;AAAA,EAE/B,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAG3B,gBAAA,EAAkB,kBAAA;AAAA,EAClB,0BAAA,EAA4B,4BAAA;AAAA,EAC5B,oBAAA,EAAsB,sBAAA;AAAA;AAAA,EAEtB,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,eAAA,EAAiB,iBAAA;AAAA,EACjB,kBAAA,EAAoB,oBAAA;AAAA;AAAA,EAEpB,4BAAA,EAA8B,8BAAA;AAAA,EAC9B,gBAAA,EAAkB,kBAAA;AAAA;AAAA,EAElB,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,kBAAA,EAAoB,oBAAA;AAAA,EACpB,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,sBAAA,EAAwB,wBAAA;AAAA,EACxB,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,0BAAA,EAA4B,4BAAA;AAAA;AAAA,EAE5B,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,iCAAA,EAAmC,mCAAA;AAAA;AAAA,EAEnC,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,0BAAA,EAA4B,4BAAA;AAAA;AAAA,EAE5B,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,gCAAA,EAAkC,kCAAA;AAAA;AAAA,EAElC,2BAAA,EAA6B,6BAAA;AAAA;AAAA,EAE7B,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,sBAAA,EAAwB,wBAAA;AAAA;AAAA,EAExB,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,8BAAA,EAAgC,gCAAA;AAAA;AAAA,EAEhC,+BAAA,EAAiC,iCAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcjC,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,iCAAA,EAAmC,mCAAA;AAAA;AAAA,EAEnC,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,iCAAA,EAAmC,mCAAA;AAAA;AAAA,EAEnC,0BAAA,EAA4B,4BAAA;AAAA;AAAA;AAAA,EAI5B,0BAAA,EAA4B,4BAAA;AAAA;AAAA,EAE5B,0BAAA,EAA4B,4BAAA;AAAA;AAAA,EAE5B,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,6BAAA,EAA+B,+BAAA;AAAA;AAAA,EAE/B,8BAAA,EAAgC,gCAAA;AAAA;AAAA,EAEhC,0BAAA,EAA4B,4BAAA;AAAA;AAAA,EAE5B,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,6BAAA,EAA+B,+BAAA;AAAA;AAAA,EAE/B,4BAAA,EAA8B,8BAAA;AAAA;AAAA,EAE9B,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,8BAAA,EAAgC,gCAAA;AAAA;AAAA,EAEhC,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAGzB,mBAAA,EAAqB,qBAAA;AAAA,EACrB,sBAAA,EAAwB,wBAAA;AAAA;AAAA,EAExB,kBAAA,EAAoB,oBAAA;AAAA,EACpB,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,6BAAA,EAA+B,+BAAA;AAAA;AAAA,EAE/B,2BAAA,EAA6B,6BAAA;AAAA;AAAA,EAE7B,mCAAA,EAAqC,qCAAA;AAAA;AAAA,EAErC,iCAAA,EAAmC,mCAAA;AAAA;AAAA,EAEnC,sBAAA,EAAwB,wBAAA;AAAA;AAAA,EAExB,oBAAA,EAAsB,sBAAA;AAAA;AAAA;AAAA,EAItB,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAE3B,kBAAA,EAAoB,oBAAA;AAAA;AAAA,EAEpB,0BAAA,EAA4B,4BAAA;AAAA;AAAA,EAG5B,qBAAA,EAAuB,uBAAA;AAAA,EACvB,mBAAA,EAAqB,qBAAA;AAAA,EACrB,wBAAA,EAA0B,0BAAA;AAAA,EAC1B,yBAAA,EAA2B,2BAAA;AAAA;AAAA,EAG3B,yBAAA,EAA2B,2BAAA;AAAA,EAC3B,wBAAA,EAA0B,0BAAA;AAAA,EAC1B,qBAAA,EAAuB,uBAAA;AAAA;AAAA,EAEvB,+BAAA,EAAiC,iCAAA;AAAA;AAAA,EAEjC,oCAAA,EAAsC,sCAAA;AAAA;AAAA,EAEtC,qBAAA,EAAuB,uBAAA;AAAA;AAAA,EAEvB,oCAAA,EAAsC,sCAAA;AAAA;AAAA,EAGtC,iBAAA,EAAmB,mBAAA;AAAA,EACnB,qBAAA,EAAuB,uBAAA;AAAA;AAAA,EAGvB,gBAAA,EAAkB,kBAAA;AAAA,EAClB,aAAA,EAAe;AACjB","file":"chunk-N7OA4WPJ.js","sourcesContent":["/**\n * The engine's structured error type, the \"Rust/Go-style, verbose, easy to\n * tell the issue\" half of the error-handling redesign (the other half is\n * `Result.ts`).\n *\n * Historical note: an earlier version of this class (`UnifiedErrorFramework.ts`,\n * still the import path most of the codebase uses. See that file, now a\n * pure re-export barrel) had a much larger field set (`severity`,\n * `recovery`, a 5-value enum, `ErrorRecoveryManager`) that was almost\n * entirely dead: nothing downstream ever read `.severity`/`.recovery`,\n * only `.message` reliably survived to a caller. This version is smaller\n * and deliberately keeps only fields something actually consumes.\n */\n\nimport type { ErrorCode } from \"@solve-js/errors/ErrorCode\";\n\n/** A character-offset (and optional line/col) span into the original expression text, for a future \"underline the offending token\" UI, not yet wired to one. */\nexport interface SourceSpan {\n  start: number;\n  end: number;\n  line?: number;\n  col?: number;\n}\n\n/**\n * Error classification, kept from the original framework, now actually\n * consulted: it's the `format()` header and lets host code group errors\n * by pipeline stage without string-matching `.code`.\n */\nexport enum ErrorCategory {\n  /** Errors during expression parsing. */\n  PARSING = \"PARSING\",\n  /** Errors during bytecode execution. */\n  EXECUTION = \"EXECUTION\",\n  /** Errors from input validation (safety limits, config). */\n  VALIDATION = \"VALIDATION\",\n  /** Errors from external services/APIs (currency rates, weather, stocks). */\n  EXTERNAL = \"EXTERNAL\",\n  /** Internal engine invariant violations. See `recoverable`'s doc comment. */\n  INTERNAL = \"INTERNAL\",\n  /** Configuration errors. */\n  CONFIG = \"CONFIG\",\n}\n\n/** Fields accepted when constructing an {@link EngineError}. */\nexport interface EngineErrorInit {\n  /** Catalog code. See `errors/ErrorCode.ts`. Not a free string: every code used by a BUILT-IN package should be registered there so `ErrorCodeCatalog.spec.ts` can catch collisions/typos. Third-party packages may still use any string here, `EngineError.code`'s runtime type is `string`. */\n  code: ErrorCode | (string & {});\n  /** Short, single-line, `Error.message`-compatible. Existing `.toThrow(/pattern/)`/`.message` assertions keep working against this field, richer detail goes in `expected`/`found`/`suggestion`, not crammed into this string. */\n  message: string;\n  /** What the parser/validator/VM expected to see, in plain words, e.g. \"a city name\", \"a 4-digit year\", \"end of expression\". */\n  expected?: string;\n  /** What was actually found instead, e.g. \"end of expression\", `NUMBER \"5\"`, the offending token's literal text. */\n  found?: string;\n  /** An actionable, worked-example fix, e.g. `e.g. \"weather in London\"`. Mirrors this codebase's best existing messages (`WEATHER_EXPECTED_CITY`, `AS_CONVERTER_EXPECTED_NAME`). */\n  suggestion?: string;\n  /**\n   * Whether this engine instance is still usable. `true` for everything that\n   * went wrong on ONE line, whether the line's fault (bad syntax, an unknown\n   * variable, a safety limit exceeded), the environment's (an external API\n   * down), or the engine's own (corrupted bytecode, a stack underflow from a\n   * buggy plugin). `false` is for the far rarer case where there is no working\n   * engine to go on with: a configuration or package-registration failure,\n   * which is what `ErrorFactory.config()` is for and the only factory method\n   * that still defaults to it.\n   *\n   * The category answers a different question, and the two used to be answered\n   * as one. Category INTERNAL says whose fault this is, the engine's, worth\n   * reporting as a bug. `recoverable` says whether the host may carry on, and\n   * after an internal slip on one line it may:\n   * `__tests__/hardening/RobustnessEngineLifecycle.spec.ts` alternates a\n   * throwing line with a good one five hundred times and every answer stays\n   * correct. Reporting that as `isFatal()` told a host the opposite, and a host\n   * that honours the name would tear a document down over one bad line.\n   *\n   * This has never gated \"does evaluation of the rest of the document\n   * continue\"; with this engine's per-line containment it always does, even for\n   * a `recoverable: false` error (see `ARCHITECTURE.md`'s async-batcher/Tier-2\n   * hardening notes). It gates what a host is TOLD. See\n   * {@link EngineError.isFatal}.\n   */\n  recoverable?: boolean;\n  /** Character-offset span into the source expression, when available. Not yet threaded through every call site, populate opportunistically, don't block on retrofitting every existing throw site. */\n  span?: SourceSpan;\n  /** Free-form structured context. The one field the pre-existing framework's real consumer (`ThreeTierEvaluator.ts`'s DAG-preservation-on-compile-error path) actually reads, kept name- and shape-compatible on purpose. */\n  context?: Record<string, unknown>;\n  /** The underlying error this one wraps, if any, passed straight through to native `Error.cause` (ES2022), so Node's default printer, most loggers, and `instanceof Error` tooling understand the chain for free. */\n  cause?: unknown;\n}\n\n/**\n * The engine's structured error type. Still a real `Error` subclass (so\n * `throw`/`catch`/`instanceof Error` all keep working exactly as before),\n * but now every field except the removed `severity`/`recovery` pair is\n * something real code reads.\n */\nexport class EngineError extends Error {\n  readonly category: ErrorCategory;\n  readonly code: string;\n  readonly expected?: string;\n  readonly found?: string;\n  readonly suggestion?: string;\n  readonly recoverable: boolean;\n  readonly span?: SourceSpan;\n  readonly context?: Record<string, unknown>;\n  readonly timestamp: Date;\n  /**\n   * Set explicitly (not via `super(message, {cause})`). This repo's\n   * `tsconfig.json` targets ES6/ES5-ES7 lib, which predates TypeScript's\n   * ES2022 `Error` constructor `cause`-option overload. `Error.prototype.cause`\n   * is still a real runtime feature in every target this engine actually\n   * runs in (Node 16.9+, all evergreen browsers, Electron/Obsidian's\n   * bundled Chromium) regardless of the TS lib target used to type-check\n   * against it, assigning it directly gets the same Node-printer/logger\n   * interop with no build-config change needed.\n   */\n  readonly cause?: unknown;\n\n  constructor(category: ErrorCategory, init: EngineErrorInit) {\n    super(init.message);\n    this.name = \"EngineError\";\n    this.category = category;\n    this.code = init.code;\n    this.expected = init.expected;\n    this.found = init.found;\n    this.suggestion = init.suggestion;\n    this.recoverable = init.recoverable ?? true;\n    this.span = init.span;\n    this.context = init.context;\n    this.cause = init.cause;\n    this.timestamp = new Date();\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, EngineError);\n    }\n  }\n\n  /** `!recoverable`. See `EngineErrorInit.recoverable`'s doc comment for what this actually gates (message framing/telemetry, not whether evaluation continues). */\n  isFatal(): boolean {\n    return !this.recoverable;\n  }\n\n  /** Walk `.cause` repeatedly, collecting the full chain (this error first). */\n  causeChain(): unknown[] {\n    const chain: unknown[] = [this];\n    let current: unknown = this.cause;\n    while (current !== undefined && current !== null) {\n      chain.push(current);\n      current = current instanceof Error ? (current as Error & { cause?: unknown }).cause : undefined;\n    }\n    return chain;\n  }\n\n  /**\n   * Rust/Go-style multi-line renderer, the NEW thing a host/CLI/test\n   * reaches for when it wants the full, verbose picture, as distinct from\n   * `.message` (kept short and stable for existing assertions). Example:\n   *\n   * ```\n   * error[WEATHER_EXPECTED_CITY]: Expected a city name after \"weather in\"\n   *   expected: a city name\n   *   found: end of expression\n   *   suggestion: e.g. \"weather in London\"\n   * ```\n   */\n  format(): string {\n    const lines = [`error[${this.code}]: ${this.message}`];\n    if (this.expected) lines.push(`  expected: ${this.expected}`);\n    if (this.found) lines.push(`  found: ${this.found}`);\n    if (this.suggestion) lines.push(`  suggestion: ${this.suggestion}`);\n    return lines.join(\"\\n\");\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      category: this.category,\n      code: this.code,\n      message: this.message,\n      expected: this.expected,\n      found: this.found,\n      suggestion: this.suggestion,\n      recoverable: this.recoverable,\n      span: this.span,\n      context: this.context,\n      timestamp: this.timestamp.toISOString(),\n    };\n  }\n}\n\n/**\n * Factory for creating classified `EngineError`s. Every method accepts\n * EITHER the original, minimal 3-arg shape (`code, message, context?`\n * every existing call site across the codebase keeps compiling unchanged)\n * OR the richer `EngineErrorInit` object (for `expected`/`found`/\n * `suggestion`/`recoverable`/`span`/`cause`), upgrade a call site to the\n * richer form only when you're already touching it, no separate churn\n * pass required.\n */\nexport class ErrorFactory {\n  private static build(\n    category: ErrorCategory,\n    defaultRecoverable: boolean,\n    codeOrInit: string | EngineErrorInit,\n    message?: string,\n    context?: Record<string, unknown>,\n  ): EngineError {\n    const init: EngineErrorInit =\n      typeof codeOrInit === \"string\"\n        ? { code: codeOrInit, message: message!, context }\n        : codeOrInit;\n    return new EngineError(category, { recoverable: defaultRecoverable, ...init });\n  }\n\n  static validation(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static validation(init: EngineErrorInit): EngineError;\n  static validation(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.VALIDATION, true, codeOrInit, message, context);\n  }\n\n  static parsing(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static parsing(init: EngineErrorInit): EngineError;\n  static parsing(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.PARSING, true, codeOrInit, message, context);\n  }\n\n  static execution(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static execution(init: EngineErrorInit): EngineError;\n  static execution(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.EXECUTION, true, codeOrInit, message, context);\n  }\n\n  static external(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static external(init: EngineErrorInit): EngineError;\n  static external(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.EXTERNAL, true, codeOrInit, message, context);\n  }\n\n  /**\n   * Reserve for genuine engine-internal invariant violations (corrupted\n   * bytecode, a stack underflow from a buggy plugin, an \"impossible\" state),\n   * not for user-input errors: the category is a bug report.\n   *\n   * Defaults `recoverable: true` all the same, because every one of these sites\n   * is an invariant that failed on ONE line and none of them leaves the engine\n   * unusable. This used to default to `false`, which conflated \"the engine's\n   * fault\" with \"the engine is finished\" and told a host to tear a document\n   * down over a line it could simply have shown an error against. A site that\n   * has looked at its own case and concluded the instance really is gone can\n   * still pass `recoverable: false` explicitly. See {@link\n   * EngineErrorInit.recoverable}.\n   */\n  static internal(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static internal(init: EngineErrorInit): EngineError;\n  static internal(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.INTERNAL, true, codeOrInit, message, context);\n  }\n\n  /** Defaults `recoverable: false`, and is now the only method that does: a configuration or package-registration failure is the one class that leaves no working engine to carry on with, rather than one bad line in a document. */\n  static config(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static config(init: EngineErrorInit): EngineError;\n  static config(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.CONFIG, false, codeOrInit, message, context);\n  }\n}\n\n/**\n * Normalize any thrown value into an `EngineError`, an `EngineError`\n * passes through as-is; a plain `Error` gets wrapped (message preserved,\n * original attached via `cause`); anything else becomes a generic\n * \"unknown error\" wrapping the stringified value. Used at every\n * throw-space/Result-space boundary (`Result.tryCatch`'s default\n * `normalize`, the VM's outer execution try/catch, `AsyncResolutionBatcher`'s\n * per-line containment) so a raw `TypeError` from a genuine engine bug\n * still surfaces as a structured, catalogued error instead of an opaque\n * uncaught exception.\n *\n * Both branches state RECOVERABLE explicitly, while keeping the INTERNAL\n * category. The two fields answer different questions and were previously\n * answering the same one:\n *\n *   category INTERNAL  whose fault is this? The engine's. Worth reporting.\n *   recoverable        is this engine instance still usable? Yes.\n *\n * Everything reaching here is by definition something the engine did not\n * anticipate on ONE line, and per-line containment means the next line\n * evaluates normally, which `__tests__/hardening/RobustnessEngineLifecycle`\n * demonstrates over hundreds of alternating failure/success pairs. Reporting\n * that as `isFatal()` told a host the opposite, and a host that honours the\n * name would tear a document down over a single bad line. The \"this is an\n * engine bug rather than your syntax\" signal a caller wants for telemetry is\n * the CATEGORY, which is unchanged.\n *\n * The flag is written out here rather than inherited from\n * `ErrorFactory.internal()`, which now defaults the same way, so that this\n * function's contract survives a future change to that default.\n */\nexport function normalizeUnknownError(error: unknown): EngineError {\n  if (error instanceof EngineError) return error;\n  if (error instanceof Error) {\n    return ErrorFactory.internal({\n      code: \"UNEXPECTED_ERROR\",\n      message: error.message,\n      context: { originalErrorName: error.name },\n      cause: error,\n      recoverable: true,\n    });\n  }\n  return ErrorFactory.internal({\n    code: \"UNKNOWN_ERROR\",\n    message: \"An unknown error occurred\",\n    context: { error: String(error) },\n    recoverable: true,\n  });\n}\n","import { type EngineError, normalizeUnknownError } from \"@solve-js/errors/EngineError\";\n\n/**\n * A Rust-style `Result<T, E>`, the value half of this engine's error-handling\n * redesign. `E` defaults to `EngineError` (this engine's structured error\n * type) but every combinator here is generic over `E`, so `Result` works\n * equally well for a domain that isn't `EngineError`-shaped.\n *\n * This exact shape used to live in `errors/UnifiedErrorFramework.ts` (kept\n * there as a barrel re-export for backward compatibility), moved here as\n * its own module because it's genuinely generic (no dependency on\n * `EngineError` beyond the default type parameter) and because the engine\n * is migrating callers to it incrementally: parsing/VM/package code that\n * expects \"a failure is a possibility, not an exception\" returns\n * `Result<T, EngineError>` instead of throwing; two explicit adapters\n * {@link throwIfErr} and {@link tryCatch}, are the sanctioned way to cross\n * the boundary between Result-based code and still-throw-based code during\n * the migration (and permanently, at the public API boundary. See\n * `ExpressionEngine.evaluateExpression()`'s documented throw contract).\n */\nexport type Result<T, E = EngineError> =\n  | { ok: true; value: T }\n  | { ok: false; error: E };\n\n/** Wrap a successful value. */\nexport function ok<T>(value: T): Result<T, never> {\n  return { ok: true, value };\n}\n\n/** Wrap a failure. */\nexport function err<E>(error: E): Result<never, E> {\n  return { ok: false, error };\n}\n\n/**\n * Narrow a {@link Result} to its success arm.\n *\n * @param r - The result to test.\n * @returns True when it succeeded, narrowing `r` so `r.value` is reachable.\n */\nexport function isOk<T, E>(r: Result<T, E>): r is { ok: true; value: T } {\n  return r.ok;\n}\n\n/**\n * Narrow a {@link Result} to its failure arm.\n *\n * @param r - The result to test.\n * @returns True when it failed, narrowing `r` so `r.error` is reachable.\n */\nexport function isErr<T, E>(r: Result<T, E>): r is { ok: false; error: E } {\n  return !r.ok;\n}\n\n/** Transform the success value; a failure passes through untouched. */\nexport function map<T, U, E>(r: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  return r.ok ? ok(fn(r.value)) : r;\n}\n\n/** Transform the error; a success passes through untouched. */\nexport function mapErr<T, E, F>(r: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  return r.ok ? r : err(fn(r.error));\n}\n\n/** Chain a Result-returning operation onto a success (a.k.a. flatMap/bind). */\nexport function andThen<T, U, E>(r: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return r.ok ? fn(r.value) : r;\n}\n\n/** Unwrap a success, or return `fallback` for a failure. Never throws. */\nexport function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T {\n  return r.ok ? r.value : fallback;\n}\n\n/** Exhaustive pattern-match, the `match`/`switch` a Rust enum gets for free. */\nexport function match<T, E, R>(r: Result<T, E>, arms: { ok: (value: T) => R; err: (error: E) => R }): R {\n  return r.ok ? arms.ok(r.value) : arms.err(r.error);\n}\n\n/**\n * Combine several Results into one, succeeds with a tuple of all values\n * iff every input succeeded; otherwise fails with the FIRST error\n * encountered (left-to-right), matching this codebase's existing\n * fail-fast convention elsewhere (e.g. `BytecodeBuilder`'s constant-pool\n * limit checks).\n */\nexport function combine<T extends readonly unknown[], E>(\n  results: { [K in keyof T]: Result<T[K], E> },\n): Result<T, E> {\n  const values: unknown[] = [];\n  for (const r of results as readonly Result<unknown, E>[]) {\n    if (!r.ok) return r;\n    values.push(r.value);\n  }\n  return ok(values as unknown as T);\n}\n\n/**\n * Cross from Result-space back to throw-space, the sanctioned boundary\n * adapter for callers (public API surface, older not-yet-migrated code,\n * tests) that still want exception-based control flow. Throws `r.error`\n * as-is (an `EngineError` is already a real `Error` subclass, so this\n * needs no wrapping).\n */\nexport function throwIfErr<T, E>(r: Result<T, E>): T {\n  if (r.ok) return r.value;\n  throw r.error;\n}\n\n/**\n * Cross from throw-space into Result-space, runs `fn`, converting any\n * thrown value into a Result via `normalize` (defaults to\n * {@link normalizeUnknownError}). The inverse of {@link throwIfErr}; the\n * pairing that lets Result-based and throw-based code interoperate during\n * an incremental migration instead of requiring a single flag-day rewrite.\n */\nexport function tryCatch<T>(\n  fn: () => T,\n  normalize: (e: unknown) => EngineError = normalizeUnknownError,\n): Result<T, EngineError> {\n  try {\n    return ok(fn());\n  } catch (e) {\n    return err(normalize(e));\n  }\n}\n\n/** Async sibling of {@link tryCatch}. */\nexport async function tryCatchAsync<T>(\n  fn: () => Promise<T>,\n  normalize: (e: unknown) => EngineError = normalizeUnknownError,\n): Promise<Result<T, EngineError>> {\n  try {\n    return ok(await fn());\n  } catch (e) {\n    return err(normalize(e));\n  }\n}\n","/**\n * The built-in error-code catalog, one typed const object per domain\n * unioned together here for autocomplete/exhaustiveness in core engine\n * code. Deliberately NOT one central enum: `IEnginePackage` is documented\n * public SDK surface for third-party packages (see `api/PackageRegistry.ts`),\n * and a closed enum would block an external package author from defining\n * their own codes without editing this file. `EngineError.code`'s runtime\n * type stays `string` for exactly that reason. This catalog is for the\n * codes THIS repo owns and wants collision/typo checking on (see\n * `__tests__/errors/ErrorCodeCatalog.spec.ts`), not a hard runtime\n * whitelist.\n *\n * As each package migrates to `Result<void, EngineError>` (see this\n * session's error-handling-refactor plan, Phase 5), it should export its\n * own small `XxxErrorCodes` const object co-located with its parselets\n * exactly like `CoreErrorCodes` below, just scoped to one domain, and get\n * unioned into `ErrorCode` here. Until a package migrates, its existing\n * free-string codes keep working (ErrorFactory accepts any string); they\n * just aren't caught by the catalog's uniqueness/orphan checks yet.\n */\n\n/**\n * Codes used directly by the parser/VM/engine/errors layers themselves\n * confirmed against the current source, not aspirational. Grouped by\n * pipeline stage via the comments, not a naming prefix (these predate any\n * naming convention and renaming them is out of scope for introducing the\n * catalog, only NEW codes need to follow a scoped/prefixed style, see\n * `STACK_UNDERFLOW` etc. below).\n */\nexport const CoreErrorCodes = {\n  // ── Parser (parser/PrecedenceParser.ts, parser/BytecodeBuilder.ts, parser/PhrasePattern.ts) ──\n  INVALID_NUMBER_LITERAL: \"INVALID_NUMBER_LITERAL\",\n  /** 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. */\n  UNTERMINATED_STRING: \"UNTERMINATED_STRING\",\n  NO_PREFIX_PARSELET: \"NO_PREFIX_PARSELET\",\n  UNEXPECTED_END_OF_INPUT: \"UNEXPECTED_END_OF_INPUT\",\n  UNEXPECTED_TOKEN_TYPE: \"UNEXPECTED_TOKEN_TYPE\",\n  NESTING_DEPTH_EXCEEDED: \"NESTING_DEPTH_EXCEEDED\",\n  UNEXPECTED_END: \"UNEXPECTED_END\",\n  UNEXPECTED_TRAILING_TOKEN: \"UNEXPECTED_TRAILING_TOKEN\",\n  PARSE_ERROR: \"PARSE_ERROR\",\n  TOO_MANY_NUMERIC_CONSTANTS: \"TOO_MANY_NUMERIC_CONSTANTS\",\n  TOO_MANY_STRING_CONSTANTS: \"TOO_MANY_STRING_CONSTANTS\",\n  NO_MATCHING_PHRASE_ALTERNATIVE: \"NO_MATCHING_PHRASE_ALTERNATIVE\",\n  INVALID_PHRASE_PATTERN: \"INVALID_PHRASE_PATTERN\",\n  PHRASE_KEYWORD_MISMATCH: \"PHRASE_KEYWORD_MISMATCH\",\n  /** User-defined-function definition parsing (`f(x, y) = ...`), an invalid token where a parameter name was expected. */\n  USER_FUNCTION_INVALID_PARAM_NAME: \"USER_FUNCTION_INVALID_PARAM_NAME\",\n  /** `f() = ...` with zero parameters, indistinguishable from a plain no-arg function call, so rejected at definition time. */\n  USER_FUNCTION_NO_PARAMS: \"USER_FUNCTION_NO_PARAMS\",\n  /** A user-defined function body calling an async plugin (weather/stocks/currency/...), rejected at definition time; v1 scope excludes async function bodies. */\n  FUNCTION_BODY_MUST_BE_SYNCHRONOUS: \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n  /** `BytecodeBuilder`'s `userFunctionBodies` side-table exceeding its capacity. Same class as `TOO_MANY_NUMERIC_CONSTANTS`/`TOO_MANY_STRING_CONSTANTS` below. */\n  TOO_MANY_FUNCTION_DEFINITIONS: \"TOO_MANY_FUNCTION_DEFINITIONS\",\n  /** `BytecodeBuilder`'s `anonymousBodies` side-table (map/reduce inline transform bodies) exceeding its capacity. Same class as `TOO_MANY_FUNCTION_DEFINITIONS` above. */\n  TOO_MANY_ANONYMOUS_BODIES: \"TOO_MANY_ANONYMOUS_BODIES\",\n\n  // ── VM (vm/VM.ts, vm/OpRegistry.ts, vm/VMBuiltins.ts) ──\n  EVALUATION_ERROR: \"EVALUATION_ERROR\",\n  INSTRUCTION_LIMIT_EXCEEDED: \"INSTRUCTION_LIMIT_EXCEEDED\",\n  STACK_LIMIT_EXCEEDED: \"STACK_LIMIT_EXCEEDED\",\n  /** 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. */\n  ALLOCATION_LIMIT_EXCEEDED: \"ALLOCATION_LIMIT_EXCEEDED\",\n  /** 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. */\n  STACK_UNDERFLOW: \"STACK_UNDERFLOW\",\n  UNDEFINED_VARIABLE: \"UNDEFINED_VARIABLE\",\n  /** 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`. */\n  GLOBAL_VARIABLE_NOT_RESOLVED: \"GLOBAL_VARIABLE_NOT_RESOLVED\",\n  UNKNOWN_FUNCTION: \"UNKNOWN_FUNCTION\",\n  /** `unwrapEvalResult()`'s pending-when-expecting-value case, a caller-contract violation, not user-input. */\n  UNEXPECTED_PENDING_RESULT: \"UNEXPECTED_PENDING_RESULT\",\n  /** 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. */\n  UNDEFINED_FUNCTION: \"UNDEFINED_FUNCTION\",\n  FUNCTION_ARITY_MISMATCH: \"FUNCTION_ARITY_MISMATCH\",\n  /** 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. */\n  BUILTIN_ARITY_MISMATCH: \"BUILTIN_ARITY_MISMATCH\",\n  USER_FUNCTION_ASYNC_UNSUPPORTED: \"USER_FUNCTION_ASYNC_UNSUPPORTED\",\n  /** 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. */\n  MAP_REDUCE_ASYNC_UNSUPPORTED: \"MAP_REDUCE_ASYNC_UNSUPPORTED\",\n  /** 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/). */\n  SYMBOLIC_ASYNC_UNSUPPORTED: \"SYMBOLIC_ASYNC_UNSUPPORTED\",\n  /** `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. */\n  EXPLAIN_ASYNC_UNSUPPORTED: \"EXPLAIN_ASYNC_UNSUPPORTED\",\n  /** `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. */\n  FUNCTION_RECURSION_LIMIT_EXCEEDED: \"FUNCTION_RECURSION_LIMIT_EXCEEDED\",\n  /** 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. */\n  FUNCTION_CALL_LIMIT_EXCEEDED: \"FUNCTION_CALL_LIMIT_EXCEEDED\",\n  /** 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. */\n  DATE_OFFSET_LIMIT_EXCEEDED: \"DATE_OFFSET_LIMIT_EXCEEDED\",\n  /** 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. */\n  WORKDAY_OFFSET_EXPECTED_DATE: \"WORKDAY_OFFSET_EXPECTED_DATE\",\n  /** 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. */\n  WORKDAYS_BETWEEN_EXPECTED_DATES: \"WORKDAYS_BETWEEN_EXPECTED_DATES\",\n  /** 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. */\n  WORKDAYS_BETWEEN_RANGE_TOO_LARGE: \"WORKDAYS_BETWEEN_RANGE_TOO_LARGE\",\n  /** 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. */\n  BIGINT_SHIFT_LIMIT_EXCEEDED: \"BIGINT_SHIFT_LIMIT_EXCEEDED\",\n  /** 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. */\n  BIGINT_POW_LIMIT_EXCEEDED: \"BIGINT_POW_LIMIT_EXCEEDED\",\n  /** 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()`. */\n  BIGINT_INEXACT_OPERAND: \"BIGINT_INEXACT_OPERAND\",\n  /** `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()`. */\n  BIGINT_DIVISION_BY_ZERO: \"BIGINT_DIVISION_BY_ZERO\",\n  /** `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. */\n  INTERNAL_MISSING_FUNCTION_BODY: \"INTERNAL_MISSING_FUNCTION_BODY\",\n  /** `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`. */\n  INTERNAL_MISSING_ANONYMOUS_BODY: \"INTERNAL_MISSING_ANONYMOUS_BODY\",\n\n  // ── Malformed bytecode on the public `./vm` surface (vm/VM.ts) ──\n  //\n  // `executeBytecode` is exported, so a bytecode program is caller input in\n  // the same sense an expression string is, and these five say so. They are\n  // VALIDATION rather than INTERNAL for exactly that reason: before they\n  // existed, every one of these cases reached a raw TypeError (`BigInt(undefined)`,\n  // `code.toUpperCase()` on a boolean, destructuring a program that was not\n  // there), which normalised to UNEXPECTED_ERROR and told the caller the\n  // engine was broken when their eleven bytes were. Reachable from ordinary\n  // source only through a compiler bug, which is why the messages name the\n  // opcode and the operand rather than the user's line.\n  /** An operand byte read past the end of the stream: the program ends in the middle of an instruction. */\n  MALFORMED_BYTECODE_TRUNCATED: \"MALFORMED_BYTECODE_TRUNCATED\",\n  /** A constant-pool operand indexing a `numbers`/`strings` entry that does not exist, or that is not of the pool's type. */\n  MALFORMED_BYTECODE_CONSTANT_INDEX: \"MALFORMED_BYTECODE_CONSTANT_INDEX\",\n  /** 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. */\n  MALFORMED_BYTECODE_OPERAND_TYPE: \"MALFORMED_BYTECODE_OPERAND_TYPE\",\n  /** `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)`. */\n  MALFORMED_BYTECODE_BODY_KIND: \"MALFORMED_BYTECODE_BODY_KIND\",\n  /** A `PUSH_BIGINT` pool entry that is not a whole number, e.g. `\"1.000\"`. `BigInt()` answers that with a raw SyntaxError. */\n  MALFORMED_BYTECODE_BIGINT_LITERAL: \"MALFORMED_BYTECODE_BIGINT_LITERAL\",\n  /** `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. */\n  MALFORMED_BYTECODE_PROGRAM: \"MALFORMED_BYTECODE_PROGRAM\",\n\n  // ── Symbolic algebra (symbolic/, vm/SymbolicOps.ts) ──\n  /** A coefficient grew past `RATIONAL_MAX_BITS`, e.g. repeated exact elimination multiplying denominators together. */\n  SYMBOLIC_RATIONAL_OVERFLOW: \"SYMBOLIC_RATIONAL_OVERFLOW\",\n  /** `NaN` or `±Infinity` reaching a symbolic expression, neither of which has an exact rational value. */\n  SYMBOLIC_NONFINITE_OPERAND: \"SYMBOLIC_NONFINITE_OPERAND\",\n  /** Division by an exactly-zero rational. Exact, unlike the double comparison it replaced, which could not distinguish a true zero from `5.551e-17`. */\n  SYMBOLIC_DIVISION_BY_ZERO: \"SYMBOLIC_DIVISION_BY_ZERO\",\n  /** A tree exceeding `SYMBOLIC_MAX_NODES` entering the simplifier. */\n  SYMBOLIC_NODE_LIMIT_EXCEEDED: \"SYMBOLIC_NODE_LIMIT_EXCEEDED\",\n  /** 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. */\n  SYMBOLIC_UNSUPPORTED_FUNCTION: \"SYMBOLIC_UNSUPPORTED_FUNCTION\",\n  /** 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. */\n  SYMBOLIC_FACTOR_LIMIT_EXCEEDED: \"SYMBOLIC_FACTOR_LIMIT_EXCEEDED\",\n  /** 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. */\n  SYMBOLIC_SOLVE_UNSUPPORTED: \"SYMBOLIC_SOLVE_UNSUPPORTED\",\n  /** 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. */\n  SYMBOLIC_SOLVE_INCOMPLETE: \"SYMBOLIC_SOLVE_INCOMPLETE\",\n  /** `solve`'s second argument not being a bare name. */\n  SOLVE_REQUIRES_VARIABLE_NAME: \"SOLVE_REQUIRES_VARIABLE_NAME\",\n  /** A derivative order outside 0..`DERIVATIVE_MAX_ORDER`. */\n  SYMBOLIC_DERIVATIVE_ORDER_LIMIT: \"SYMBOLIC_DERIVATIVE_ORDER_LIMIT\",\n  /** 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. */\n  SYMBOLIC_INTEGRAL_UNSUPPORTED: \"SYMBOLIC_INTEGRAL_UNSUPPORTED\",\n  /** A Taylor degree outside 0..`TAYLOR_MAX_DEGREE`. */\n  SYMBOLIC_TAYLOR_DEGREE_LIMIT: \"SYMBOLIC_TAYLOR_DEGREE_LIMIT\",\n  /** A Taylor coefficient that does not reduce to an exact number at the expansion point. */\n  SYMBOLIC_TAYLOR_INEXACT: \"SYMBOLIC_TAYLOR_INEXACT\",\n  /** An algebra verb's variable-name argument not being a bare name. */\n  SYMBOLIC_REQUIRES_VARIABLE_NAME: \"SYMBOLIC_REQUIRES_VARIABLE_NAME\",\n  /** `jacobian` called with expressions containing no unknown to differentiate against. */\n  SYMBOLIC_JACOBIAN_NO_VARIABLES: \"SYMBOLIC_JACOBIAN_NO_VARIABLES\",\n  /** A finite number whose decimal form could not be read back, which the regex covering every `Number.prototype.toString` output should make unreachable. */\n  INTERNAL_RATIONAL_PARSE: \"INTERNAL_RATIONAL_PARSE\",\n\n  // ── Engine (engine/ExpressionEngine.ts, engine/ExpressionEngineSafety.ts, engine/AsyncResolutionBatcher.ts) ──\n  EXPRESSION_TOO_LONG: \"EXPRESSION_TOO_LONG\",\n  EXPRESSION_TOO_COMPLEX: \"EXPRESSION_TOO_COMPLEX\",\n  /** 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. */\n  DOCUMENT_TOO_LARGE: \"DOCUMENT_TOO_LARGE\",\n  NORMALIZED_TOKEN_LIMIT_EXCEEDED: \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n  /** `\"=>\"` with nothing before it, needs an expression or variable name to solve/simplify. */\n  THEREFORE_REQUIRES_EXPRESSION: \"THEREFORE_REQUIRES_EXPRESSION\",\n  /** A `\"=>\"`-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies. */\n  THEREFORE_ASYNC_UNSUPPORTED: \"THEREFORE_ASYNC_UNSUPPORTED\",\n  /** A compound assignment (`name += expr` / `name -= expr`) with nothing on the right, a line half-typed on the way to `total += 5`. */\n  COMPOUND_ASSIGN_REQUIRES_EXPRESSION: \"COMPOUND_ASSIGN_REQUIRES_EXPRESSION\",\n  /** A running total (`+= / -=`) whose right-hand side calls an async plugin (weather/stocks/currency). The same v1 scope restriction as the `\"=>\"` and user-function bodies. */\n  COMPOUND_ASSIGN_ASYNC_UNSUPPORTED: \"COMPOUND_ASSIGN_ASYNC_UNSUPPORTED\",\n  /** A savings-goal contribution period that is not one of daily/weekly/monthly/yearly (`how long to save $X at $Y <period>`). Names the accepted set. */\n  UNKNOWN_SAVINGS_PERIOD: \"UNKNOWN_SAVINGS_PERIOD\",\n  /** 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. */\n  INVALID_TIME_LITERAL: \"INVALID_TIME_LITERAL\",\n\n  // ── Snapshot / restore (engine/EngineSnapshot.ts, engine/ExpressionEngine.ts) ──\n  /** `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()`. */\n  SNAPSHOT_VERSION_MISMATCH: \"SNAPSHOT_VERSION_MISMATCH\",\n  /** 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. */\n  SNAPSHOT_MALFORMED: \"SNAPSHOT_MALFORMED\",\n  /** 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. */\n  SNAPSHOT_UNSUPPORTED_VALUE: \"SNAPSHOT_UNSUPPORTED_VALUE\",\n\n  // ── Config (constants/Configuration.ts) ──\n  CONFIG_PATH_NOT_FOUND: \"CONFIG_PATH_NOT_FOUND\",\n  INVALID_CONFIG_PATH: \"INVALID_CONFIG_PATH\",\n  CONFIG_SECTION_NOT_FOUND: \"CONFIG_SECTION_NOT_FOUND\",\n  CONFIG_PROPERTY_NOT_FOUND: \"CONFIG_PROPERTY_NOT_FOUND\",\n\n  // ── Package/lexer registration-time collisions (lexer/ExpressionLexer.ts) ──\n  PLUGIN_OPERATOR_COLLISION: \"PLUGIN_OPERATOR_COLLISION\",\n  PLUGIN_KEYWORD_COLLISION: \"PLUGIN_KEYWORD_COLLISION\",\n  PLUGIN_UNIT_COLLISION: \"PLUGIN_UNIT_COLLISION\",\n  /** A package's declared `IEnginePackage.engineVersion` semver range doesn't satisfy the running engine's ENGINE_VERSION. See api/EngineVersionCompatibility.ts. */\n  PACKAGE_ENGINE_VERSION_MISMATCH: \"PACKAGE_ENGINE_VERSION_MISMATCH\",\n  /** A package's declared `IEnginePackage.engineVersion` isn't a parseable semver range at all (a typo in the package's own descriptor). */\n  PACKAGE_ENGINE_VERSION_INVALID_RANGE: \"PACKAGE_ENGINE_VERSION_INVALID_RANGE\",\n  /** `OpRegistry.allocateOpcode()`'s dynamic opcode pool (started at 201) exhausted, too many packages calling it. */\n  OPCODE_POOL_EXHAUSTED: \"OPCODE_POOL_EXHAUSTED\",\n  /** `VMBuiltins.allocatePluginFunctionIndex()`'s 0-255 index pool (a single opcode-stream byte) exhausted. */\n  PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: \"PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED\",\n\n  // ── vm/Value.ts caller-contract violations (check isRateUnit()/isTimecodeUnit() first) ──\n  INVALID_RATE_UNIT: \"INVALID_RATE_UNIT\",\n  INVALID_TIMECODE_UNIT: \"INVALID_TIMECODE_UNIT\",\n\n  // ── errors/EngineError.ts's own fallback normalization ──\n  UNEXPECTED_ERROR: \"UNEXPECTED_ERROR\",\n  UNKNOWN_ERROR: \"UNKNOWN_ERROR\",\n} as const;\n\n/** Every error code the engine's own layers can produce, from {@link CoreErrorCodes}. */\nexport type CoreErrorCode = (typeof CoreErrorCodes)[keyof typeof CoreErrorCodes];\n\n/**\n * The aggregated catalog type. Currently just `CoreErrorCode`, union in\n * each package's own code-object type here as Phase 5 converts it, e.g.\n * `CoreErrorCode | WeatherErrorCode | StocksErrorCode | ...`.\n */\nexport type ErrorCode = CoreErrorCode;\n"]}