solve-engine 1.0.2 → 1.1.0

package/dist/{chunk-3D7V24DG.js → chunk-ERCOHGXD.js}

@@ -225,12 +225,20 @@ var CoreErrorCodes = {
   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. */
@@ -311,6 +319,13 @@ var CoreErrorCodes = {
   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",
@@ -337,5 +352,5 @@ var CoreErrorCodes = {
 };
 
 export { CoreErrorCodes, EngineError, ErrorCategory, ErrorFactory, andThen, combine, err, isErr, isOk, map, mapErr, match, normalizeUnknownError, ok, throwIfErr, tryCatch, tryCatchAsync, unwrapOr };
-//# sourceMappingURL=chunk-3D7V24DG.js.map
-//# sourceMappingURL=chunk-3D7V24DG.js.map
+//# sourceMappingURL=chunk-ERCOHGXD.js.map
+//# sourceMappingURL=chunk-ERCOHGXD.js.map

package/dist/chunk-ERCOHGXD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors/EngineError.ts","../src/errors/Result.ts","../src/errors/ErrorCode.ts"],"names":["ErrorCategory"],"mappings":"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","file":"chunk-ERCOHGXD.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  /** 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"]}

package/dist/{chunk-IF532O7C.js → chunk-FD5ZZHEU.js}

@@ -87,15 +87,6 @@ var abortLogger = {
   }
 };
 
-// src/utilities/Hash.ts
-function djb2Hash(str) {
-  let hash = 5381;
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
-  }
-  return hash >>> 0;
-}
-
-export { abortLogger, djb2Hash };
-//# sourceMappingURL=chunk-IF532O7C.js.map
-//# sourceMappingURL=chunk-IF532O7C.js.map
+export { abortLogger };
+//# sourceMappingURL=chunk-FD5ZZHEU.js.map
+//# sourceMappingURL=chunk-FD5ZZHEU.js.map

package/dist/chunk-FD5ZZHEU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utilities/AbortControllerLogger.ts"],"names":[],"mappings":";AA4BA,IAAM,iBAAiB,OAAO,OAAA,KAAY,WAAA,IAAe,OAAA,CAAQ,IAAI,eAAA,KAAoB,MAAA;AAQlF,IAAM,WAAA,GAAc;AAAA;AAAA,EAE1B,IAAI,OAAA,GAAmB;AACtB,IAAA,OAAO,cAAA;AAAA,EACR,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,gBAAA,GAAyB;AACxB,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,MAAM,+BAA+B,CAAA;AAAA,EAC9C,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAiB,MAAA,EAAsB;AACtC,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,KAAA,CAAM,CAAA,+BAAA,EAAkC,MAAM,CAAA,CAAE,CAAA;AAAA,EACzD,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,uBAAuB,MAAA,EAAsB;AAC5C,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,KAAA,CAAM,CAAA,2BAAA,EAA8B,MAAM,CAAA,CAAA,CAAG,CAAA;AAAA,EACtD,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,aAAa,MAAA,EAAsB;AAClC,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,KAAA,CAAM,CAAA,0BAAA,EAA6B,MAAM,CAAA,kBAAA,CAAe,CAAA;AAAA,EACjE,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,eAAe,MAAA,EAAsB;AACpC,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,KAAA,CAAM,CAAA,4BAAA,EAA+B,MAAM,CAAA,CAAA,CAAG,CAAA;AAAA,EACvD,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,mBAAmB,SAAA,EAA0B;AAC5C,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,KAAA;AAAA,MACP,uDAAkD,SAAS,CAAA,CAAA;AAAA,KAC5D;AAAA,EACD,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,sBAAA,GAA+B;AAC9B,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,MAAM,6CAA6C,CAAA;AAAA,EAC5D,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,kBAAA,CAAmB,UAAkB,OAAA,EAAuB;AAC3D,IAAA,IAAI,CAAC,cAAA,EAAgB;AACrB,IAAA,OAAA,CAAQ,KAAA;AAAA,MACP,CAAA,2BAAA,EAA8B,QAAQ,CAAA,EAAA,EAAK,OAAO,CAAA,CAAA;AAAA,KACnD;AAAA,EACD;AACD","file":"chunk-FD5ZZHEU.js","sourcesContent":["/**\n * Debug logging for the AbortController lifecycle in the \"One AbortController\n * Per Keystroke\" pattern.\n *\n * Enabled when `process.env.DEBUG_ABORTCTRL === \"true\"`.\n *\n * This is **opt-in only**, even in development mode you must explicitly\n * set the flag to avoid log noise from large documents.\n *\n * Logs controller creation, abortion, signal linking, keystroke signal\n * propagation, and stale-data discard guards.  All messages are output via\n * `console.debug` with an `[AbortCtrl]` prefix so they can be filtered\n * in the DevTools console.\n *\n * ── Usage ─────────────────────────────────────────────────────────────\n * import { abortLogger } from \"@solve-js/utilities/AbortControllerLogger\";\n *\n * // Enable explicitly (before the plugin boots):\n * //   process.env.DEBUG_ABORTCTRL = \"true\";\n *\n * abortLogger.keystrokeCreated();\n * abortLogger.localControllerCreated(\"executeAndStore\");\n * abortLogger.signalLinked(\"executeAndStore\", \"keystroke\");\n * abortLogger.keystrokeAborted(\"New keystroke\");\n * abortLogger.staleDataDiscarded(\"USD:GBP\", \"signal aborted\");\n * abortLogger.keystrokeSignalSet(true);  // signal set, not aborted\n * abortLogger.keystrokeSignalCleared();\n */\nconst isDebugEnabled = typeof process !== \"undefined\" && process.env.DEBUG_ABORTCTRL === \"true\";\n\n/**\n * Records abort-signal lifecycle for debugging cancellation.\n *\n * Keystroke cancellation is hard to reason about after the fact, because the\n * evidence is gone by the time anything looks wrong. This keeps it.\n */\nexport const abortLogger = {\n\t/** Whether debug logging is currently active. */\n\tget enabled(): boolean {\n\t\treturn isDebugEnabled;\n\t},\n\n\t// ── Keystroke-level controller (MarkdownEditorViewPlugin) ──────\n\n\t/**\n\t * Log creation of the keystroke-level AbortController.\n\t * Called in the plugin constructor and on each new keystroke.\n\t */\n\tkeystrokeCreated(): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(\"[AbortCtrl] KEYSTROKE CREATED\");\n\t},\n\n\t/**\n\t * Log abortion of the keystroke-level AbortController.\n\t * @param reason Why the keystroke was aborted (e.g. \"New keystroke\",\n\t *   \"Document switch\", \"Plugin destroyed\").\n\t */\n\tkeystrokeAborted(reason: string): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(`[AbortCtrl] KEYSTROKE ABORTED: ${reason}`);\n\t},\n\n\t// ── Local per-evaluation controllers (ExpressionEngine) ─────────\n\n\t/**\n\t * Log creation of a local AbortController that is linked to the\n\t * keystroke signal.\n\t * @param source Which code path created the controller\n\t *   (e.g. \"executeAndStore\", \"executeRaw\", \"preflight\", \"vm\").\n\t */\n\tlocalControllerCreated(source: string): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(`[AbortCtrl] LOCAL CREATED (${source})`);\n\t},\n\n\t/**\n\t * Log that a local AbortController was linked to the keystroke signal.\n\t * When the keystroke signal is aborted, this local controller will\n\t * be aborted automatically.\n\t * @param source The code path that created the controller.\n\t */\n\tsignalLinked(source: string): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(`[AbortCtrl] LOCAL LINKED (${source}) → keystroke`);\n\t},\n\n\t/**\n\t * Log that a local AbortController's listener was removed from the\n\t * keystroke signal (cleanup).\n\t * @param source The code path.\n\t */\n\tsignalUnlinked(source: string): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(`[AbortCtrl] LOCAL UNLINKED (${source})`);\n\t},\n\n\t// ── Keystroke signal propagation (ThreeTierEvaluator → ExpressionEngine) ──\n\n\t/**\n\t * Log that the keystroke signal was propagated INTO the engine.\n\t * @param isAborted Whether the signal was already aborted when set.\n\t */\n\tkeystrokeSignalSet(isAborted: boolean): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(\n\t\t\t`[AbortCtrl] KEYSTROKE_SIGNAL → engine (aborted=${isAborted})`,\n\t\t);\n\t},\n\n\t/**\n\t * Log that the keystroke signal was CLEARED from the engine\n\t * (typically in the evaluator's finally block).\n\t */\n\tkeystrokeSignalCleared(): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(\"[AbortCtrl] KEYSTROKE_SIGNAL cleared (null)\");\n\t},\n\n\t// ── Stale-data discard guards (resolveAsync) ────────────────────\n\n\t/**\n\t * Log that a stale async result was discarded because its signal\n\t * was aborted.\n\t * @param queryKey The cache key for the discarded result.\n\t * @param context Additional context (e.g. \"after await\", \"after error\").\n\t */\n\tstaleDataDiscarded(queryKey: string, context: string): void {\n\t\tif (!isDebugEnabled) return;\n\t\tconsole.debug(\n\t\t\t`[AbortCtrl] STALE DISCARD: ${queryKey} (${context})`,\n\t\t);\n\t},\n};\n"]}

package/dist/{chunk-7FSDNNNC.js → chunk-G7Z4HJQA.js}

@@ -1,7 +1,7 @@
-import { ErrorFactory } from './chunk-3D7V24DG.js';
+import { ErrorFactory } from './chunk-ERCOHGXD.js';
 
 // package.json
-var version = "1.0.2";
+var version = "1.1.0";
 
 // src/constants/version.ts
 var ENGINE_VERSION = version;
@@ -58,7 +58,13 @@ var DEFAULT_CONFIG = {
     // the calls it does allow cost single-digit megabytes rather than the
     // heap. A document that needs more than ten thousand calls on one line
     // is doing something a calculator was not built for.
-    maxFunctionCalls: 1e4
+    maxFunctionCalls: 1e4,
+    // A hundred bisection steps resolve an input to one part in 2^100, far
+    // finer than any document needs and a firm stop for an untrusted one. A
+    // continuous, monotonic relationship converges in tens of steps, well
+    // under this; hitting it means the target is unreachable or the
+    // relationship is not the smooth one goal seek assumes.
+    maxGoalSeekIterations: 100
   },
   worker: {
     maxConcurrentWorkers: 4,
@@ -194,5 +200,5 @@ var ConfigManager = class {
 };
 
 export { ConfigManager, DEFAULT_CONFIG, ENGINE_VERSION, mergeEngineConfig };
-//# sourceMappingURL=chunk-7FSDNNNC.js.map
-//# sourceMappingURL=chunk-7FSDNNNC.js.map
+//# sourceMappingURL=chunk-G7Z4HJQA.js.map
+//# sourceMappingURL=chunk-G7Z4HJQA.js.map

package/dist/chunk-G7Z4HJQA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../package.json","../src/constants/version.ts","../src/constants/Configuration.ts"],"names":[],"mappings":"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","file":"chunk-G7Z4HJQA.js","sourcesContent":["{\n  \"name\": \"solve-engine\",\n  \"version\": \"1.1.0\",\n  \"description\": \"An embeddable expression engine for natural-language calculations: units, currencies, percentages, dates and matrices, with the parsing and evaluation plumbing already built.\",\n  \"keywords\": [\n    \"expression-evaluator\",\n    \"calculator\",\n    \"bytecode-vm\",\n    \"parser\",\n    \"lexer\",\n    \"dsl\",\n    \"markdown\",\n    \"obsidian\"\n  ],\n  \"license\": \"MIT\",\n  \"author\": \"Liam Riddell\",\n  \"homepage\": \"https://liamriddell.github.io/solve-engine/\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/LiamRiddell/solve-engine.git\",\n    \"directory\": \"packages/engine\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/LiamRiddell/solve-engine/issues\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=22\"\n  },\n  \"files\": [\n    \"dist\",\n    \"LICENSE\"\n  ],\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./engine\": {\n      \"import\": {\n        \"types\": \"./dist/engine.d.ts\",\n        \"default\": \"./dist/engine.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/engine.d.cts\",\n        \"default\": \"./dist/engine.cjs\"\n      }\n    },\n    \"./vm\": {\n      \"import\": {\n        \"types\": \"./dist/vm.d.ts\",\n        \"default\": \"./dist/vm.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/vm.d.cts\",\n        \"default\": \"./dist/vm.cjs\"\n      }\n    },\n    \"./format\": {\n      \"import\": {\n        \"types\": \"./dist/format.d.ts\",\n        \"default\": \"./dist/format.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/format.d.cts\",\n        \"default\": \"./dist/format.cjs\"\n      }\n    },\n    \"./language\": {\n      \"import\": {\n        \"types\": \"./dist/language.d.ts\",\n        \"default\": \"./dist/language.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/language.d.cts\",\n        \"default\": \"./dist/language.cjs\"\n      }\n    },\n    \"./packages\": {\n      \"import\": {\n        \"types\": \"./dist/packages.d.ts\",\n        \"default\": \"./dist/packages.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/packages.d.cts\",\n        \"default\": \"./dist/packages.cjs\"\n      }\n    },\n    \"./constants\": {\n      \"import\": {\n        \"types\": \"./dist/constants.d.ts\",\n        \"default\": \"./dist/constants.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/constants.d.cts\",\n        \"default\": \"./dist/constants.cjs\"\n      }\n    },\n    \"./lexer\": {\n      \"import\": {\n        \"types\": \"./dist/lexer.d.ts\",\n        \"default\": \"./dist/lexer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/lexer.d.cts\",\n        \"default\": \"./dist/lexer.cjs\"\n      }\n    },\n    \"./parser\": {\n      \"import\": {\n        \"types\": \"./dist/parser.d.ts\",\n        \"default\": \"./dist/parser.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/parser.d.cts\",\n        \"default\": \"./dist/parser.cjs\"\n      }\n    },\n    \"./normalizer\": {\n      \"import\": {\n        \"types\": \"./dist/normalizer.d.ts\",\n        \"default\": \"./dist/normalizer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/normalizer.d.cts\",\n        \"default\": \"./dist/normalizer.cjs\"\n      }\n    },\n    \"./variables\": {\n      \"import\": {\n        \"types\": \"./dist/variables.d.ts\",\n        \"default\": \"./dist/variables.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/variables.d.cts\",\n        \"default\": \"./dist/variables.cjs\"\n      }\n    },\n    \"./resolvers\": {\n      \"import\": {\n        \"types\": \"./dist/resolvers.d.ts\",\n        \"default\": \"./dist/resolvers.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/resolvers.d.cts\",\n        \"default\": \"./dist/resolvers.cjs\"\n      }\n    },\n    \"./errors\": {\n      \"import\": {\n        \"types\": \"./dist/errors.d.ts\",\n        \"default\": \"./dist/errors.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/errors.d.cts\",\n        \"default\": \"./dist/errors.cjs\"\n      }\n    },\n    \"./utilities\": {\n      \"import\": {\n        \"types\": \"./dist/utilities.d.ts\",\n        \"default\": \"./dist/utilities.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/utilities.d.cts\",\n        \"default\": \"./dist/utilities.cjs\"\n      }\n    },\n    \"./uom\": {\n      \"import\": {\n        \"types\": \"./dist/uom.d.ts\",\n        \"default\": \"./dist/uom.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/uom.d.cts\",\n        \"default\": \"./dist/uom.cjs\"\n      }\n    },\n    \"./services\": {\n      \"import\": {\n        \"types\": \"./dist/services.d.ts\",\n        \"default\": \"./dist/services.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/services.d.cts\",\n        \"default\": \"./dist/services.cjs\"\n      }\n    },\n    \"./worker\": {\n      \"import\": {\n        \"types\": \"./dist/worker.d.ts\",\n        \"default\": \"./dist/worker.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/worker.d.cts\",\n        \"default\": \"./dist/worker.cjs\"\n      }\n    },\n    \"./testing\": {\n      \"import\": {\n        \"types\": \"./dist/testing.d.ts\",\n        \"default\": \"./dist/testing.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/testing.d.cts\",\n        \"default\": \"./dist/testing.cjs\"\n      }\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"prepublishOnly\": \"npm run build && node ../../scripts/assert-publishable.mjs .\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"jest --config jest.config.cjs --no-coverage\",\n    \"typecheck\": \"tsgo --noEmit --skipLibCheck\",\n    \"typecheck:tsc\": \"tsc --noEmit --skipLibCheck\"\n  },\n  \"dependencies\": {\n    \"@tanstack/query-core\": \"^5.100.10\"\n  },\n  \"devDependencies\": {\n    \"@jest/globals\": \"^30.4.1\",\n    \"@types/node\": \"^26.2.0\",\n    \"@types/semver\": \"^7.5.0\",\n    \"convert\": \"^7.0.0\",\n    \"jest\": \"^30.4.2\",\n    \"semver\": \"^7.6.0\",\n    \"ts-jest\": \"^29.4.12\",\n    \"tsup\": \"8.5.1\",\n    \"typescript\": \"5.9.3\"\n  },\n  \"//sideEffects\": \"Load-bearing claim, not boilerplate. tsup's splitting emits bare chunk imports at the top of dist/index.js, and this field tells Rollup, webpack and Vite they may delete them, which esbuild reports as [ignored-bare-import] once per import during `npm run size`. The engine does have module-level work to lose: registerAllTokenTypes(), _PrecedenceParser.BP_TABLE and its cached token ids, and several process-wide registries. It is safe because every chunk doing that work is also imported for its bindings somewhere, so no bundler can drop it. That is a property of how tsup currently splits the code rather than a design guarantee, so `npm run smoke:bundled` (scripts/check-tree-shaking.mjs) proves it on every run of `npm run verify` instead of assuming it, and its header explains the two fixes if it ever stops holding.\",\n  \"sideEffects\": false\n}\n","/**\n * The running engine's own semver version, sourced directly from this\n * package's package.json so it can never drift from what's actually\n * published. Exists so IEnginePackage.engineVersion range checks\n * (api/EngineVersionCompatibility.ts) have something real to check\n * against.\n */\nimport { version } from \"../../package.json\";\n\n/**\n * The running engine's version, taken from package.json.\n *\n * What a package's `engineVersion` range is checked against at registration.\n * A prerelease is compared by its coerced release version, so a 1.0.0 beta\n * satisfies `^1.0.0`. See `api/EngineVersionCompatibility.ts`.\n */\nexport const ENGINE_VERSION: string = version;\n","/**\n * Configuration Module for solve-js Engine\n * \n * This module provides the **single source of truth** for all engine configuration.\n * Every configurable aspect of the engine, from safety limits and performance\n * budgets to VM constraints and worker pool sizing, is defined here.\n * \n * ### Design principles\n * \n * 1. **Engine owns its config.** The engine defines its own config shape and defaults.\n *    Consumers (e.g., the Obsidian plugin) pass partial overrides; all unspecified\n *    fields fall back to `DEFAULT_CONFIG`.\n * \n * 2. **Self-documenting.** Every interface and field has descriptive JSDoc so the\n *    config is understandable at a glance, whether you're using the engine as an\n *    npm package or reading the source.\n * \n * 3. **Minimal consumer knowledge.** Consumers only need to pass `Partial<EngineConfig>`.\n *    They don't need to replicate the full config shape, just the fields they\n *    want to override.\n * \n * @module Configuration\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * A host's test for whether a calendar date is a public holiday, given the\n * `Date` for that day at local midnight. Return `true` to exclude it from\n * working-day arithmetic.\n */\nexport type HolidayPredicate = (date: Date) => boolean;\n\n/**\n * The host-supplied public-holiday calendar, in the same \"bring your own data\"\n * shape the stocks and weather packages already use for a host callback (see\n * `packages/stocks/StocksPackage.ts`): weekends are decidable from the date\n * alone, holidays are not, so they come from the host or not at all.\n *\n * Either a {@link HolidayPredicate}, for a host that computes holidays itself\n * (an existing library, a region rule), or an iterable of specific dates as\n * `YYYY-MM-DD` strings, epoch-millisecond numbers or `Date` objects, for a host\n * that just has a list. Resolved to one internal predicate by\n * `vm/HolidayCalendar.ts`'s `resolveHolidayPredicate()`.\n *\n * Left unset, working-day arithmetic skips weekends only, which is the honest\n * default: the engine excludes exactly the days it can prove are non-working.\n */\nexport type HolidayCalendar = HolidayPredicate | Iterable<string | number | Date>;\n\n/**\n * Date-related configuration.\n * Controls the bounds and formatting for date/time expression evaluation\n * (e.g., `today + 20 days`, `last monday`).\n */\nexport interface DateConfig {\n  /**\n   * How far forward a date offset whose COST grows with the offset may reach,\n   * in years. Enforced by `vm/VM.ts`'s `addBusinessDays()`.\n   *\n   * Bounds the walk, not the calendar. Every other date offset in the engine\n   * is arithmetic on a Date field, so `today + 100000 days` costs exactly what\n   * one day costs and needs no ceiling; workdays are the one offset that has\n   * to step day by day, because which days are skipped depends on where each\n   * step lands. `today + 100000000 workdays` therefore froze the host for\n   * thirteen seconds inside a single ADD opcode (where `vm.maxInstructions`\n   * cannot see it) and then answered \"Invalid Date\", and a trillion never\n   * returned at all.\n   *\n   * Release hardening: this field was declared, documented as a \"safety\n   * limit\", and read nowhere, so it bounded nothing. A limit a host can\n   * configure and the engine ignores is worse than no limit, because it reads\n   * as protection that is not there.\n   */\n  readonly maxOffsetYears: number;\n  /** How far BACK the same walk may reach, in years, as a negative number. See {@link maxOffsetYears}. */\n  readonly minOffsetYears: number;\n  /** Default date string format for display (moment.js format string) */\n  readonly defaultFormat: string;\n  /**\n   * Public-holiday calendar for working-day arithmetic (`N working days after\n   * <date>`, `working days between <date> and <date>`, `<date> + N workdays`).\n   * See {@link HolidayCalendar}.\n   *\n   * Optional and unset by default: with no calendar, working-day arithmetic\n   * skips weekends only. A host that wants holidays excluded too supplies one\n   * here (`new ExpressionEngine(\"en\", false, { date: { holidays } })`), the\n   * same way stocks and weather take a host data source. Threaded into the VM\n   * by `engine/ExpressionEngine.ts` exactly as {@link maxOffsetYears} is,\n   * because working-day math is a VM operation several grammar forms share, so\n   * the calendar has to be one source the VM owns rather than per-package state\n   * the VM cannot see.\n   */\n  readonly holidays?: HolidayCalendar;\n}\n\n/**\n * Performance-related configuration.\n * Controls caching, timeouts, and processing limits to prevent runaway\n * resource consumption on large documents.\n */\nexport interface PerformanceConfig {\n  /**\n   * Maximum number of entries in {@link ExpressionEngine}'s bytecode cache\n   * (per-instance, keyed by expression text) before the oldest entry is\n   * evicted. Raise this for documents with many distinct expressions if\n   * repeated re-evaluation (e.g. scrolling) is re-parsing instead of\n   * hitting cache, bug fix (release hardening pass): this field used to\n   * be read nowhere; the cache size was a hardcoded, unconfigurable\n   * constant. Note this does NOT bound {@link LineCache}, which has no\n   * size limit of its own.\n   */\n  readonly defaultCacheSize: number;\n  /**\n   * Maximum lines a document may have for the engine to process it in one\n   * pass. Enforced by `ExpressionEngine.parseDocument()` and by\n   * `engine/DocumentModel.ts`'s `setDocument()`, the two entry points that\n   * take a whole document.\n   *\n   * A document costs memory per line whatever each line says: a parsed line\n   * record, a cache entry, a dependency-graph node. Two hundred thousand\n   * lines of `1 + 1` therefore exhausted the heap and aborted the process\n   * before any per-line limit had anything to object to, which is the same\n   * shape of hole as an unbounded expression and needs the same kind of\n   * ceiling. Refusing the document names the limit; a host that genuinely has\n   * a larger one raises this field.\n   *\n   * Release hardening: declared and read nowhere until now.\n   */\n  readonly maxDocumentLines: number;\n}\n\n/**\n * Validation / safety-limit configuration.\n * Protects against runaway expressions that could cause excessive memory use\n * or stack overflow. These limits are checked during lexing and parsing.\n */\n/** Bounds on untrusted input: expression length and nesting depth. */\nexport interface ValidationConfig {\n  /** Maximum expression length in characters. Prevents excessively long strings from entering the pipeline. */\n  readonly maxExpressionLength: number;\n  /** Maximum expression complexity score (`tokens + functionCalls×5 + nestingDepth×10`). Protects against deeply nested or combinatorially complex expressions. */\n  readonly maxComplexity: number;\n  /** Maximum parentheses nesting depth. Prevents stack overflow in the recursive-descent parser. */\n  readonly maxNestingDepth: number;\n  /**\n   * Auto-balance unmatched parentheses by appending missing closing parens\n   * or prepending missing opening parens. When disabled, unbalanced expressions\n   * cause parse errors instead of being silently corrected.\n   *\n   * Disabled by default for strict parsing. Enable for forgiving user input\n   * (e.g., chat-style calculators where users often omit closing parens).\n   * Has zero overhead when disabled, the O(n) paren-count scan is skipped.\n   */\n  readonly autoBalanceParens: boolean;\n}\n\n/**\n * Worker pool configuration.\n * Controls the parallel execution workers used for batch evaluation.\n */\nexport interface WorkerConfig {\n  /** Maximum number of concurrent Web Workers allowed */\n  readonly maxConcurrentWorkers: number;\n  /** Time (ms) a worker stays alive while idle before being terminated */\n  readonly idleTimeoutMs: number;\n  /** Maximum retry attempts for a failed worker operation */\n  readonly maxRetries: number;\n  /** Base backoff delay (ms) between retries (exponential backoff applied on top) */\n  readonly baseBackoffMs: number;\n}  /**\n   * Diagnostic / telemetry configuration.\n   * Controls the diagnostic event pipeline for profiling and debugging.\n   * All diagnostics are disabled by default for maximum production performance.\n   */\n  export interface DiagnosticConfig {\n    /** Master switch: enable the diagnostic pipeline (collectors receive events for all pipeline stages) */\n    readonly enabled: boolean;\n    /** Enable VM trace mode, emits per-opcode execution events (very verbose; disables some optimizations) */\n    readonly vmTraceEnabled: boolean;\n  }\n\n  /**\n   * Virtual Machine configuration.\n   * Controls the internal bytecode VM that executes compiled expressions.\n   */\n  export interface VMConfig {\n    /** Maximum stack depth (value slots) for VM execution, prevents stack overflow in recursive/pratt-parser generated bytecode */\n    readonly maxStackDepth: number;\n    /** Maximum opcodes executed per expression, halts runaway infinite loops */\n    readonly maxInstructions: number;\n    /**\n     * Maximum elements a collection may be expanded to before `map`/`reduce`/\n     * `sum`/`prod` will iterate it.\n     *\n     * A Range is stored as its two bounds and costs nothing until something\n     * materializes it, at which point it becomes one Value per element. Twenty\n     * characters (`sum(x, 1:100000000)`) therefore asked for a hundred million\n     * of them, and neither `maxInstructions` nor `maxStackDepth` could see it:\n     * the expansion happens inside a single opcode, so the instruction counter\n     * is never consulted while it runs, and the elements never reach the value\n     * stack. V8 aborted the whole process with \"Reached heap limit\", which a\n     * host embedding the engine cannot catch.\n     */\n    readonly maxCollectionSize: number;\n    /**\n     * Maximum elements (collection Values, matrix cells) one evaluation may\n     * materialize in total.\n     *\n     * `maxCollectionSize` above bounds a single collection. This bounds the sum\n     * of everything an expression asks for, which is a different question and\n     * the one that actually protects the host: two collections that are\n     * individually legal are legal together, and an operation whose result is\n     * the PRODUCT of two legal operands is bounded by neither of them. A matrix\n     * multiply is exactly that shape, so three lines within every other limit\n     * (`:a = map(1*x, 0:20000)`, `:b = transpose(a)`, `b * a`) asked for four\n     * hundred million cells and aborted the process.\n     *\n     * Counted in elements rather than bytes, because a count is what a call\n     * site has before it allocates. An element is 8 bytes as a numeric matrix\n     * cell and closer to a hundred as a full Value, so the default is worth\n     * roughly 16 MB of matrix or 200 MB of expanded collection: far past any\n     * document and far short of what an editor cannot survive.\n     */\n    readonly maxAllocatedElements: number;\n    /**\n     * Maximum user-defined-function calls one evaluation may make in TOTAL,\n     * however deeply or widely they nest.\n     *\n     * `maxFunctionRecursionDepth` bounds how DEEP calls nest and cannot see\n     * how MANY there are, and those are different numbers. Twenty-two lines of\n     * `f(n)(v) = f(n-1)(v) + f(n-1)(v)` reach a depth of only 22 against a\n     * limit of 50, and make 2,097,152 calls doing it: a fatal heap abort in\n     * under a second. `maxInstructions` cannot bound it either, because\n     * `executeBytecode()` re-enters itself per call and each reentrant call\n     * gets its OWN instruction count, so recursion refreshes its allowance on\n     * the way in. This is the tally that does not refresh; see\n     * `vm/AllocationBudget.ts`, which holds it for the same reason it holds\n     * the element tally.\n     *\n     * Counted in calls rather than in the instructions they run, because the\n     * call is the thing that multiplies: every call allocates a frame, its\n     * arguments and its result whatever its body says.\n     */\n    readonly maxFunctionCalls: number;\n    /**\n     * Hard ceiling on how many bisection steps goal seek (`solve line N for\n     * <var> = <target>`, see `packages/goalseek/`) may take before it gives up\n     * with a structured error rather than continuing.\n     *\n     * Goal seek re-evaluates the target line's expression once per step while\n     * narrowing an interval, and an untrusted document must never be able to\n     * make that loop spin. `maxInstructions` bounds each individual\n     * re-evaluation, but not how many of them the search performs, so this is\n     * the tally that bounds the search itself, the same reason `maxFunctionCalls`\n     * exists alongside `maxInstructions`. Bisection halves the interval every\n     * step, so a hundred steps resolves an input to roughly one part in 2^100:\n     * far past any precision a document needs, and a definite stop either way.\n     */\n    readonly maxGoalSeekIterations: number;\n  }\n\n/**\n * Complete engine configuration.\n *\n * Every field has a default in `DEFAULT_CONFIG`. To customize, pass a\n * `Partial<EngineConfig>` when constructing `ExpressionEngine`. Only the\n * sections/fields you supply are overridden; all others use their defaults.\n *\n * @example\n * ```typescript\n * import { ExpressionEngine } from \"solve-js\";\n *\n * const engine = new ExpressionEngine(\"en\", false, {\n *   validation: {\n *     maxExpressionLength: 1000,\n *     maxComplexity: 200,\n *   },\n *   // date, performance, vm, worker, diagnostic all use defaults\n * });\n * ```\n */\nexport interface EngineConfig {\n    /** Date/time expression evaluation bounds and formatting */\n    readonly date: DateConfig;\n    /** Performance budgets and cache sizing */\n    readonly performance: PerformanceConfig;\n    /** Safety limits for expression complexity */\n    readonly validation: ValidationConfig;\n    /** Internal bytecode VM configuration */\n    readonly vm: VMConfig;\n    /** Parallel worker pool configuration */\n    readonly worker: WorkerConfig;\n    /** Diagnostic pipeline configuration */\n    readonly diagnostic: DiagnosticConfig;\n  }\n\n/**\n * Default configuration values\n */\nexport const DEFAULT_CONFIG: EngineConfig = {\n   date: {\n     // A century of workdays is about 26,000 steps, which is microseconds,\n     // and past any offset a person means. The walk is what these bound; see\n     // DateConfig above for why no other date offset needs a ceiling.\n     maxOffsetYears: 100,\n     minOffsetYears: -100,\n     defaultFormat: 'YYYY-MM-DD'\n   },\n   performance: {\n     // Preserves the effective cache size the hardcoded (now-removed)\n     // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up\n     // doesn't silently shrink the default cache for existing consumers.\n     defaultCacheSize: 2000,\n     // Raised from the 10,000 this field was declared with, which was never\n     // enforced and turned out to be under what this engine already supports:\n     // its paging design is tested against a 20,000-line document\n     // (`engine/PageManager.ts` and its spec) and its throughput benchmark\n     // parses a 50,000-line one. Twice the largest of those, and the same\n     // number `ConfigManager.validate()` already refuses to go above.\n     //\n     // Measured under a 256MB heap: setting a 100,000-line document costs\n     // 64MB, evaluating every line of a 20,000-line one costs 106MB, and\n     // 200,000 lines aborts the process before a single expression is looked\n     // at. A host with a small heap should lower this; the ceiling is here to\n     // stop the size that cannot work anywhere.\n     maxDocumentLines: 100000,\n   },\n    validation: {\n      maxExpressionLength: 2000,\n      maxComplexity: 500,\n      maxNestingDepth: 50,\n      autoBalanceParens: false,\n    },\n    vm: {\n      maxStackDepth: 200,\n      maxInstructions: 50000,\n      // Two orders of magnitude above anything a person types by hand (the\n      // longest range in the test suite is 1000 elements) and small enough\n      // that expanding it is measured in milliseconds rather than in whether\n      // the host survives.\n      maxCollectionSize: 100000,\n      // Twenty times the single-collection ceiling above, so an expression may\n      // legitimately handle a number of large collections, and two hundred\n      // times below the allocation that took the process down.\n      maxAllocatedElements: 2000000,\n      // Six hundred times the largest call count any test or example makes\n      // (five levels of composition is sixteen calls), and small enough that\n      // the calls it does allow cost single-digit megabytes rather than the\n      // heap. A document that needs more than ten thousand calls on one line\n      // is doing something a calculator was not built for.\n      maxFunctionCalls: 10000,\n      // A hundred bisection steps resolve an input to one part in 2^100, far\n      // finer than any document needs and a firm stop for an untrusted one. A\n      // continuous, monotonic relationship converges in tens of steps, well\n      // under this; hitting it means the target is unreachable or the\n      // relationship is not the smooth one goal seek assumes.\n      maxGoalSeekIterations: 100,\n    },\n    worker: {\n      maxConcurrentWorkers: 4,\n      idleTimeoutMs: 30000,\n      maxRetries: 3,\n      baseBackoffMs: 1000,\n    },\n    diagnostic: {\n      enabled: false,\n      vmTraceEnabled: false,\n    },\n  };\n\n/**\n * Merge a partial config override onto a base `EngineConfig`, section by\n * section, `{ ...base.section, ...override.section }` for each of the 7\n * top-level sections, not a single top-level spread.\n *\n * A shallow `{ ...base, ...override }` at the TOP level replaces an entire\n * section wholesale the moment a caller overrides even one field in it\n * (e.g. `{ performance: { defaultCacheSize: 500 } }` would silently drop\n * every other `performance.*` field back to `undefined`, not to its\n * default). This function exists specifically so every config consumer\n * shares one correct merge instead of each hand-rolling (and risking) its\n * own. `ConfigManager` and `ExpressionEngine` both call this rather than\n * either duplicating the section list or instantiating a whole\n * `ConfigManager` just to reuse its private merge logic.\n */\nexport function mergeEngineConfig(\n  base: EngineConfig,\n  override: Partial<EngineConfig>\n): EngineConfig {\n  return {\n    date: { ...base.date, ...override.date },\n    performance: { ...base.performance, ...override.performance },\n    validation: { ...base.validation, ...override.validation },\n    vm: { ...base.vm, ...override.vm },\n    worker: { ...base.worker, ...override.worker },\n    diagnostic: { ...base.diagnostic, ...override.diagnostic },\n  };\n}\n\n/**\n * Configuration manager for engine settings\n *\n * @example\n * ```typescript\n * const configManager = new ConfigManager();\n * configManager.set('performance.defaultCacheSize', 2000);\n * const cacheSize = configManager.get('performance.defaultCacheSize');\n * ```\n */\nexport class ConfigManager {\n  private config: EngineConfig;\n\n  constructor(config: Partial<EngineConfig> = {}) {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);\n  }\n\n  /**\n   * Get configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @returns Configuration value\n   */\n  get<T>(path: string): T {\n    const keys = path.split('.');\n    let current: unknown = this.config;\n\n    for (const key of keys) {\n      if (current && typeof current === 'object' && key in current) {\n        current = (current as Record<string, unknown>)[key];\n      } else {\n        throw ErrorFactory.config(\n          \"CONFIG_PATH_NOT_FOUND\",\n          `Configuration path not found: ${path}`,\n          { path }\n        );\n      }\n    }\n\n    return current as T;\n  }\n\n  /**\n   * Set configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @param value - New value\n   */\n  set<T>(path: string, value: T): void {\n    const keys = path.split('.');\n    if (keys.length < 2) {\n      throw ErrorFactory.config(\n        \"INVALID_CONFIG_PATH\",\n        `Invalid path: ${path}. Must be in format 'section.property'`,\n        { path }\n      );\n    }\n    \n    const section = keys[0];\n    const property = keys[1];\n    \n    if (!(section in this.config)) {\n      throw ErrorFactory.config(\n        \"CONFIG_SECTION_NOT_FOUND\",\n        `Configuration section not found: ${section}`,\n        { section, path }\n      );\n    }\n    \n    const sectionConfig = this.config[section as keyof EngineConfig];\n    if (sectionConfig && typeof sectionConfig === 'object') {\n      (sectionConfig as unknown as Record<string, unknown>)[property] = value;\n    } else {\n      throw ErrorFactory.config(\n        \"CONFIG_PROPERTY_NOT_FOUND\",\n        `Configuration property not found: ${path}`,\n        { path }\n      );\n    }\n  }\n\n  /**\n   * Get complete configuration.\n   *\n   * A detached copy, section objects included. A top-level spread would hand\n   * the caller this manager's own section objects, so `getConfig().vm.x = 1`\n   * would be an undeclared back door into {@link set}, bypassing its path\n   * validation and reaching every later {@link get}.\n   */\n  getConfig(): EngineConfig {\n    return mergeEngineConfig(this.config, {});\n  }\n\n  /**\n   * Update multiple configuration values\n   */\n  update(config: Partial<EngineConfig>): void {\n    this.config = mergeEngineConfig(this.config, config);\n  }\n\n  /**\n   * Reset to default configuration.\n   *\n   * Goes through {@link mergeEngineConfig} for the same reason the constructor\n   * does. A top-level `{ ...DEFAULT_CONFIG }` copies the six section\n   * references, not the sections, so after a reset this manager's\n   * `performance` object WAS `DEFAULT_CONFIG.performance` and the next\n   * `set('performance.x', ...)` wrote into the module constant. That constant\n   * is what every `ExpressionEngine` is built from, so one manager's reset\n   * could change the cache size, instruction ceiling or allocation budget of\n   * every engine constructed later in the process.\n   */\n  reset(): void {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, {});\n  }\n\n  /**\n   * Validate configuration values\n   */\n  validate(): ValidationResult {\n    const errors: string[] = [];\n\n    // Validate performance config\n    if (this.config.performance.maxDocumentLines > 100000) {\n      errors.push('maxDocumentLines cannot exceed 100,000');\n    }\n\n    // Validate date config\n    if (this.config.date.maxOffsetYears > 1000) {\n      errors.push('maxOffsetYears cannot exceed 1000');\n    }\n\n    return {\n      valid: errors.length === 0,\n      error: errors.join('; '),\n      warnings: []\n    };\n  }\n}\n\n/**\n * Result type for {@link ConfigManager.validate}.\n */\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n  warnings?: string[];\n}\n\n"]}

package/dist/{chunk-FQGX2PA2.js → chunk-GQMUHVE3.js}

@@ -1,7 +1,7 @@
-import { registerAllTokenTypes, tokenTypeId } from './chunk-VB37OC6I.js';
+import { registerAllTokenTypes, tokenTypeId } from './chunk-4D6NIHE2.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
 import { knownUnits } from './chunk-SBUFNJVE.js';
-import { ErrorFactory } from './chunk-3D7V24DG.js';
+import { ErrorFactory } from './chunk-ERCOHGXD.js';
 
 // src/lexer/ExpressionLexer.ts
 registerAllTokenTypes();
@@ -182,6 +182,16 @@ var _ExpressionLexer = class _ExpressionLexer {
     // Line / column tracking (1-indexed)
     this.line = 1;
     this.lineStartPos = 0;
+    // Open-bracket context stack for the current line, one entry per unclosed
+    // `(`/`[`, `true` when a comma inside it is a separator rather than a
+    // thousands group. A `[` (vector/matrix) and a CALL `(` (`rgb(255,255,255)`,
+    // preceded by an identifier) are separator contexts; a bare GROUPING `(`
+    // (`(1,000)`, preceded by an operator or the line start) is not, so a
+    // parenthesised thousands number still reads as one scalar. The number scanner
+    // consults the innermost entry. Tracked here because the flat token stream
+    // carries no nesting otherwise; reset per line, so an unbalanced bracket
+    // cannot bleed the decision into the next.
+    this.groupingStack = [];
     // Plugin-extensible keyword map (merged with locale keywordMap)
     this.pluginKeywordMap = /* @__PURE__ */ new Map();
     // Plugin-extensible two-char operators: firstChar → (secondChar → tokenType)
@@ -591,6 +601,9 @@ var _ExpressionLexer = class _ExpressionLexer {
           } else if (c0 === 247) {
             yield new LexerToken("SLASH", tokenTypeId("SLASH"), "\xF7", "\xF7", 0, 0, 1, 1);
             tokenIndex++;
+          } else if (c0 === 177) {
+            yield new LexerToken("PLUS_MINUS", tokenTypeId("PLUS_MINUS"), "\xB1", "\xB1", 0, 0, 1, 1);
+            tokenIndex++;
           } else if (c0 === 8800) {
             yield new LexerToken("NEQ", tokenTypeId("NEQ"), "\u2260", "\u2260", 0, 0, 1, 1);
             tokenIndex++;
@@ -641,6 +654,7 @@ var _ExpressionLexer = class _ExpressionLexer {
       return;
     }
     const input = this.input;
+    this.groupingStack.length = 0;
     while (this.pos < len) {
       const c0 = input.charCodeAt(this.pos);
       const cc = _ExpressionLexer.CHAR_CLASS[c0] ?? 0 /* SKIP */;
@@ -655,12 +669,14 @@ var _ExpressionLexer = class _ExpressionLexer {
           if (c0 === 10) {
             this.line++;
             this.lineStartPos = this.pos;
+            this.groupingStack.length = 0;
           } else if (c0 === 13) {
             this.line++;
             if (this.pos < len && input.charCodeAt(this.pos) === 10) {
               this.pos++;
             }
             this.lineStartPos = this.pos;
+            this.groupingStack.length = 0;
           }
           break;
         // ── Digit, inline number tokenizer ───────────────────────────
@@ -756,6 +772,10 @@ var _ExpressionLexer = class _ExpressionLexer {
             yield new LexerToken("SLASH", tokenTypeId("SLASH"), "\xF7", "\xF7", this.pos, 0, this.line, col);
             this.pos++;
             tokenIndex++;
+          } else if (c0 === 177) {
+            yield new LexerToken("PLUS_MINUS", tokenTypeId("PLUS_MINUS"), "\xB1", "\xB1", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
           } else if (c0 === 8800) {
             yield new LexerToken("NEQ", tokenTypeId("NEQ"), "\u2260", "\u2260", this.pos, 0, this.line, col);
             this.pos++;
@@ -873,6 +893,9 @@ var _ExpressionLexer = class _ExpressionLexer {
       pos++;
     }
     while (hasIntPart && pos < len && (input.charCodeAt(pos) === 44 || input.charCodeAt(pos) === 46)) {
+      if (input.charCodeAt(pos) === 44 && this.groupingStack.length > 0 && this.groupingStack[this.groupingStack.length - 1]) {
+        break;
+      }
       if (pos + 4 <= len) {
         const d1 = input.charCodeAt(pos + 1);
         const d2 = input.charCodeAt(pos + 2);
@@ -992,6 +1015,42 @@ var _ExpressionLexer = class _ExpressionLexer {
     return false;
   }
   // ── Inline operator tokenizer ─────────────────────────────────────────
+  /**
+   * Whether the `(` at `parenPos` opens a function call rather than a bare
+   * grouping, deciding whether a comma inside it is a separator or a thousands
+   * group (see {@link groupingStack}).
+   *
+   * It is a call when the nearest non-whitespace character before it belongs to
+   * the value the call applies to: a closing `)`/`]` (a call on a result), or an
+   * IDENTIFIER (`rgb(`, `vec2(`). A run of digits alone is a number, not an
+   * identifier, so `2(1,000)` is implicit multiplication over the grouping
+   * `(1,000)`, not a call, while `vec2(` and `atan2(` (identifiers that end in a
+   * digit) are calls. A `(` after an operator, a comma, or the line start is a
+   * grouping.
+   */
+  precededByCallTarget(parenPos) {
+    const input = this.input;
+    const start = this.lineStartPos;
+    let i = parenPos - 1;
+    while (i >= start && (input.charCodeAt(i) === 32 || input.charCodeAt(i) === 9)) i--;
+    if (i < start) return false;
+    const c = input.charCodeAt(i);
+    const isWord = (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch === 95;
+    const isAlpha = (ch) => ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch === 95;
+    if (!isWord(c)) return false;
+    const wordEnd = i + 1;
+    let hasAlpha = false;
+    while (i >= start) {
+      const ch = input.charCodeAt(i);
+      if (!isWord(ch)) break;
+      if (isAlpha(ch)) hasAlpha = true;
+      i--;
+    }
+    if (!hasAlpha) return false;
+    const word = input.slice(i + 1, wordEnd).toLowerCase();
+    const keywordType = this.mergedKeywords.get(word);
+    return keywordType === void 0 || keywordType === "FUNC";
+  }
   /**
    * Reads an operator/punctuation token.
    * Handles two-char operators (==, !=, >=, <=, **) and the special
@@ -1050,6 +1109,13 @@ var _ExpressionLexer = class _ExpressionLexer {
       }
     }
     this.pos = pos + 1;
+    if (c0 === 91) {
+      this.groupingStack.push(true);
+    } else if (c0 === 40) {
+      this.groupingStack.push(this.precededByCallTarget(pos));
+    } else if (c0 === 41 || c0 === 93) {
+      if (this.groupingStack.length > 0) this.groupingStack.pop();
+    }
     const opType = OP_MAP[c0];
     const text = input.charAt(pos);
     return new LexerToken(opType || "ERROR", tokenTypeId(opType || "ERROR"), text, text, pos, 0, this.line, col);
@@ -1162,6 +1228,36 @@ var _ExpressionLexer = class _ExpressionLexer {
     }
     return pos;
   }
+  /**
+   * The end offset (exclusive) of a `#hex` colour literal starting at `hashPos`,
+   * or -1 if the run there is not one. A colour is `#` followed by EXACTLY 3, 4,
+   * 6 or 8 hex digits (the CSS forms `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa`) and
+   * then a boundary, not a longer word or number. This is the one predicate that
+   * carves colours out of the two things `#` otherwise means, a markdown heading
+   * at line start and a comment mid-line, and it is pure character logic so line
+   * classification stays vocabulary-independent. Examples: `#f00`, `#ff0000`,
+   * `#deadbeef` match; `# Heading` (space), `#tag`/`#todo` (non-hex letter),
+   * `#12345` (length 5), `#ff0000zz` (trailing word) do not.
+   */
+  matchHexColourEnd(hashPos, end) {
+    const input = this.input;
+    let p = hashPos + 1;
+    let n = 0;
+    while (p < end) {
+      const c = input.charCodeAt(p);
+      const isHex = c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+      if (!isHex) break;
+      n++;
+      p++;
+    }
+    if (n !== 3 && n !== 4 && n !== 6 && n !== 8) return -1;
+    if (p < end) {
+      const c = input.charCodeAt(p);
+      const isWord = c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+      if (isWord) return -1;
+    }
+    return p;
+  }
   classifyFromPositions(start, end) {
     const len = end;
     if (start >= len) {
@@ -1180,6 +1276,13 @@ var _ExpressionLexer = class _ExpressionLexer {
     const c0 = input.charCodeAt(pos);
     let hasInline;
     if (c0 === 35) {
+      if (this.matchHexColourEnd(pos, len) !== -1) {
+        if (hasInline === void 0) {
+          const idx = input.indexOf("s`", pos);
+          hasInline = idx !== -1 && idx < len;
+        }
+        return { type: "expression", skip: false, hasInlineSolve: hasInline };
+      }
       let hashCount = 1;
       while (pos + hashCount < len && input.charCodeAt(pos + hashCount) === 35) {
         hashCount++;
@@ -1365,6 +1468,14 @@ var _ExpressionLexer = class _ExpressionLexer {
     const len = this.len;
     const start = this.pos;
     const startCol = start - this.lineStartPos + 1;
+    if (input.charCodeAt(start) === 35) {
+      const hexEnd = this.matchHexColourEnd(start, len);
+      if (hexEnd !== -1) {
+        const text2 = input.slice(start, hexEnd);
+        this.pos = hexEnd;
+        return new LexerToken("HEX_COLOUR", tokenTypeId("HEX_COLOUR"), text2, text2, start, 0, this.line, startCol);
+      }
+    }
     let pos = this.pos;
     if (pos + 1 < len && input.charCodeAt(pos + 1) === 47) {
       pos += 2;
@@ -1385,5 +1496,5 @@ _ExpressionLexer.CHAR_CLASS = buildCharClassTable();
 var ExpressionLexer = _ExpressionLexer;
 
 export { ExpressionLexer, LexerToken };
-//# sourceMappingURL=chunk-FQGX2PA2.js.map
-//# sourceMappingURL=chunk-FQGX2PA2.js.map
+//# sourceMappingURL=chunk-GQMUHVE3.js.map
+//# sourceMappingURL=chunk-GQMUHVE3.js.map