solve-engine 1.0.0-beta.7 → 1.0.0

package/dist/chunk-6RDSQURE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/errors/EngineError.ts","../src/errors/Result.ts","../src/errors/ErrorCode.ts"],"names":["ErrorCategory"],"mappings":"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","file":"chunk-6RDSQURE.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   * `true` (the default) for every EXPECTED failure mode of user input or\n   * environment, bad syntax, an unknown variable/function, a safety limit\n   * exceeded, an external API being down. `false` is reserved for genuine\n   * ENGINE-INTERNAL invariant violations (corrupted bytecode, a stack\n   * underflow from a buggy plugin, an \"impossible\" state)\n   * `ErrorFactory.internal()`/`.config()` default to `false`, every other\n   * factory method defaults to `true`.\n   *\n   * This does NOT gate \"does evaluation of the rest of the document\n   * continue\", with this engine's per-line containment, it always does\n   * even for a `recoverable: false` error (see `ARCHITECTURE.md`'s\n   * async-batcher/Tier-2 hardening notes). It gates MESSAGE FRAMING and\n   * telemetry: \"fix your syntax\" vs. \"this is an engine bug, worth\n   * reporting\". See `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  /** Defaults `recoverable: false`, reserve for genuine engine-internal invariant violations, not user-input errors. */\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, false, codeOrInit, message, context);\n  }\n\n  /** Defaults `recoverable: false`, a bad config is an environment-setup problem, not a per-line user-input error. */\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 */\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    });\n  }\n  return ErrorFactory.internal({\n    code: \"UNKNOWN_ERROR\",\n    message: \"An unknown error occurred\",\n    context: { error: String(error) },\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  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  /** 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. Always `recoverable: false` (internal invariant violation). */\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  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  /** `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  /** `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  // ── 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  /** `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  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\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-75JP4BZX.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parser/OpCode.ts"],"names":["OpCode"],"mappings":"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","file":"chunk-75JP4BZX.js","sourcesContent":["/**\n * The VM's bytecode instruction set.\n *\n * Emitted by parselets (via {@link BytecodeBuilder}) during parsing and\n * consumed by the VM's dispatch loop during execution. Values are grouped\n * into numeric bands by category (0-9 stack ops, 10-19 push-literal, 20-29\n * arithmetic, ...) purely for readability, the VM dispatches on the exact\n * numeric value, not the band.\n *\n * Third-party packages emit `CALL_PLUGIN` (with a plugin-function index\n * from {@link allocatePluginFunctionIndex}) to invoke their own logic\n * see `IEnginePackage.pluginFunctions`. The other opcodes are used\n * internally by the built-in packages' parselets.\n */\nexport enum OpCode {\n\t// Stack operations\n\tNOP = 0,\n\tHALT = 1,\n\tSWAP = 2,\n\tDUP = 3,\n\n\t// Push literals\n\tPUSH_NUMBER = 10,\n\tPUSH_BIGINT = 11,\n\tPUSH_HEX = 12,\n\tPUSH_STRING = 13,\n\tPUSH_BOOLEAN = 14,\n\tPUSH_VARIABLE = 15,\n\n\t// Arithmetic (BinaryOperator)\n\tADD = 20,\n\tSUB = 21,\n\tMUL = 22,\n\tDIV = 23,\n\tMOD = 24,\n\tEXP = 25,\n\tNEG = 26,\n\tPOS = 27,\n\n\t// Bitwise\n\tLSHIFT = 30,\n\tRSHIFT = 31,\n\tURSHIFT = 32,\n\tBIT_AND = 33,\n\tBIT_OR = 34,\n\tBIT_XOR = 35,\n\tBIT_NOT = 36,\n\n\t// Comparison\n\tEQ = 40,\n\tNEQ = 41,\n\tLT = 42,\n\tLTE = 43,\n\tGT = 44,\n\tGTE = 45,\n\n\t// Functions\n\tCALL_PLUGIN = 50,     // Plugin-registered functions (may be async — pre-resolved by orchestrator)\n\tCALL_BUILTIN = 51,    // Sync built-in functions (sqrt, sin, diceRoll, matmul)\n\tRETURN = 52,          // Reserved for future user-defined functions\n\n\t// Variables\n\tLOAD_VAR = 60,\n\tSTORE_VAR = 61,\n\tLOAD_GLOBAL_VAR = 62,   // Reads from the process-wide GlobalVariableStore, not the VM's local scope\n\tSTORE_GLOBAL_VAR = 63,  // Writes to the process-wide GlobalVariableStore, visible to every document\n\n\t// Type conversion\n\tTO_NUMBER = 70,\n\tTO_HEX = 71,\n\tTO_PERCENTAGE = 74,\n\n\t// UoM\n\tUOM_CONVERT = 80,\n\tUOM_CONVERT_TO = 81,\n\tUOM_GET_VALUE = 82,\n\tUOM_BEST = 83,\n\tUOM_CONVERT_IN = 84,\n\tUOM_POSSIBILITIES = 85,  // \"sourceUnit to ?\" — list units convertible from sourceUnit\n\n\t// Datetime\n\tDATE_NOW = 90,\n\tDATE_ADD = 91,\n\tDATE_SUB = 92,\n\tDATE_NEXT_WEEKDAY = 93,  // \"next <Weekday>\" — the next occurrence strictly after now\n\tDATE_LAST_WEEKDAY = 94,  // \"last <Weekday>\" — the previous occurrence strictly before now\n\tDATE_LITERAL = 95,       // Push a datetime literal whose epoch-ms was already resolved at parse time (see DateLiteralParselet)\n\n\t// Rate, \"quantity per unit of something\" ($99/week, 30 fps). See\n\t// vm/Value.ts's rateValue()/isRateUnit()/splitRateUnit() for the\n\t// representation these opcodes operate on.\n\tRATE_DIV = 110,      // Uom ÷ Uom (different measures) -> Rate — the construction op\n\tRATE_MUL = 111,      // Rate × Uom (same measure as denominator) -> plain Uom (denominator cancels)\n\tRATE_CONVERT = 112,  // Rate -> Rate with a rescaled denominator unit (keeps the same real-world rate)\n\n\t// Time, clock-time-of-day, lap times, video timecode (distinct from\n\t// the Datetime band's calendar-date arithmetic).\n\tCLOCK_TIME_TODAY = 120,  // minutes-since-midnight -> Datetime anchored to today's calendar date\n\n\t// Conditionals, boolean logic and eager-evaluated ternary selection.\n\t// EQ/NEQ/LT/LTE/GT/GTE (40-45, above) already existed as dead opcodes\n\t// before this band was wired up; see vm/VM.ts for their handlers.\n\tLOGICAL_AND = 130,  // Boolean && Boolean -> Boolean\n\tLOGICAL_OR = 131,   // Boolean || Boolean -> Boolean\n\tSELECT = 132,       // (thenVal, elseVal, condition) -> thenVal if condition else elseVal — EAGER (both\n\t                    // branches already evaluated by the time this runs; no real branching/short-circuit,\n\t                    // a deliberate simplification for a side-effect-free expression language, see\n\t                    // packages/conditionals/parselets/IfThenElseParselet.ts)\n\n\t// Converters, the general \"as <type>\" mechanism. TO_NUMBER/TO_HEX/\n\t// TO_PERCENTAGE (70/71/74, above) cover the simplest cases; these cover\n\t// the ones with no existing opcode. CALL_AS_CONVERTER is the SDK\n\t// extension point. See IEnginePackage.asConverters and\n\t// vm/VMBuiltins.ts's asConverterRegistry.\n\tTO_FRACTION = 140,       // Number -> String, simplified fraction (\"0.5\" -> \"1/2\")\n\tTO_MULTIPLIER = 141,     // Number -> String, \"1 + n\" growth multiplier (\"0.5\" -> \"1.5x\")\n\tTO_SCI = 142,            // Number -> String, scientific notation (\"1500000\" -> \"1.5e+6\")\n\tTO_BINARY = 143,         // Number -> String, base-2 display (\"10\" -> \"0b1010\")\n\tTO_OCTAL = 144,          // Number -> String, base-8 display (\"10\" -> \"0o12\")\n\tCALL_AS_CONVERTER = 145, // (value, name) -> runtime asConverterRegistry lookup + call\n\n\t// User-defined, parameterized, reusable functions (f(x) = expr, then\n\t// f(5). See parser/PrecedenceParser.ts's IDENT_ID case\n\t// parser/BytecodeBuilder.ts's UserFunctionDef/emitUserFunctionBody, and\n\t// vm/VM.ts's VM.userFunctions/callFrames). Parameter references inside a\n\t// function body are ORDINARY LOAD_VAR opcodes, not a dedicated\n\t// parameter-load opcode, CALL_USER_FUNCTION binds arguments into a\n\t// name-keyed call frame at runtime, and LOAD_VAR checks the innermost\n\t// call frame before the flat variable store (see VM.getVar()).\n\tDEFINE_USER_FUNCTION = 150, // (operand = index into bytecode.userFunctionBodies) -> register name/params/program into vm.userFunctions. Registration happens at VM-EXECUTION time, not parse time, so a diagnostic/lookahead parse that compiles but never executes a definition line has no side effect on the shared registry.\n\tCALL_USER_FUNCTION = 151,   // (N arg values already on stack) -> pop N args, bind by NAME into a new call frame, execute the named function's stored body (reentrant executeBytecode), push its result\n\n\t// Matrix (Calca-parity, replaces the old ARR_* vector-only opcodes\n\t// which were never emitted by any registered parselet; see\n\t// vm/MatrixOps.ts for the shared column-major storage helpers this band\n\t// operates on, and vm/Value.ts's MatrixData for the representation).\n\tMAT_NEW = 152,      // (rows, cols operands; rows*cols values already on stack, ROW-MAJOR push order) -> pop rows*cols values, transpose to column-major, push a Matrix\n\tMAT_INDEX1 = 153,   // (matrix, index already on stack) -> column-major single-index read `a[i]`\n\tMAT_INDEX2 = 154,   // (matrix, row, col already on stack) -> `a[row, col]` read\n\tMAT_SLICE = 155,    // (matrix, rowRange, colRange already on stack) -> sub-matrix via two Range values\n\tRANGE_NEW = 156,    // (min, max already on stack) -> push a Range value `min:max`\n\tMAP_INVOKE = 157,   // map(...) — see parser/BytecodeBuilder.ts's `anonymousBodies` side-table\n\tREDUCE_INVOKE = 158, // reduce(...) — same anonymousBodies mechanism as MAP_INVOKE\n\t// 159 and 160 were THEREFORE_SOLVE and STORE_EQUATION_OR_ASSIGNMENT, declared\n\t// but never emitted by any parselet nor handled in the VM switch. Both shapes\n\t// have effects (a stored equation, a direct vm.setVar()) that a cached\n\t// bytecode program cannot represent, so engine/ExpressionEngine.ts intercepts\n\t// them before compilation and always will. The numbers are free to reuse.\n}\n\n// Reverse lookup built once at module load, getOpCodeName() is called once\n// per VM instruction whenever a diagnostic collector is attached (VM.ts's\n// trace path), so a per-call linear scan of every enum entry (TS numeric\n// enums are bidirectional at runtime, so Object.entries(OpCode) yields both\n// \"NOP\" -> 0 and \"0\" -> \"NOP\" style entries) would otherwise redo the same\n// scan every single traced instruction. Only the numeric-valued entries are\n// kept, the string-valued reverse entries TS also generates aren't needed\n// here.\nconst OP_CODE_NAMES: ReadonlyMap<number, string> = (() => {\n\tconst map = new Map<number, string>();\n\tfor (const [key, value] of Object.entries(OpCode)) {\n\t\tif (typeof value === \"number\") map.set(value, key);\n\t}\n\treturn map;\n})();\n\n/**\n * Gets the name of an OpCode as a string.\n * @param op The OpCode value\n * @returns The enum name as a string, or \"UNKNOWN_<value>\" if not found\n */\nexport function getOpCodeName(op: number): string {\n\treturn OP_CODE_NAMES.get(op) ?? `UNKNOWN_${op}`;\n}\n"]}

package/dist/chunk-AHCLWAM5.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/normalizer/TokenNormalizer.ts","../src/normalizer/PhraseTrie.ts","../src/normalizer/BuiltinNormalizerRules.ts"],"names":["LexerToken","tokenTypeId","ErrorFactory"],"mappings":"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","file":"chunk-AHCLWAM5.cjs","sourcesContent":["//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * TokenNormalizer, post-lexer token normalization pass.\n *\n * ## Purpose\n * Applies domain-specific {@link NormalizerRule | NormalizerRules} to the raw\n * token stream produced by the {@link ExpressionLexer}. This keeps the lexer\n * slim and focused on single-token production, while multi-token pattern\n * matching (phrases, implicit operators, domain merges) lives here.\n *\n * ## What rules can do\n * - **Phrase fusion**: Merge consecutive words into compound tokens\n *   (e.g., `IDENT + ... + IDENT` → `CARET`)\n * - **Implicit operator insertion**: Insert missing operators between tokens\n *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)\n * - **Domain-specific transformations**: Coalesce item names, currency pairs,\n *   percentage syntax, etc.\n *\n * ## Architecture\n * Providers register NormalizerRules alongside Parselets and OpCode handlers\n * via {@link IEnginePackage.normalizerRules}. The normalizer applies them\n * greedily left-to-right in multiple passes with safety limits.\n *\n * @module TokenNormalizer\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, TokenFusion } from \"./NormalizerRule\";\nimport { PhraseTrie } from \"./PhraseTrie\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n//#endregion\n//#region ─── NormalizerOptions, Configuration ────────────────────────────────\n\n/**\n * Configuration options for the normalization pass.\n *\n * These control safety limits and diagnostic callbacks. The defaults\n * are chosen to be generous enough for any realistic expression while\n * preventing runaway token expansion from recursive rules.\n */\nexport interface NormalizerOptions {\n  /**\n   * Maximum number of full passes over the token stream before bailing out.\n   * Prevents infinite loops from recursive rule chains.\n   * @default 100\n   */\n  maxPasses?: number;\n\n  /**\n   * Maximum number of tokens allowed after normalization.\n   * If exceeded, an Error is thrown rather than passing a bloated stream\n   * to the parser.\n   * @default 10000\n   */\n  maxTokens?: number;\n\n  /**\n   * Callback invoked for each fusion event during normalization.\n   * Used by diagnostic mode to populate {@link NormalizerOutput.fusions}.\n   * When `undefined`, fusions are still tracked internally but no callbacks fire.\n   */\n  onFusion?: (fusion: TokenFusion) => void;\n}\n\n//#endregion\n//#region ─── Default Options ──────────────────────────────────────────────────\n\n/** Sensible defaults that catch infinite loops without limiting real expressions. */\nconst DEFAULT_OPTIONS: Required<NormalizerOptions> = {\n  maxPasses: 100,\n  maxTokens: 10000,\n  onFusion: () => {},\n};\n\n//#endregion\n//#region ─── createFusedToken, Token Factory ──────────────────────────────────\n\n/**\n * Creates a new normalized token from fused source tokens.\n *\n * The fused token inherits position information (offset, line, column)\n * from the first source token, which preserves source-map accuracy\n * for error messages and diagnostic highlighting.\n *\n * It also records where the source text ENDS, on `sourceEnd`. The start alone\n * is not enough to describe the span a fusion covers, because `text` is the\n * replacement rather than the original: `10 frames` fuses into a FRAME_COUNT\n * whose text is `10`, and a timecode fuses into a token whose text is a\n * comma-separated tuple that appears nowhere in the line. Anything painting the\n * line needs both ends, and only this function is in a position to know them.\n *\n * @param type         - The new token type (e.g., \"CARET\", \"TIMES_BY\")\n * @param text         - The combined text representation (e.g., \"to the power of\")\n * @param sourceTokens - The original tokens being fused (at least 2)\n * @returns A new {@link LexerToken} with the fused type and combined text\n */\nexport function createFusedToken(\n  type: string,\n  text: string,\n  sourceTokens: Token[]\n): Token {\n  const first = sourceTokens[0];\n  const last = sourceTokens[sourceTokens.length - 1];\n  const token = new LexerToken(\n    type,\n    tokenTypeId(type),\n    text,\n    text,\n    first.offset,\n    first.lineBreaks ?? 0,\n    first.line,\n    first.col,\n  );\n  token.sourceEnd = last.offset + last.value.length;\n  return token;\n}\n\n/**\n * Record, on a token that replaced several, where its source text ended.\n *\n * Called centrally rather than left to each rule. A rule that builds its\n * replacement by hand rather than through {@link createFusedToken} is doing\n * nothing wrong, and several do: the date-literal rule needs a token whose\n * value is an epoch and whose text is the source, which that factory cannot\n * express. Stamping here means every fusion carries its span, including ones\n * written after this was.\n *\n * Reads `sourceEnd` off the last source token when it has one, so a fusion of\n * a fusion still describes the original text rather than the intermediate.\n *\n * @param fused - The single token the rule produced.\n * @param sourceTokens - The tokens it consumed.\n */\nfunction recordSourceSpan(fused: Token, sourceTokens: Token[]): void {\n  const last = sourceTokens[sourceTokens.length - 1];\n  if (!last) return;\n  fused.sourceEnd = last.sourceEnd ?? last.offset + last.value.length;\n}\n\n//#endregion\n//#region ─── NON_WORD_TOKEN_TYPES, Type-guard skip set ────────────────────────\n\n/**\n * Token types that can NEVER start a multi-word phrase.\n *\n * Used by {@link normalize} to skip the PhraseTrie walk entirely at\n * positions where the token type makes phrase matching impossible.\n * This avoids even the O(1) {@link PhraseTrie.canStart} check.\n *\n * Types NOT in this set (IDENT, KEYWORD, FUNC, UNIT, and any custom\n * types registered by packages) still pass through to the trie for\n * a full match attempt.\n */\n// ── Non-word type ID lookup table (flat Uint8Array, true O(1) array index) ──\n//\n// Index = token typeId, value = 1 if non-word (skip trie), 0 otherwise.\n// Array indexing avoids ALL hashing: no Set.has(), no Map.get(), no string ops.\n//\n// Custom types from packages get IDs beyond the table length, so the bounds\n// check `tid < TABLE.length` safely passes them through to the trie.\n//\n// Arithmetic operators (PLUS, MINUS, STAR, SLASH, CARET, MOD, PERCENT) are\n// intentionally excluded: in keyword locales the lexer maps \"times\"→STAR,\n// \"divide\"→SLASH etc., and those tokens CAN start phrases like \"times by\".\n/**\n * Token type names that can NEVER start a multi-word phrase.\n *\n * Exported for testing only, consumers should use the type-guard behavior\n * of {@link TokenNormalizer.normalize} rather than this list directly.\n */\nexport const NON_WORD_NAMES = [\n\t\"NUMBER\", \"HEX\", \"BIGINT\", \"FLOAT\",\n\t\"LSHIFT\", \"RSHIFT\", \"BIT_AND\", \"BIT_OR\", \"BIT_XOR\",\n\t\"LPAREN\", \"RPAREN\", \"LBRACKET\", \"RBRACKET\",\n\t\"COMMA\", \"COLON\", \"EQUALS\", \"THEREFORE\", \"PIPE\", \"AMPERSAND\", \"AT\",\n\t\"SEMICOLON\", \"QUESTION\", \"EXCLAMATION\",\n\t\"EOF\", \"WS\", \"NEWLINE\",\n] as const;\n\n/**\n * Flat Uint8Array lookup table: index = token typeId, value = 1 if non-word.\n *\n * Exported for testing only, consumers should not depend on the internal\n * table layout, as the set of non-word types may change.\n */\nexport const NON_WORD_TABLE: Uint8Array = (() => {\n\t// Resolve all non-word type names to their numeric IDs\n\tconst ids = NON_WORD_NAMES.map(n => tokenTypeId(n));\n\t// Size the table to cover the largest ID + 1\n\tconst len = Math.max(...ids) + 1;\n\tconst table = new Uint8Array(len);\n\t// Mark non-word type positions\n\tfor (const id of ids) table[id] = 1;\n\treturn table;\n})();\n\n//#endregion\n//#region ─── TokenNormalizer Class ─────────────────────────────────────────────\n\n/**\n * Token normalizer: applies {@link NormalizerRule | NormalizerRules} to a token stream.\n *\n * ## Lifecycle\n * 1. **Registration**: Rules are added via {@link register} and sorted by priority\n * 2. **Normalization**: {@link normalize} applies rules greedily left-to-right\n * 3. **Cleanup**: {@link clear} or {@link unregister} removes rules\n *\n * ## Normalization algorithm\n * The normalizer uses a greedy left-to-right multi-pass algorithm:\n * - At each token position, rules are tried in priority order (highest first)\n * - When a rule matches, matched tokens are consumed and replaced\n * - Processing continues from the replacement position\n * - Multiple passes handle cascading matches (one rule's output triggers another)\n * - Safety limits ({@link NormalizerOptions.maxPasses}) prevent infinite loops\n *\n * @example\n * ```ts\n * const normalizer = new TokenNormalizer();\n * normalizer.register(phraseRule);       // \"to the power of\" → CARET\n * normalizer.register(implicitMultRule); // \"2 x\" → \"2 * x\"\n * const normalized = normalizer.normalize(rawTokens);\n * ```\n */\nexport class TokenNormalizer {\n  /** Registered rules, unsorted, the source of truth. */\n  private rules: NormalizerRule[] = [];\n\n  /**\n   * Priority-sorted copy of {@link rules}, rebuilt lazily on the next\n   * {@link normalize} call after a mutation. Rules are registered once at\n   * engine/package-registration time and essentially never change during a\n   * session, but normalize() runs on every keystroke-driven evaluation, an\n   * earlier version re-sorted a fresh copy of `rules` on every single call,\n   * which meant every keystroke paid for an allocation + sort of a list that\n   * had usually not changed since the last one. `null` means \"stale, rebuild\n   * on next use\"; {@link register}/{@link unregister}/{@link clear} all\n   * invalidate it.\n   */\n  private sortedRulesCache: NormalizerRule[] | null = null;\n\n  /**\n   * Phrase trie for single-pass multi-word phrase fusion.\n   * Tried at each token position BEFORE other rules, the trie walk\n   * is O(depth) vs O(R × W) for separate rule matching.\n   */\n  private phraseTrie = new PhraseTrie();\n\n  /** Merged options with defaults applied. */\n  private options: Required<NormalizerOptions>;\n\n  // ── Constructor ──────────────────────────────────────────────────────────\n\n  /**\n   * @param options - Configuration overrides for safety limits and diagnostic callbacks\n   */\n  constructor(options: NormalizerOptions = {}) {\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n  }\n\n  // ── Rule Management ──────────────────────────────────────────────────────\n\n  /**\n   * Register a normalization rule.\n   *\n   * Rules are sorted by priority (descending) on each {@link normalize} call.\n   * Multiple rules can share the same priority, they are tried in registration\n   * order when priorities are equal.\n   *\n   * @param rule - The rule to register\n   */\n  register(rule: NormalizerRule): void {\n    this.rules.push(rule);\n    this.sortedRulesCache = null;\n  }\n\n  /**\n   * Unregister a normalization rule by its {@link NormalizerRule.name | name}.\n   *\n   * If multiple rules share the same name, all are removed. This is safe to\n   * call with a name that doesn't match any rule, it simply has no effect.\n   *\n   * @param ruleName - The name of the rule to remove\n   */\n  unregister(ruleName: string): void {\n    this.rules = this.rules.filter(r => r.name !== ruleName);\n    this.sortedRulesCache = null;\n  }\n\n  /**\n   * Remove all registered rules, resetting the normalizer to its initial state.\n   * Also clears the phrase trie.\n   */\n  clear(): void {\n    this.rules = [];\n    this.sortedRulesCache = null;\n    this.phraseTrie = new PhraseTrie();\n  }\n\n  /**\n   * Priority-sorted view of {@link rules} (descending priority; registration\n   * order preserved for ties, since {@link Array.prototype.sort} is stable).\n   * Cached until the next mutation. See {@link sortedRulesCache}.\n   */\n  private getSortedRules(): NormalizerRule[] {\n    if (this.sortedRulesCache === null) {\n      this.sortedRulesCache = [...this.rules].sort((a, b) => b.priority - a.priority);\n    }\n    return this.sortedRulesCache;\n  }\n\n  /**\n   * Get the number of currently registered rules (excludes phrase trie entries).\n   */\n  get ruleCount(): number {\n    return this.rules.length;\n  }\n\n  // ── Phrase Registration ────────────────────────────────────────────────\n\n  /**\n   * Register a multi-word phrase for fusion into a single compound token.\n   *\n   * This is the preferred way to add phrase patterns. It inserts into the\n   * internal {@link PhraseTrie}, which collapses all phrase rules into a\n   * single O(depth) trie walk per position, no separate rule scanning.\n   *\n   * @param phrase    - Multi-word phrase (e.g., \"to the power of\", \"abyssal whip\")\n   * @param tokenType - Target token type after fusion (e.g., \"CARET\", \"ITEM\")\n   */\n  addPhrase(phrase: string, tokenType: string): void {\n    this.phraseTrie.addPhrase(phrase, tokenType);\n  }\n\n  /**\n   * Check whether a word can start any registered phrase.\n   *\n   * Used by {@link implicitMultiplyRule} to suppress `*` insertion\n   * before phrase-starting identifiers (e.g., \"2 power of 3\" → `2 ^ 3`,\n   * not `2 * power of 3`). Delegates to {@link PhraseTrie.canStart}.\n   */\n  /**\n   * Get all registered phrases and their target token types.\n   *\n   * Exposes the full phrase trie structure for diagnostic rendering\n   * in the playground's NormalizerTab. Returns ALL registered phrases,\n   * not just the ones that matched in the last evaluation.\n   */\n  getPhrases(): Record<string, string> {\n    return this.phraseTrie.getAllPhrases();\n  }\n\n  canStartPhrase(word: string): boolean {\n    return this.phraseTrie.canStart(word);\n  }\n\n  // ── Normalization ────────────────────────────────────────────────────────\n\n  /**\n   * Normalize a token stream by applying all registered rules.\n   *\n   * ## Algorithm\n   * Applies rules greedily left-to-right in multiple passes:\n   * 1. Sort rules by priority (descending)\n   * 2. Walk the token stream left to right\n   * 3. At each position, try rules in priority order\n   * 4. On match: consume matched tokens, insert replacements, restart from insert point\n   * 5. On no match: pass token through unchanged\n   * 6. Repeat until a full pass produces no changes, or maxPasses is reached\n   *\n   * ## Fusion tracking\n   * When a rule consumes more tokens than it produces, the normalizer calls\n   * `onFusion` with a {@link TokenFusion} record for diagnostic collection.\n   * This populates {@link NormalizerOutput.fusions} in the playground pipeline view.\n   *\n   * ## Safety\n   * If the normalized token count exceeds {@link NormalizerOptions.maxTokens},\n   * an Error is thrown to prevent memory exhaustion from runaway rule expansion.\n   *\n   * @param tokens   - Raw tokens from the lexer\n   * @param onFusion - Optional fusion callback (overrides {@link NormalizerOptions.onFusion})\n   * @returns Normalized tokens ready for parsing\n   * @throws {Error} If the normalized token count exceeds maxTokens\n   */\n  normalize(tokens: Token[], onFusion?: (fusion: TokenFusion) => void): Token[] {\n    // ── Early exit: nothing to normalize ──\n    if (tokens.length === 0) return tokens;\n\n    // ── Priority-sorted rules, cached across calls, see getSortedRules() ──\n    const sorted = this.getSortedRules();\n    const fusionHandler = onFusion ?? this.options.onFusion;\n    const maxPasses = this.options.maxPasses;\n    const maxTokens = this.options.maxTokens;\n\n    let current = tokens;\n    let changed = true;\n    let passCount = 0;\n\n    // Multi-pass loop: rules may trigger cascading matches across passes\n    while (changed && passCount < maxPasses) {\n      changed = false;\n      passCount++;\n\n      const result: Token[] = [];\n      let pos = 0;\n\n      // Single-pass left-to-right greedy walk\n      while (pos < current.length) {\n        let matched = false;\n\n        // ── Fast path: phrase trie (O(depth) single walk vs O(R × W) per rule) ──\n        // O(1) type-guard: skip trie entirely for tokens that can't start phrases.\n        // Flat Uint8Array indexed by typeId, no hashing, no Set lookup, true O(1).\n        const tid = current[pos].typeId;\n        if (tid >= NON_WORD_TABLE.length || NON_WORD_TABLE[tid] === 0) {\n          const trieMatch = this.phraseTrie.matchAt(current, pos);\n          if (trieMatch) {\n            const sourceTokens = current.slice(pos, pos + trieMatch.consumed);\n            for (const rt of trieMatch.replacement) {\n              result.push(rt);\n            }\n            if (trieMatch.consumed > 1 && trieMatch.replacement.length === 1) {\n              recordSourceSpan(trieMatch.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: trieMatch.ruleName ?? \"phrase-trie\",\n                sourceTokens,\n                fusedToken: trieMatch.replacement[0],\n              });\n            }\n            pos += trieMatch.consumed;\n            changed = true;\n            continue; // trie matched — skip other rules at this position (no need to set matched)\n          }\n        }\n\n        // Try every rule in priority order at this position\n        for (const rule of sorted) {\n          const match = rule.match(current, pos);\n          if (match) {\n            // Collect source tokens for fusion tracking\n            const sourceTokens = current.slice(pos, pos + match.consumed);\n\n            // Insert replacement tokens into result\n            for (const rt of match.replacement) {\n              result.push(rt);\n            }\n\n            // Track fusion events for diagnostics:\n            // - Multiple tokens → single token: classic fusion\n            // - Multiple tokens → fewer tokens: partial fusion\n            if (match.consumed > 1 && match.replacement.length === 1) {\n              recordSourceSpan(match.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: rule.name,\n                sourceTokens,\n                fusedToken: match.replacement[0],\n              });\n            } else if (match.consumed > 1 && match.replacement.length < match.consumed) {\n              for (const rt of match.replacement) {\n                fusionHandler({\n                  rule: rule.name,\n                  sourceTokens,\n                  fusedToken: rt,\n                });\n              }\n            }\n\n            // Advance position past consumed tokens\n            pos += match.consumed;\n            changed = true;\n            matched = true;\n            break; // Rule matched — restart at new position with highest-priority rules\n          }\n        }\n\n        if (!matched) {\n          // No rule matched at this position, pass token through unchanged\n          result.push(current[pos]);\n          pos++;\n        }\n      }\n\n      // Safety: bail if token count explodes (runaway rule expansion)\n      if (result.length > maxTokens) {\n        // A raw Error here would bypass ThreeTierEvaluator's DAG-preservation\n        // enrichment on compile failure (it specifically checks for\n        // EngineError). Same reasoning as ExpressionEngineSafety.ts's\n        // complexity/length checks, which this mirrors.\n        throw ErrorFactory.validation(\n          \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n          `Normalized token count (${result.length}) exceeds safety limit (${maxTokens})`,\n          { tokenCount: result.length, maxTokens }\n        );\n      }\n\n      current = result;\n    }\n\n    return current;\n  }\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * PhraseTrie, optimized word-level trie for multi-word phrase fusion.\n *\n * ## Problem\n * The normalizer previously applied N separate `phraseFusionRule` instances,\n * each scanning forward from the current token position. For R phrase rules\n * and W average phrase length, this cost O(N × R × W) per pass.\n *\n * ## Solution\n * A single trie walk per position collapses all phrase rules into O(D)\n * where D ≤ longest phrase depth (typically ≤ 5 words). The trie tracks\n * the deepest terminal node reached, implementing longest-match-wins\n * without priority sorting.\n *\n * ## Optimizations\n * 1. **Set<string> quick-reject**, the `startWords` set contains the first\n *    word of every registered phrase. At each position, if the token's\n *    lowercase value isn't in the set, we bail in O(1) without touching\n *    the trie. ~80% of tokens (numbers, operators) hit this fast path.\n * 2. **Longest-match-wins**, the `matchAt()` walk continues past terminal\n *    nodes, tracking the deepest one. Shorter overlapping phrases (e.g.,\n *    \"power of\") don't need lower priority, the trie naturally prefers\n *    the longer match.\n * 3. **Map-based children**, `Map<string, TrieNode>` gives O(1) amortized\n *    child lookup per word, faster than array scanning for sparse branches.\n *\n * ## Package integration\n * Packages add phrases via {@link TokenNormalizer.addPhrase} (public API)\n * or the {@link IEnginePackage.phrases} declarative field. Each call to\n * `addPhrase()` inserts the phrase into this trie and updates `startWords`.\n *\n * @module PhraseTrie\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport type { NormalizerMatch } from \"./NormalizerRule\";\nimport { createFusedToken } from \"./TokenNormalizer\";\n\n//#endregion\n//#region ─── TrieNode ─────────────────────────────────────────────────────────\n\n/**\n * Internal trie node.\n *\n * Each node represents a matched word in a phrase. The path from root\n * to a node spells out a partial or complete phrase.\n */\ninterface TrieNode {\n\t/** Child nodes keyed by next word (all lowercase). */\n\tchildren: Map<string, TrieNode>;\n\t/**\n\t * If this node completes a phrase, the terminal metadata.\n\t * A node can be both terminal AND have children. This handles\n\t * overlapping phrases like \"power of\" and \"to the power of\".\n\t */\n\tterminal: TrieTerminal | null;\n}\n\n/** Metadata stored at terminal nodes for deferred token creation. */\ninterface TrieTerminal {\n\t/** The target token type after fusion (e.g., \"CARET\", \"TIMES_BY\"). */\n\ttokenType: string;\n\t/** The original phrase string (e.g., \"to the power of\"). */\n\tphrase: string;\n\t/** Number of tokens consumed by this phrase. */\n\tconsumed: number;\n}\n\n//#endregion\n//#region ─── PhraseTrie ─────────────────────────────────────────────────────\n\n/**\n * Word-level trie for single-pass multi-word phrase matching.\n *\n * @example\n * ```ts\n * const trie = new PhraseTrie();\n * trie.addPhrase(\"to the power of\", \"CARET\");\n * trie.addPhrase(\"power of\", \"CARET\");\n * trie.addPhrase(\"abyssal whip\", \"ITEM\");\n *\n * // At position 0 with tokens [\"to\",\"the\",\"power\",\"of\",\"3\"]\n * const match = trie.matchAt(tokens, 0);\n * // → { consumed: 4, replacement: [CARET(\"to the power of\")] }\n * ```\n */\nexport class PhraseTrie {\n\t/**\n\t * First words that can start any registered phrase (all lowercase).\n\t * O(1) quick-reject: if `tokens[pos].value.toLowerCase()` isn't here,\n\t * no phrase can match at this position.\n\t */\n\tprivate startWords = new Set<string>();\n\n\t/**\n\t * Root maps first word → child node.\n\t * Two-level root avoids an unnecessary intermediate TrieNode.\n\t */\n\tprivate root = new Map<string, TrieNode>();\n\n\t// ── Registration ──────────────────────────────────────────────────────\n\n\t/**\n\t * Register a phrase for fusion into a single compound token.\n\t *\n\t * @param phrase    - Multi-word phrase (e.g., \"to the power of\")\n\t * @param tokenType - Target token type after fusion (e.g., \"CARET\")\n\t */\n\taddPhrase(phrase: string, tokenType: string): void {\n\t\tconst words = phrase.toLowerCase().trim().split(/\\s+/);\n\t\tif (words.length === 0 || words[0] === \"\") return;\n\n\t\tthis.startWords.add(words[0]);\n\n\t\tconst firstWord = words[0];\n\t\tlet node: TrieNode;\n\n\t\tif (this.root.has(firstWord)) {\n\t\t\tnode = this.root.get(firstWord)!;\n\t\t} else {\n\t\t\tnode = { children: new Map(), terminal: null };\n\t\t\tthis.root.set(firstWord, node);\n\t\t}\n\n\t\t// Single-word phrase: terminal at root's child\n\t\tif (words.length === 1) {\n\t\t\tnode.terminal = { tokenType, phrase, consumed: 1 };\n\t\t\treturn;\n\t\t}\n\n\t\t// Walk/insert remaining words\n\t\tfor (let i = 1; i < words.length; i++) {\n\t\t\tconst word = words[i];\n\t\t\tif (!node.children.has(word)) {\n\t\t\t\tnode.children.set(word, { children: new Map(), terminal: null });\n\t\t\t}\n\t\t\tnode = node.children.get(word)!;\n\t\t}\n\n\t\tnode.terminal = { tokenType, phrase, consumed: words.length };\n\t}\n\n\t// ── Matching ──────────────────────────────────────────────────────────\n\n\t/**\n\t * Attempt to match a phrase starting at `pos` in the token stream.\n\t *\n\t * Walks the trie one token at a time, tracking the deepest terminal\n\t * node reached. Returns the longest match found, or `null` if no\n\t * phrase starts at this position.\n\t *\n\t * @param tokens - The current token stream\n\t * @param pos    - Position to attempt matching from\n\t * @returns The longest {@link NormalizerMatch}, or `null` on no match\n\t */\n\tmatchAt(tokens: Token[], pos: number): NormalizerMatch | null {\n\t\t// ── Bounds guard ──\n\t\tif (pos >= tokens.length) return null;\n\n\t\t// ── O(1) quick-reject: first word not a phrase starter ──\n\t\tconst firstWord = tokens[pos].value.toLowerCase();\n\t\tif (!this.startWords.has(firstWord)) return null;\n\n\t\t// ── Walk trie, tracking deepest terminal ──\n\t\tlet node: TrieNode | undefined = this.root.get(firstWord);\n\t\tif (!node) return null;\n\n\t\tlet best: NormalizerMatch | null = null;\n\t\tlet depth = 1;\n\n\t\t// Check single-word phrase at first node\n\t\tif (node.terminal) {\n\t\t\tconst sourceTokens = tokens.slice(pos, pos + 1);\n\t\t\tbest = {\n\t\t\t\tconsumed: 1,\n\t\t\t\treplacement: [createFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens)],\n\t\t\t\truleName: node.terminal.phrase,\n\t\t\t};\n\t\t}\n\n\t\t// Walk deeper for multi-word phrases\n\t\tfor (let i = pos + 1; i < tokens.length && node?.children; i++) {\n\t\t\tconst word = tokens[i].value.toLowerCase();\n\t\t\tnode = node.children.get(word);\n\t\t\tif (!node) break; // dead end\n\t\t\tdepth++;\n\n\t\t\tif (node.terminal) {\n\t\t\t\t// Deferred fused-token creation, only on deepest match found\n\t\t\t\tconst sourceTokens = tokens.slice(pos, pos + depth);\n\t\t\t\tbest = {\n\t\t\t\t\tconsumed: depth,\n\t\t\t\t\treplacement: [\n\t\t\t\t\t\tcreateFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens),\n\t\t\t\t\t],\n\t\t\t\t\truleName: node.terminal.phrase,\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\treturn best;\n\t}\n\n\t// ── Introspection ─────────────────────────────────────────────────────\n\n\t/** Number of unique first words (not total phrases). */\n\tget size(): number {\n\t\treturn this.root.size;\n\t}\n\n\t/**\n\t * Return all registered phrases and their target token types.\n\t *\n\t * Used by diagnostic mode to expose the complete trie structure to the\n\t * playground's NormalizerTab for rendering ALL registered phrases\n\t * (not just the ones that matched in this evaluation).\n\t */\n\tgetAllPhrases(): Record<string, string> {\n\t\tconst result: Record<string, string> = {};\n\n\t\tconst collect = (node: TrieNode, path: string[]): void => {\n\t\t\tif (node.terminal) {\n\t\t\t\tresult[path.join(' ')] = node.terminal.tokenType;\n\t\t\t}\n\t\t\tfor (const [word, child] of node.children) {\n\t\t\t\tcollect(child, [...path, word]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [firstWord, node] of this.root) {\n\t\t\tcollect(node, [firstWord]);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/** Check if any phrase starts with this word (case-insensitive). */\n\tcanStart(word: string): boolean {\n\t\treturn this.startWords.has(word.toLowerCase());\n\t}\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * Built-in normalization rules for the {@link TokenNormalizer}.\n *\n * These rules handle common expression patterns that span multiple tokens.\n * Phrase fusion (e.g., \"to the power of\" → CARET) is handled by the\n * internal {@link PhraseTrie}. See {@link TokenNormalizer.addPhrase}.\n * This module only exports non-phrase rules like {@link implicitMultiplyRule}.\n *\n * @module BuiltinNormalizerRules\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"./NormalizerRule\";\n\n//#endregion\n//#region ─── PHRASE_START_WORDS, Implicit Multiply Guard ─────────────────────\n\n/**\n * Words that can start multi-word phrases, hardcoded fallback.\n *\n * This is ONLY used as the default fallback in {@link implicitMultiplyRule}\n * when no `canStart` predicate is provided. In the recommended pattern,\n * the {@link PhraseTrie}'s live `canStart()` set is passed instead, keeping\n * the guard in sync with package-registered phrases.\n *\n * @see {@link TokenNormalizer.canStartPhrase}\n */\n/**\n * Words that introduce a rate denominator when a unit follows.\n *\n * Kept next to the implicit-multiplication rule because that is the only\n * thing they change here; the rate itself is built in the uom package.\n */\nconst RATE_DENOMINATOR_WORDS = new Set([\"per\", \"a\", \"an\", \"each\", \"every\"]);\n\nconst PHRASE_START_WORDS = new Set([\n  \"to\", \"power\", \"increase\", \"decrease\", \"times\", \"multiply\", \"divide\", \"by\",\n]);\n\n//#endregion\n//#region ─── implicitMultiplyRule, Implicit Operator Insertion ────────────────\n\n/**\n * Creates a normalization rule that inserts an implicit multiplication operator\n * between adjacent tokens where multiplication is implied.\n *\n * ## When it fires\n * Inserts a STAR token between:\n * - `NUMBER IDENT` (e.g., \"2 x\" → \"2 * x\")\n * - `RPAREN IDENT` (e.g., \"(x+1)y\" → \"(x+1) * y\")\n * - `NUMBER LPAREN` (e.g., \"2(x+1)\" → \"2 * (x+1)\")\n * - `NUMBER PI` / `NUMBER E` (e.g., \"2π\" → \"2 * π\")\n *\n * ## When it doesn't fire\n * - When the following identifier starts a multi-word phrase\n *   (checked against {@link PHRASE_START_WORDS})\n * - When the following token is not an identifier or parenthesized expression\n *\n * ## Priority\n * Default priority is 50, below phrase fusion so phrases match first.\n *\n * @param priority - Rule priority (default 50)\n * @returns A {@link NormalizerRule} that inserts implicit multiply operators\n */\nexport function implicitMultiplyRule(\n\tpriority: number = 50,\n\tcanStart?: (word: string) => boolean\n): NormalizerRule {\n\tconst phraseGuard = canStart ?? ((word: string) => PHRASE_START_WORDS.has(word.toLowerCase()));\n\n\treturn {\n    name: \"implicit:multiply\",\n    priority,\n    match(tokens: Token[], pos: number): NormalizerMatch | null {\n      // ── Need at least one token after the current position ──\n      if (pos + 1 >= tokens.length) return null;\n\n      const t = tokens[pos];\n      const next = tokens[pos + 1];\n\n      // ── Guard: suppress if the next identifier starts a phrase ──\n      // Uses the trie's canStart when available, falls back to hardcoded set.\n      // This prevents \"2 power of 3\" from becoming \"2 * power of 3\".\n      const nextValue = next.value.toLowerCase();\n      if (phraseGuard(nextValue)) return null;\n\n      // ── Guard: a rate denominator, not a multiplication ──\n      // \"99 per week\" is ninety-nine a week, not ninety-nine times something\n      // called per. The trie guard above cannot cover this, because these are\n      // not registered phrases; they are recognised by the uom package's\n      // bare-denominator rule, which runs after this one and then finds its\n      // fused token stranded in operand position. The slash spelling never had\n      // the problem, which is what made it hard to see.\n      if (RATE_DENOMINATOR_WORDS.has(nextValue) && tokens[pos + 2]?.type === \"UNIT\") return null;\n\n      // ── Check trigger conditions ──\n      const triggers =\n        (t.type === \"NUMBER\" || t.type === \"RPAREN\") &&\n        (next.type === \"IDENT\" || next.type === \"LPAREN\" || next.type === \"PI\" || next.type === \"E\");\n\n      if (!triggers) return null;\n\n      // ── Insert a STAR token at the next token's position ──\n      const starToken = new LexerToken(\n        \"STAR\", tokenTypeId(\"STAR\"), \"*\", \"*\",\n        next.offset, 0, next.line, next.col,\n      );\n\n      // consumed = 1: only the current token is replaced with [current, STAR]\n      // The next token is NOT consumed, it stays for the next iteration\n      return { consumed: 1, replacement: [t, starToken] };\n    },\n  };\n}\n\n//#endregion\n//#region ─── isInsideRangeContext, Bracket/Call-Paren Context Guard ───────────\n\n/**\n * Whether token `pos` sits inside a context where a bare `NUMBER:NUMBER`\n * sequence means a Range, not a clock-time/laptime/video-timecode literal:\n * a matrix literal/index/slice (`[1,2,3]`, `a[0:3]`), OR a `map`/`reduce`/\n * `sum`/`prod` call's own argument-list parens (`map(f, 0:3)`, these\n * accept a bare Range argument directly, per the Calca spec's own\n * example). Scans backward from `pos` over the CURRENT pass's token array,\n * tracking `[`/`(` nesting depth, the same \"positional guard via\n * backward scan\" idiom already used elsewhere in this normalizer layer\n * (e.g. `LineRefNormalizerRule`'s previous-token check), generalized to\n * depth-tracking. An `LBRACKET` is unconditionally a range-safe opener; an\n * `LPAREN` is range-safe ONLY when immediately preceded by MAP/REDUCE/\n * SUM_FN/PROD_FN, an ordinary grouping/function-call paren is NOT, so\n * `(9:00) + 5` still means a clock time, not a range.\n *\n * Needed because the clock-time/laptime/video-timecode rules each match a\n * bare `NUMBER COLON NUMBER...` shape with ZERO context-awareness, a real\n * collision discovered when adding Range support, since e.g. \"0:3\" is\n * valid input to BOTH features. These contexts have no legitimate use for\n * a clock-time/laptime/timecode literal, so the carve-out costs the time\n * features nothing.\n *\n * IMPORTANT cross-pass-timing gotcha (a real bug found and fixed here,\n * not a hypothetical): the `LPAREN`-opener check deliberately tests the\n * RAW word text (`prev.value.toLowerCase()`), not `prev.type ===\n * \"MAP\"/\"REDUCE\"/...`. The normalizer's multi-pass loop hands every rule\n * the SAME frozen `tokens` snapshot for an entire pass, a rule scanning\n * a LATER position in that pass cannot see a fusion `mapReduceCallNormalizerRule`\n * performs at an EARLIER position in that SAME pass (fusion results only\n * become visible to other rules starting the NEXT pass). Checking the\n * fused token type here would miss exactly the case that matters most\n * `map(f, 0:3)` on its very first normalization pass, silently letting\n * `0:3` fuse into a clock time before `map(`'s own fusion ever lands.\n * Testing the raw word is immune to this: it's true from the very first\n * pass, regardless of whether `mapReduceCallNormalizerRule` has run yet.\n * (`LBRACKET` above has no equivalent issue, it's a genuine lexer token\n * from the start, never itself the product of a fusion.)\n */\nexport function isInsideRangeContext(tokens: Token[], pos: number): boolean {\n  const safeStack: boolean[] = [];\n  for (let i = 0; i < pos; i++) {\n    const t = tokens[i];\n    if (t.type === \"LBRACKET\") {\n      safeStack.push(true);\n    } else if (t.type === \"LPAREN\") {\n      const prev = tokens[i - 1];\n      const opensMapReduceCall = !!prev && (\n        prev.type === \"MAP\" || prev.type === \"REDUCE\" || prev.type === \"SUM_FN\" || prev.type === \"PROD_FN\" ||\n        (prev.type === \"IDENT\" && (prev.value.toLowerCase() === \"map\" || prev.value.toLowerCase() === \"reduce\" || prev.value.toLowerCase() === \"sum\" || prev.value.toLowerCase() === \"prod\"))\n      );\n      safeStack.push(opensMapReduceCall);\n    } else if (t.type === \"RBRACKET\" || t.type === \"RPAREN\") {\n      safeStack.pop();\n    }\n  }\n  return safeStack.length > 0 && safeStack[safeStack.length - 1];\n}\n\n//#endregion\n//#region ─── createBuiltinNormalizerRules, All Built-in Rules ─────────────────\n\n/**\n * Creates built-in non-phrase normalization rules.\n *\n * Returns implicit multiply insertion (priority 50).\n *\n * **Prefer** calling {@link implicitMultiplyRule} directly with a\n * `canStart` predicate wired to the normalizer's phrase trie:\n * ```ts\n * normalizer.register(implicitMultiplyRule(50, (w) => normalizer.canStartPhrase(w)));\n * ```\n * Without the predicate, this function falls back to a hardcoded\n * {@link PHRASE_START_WORDS} set that won't reflect package-registered phrases.\n *\n * @returns An array of {@link NormalizerRule} instances ready for registration\n */\nexport function createBuiltinNormalizerRules(): NormalizerRule[] {\n  return [\n    // ── Implicit operator insertion (priority 50) ──\n    implicitMultiplyRule(),\n  ];\n}\n\n/**\n * Built-in phrase → tokenType mappings.\n *\n * These are registered into the engine's {@link PhraseTrie} during\n * construction. Tests that create a standalone {@link TokenNormalizer}\n * should register these via {@link TokenNormalizer.addPhrase}.\n */\nexport const BUILTIN_PHRASES: Record<string, string> = {\n\t\"to the power of\": \"CARET\",\n\t\"power of\": \"CARET\",\n\t\"increase by\": \"INCREASE_BY\",\n\t\"decrease by\": \"DECREASE_BY\",\n\t\"times by\": \"TIMES_BY\",\n\t\"multiply by\": \"MULTIPLY_BY\",\n\t\"divide by\": \"DIVIDE_BY\",\n\t// The past-tense spellings, which is how the operation is usually written\n\t// out: \"3 multiplied by 4\". Same tokens, so no new parselets. Both this\n\t// branch and the parity branch added \"multiplied by\" independently; the\n\t// merge kept both copies and the locale table rejected the duplicate key.\n\t\"multiplied by\": \"MULTIPLY_BY\",\n\t\"divided by\": \"DIVIDE_BY\",\n};\n\n//#endregion\n"]}