solve-engine 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/chunk-SDGRK7EP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parser/registry/ParseletRegistry.ts","../src/parser/PrecedenceParser.ts"],"names":[],"mappings":"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","file":"chunk-SDGRK7EP.js","sourcesContent":["import { PrefixParselet, InfixParselet } from \"@solve-js/parser/Parselet\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\n\n/**\n * Binding-power fields a parselet may expose beyond what its interface\n * requires, read only for diagnostic display.\n *\n * `PrefixParselet` declares no binding power at all and `InfixParselet` declares\n * a single `bindingPower`, but some parselets carry a separate left and right\n * power. The diagnostic views want whatever is there without requiring it, so\n * this describes the optional surface instead of reaching through `any` at each\n * access. `category` is not here: both interfaces already declare it.\n */\ninterface ParseletBindingPowers {\n\treadonly bindingPower?: number;\n\treadonly leftBindingPower?: number;\n\treadonly rightBindingPower?: number;\n}\n\n/** Reads the optional binding-power fields off a parselet for diagnostics. */\nfunction bindingPowersOf(parselet: PrefixParselet | InfixParselet): ParseletBindingPowers {\n\treturn parselet as ParseletBindingPowers;\n}\n\n/**\n * Dual-keyed ParseletRegistry, accepts both string token types and\n * integer token type IDs for fast dispatch in the Parser hot path.\n *\n * Providers call registerPrefix(\"NUMBER\", ...) with string token types.\n * Internally, we populate both string-keyed and integer-keyed maps so\n * Parser.parseExpression() can use token.typeId (integer) for lookup\n * while diagnostics and error messages use token.type (string).\n *\n * Performance: Integer Map.get() avoids string hashing, saving ~2-5ns\n * per dispatch. With ~10-15 dispatches per expression, that's ~20-75ns.\n */\nexport class ParseletRegistry {\n\t// String-keyed maps (kept for diagnostics + backwards compat)\n\tprivate prefixParselets: Map<string, PrefixParselet> = new Map();\n\tprivate infixParselets: Map<string, InfixParselet> = new Map();\n\n\t// Integer-keyed maps for parser hot path\n\tprivate prefixById: Map<number, PrefixParselet> = new Map();\n\tprivate infixById: Map<number, InfixParselet> = new Map();\n\n\t/**\n\t * Register a prefix parselet for `tokenType`.\n\t *\n\t * If another parselet is already registered for this token type, it is\n\t * silently overwritten by default (`Map.set()` semantics), the old\n\t * parselet is simply unreachable from then on, with no error. This is\n\t * a real footgun for third-party packages: two packages independently\n\t * choosing the same custom token type will collide with zero signal\n\t * about which one \"won\". Mirrors ResolverRegistry.register()'s and\n\t * ExpressionEngine.registerPackage()'s existing \"warn and replace\"\n\t * pattern for the same class of problem at the resolver-namespace and\n\t * package-name levels.\n\t *\n\t * Note: this warns about registry-level collisions only. It does NOT\n\t * detect the separate case where `tokenType` is one of PrecedenceParser's\n\t * Tier-1 fast-path token types (NUMBER, STRING, IDENT, LPAREN, MINUS,\n\t * PLUS, and the Tier-1 infix operators), those are deliberately kept\n\t * registered here for introspection/diagnostics even though Tier-1\n\t * always intercepts them before this registry is consulted (see\n\t * PrecedenceParser.parsePrefix()'s docs), so warning there would\n\t * misfire on that intentional, already-documented pattern.\n\t */\n\tregisterPrefix(tokenType: string, parselet: PrefixParselet): void {\n\t\tconst existing = this.prefixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Prefix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.prefixParselets.set(tokenType, parselet);\n\t\tthis.prefixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */\n\tregisterInfix(tokenType: string, parselet: InfixParselet): void {\n\t\tconst existing = this.infixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Infix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.infixParselets.set(tokenType, parselet);\n\t\tthis.infixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Iterate all registered prefix parselets for diagnostic display. */\n\tgetAllPrefix(): Array<{ tokenType: string; bindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; bindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.prefixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tbindingPower: bindingPowersOf(parselet).bindingPower ?? 0,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Iterate all registered infix parselets for diagnostic display. */\n\tgetAllInfix(): Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.infixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tleftBindingPower: bindingPowersOf(parselet).leftBindingPower ?? 0,\n\t\t\t\trightBindingPower: bindingPowersOf(parselet).rightBindingPower ?? 0,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Number of registered prefix parselets. */\n\tget prefixCount(): number { return this.prefixParselets.size; }\n\n\t/** Number of registered infix parselets. */\n\tget infixCount(): number { return this.infixParselets.size; }\n\n\t/**\n\t * Get prefix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings\n\t * (diagnostics, error messages, backwards compatibility).\n\t */\n\tgetPrefix(tokenType: string | number): PrefixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.prefixById.get(tokenType);\n\t\treturn this.prefixParselets.get(tokenType);\n\t}\n\n\t/**\n\t * Get infix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings.\n\t */\n\tgetInfix(tokenType: string | number): InfixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.infixById.get(tokenType);\n\t\treturn this.infixParselets.get(tokenType);\n\t}\n\n\thasPrefix(tokenType: string): boolean {\n\t\treturn this.prefixParselets.has(tokenType);\n\t}\n\n\thasInfix(tokenType: string): boolean {\n\t\treturn this.infixParselets.has(tokenType);\n\t}\n\n\tclear(): void {\n\t\tthis.prefixParselets.clear();\n\t\tthis.infixParselets.clear();\n\t\tthis.prefixById.clear();\n\t\tthis.infixById.clear();\n\t}\n}\n\n/**\n * A process-wide parselet registry.\n *\n * @deprecated An engine builds its own registry and does not read this one, so\n * registering here reaches nothing that evaluates. It survives for the\n * deprecated {@link PackageRegistry} path only.\n */\nexport const sharedParseletRegistry = new ParseletRegistry();\n","import { ParseletRegistry } from \"@solve-js/parser/registry/ParseletRegistry\";\nimport { Token, tokenTypeId, TokenTypes } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { DiagnosticPipeline, DiagnosticEventType, type DiagnosticEvent } from \"@solve-js/diagnostics\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower, buildBindingPowerTable } from \"@solve-js/parser/BindingPower\";\nimport { getLocale } from \"@solve-js/constants/locales\";\n\n/**\n * Matches a CHAINED thousands-grouped integer using \".\" as the group\n * separator (e.g. \"1.234.567\"), independent of locale. Kept in sync with\n * the identical constant in NumberParselet.ts (not imported from there\n * that file transitively re-imports PrecedenceParser via Parser.ts's\n * `export { PrecedenceParser as Parser }`, so importing the other\n * direction would create a circular dependency for the sake of one\n * regex literal). See NumberParselet.ts's copy for the full explanation.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/**\n * ── Hybrid Precedence Climbing Parser ─────────────────────────────────────────\n *\n * Two-tier dispatch strategy:\n *\n *   Tier 1 (Fast Path): Inline switch on token.typeId for built-in operators.\n *     - Prefix: NUMBER, IDENT, LPAREN, MINUS, PLUS, STRING\n *     - Infix:  checked via static BP_TABLE (Uint8Array indexed by typeId)\n *     - No Map.get(), no parselet function call overhead for ~95% of tokens\n *\n *   Tier 2 (Plugin Path): ParseletRegistry fallback for custom/plugin tokens.\n *     - Prefix: Map.get(tokenTypeId) for PrefixParselet\n *     - Infix:  Map.get(tokenTypeId) for InfixParselet\n *     - Full flexibility for custom syntax\n *\n * The parser emits directly to a BytecodeBuilder, no AST intermediate.\n * Implements the same public API as the legacy Parser class so existing\n * parselets continue to work without modification.\n */\nexport class PrecedenceParser {\n  private tokens: Token[] = [];\n  private current = 0;\n  private depth = 0;\n  private maxDepth: number;\n\n  /** Cached registry reference, avoids property chain in hot loop */\n  private registry: ParseletRegistry;\n\n  /** BytecodeBuilder, set before each parseExpression call */\n  private builder!: BytecodeBuilder;\n\n  /** Diagnostic pipeline for parselet-matched events */\n  private diagnosticPipeline: DiagnosticPipeline | undefined;\n  private currentExpression: string = \"\";\n  private localeCode: string;\n\n  /**\n   * Static binding power table, built once at module load, shared across all instances.\n   * Index = tokenTypeId, value = binding power (0 = not a built-in infix).\n   */\n  static readonly BP_TABLE: Uint8Array = buildBindingPowerTable();\n\n  // ── Pre-computed token type IDs for inline dispatch ────────────────────────\n  // Prefix built-ins\n  private static readonly NUMBER_ID   = tokenTypeId(TokenTypes.NUMBER);\n  private static readonly BIGINT_ID   = tokenTypeId(TokenTypes.BIGINT);\n  private static readonly STRING_ID   = tokenTypeId(TokenTypes.STRING);\n  private static readonly IDENT_ID    = tokenTypeId(TokenTypes.IDENT);\n  private static readonly LPAREN_ID   = tokenTypeId(TokenTypes.LPAREN);\n  private static readonly RPAREN_ID   = tokenTypeId(TokenTypes.RPAREN);\n  private static readonly MINUS_ID    = tokenTypeId(TokenTypes.MINUS);\n  private static readonly PLUS_ID     = tokenTypeId(TokenTypes.PLUS);\n  private static readonly KEYWORD_ID  = tokenTypeId(TokenTypes.KEYWORD);\n\n  // Infix built-ins (Tier 1, full inline emission)\n  private static readonly STAR_ID     = tokenTypeId(TokenTypes.STAR);\n  private static readonly SLASH_ID    = tokenTypeId(TokenTypes.SLASH);\n  private static readonly MOD_ID      = tokenTypeId(TokenTypes.MOD);\n  private static readonly CARET_ID    = tokenTypeId(TokenTypes.CARET);\n  private static readonly LSHIFT_ID   = tokenTypeId(TokenTypes.LSHIFT);\n  private static readonly RSHIFT_ID   = tokenTypeId(TokenTypes.RSHIFT);\n  private static readonly BIT_AND_ID  = tokenTypeId(TokenTypes.BIT_AND);\n  private static readonly BIT_OR_ID   = tokenTypeId(TokenTypes.BIT_OR);\n  private static readonly BIT_XOR_ID  = tokenTypeId(TokenTypes.BIT_XOR);\n  private static readonly PERCENT_ID  = tokenTypeId(TokenTypes.PERCENT);\n  private static readonly OF_ID       = tokenTypeId(TokenTypes.OF);\n\n  /**\n   * Inline opcode map for Tier 1 infix operators.\n   * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).\n   */\n  private static readonly INFIX_OPCODE: Record<number, OpCode> = {\n    [tokenTypeId(TokenTypes.PLUS)]:    OpCode.ADD,\n    [tokenTypeId(TokenTypes.MINUS)]:   OpCode.SUB,\n    [tokenTypeId(TokenTypes.STAR)]:    OpCode.MUL,\n    [tokenTypeId(TokenTypes.SLASH)]:   OpCode.DIV,\n    [tokenTypeId(TokenTypes.MOD)]:     OpCode.MOD,\n    [tokenTypeId(TokenTypes.CARET)]:   OpCode.EXP,\n    [tokenTypeId(TokenTypes.LSHIFT)]:  OpCode.LSHIFT,\n    [tokenTypeId(TokenTypes.RSHIFT)]:  OpCode.RSHIFT,\n    [tokenTypeId(TokenTypes.BIT_AND)]: OpCode.BIT_AND,\n    [tokenTypeId(TokenTypes.BIT_OR)]:  OpCode.BIT_OR,\n    [tokenTypeId(TokenTypes.BIT_XOR)]: OpCode.BIT_XOR,\n    [tokenTypeId(TokenTypes.OF)]:      OpCode.MUL,\n  };\n\n  constructor(parseletRegistry: ParseletRegistry, maxDepth = 50, localeCode = \"en\") {\n    this.registry = parseletRegistry;\n    this.maxDepth = maxDepth;\n    this.localeCode = localeCode;\n  }\n\n  /** Get locale code for NumberParselet to normalize separators */\n  getLocaleCode(): string {\n    return this.localeCode;\n  }\n\n  /**\n   * Set the diagnostic pipeline for parselet matching events.\n   * Cleared after each non-cached parse to avoid holding refs.\n   */\n  setDiagnosticPipeline(pipeline: DiagnosticPipeline | undefined, expression: string): void {\n    this.diagnosticPipeline = pipeline;\n    this.currentExpression = expression ?? \"\";\n  }\n\n  /**\n   * Load tokens for parsing. Identical to Parser.load().\n   *\n   * @param hasParens - if false, skips the O(n) paren balance scan (~90% of expressions)\n   */\n  load(tokens: Token[], hasParens?: boolean): void {\n    if (hasParens === false) {\n      this.tokens = tokens;\n      this.current = 0;\n      this.depth = 0;\n      return;\n    }\n    // Paren scan: count balance to skip array copy for balanced expressions.\n    const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n    const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n    let openCount = 0;\n    for (let i = 0; i < tokens.length; i++) {\n      if (tokens[i].typeId === LPAREN_ID) openCount++;\n      else if (tokens[i].typeId === RPAREN_ID) openCount--;\n    }\n    this.tokens = openCount === 0 ? tokens : this.balanceParens(tokens, openCount);\n    this.current = 0;\n    this.depth = 0;\n  }\n\n  /**\n   * Auto-balance unmatched parentheses.\n   */\n  private balanceParens(tokens: Token[], openCount: number): Token[] {\n    const result = tokens.slice();\n    if (openCount > 0) {\n      const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n      for (let i = 0; i < openCount; i++) {\n        const lastToken = tokens[tokens.length - 1];\n        result.push({\n          type: TokenTypes.RPAREN,\n          typeId: RPAREN_ID,\n          value: \")\",\n          text: \")\",\n          offset: lastToken ? lastToken.offset + lastToken.text.length : 0,\n          lineBreaks: 0,\n          line: lastToken ? lastToken.line : 1,\n          col: lastToken ? lastToken.col + lastToken.text.length : 1,\n        } as Token);\n      }\n    } else if (openCount < 0) {\n      const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n      for (let i = 0; i < -openCount; i++) {\n        result.unshift({\n          type: TokenTypes.LPAREN,\n          typeId: LPAREN_ID,\n          value: \"(\",\n          text: \"(\",\n          offset: 0,\n          lineBreaks: 0,\n          line: 1,\n          col: 1,\n        } as Token);\n      }\n    }\n    return result;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Main entry point: precedence climbing parse expression\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a full expression starting at the current token position.\n   *\n   * @param minBp - minimum binding power (precedence climbing threshold).\n   *   For left-associative operators, the recursive call uses `bp + 1`.\n   *   For right-associative operators (^), it uses `bp`.\n   * @param _builder - accepted for parselet API compatibility; always uses `this.builder`.\n   */\n  parseExpression(minBp: number = 0, _builder?: BytecodeBuilder): void {\n    // Accept builder via parameter for backward compatibility with the old Parser API.\n    // The ExpressionEngine always calls setBuilder() before parseExpression(),\n    // but tests and parselets pass builder as a parameter.\n    if (_builder) {\n      this.builder = _builder;\n    }\n    this.depth++;\n    if (this.depth > this.maxDepth) {\n      this.depth--;\n      throw ErrorFactory.parsing(\n        \"NESTING_DEPTH_EXCEEDED\",\n        `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,\n        { maxDepth: this.maxDepth, currentDepth: this.depth }\n      );\n    }\n\n    const token = this.consume();\n    if (!token) {\n      this.depth--;\n      throw ErrorFactory.parsing(\"UNEXPECTED_END\", \"Unexpected end of expression\");\n    }\n\n    // ── Prefix ──────────────────────────────────────────────────────────────\n    this.parsePrefix(token);\n\n    // ── Infix loop (precedence climbing with inline Tier 1 dispatch) ──────────\n    const tokens = this.tokens;\n    const len = tokens.length;\n    const bpTable = PrecedenceParser.BP_TABLE;\n    const registry = this.registry;\n    const builder = this.builder;\n    let idx = this.current;\n\n    while (idx < len) {\n      const lookahead = tokens[idx];\n      if (!lookahead) break;\n\n      const bp = bpTable[lookahead.typeId];\n      if (bp > 0) {\n        // Tier 1: Built-in infix, full inline emission, zero parselet delegation\n        if (bp <= minBp) break;\n\n        if (this.diagnosticPipeline) {\n          // Fast path skips the registry, but built-ins are still registered\n          // there (for introspection/tests), look them up only in this\n          // diagnostics-only branch so the playground's \"matched parselets\"\n          // view isn't permanently blind to every arithmetic operator.\n          const infixParselet = registry.getInfix(lookahead.typeId);\n          if (infixParselet) {\n            this.fireParseletMatched(infixParselet, lookahead, false, bp);\n          }\n        }\n\n        this.current = ++idx;\n        const typeId = lookahead.typeId;\n\n        if (typeId === PrecedenceParser.PERCENT_ID) {\n          // Postfix: no right operand. \"50%\" → value / 100\n          builder.emitOpcode(OpCode.PUSH_NUMBER);\n          builder.emitNumber(100);\n          builder.emitOpcode(OpCode.DIV);\n        } else if (typeId === PrecedenceParser.CARET_ID && this.tryEmitMatrixCaretOp(builder)) {\n          // `^T` (transpose) or `^-1` (inverse), already fully handled\n          // including consuming their own trailing tokens.\n        } else {\n          // Infix: parse right operand, then emit opcode.\n          // Right-associative for CARET (^), left-associative for all others.\n          const rightBp = (typeId === PrecedenceParser.CARET_ID) ? bp : bp + 1;\n          this.parseExpression(rightBp, builder);\n          builder.emitOpcode(PrecedenceParser.INFIX_OPCODE[typeId]);\n        }\n      } else {\n        // Tier 2: Plugin parselet fallback, full flexibility for custom syntax\n        const infixParselet = registry.getInfix(lookahead.typeId);\n        if (!infixParselet) break;\n        if (infixParselet.bindingPower <= minBp) break;\n\n        this.current = ++idx;\n\n        if (this.diagnosticPipeline) {\n          this.fireParseletMatched(infixParselet, lookahead, false, infixParselet.bindingPower);\n        }\n        // Parselet handles its own recursion for right operand internally\n        infixParselet.parse(this, token, lookahead, builder);\n      }\n\n      idx = this.current;\n    }\n\n    this.current = idx;\n    this.depth--;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Prefix dispatch: inline switch for built-ins, parselet registry for plugins\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a prefix token. Built-in tokens (NUMBER, IDENT, LPAREN, etc.) are\n   * handled inline with zero registry lookup. Everything else falls through\n   * to the parselet registry (Tier 2).\n   */\n  private parsePrefix(token: Token): void {\n    const builder = this.builder;\n    const typeId = token.typeId;\n\n    if (this.diagnosticPipeline) {\n      // Fast path below skips the registry for built-ins, but they're still\n      // registered there (for introspection/tests), look up here so the\n      // playground's \"matched parselets\" view isn't permanently blind to\n      // every number, identifier, paren, and unary operator.\n      const parselet = this.registry.getPrefix(typeId);\n      if (parselet) {\n        this.fireParseletMatched(parselet, token, true);\n      }\n    }\n\n    switch (typeId) {\n      // ── Numeric literals ──────────────────────────────────────────────────\n      case PrecedenceParser.NUMBER_ID: {\n        // Parse number with locale-aware separator normalization\n        let v: number;\n        const raw = token.value;\n        if (raw.startsWith(\"0x\") || raw.startsWith(\"0X\")) {\n          v = parseInt(raw, 16);\n          // A prefix with no digits after it (\"0x\" alone) makes parseInt\n          // return NaN. This used to push straight through as a silent\n          // NaN Number value instead of a visible error.\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid hex literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0b\") || raw.startsWith(\"0B\")) {\n          v = parseInt(raw.slice(2), 2);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid binary literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0o\") || raw.startsWith(\"0O\")) {\n          v = parseInt(raw.slice(2), 8);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid octal literal: \"${raw}\"`, { raw });\n          }\n        } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {\n          // The lexer accepts \".\" as a thousands-group separator\n          // independent of locale (ExpressionLexer's number-scanning\n          // \"Thousands separators\" block), but the locale-based\n          // normalization below only strips the ACTIVE locale's own\n          // configured thousandsSeparator character, for \"en\" that's\n          // \",\", not \".\", so a chained dot-grouped literal like\n          // \"1.234.567\" fell through to parseFloat() untouched, which\n          // stops at the second \".\" and silently truncated it to 1.234\n          // (over 99% of the digits dropped, with no error). This is the\n          // REAL number-parsing path for actual evaluation, Tier 1 of\n          // the two-tier dispatch above always returns for NUMBER_ID, so\n          // NumberParselet.parse() (which has the identical fix) never\n          // actually runs except via direct unit tests / the \"matched\n          // parselets\" diagnostic display.\n          v = parseFloat(raw.split(\".\").join(\"\"));\n        } else {\n          const locale = getLocale(this.localeCode);\n          const decimalSep = locale.display.decimalSeparator;\n          const thousandsSep = locale.display.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation)\n          if (thousandsSep) {\n            normalized = normalized.split(thousandsSep).join(\"\");\n          }\n          // Replace locale decimal separator with \".\" for JavaScript parsing\n          if (decimalSep && decimalSep !== \".\") {\n            normalized = normalized.replace(decimalSep, \".\");\n          }\n          v = parseFloat(normalized);\n        }\n        builder.emitOpcode(OpCode.PUSH_NUMBER);\n        builder.emitNumber(v);\n        return;\n      }\n\n      case PrecedenceParser.BIGINT_ID: {\n        // Strip optional 'n' suffix before emitting as string\n        let raw = token.value;\n        if (raw.endsWith(\"n\")) raw = raw.slice(0, -1);\n        builder.emitOpcode(OpCode.PUSH_BIGINT);\n        builder.emitString(raw);\n        return;\n      }\n\n      case PrecedenceParser.STRING_ID: {\n        builder.emitOpcode(OpCode.PUSH_STRING);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Identifiers (variables) ────────────────────────────────────────────\n      case PrecedenceParser.IDENT_ID: {\n        // An identifier immediately followed by \"(\" may be a user-defined\n        // function DEFINITION (`f(x) = ...`) or CALL (`f(5)`). See\n        // parseUserFunctionDefOrCall's doc comment for the full\n        // disambiguation. Only the (cheap) LPAREN check runs for the\n        // overwhelmingly common case of a bare identifier with nothing\n        // following it.\n        if (this.peek()?.typeId === PrecedenceParser.LPAREN_ID) {\n          this.parseUserFunctionDefOrCall(token, builder);\n          return;\n        }\n        // IDENT tokens map to LOAD_VAR by default. The IdentifierParselet\n        // and VariableParselet add STORE_VAR for assignments, those are\n        // handled via the parselet registry below. Note this is also how a\n        // user-defined function's own PARAMETER references compile. See\n        // UserFunctionDef's doc comment in BytecodeBuilder.ts for why there\n        // is no separate parameter-load opcode: `LOAD_VAR` resolution\n        // dynamically checks the VM's innermost call frame first.\n        builder.emitOpcode(OpCode.LOAD_VAR);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Grouping / bare-tuple vector literal ─────────────────────────────────\n      // `(expr)` groups for precedence; `(x, y[, z[, w]])` is the bare-tuple\n      // vector literal documented as an alternative to vec2/vec3/vec4(...)\n      // (wiki: Arithmetic/Vector). This Tier-1 case is what actually runs for\n      // every LPAREN in production parsing, GroupParselet.ts mirrors this\n      // logic for registry-introspection/diagnostic-listing purposes, but a\n      // package can never override LPAREN's dispatch here (Tier 1 always\n      // wins over the ParseletRegistry fallback below), so both must be kept\n      // in sync by hand.\n      case PrecedenceParser.LPAREN_ID: {\n        this.parseExpression(0, builder);\n        let count = 1;\n        while (this.match(TokenTypes.COMMA)) {\n          this.parseExpression(0, builder);\n          count++;\n        }\n        this.consume(TokenTypes.RPAREN);\n        if (count > 1) {\n          // Legacy bare-tuple vector sugar, a 1xN row-vector Matrix (see\n          // packages/vector/parselets/VectorParselet.ts's comment).\n          builder.emitOpcode(OpCode.MAT_NEW);\n          builder.emitIndex(1);\n          builder.emitIndex(count);\n        }\n        return;\n      }\n\n      // ── Unary operators ───────────────────────────────────────────────────\n      case PrecedenceParser.MINUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.NEG);\n        return;\n      }\n\n      case PrecedenceParser.PLUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.POS);\n        return;\n      }\n\n      // ── Keyword constants ─────────────────────────────────────────────────\n      case PrecedenceParser.KEYWORD_ID: {\n        // Keywords are handled by parselets (pi→PI, e→E, etc.)\n        // Fall through to registry below.\n      }\n    }\n\n    // ── Tier 2: Plugin/parselet prefix path ──────────────────────────────────\n    const prefixParselet = this.registry.getPrefix(typeId);\n    if (!prefixParselet) {\n      throw ErrorFactory.parsing(\n        \"NO_PREFIX_PARSELET\",\n        `No prefix parselet found for token: ${token.type} (\"${token.value}\")`,\n        { tokenType: token.type, tokenValue: token.value }\n      );\n    }\n\n    prefixParselet.parse(this, token, builder);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // The \"Tier-1 shape-exception\" pattern\n  // ═══════════════════════════════════════════════════════════════════════════════\n  //\n  // Tier 1 exists purely for performance, avoid a Map lookup + parselet call\n  // on ~95% of tokens (see this file's own module doc comment above). A\n  // recurring consequence: any grammar shape tied to a Tier-1 token type can\n  // ONLY be implemented by hand-editing this switch, since a package-\n  // registered ParseletRegistry parselet for that same token type would\n  // simply never run in production (Tier 1 always wins over the registry\n  // fallback). Five confirmed instances of this tension exist in this file\n  // (plus one that had to move OUTSIDE it entirely):\n  //   1. NUMBER_ID, the full locale-aware number-literal parsing (hex/\n  //      binary/octal, chained-dot thousands grouping, decimal-separator\n  //      normalization) is inlined in parsePrefix() above; NumberParselet.ts's\n  //      own copy is dead code for real evaluation, kept registered only for\n  //      the \"matched parselets\" diagnostic view.\n  //   2. IDENT_ID, parseUserFunctionDefOrCall's lookahead (below) disambig-\n  //      uates a function DEFINITION from a CALL from a plain variable load.\n  //   3. LPAREN_ID, the bare-tuple vector-literal sugar (\"(x,y[,z[,w]])\" ->\n  //      MAT_NEW) is inlined in parsePrefix() above; GroupParselet.ts mirrors\n  //      it for introspection only and must be kept in sync by hand.\n  //   4. CARET_ID, the transpose/inverse suffix table just below.\n  //   5. PLUS_ID, the locale word \"and\" lexes as PLUS (Tier-1, fixed Sum\n  //      binding power), so a registry parselet can never intercept it the\n  //      way LogicalParselet.ts intercepts \"or\"/&&/||; unlike the other four,\n  //      there's no SHAPE to special-case on here (the token itself IS the\n  //      operator), so the workaround lives entirely outside this file, as a\n  //      runtime Boolean/Boolean type-check inside vm/VM.ts's OpCode.ADD\n  //      handler instead.\n  //\n  // Deliberate non-goal: none of this is exposed as an IEnginePackage\n  // extension point (unlike prefixParselets/infixParselets). Letting\n  // third-party packages register their own Tier-1 shape-matchers would put\n  // per-package matcher iteration on a genuinely hot path (every CARET/\n  // NUMBER/IDENT/LPAREN/PLUS token, matched or not), a materially bigger\n  // separate product decision than \"make this one table more concise,\" and\n  // not one this pattern write-up makes.\n\n  /**\n   * A single `^`-suffix shape: `matches` peeks ahead (consuming nothing) to\n   * check whether this shape starts at the current position; `emit` is only\n   * called immediately after `matches` returned true for that SAME position,\n   * and is responsible for consuming that shape's own trailing tokens and\n   * emitting its bytecode.\n   */\n  private static readonly CARET_SUFFIX_RULES: ReadonlyArray<{\n    name: string;\n    matches(parser: PrecedenceParser): boolean;\n    emit(parser: PrecedenceParser, builder: BytecodeBuilder): void;\n  }> = [\n    {\n      name: \"transpose (^T)\",\n      matches: (p) => {\n        const next = p.peek();\n        return next?.type === TokenTypes.IDENT && next.value === \"T\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(63); // transpose — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n    {\n      name: \"inverse (^-1)\",\n      matches: (p) => {\n        const next = p.peek();\n        if (next?.typeId !== PrecedenceParser.MINUS_ID) return false;\n        const afterMinus = p.peekAt(1);\n        return afterMinus?.type === TokenTypes.NUMBER && afterMinus.value === \"1\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(65); // inv — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n  ];\n\n  /**\n   * After a `^` token (already consumed by the Tier-1 infix loop above),\n   * checks {@link CARET_SUFFIX_RULES} in order for a shape that means\n   * something other than ordinary exponentiation: `^T` (transpose) and `^-1`\n   * (matrix inverse, LITERALLY the integer exponent `-1`; `^-2`, `^-1.5`\n   * etc. still mean ordinary exponentiation). On a match, the rule's `emit`\n   * consumes that shape's own tokens and this returns `true`. On no match,\n   * consumes NOTHING, returning `false` so the caller falls through to\n   * ordinary `EXP` parsing.\n   *\n   * Every rule dispatches purely on SHAPE, never on operand type (unknowable\n   * at parse time): `inv()`'s own handler (`VMBuiltins.ts` index 65) returns\n   * `1/x` for a plain Number, byte-identical to what `Math.pow(x, -1)`\n   * already computed for `x^-1` before this feature existed, and a real\n   * matrix inverse for a Matrix, so `5^-1` still means exactly what it always\n   * has; only a Matrix operand actually inverts.\n   *\n   * Adding a future `^`-suffix shape is a new table entry here, not a new\n   * if-block. See the \"Tier-1 shape-exception\" pattern write-up above for\n   * why this table can't instead be a package-registered parselet.\n   */\n  private tryEmitMatrixCaretOp(builder: BytecodeBuilder): boolean {\n    for (const rule of PrecedenceParser.CARET_SUFFIX_RULES) {\n      if (rule.matches(this)) {\n        rule.emit(this, builder);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // User-defined, parameterized, reusable functions (f(x) = 2*x + 1, then f(5))\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * From an LPAREN token index, scan forward tracking paren depth and\n   * return the index of the matching RPAREN, or `null` if the parens never\n   * balance before the token stream ends. No emission, no position\n   * advance. Same class of technique as {@link balanceParens}'s own\n   * pre-scan, just exposed mid-parse instead of only at `load()` time.\n   * `openIdx` must point AT the LPAREN itself.\n   */\n  private findMatchingRParen(openIdx: number): number | null {\n    let depth = 0;\n    for (let i = openIdx; i < this.tokens.length; i++) {\n      const t = this.tokens[i];\n      if (t.typeId === PrecedenceParser.LPAREN_ID) depth++;\n      else if (t.typeId === PrecedenceParser.RPAREN_ID) {\n        depth--;\n        if (depth === 0) return i;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Disambiguates a bare `IDENT` immediately followed by `(` between three\n   * things, using ONLY a bracket-depth scan (no backtracking, nothing is\n   * consumed until the shape is known):\n   * - `f(x) = expr`, a DEFINITION: the matching `)` is followed by `=`.\n   * - `f(5)`, a CALL to a (possibly not-yet-defined) function: anything\n   *   else. This was never valid syntax before this feature (a bare\n   *   `IDENT` immediately before `(` has no pre-existing \"plain variable\n   *   read + separately grouped `(...)`\" meaning to preserve, confirmed\n   *   via `BuiltinNormalizerRules.ts`'s `implicitMultiplyRule()`, which\n   *   only inserts an implicit `*` for `NUMBER/RPAREN` immediately before\n   *   `IDENT/LPAREN`, never for a bare `IDENT` immediately before\n   *   `LPAREN`). Always commits to a CALL; an unregistered name produces a\n   *   clear `UNDEFINED_FUNCTION` error at VM-execution time, the same\n   *   forward-reference philosophy `LOAD_VAR`/`UNDEFINED_VARIABLE` already\n   *   uses, rather than any parse-time registry lookup.\n   * If the parens never balance, this falls through to the ordinary\n   * `LOAD_VAR` path (a malformed expression surfaces its own parse error\n   * shortly after, from the normal expression grammar).\n   */\n  private parseUserFunctionDefOrCall(nameToken: Token, builder: BytecodeBuilder): void {\n    const closeIdx = this.findMatchingRParen(this.current);\n    if (closeIdx === null) {\n      builder.emitOpcode(OpCode.LOAD_VAR);\n      builder.emitString(nameToken.value);\n      return;\n    }\n    const afterClose = this.tokens[closeIdx + 1];\n    if (afterClose?.type === TokenTypes.EQUALS) {\n      this.parseUserFunctionDefinition(nameToken, builder);\n    } else {\n      this.parseUserFunctionCall(nameToken, builder);\n    }\n  }\n\n  /**\n   * A parameter name, accepted as either `IDENT` or `UNIT`, matches this\n   * codebase's established `:name = value` variable-name policy\n   * (`VariableParselet.ts` explicitly accepts `UNIT`-typed tokens too, e.g.\n   * `:b = 5` for the \"b\" bits unit) since common short parameter names\n   * like `h`/`l`/`b`/`t`/`s`/`m` collide with real unit abbreviations\n   * (hour, liter, bits, ton, second, meter, ...) and lex as `UNIT`, not\n   * `IDENT`.\n   */\n  private consumeParamName(): string {\n    const token = this.peek();\n    if (token?.type === TokenTypes.IDENT || token?.type === TokenTypes.UNIT) {\n      this.consume();\n      return token.value;\n    }\n    throw ErrorFactory.parsing(\n      \"USER_FUNCTION_INVALID_PARAM_NAME\",\n      `Expected a parameter name but got \"${token?.type ?? \"end of input\"}\"${token ? ` (\"${token.value}\")` : \"\"}`,\n      { actualType: token?.type },\n    );\n  }\n\n  private parseUserFunctionDefinition(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    const params: string[] = [];\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      params.push(this.consumeParamName());\n      while (this.match(TokenTypes.COMMA)) {\n        params.push(this.consumeParamName());\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n    this.consume(TokenTypes.EQUALS);\n\n    if (params.length === 0) {\n      throw ErrorFactory.parsing(\n        \"USER_FUNCTION_NO_PARAMS\",\n        `\"${nameToken.value}()\" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,\n        { name: nameToken.value },\n      );\n    }\n\n    // Compile the body into its OWN independent BytecodeBuilder, reusing\n    // the SAME parser/token stream but directing emission elsewhere.\n    // `parseExpression(minBp, _builder)` sets `this.builder = _builder`\n    // with NO automatic restore, explicitly restoring via `setBuilder()`\n    // afterward (not a `finally`, since a thrown parse error here should\n    // propagate as-is; there's no further use of `this.builder` on that\n    // path before the whole parse aborts) avoids silently emitting\n    // whatever parses next (in this same expression, or, via\n    // ExpressionEngine's builder pool, a LATER, unrelated line) into a\n    // stale, already-.build()'d body builder.\n    const bodyBuilder = new BytecodeBuilder();\n    this.parseExpression(BindingPower.Lowest, bodyBuilder);\n    this.setBuilder(builder);\n\n    const bodyProgram = bodyBuilder.build();\n    if (bodyProgram.hasAsync) {\n      // v1 scope decision: a function body calling an async plugin\n      // (weather, stocks, currency, ...) isn't supported yet, propagating\n      // a 'pending' result up through a reentrant executeBytecode() call\n      // would need the OUTER expression's own bytecode position/stack\n      // state to also be resumable later, which this first pass doesn't\n      // implement. Rejecting at DEFINITION time (not call time) gives the\n      // clearest possible error, matching this codebase's \"never silently\n      // pretend to support something it doesn't\" convention (e.g.\n      // addBusinessDays()'s own disclosed holiday-exclusion scope-down).\n      throw ErrorFactory.parsing(\n        \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n        `\"${nameToken.value}(...)\"'s body calls an async operation (weather, stocks, currency, ...) — user-defined function bodies must be synchronous`,\n        { name: nameToken.value },\n      );\n    }\n\n    const bodyIdx = builder.emitUserFunctionBody(nameToken.value, params, bodyProgram);\n    builder.emitOpcode(OpCode.DEFINE_USER_FUNCTION);\n    builder.emitIndex(bodyIdx);\n\n    // A definition line has no single input value to echo back the way an\n    // assignment does, push a plain confirmation string, matching this\n    // codebase's \"never silently produce a misleading numeric 0\" principle.\n    builder.emitOpcode(OpCode.PUSH_STRING);\n    builder.emitString(`${nameToken.value}(${params.join(\", \")}) defined`);\n  }\n\n  private parseUserFunctionCall(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    let argCount = 0;\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      this.parseExpression(BindingPower.Lowest, builder);\n      argCount++;\n      while (this.match(TokenTypes.COMMA)) {\n        this.parseExpression(BindingPower.Lowest, builder);\n        argCount++;\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n\n    builder.emitOpcode(OpCode.CALL_USER_FUNCTION);\n    builder.emitString(nameToken.value);\n    builder.emitByte(argCount);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Token stream navigation (identical API to Parser)\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  consume(expectedType?: string): Token {\n    const token = this.tokens[this.current];\n    if (!token) {\n      throw ErrorFactory.parsing(\n        \"UNEXPECTED_END_OF_INPUT\",\n        \"Unexpected end of input\"\n      );\n    }\n    if (expectedType !== undefined) {\n      const expectedId = tokenTypeId(expectedType);\n      if (token.typeId !== expectedId) {\n        throw ErrorFactory.parsing(\n          \"UNEXPECTED_TOKEN_TYPE\",\n          `Expected token type \"${expectedType}\" but got \"${token.type}\" (\"${token.value}\")`,\n          { expectedType, actualType: token.type, actualValue: token.value }\n        );\n      }\n    }\n    this.current++;\n    return token;\n  }\n\n  match(expectedType: string): boolean {\n    const token = this.peek();\n    if (token && token.typeId === tokenTypeId(expectedType)) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  peek(): Token | undefined {\n    return this.tokens[this.current];\n  }\n\n  /**\n   * Read-only lookahead `offset` tokens past the current position, without\n   * consuming anything, `peekAt(0)` is equivalent to {@link peek}.\n   * `this.tokens` is a plain in-memory array (not a stream), so this is a\n   * simple, safe index read; no rewind/checkpoint mechanism is needed since\n   * nothing is consumed.\n   */\n  peekAt(offset: number): Token | undefined {\n    return this.tokens[this.current + offset];\n  }\n\n  previous(): Token | undefined {\n    return this.current > 0 ? this.tokens[this.current - 1] : undefined;\n  }\n\n  private advance(): void {\n    this.current++;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Builder access, set before parse, read by inline prefix handlers\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** Set the builder to use for the current parse. Called by ExpressionEngine. */\n  setBuilder(builder: BytecodeBuilder): void {\n    this.builder = builder;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Diagnostics\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  private fireParseletMatched(\n    parselet: { category: string },\n    token: Token,\n    isPrefix: boolean,\n    bindingPower?: number\n  ): void {\n    const pipeline = this.diagnosticPipeline!;\n    const event: DiagnosticEvent & { type: \"parselet_matched\" } = {\n      type: DiagnosticEventType.ParseletMatched,\n      elapsedNs: 0,\n      expression: this.currentExpression,\n      tokenType: token.type,\n      tokenValue: token.value,\n      parseletCategory: parselet.category,\n      parseletType: parselet.constructor?.name ?? \"unknown\",\n      isPrefix,\n      bindingPower,\n      tokenOffset: token.offset || 0,\n    };\n    pipeline.fireParseletMatched(event);\n  }\n}\n"]}

package/dist/chunk-XJCMXB2E.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/uom/CurrencyExchange.ts"],"names":["createTimeoutSignal","ErrorFactory"],"mappings":"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","file":"chunk-XJCMXB2E.cjs","sourcesContent":["/**\n * Production-grade currency exchange service with scalable architecture\n * Integrates with DataQueryService for worker-based execution\n */\n\nimport { createTimeoutSignal } from \"@solve-js/utilities/TimeoutSignal\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * Error codes for this service. Co-located rather than unioned into\n * `errors/ErrorCode.ts`'s core catalog (that catalog is scoped to the\n * parser/VM/engine/errors/config/lexer layers, not yet the ~17 domain\n * packages. See that file's module doc for the intended per-package\n * pattern this follows).\n */\nexport const CurrencyErrorCodes = {\n  /** Frankfurter's rates endpoint returned a non-OK HTTP status. */\n  API_ERROR: \"CURRENCY_API_ERROR\",\n  /** A requested currency/crypto code isn't in the fetched rate table, an unrecognized code, not an API failure. */\n  UNKNOWN_CODE: \"UNKNOWN_CURRENCY_CODE\",\n  /** CoinGecko's simple-price endpoint returned a non-OK HTTP status. */\n  CRYPTO_API_ERROR: \"CRYPTO_PRICE_API_ERROR\",\n} as const;\n\n// ============================================================================\n// CURRENCY EXCHANGE SERVICE\n// ============================================================================\n\n/**\n * Caches exchange rates fetched from an external source.\n *\n * Rates are global market data rather than per-engine configuration, which is\n * why one instance is shared. Two engines with private copies would fetch the\n * same endpoint twice and could disagree about one pair at one moment. See\n * `engine/EngineContext.ts`.\n */\nexport class CurrencyExchangeService {\n  /**\n   * Live rate tables cached from successful getRate() fetches, keyed by\n   * uppercase base currency. Each table holds every rate the API returned\n   * for that base (plus the base itself at 1), so any pair whose two codes\n   * appear in one fresh table can be served synchronously, including\n   * cross pairs via triangulation (EUR→GBP through a USD-base table).\n   * Stale tables are ignored, not evicted; the next successful fetch for\n   * the same base overwrites them.\n   */\n  private baseTables: Map<string, { fetchedAt: number; rates: Record<string, number> }> = new Map();\n\n  /**\n   * How long a fetched rate may be served synchronously by getRateSync().\n   * Beyond this window callers fall through to the async path (expression\n   * shows Pending until the fetch lands).\n   */\n  private static readonly RATE_FRESHNESS_MS = 15 * 60 * 1000;\n\n  /**\n   * Ticker → CoinGecko coin id, for the cryptocurrencies `isCurrency()`\n   * recognizes. Frankfurter (the fiat rate source below) is ECB reference\n   * rates only and has no concept of BTC/ETH/etc, routing a crypto code\n   * through it as `base=BTC` fails outright, which is why crypto pairs\n   * previously never resolved (see CurrencyAsyncResolver/VM.ts's ADD\n   * handling for the two bugs that let that failure pass silently instead\n   * of surfacing as a real fetch).\n   */\n  private static readonly CRYPTO_IDS: Record<string, string> = {\n    BTC: \"bitcoin\", ETH: \"ethereum\", SOL: \"solana\", XRP: \"ripple\",\n    ADA: \"cardano\", DOGE: \"dogecoin\", DOT: \"polkadot\",\n  };\n\n  private isCryptoCode(code: string): boolean {\n    return code.toUpperCase() in CurrencyExchangeService.CRYPTO_IDS;\n  }\n\n  constructor() {}\n\n  // ------------------------------------------------------------------------\n  // RATE FETCHING\n  // ------------------------------------------------------------------------\n\n  /**\n   * Timeout (ms) for currency exchange rate fetches.\n   *\n   * If the frankfurter API doesn't respond within this window, the fetch\n   * is aborted, preventing indefinite \"Pending\" states in the playground\n   * and Obsidian plugin when the exchange rate API is unreachable.\n   */\n  private static readonly FETCH_TIMEOUT_MS = 10_000;\n\n  /**\n   * Fetch the live exchange rate for converting 1 unit of `from` into `to`.\n   *\n   * Routes cryptocurrency codes (see {@link CRYPTO_IDS}) to CoinGecko and\n   * everything else to Frankfurter (ECB reference rates, fiat-only). On\n   * success, caches the whole returned rate table for `from` so subsequent\n   * lookups, including cross-pairs via triangulation, can be served\n   * synchronously by {@link getRateSync} within the freshness window.\n   *\n   * @throws If the currency code is unrecognized or the fetch fails/times out.\n   */\n  async getRate(from: string, to: string, signal?: AbortSignal): Promise<number> {\n    const fromUpper = from.toUpperCase();\n    const toUpper = to.toUpperCase();\n\n    if (this.isCryptoCode(fromUpper) || this.isCryptoCode(toUpper)) {\n      return this.getCryptoRate(fromUpper, toUpper, signal);\n    }\n\n    // Combine the caller's optional abort signal with a hard timeout so a\n    // hanging currency API never blocks re-evaluation indefinitely.\n    const { signal: fetchSignal, cleanup } = createTimeoutSignal(\n      signal,\n      CurrencyExchangeService.FETCH_TIMEOUT_MS,\n      \"Currency API fetch\",\n    );\n\n    try {\n      const response = await fetch(`https://api.frankfurter.dev/v2/rates?base=${fromUpper}`, { signal: fetchSignal });\n      if (!response.ok) throw ErrorFactory.external(CurrencyErrorCodes.API_ERROR, `Currency API returned ${response.status}`, { status: response.status });\n      const data = await response.json();\n      // The v2 endpoint returns a flat array of { date, base, quote, rate }\n      // entries (one per target currency) rather than the classic v1 shape\n      // { base, date, rates: { CODE: rate } }. Reading data.rates against\n      // the real response is always undefined, so every conversion used to\n      // throw \"Unknown currency\" no matter which currencies were requested.\n      // Accept both shapes so a future API revision back to the object form\n      // doesn't silently break this again.\n      const rates: Record<string, number> = Array.isArray(data)\n        ? Object.fromEntries(\n            data\n              .filter((entry: unknown): entry is { quote: string; rate: number } => {\n                if (typeof entry !== \"object\" || entry === null) return false;\n                const candidate = entry as { quote?: unknown; rate?: unknown };\n                return typeof candidate.quote === \"string\" && typeof candidate.rate === \"number\";\n              })\n              .map((entry: { quote: string; rate: number }) => [entry.quote.toUpperCase(), entry.rate])\n          )\n        : (data.rates ?? {});\n      if (rates[toUpper] === undefined) throw ErrorFactory.validation(CurrencyErrorCodes.UNKNOWN_CODE, `Unknown currency: ${toUpper}`, { code: toUpper });\n\n      // The API returns ALL rates for the base currency, cache the whole\n      // table so subsequent conversions (including cross pairs via\n      // triangulation) resolve synchronously within the freshness window\n      // instead of going Pending again.\n      this.baseTables.set(fromUpper, {\n        fetchedAt: Date.now(),\n        rates: { ...rates, [fromUpper]: 1 },\n      });\n\n      return rates[toUpper];\n    } finally {\n      cleanup();\n    }\n  }\n\n  /**\n   * Crypto rate fetch, routed through CoinGecko's no-auth simple-price\n   * endpoint instead of Frankfurter (fiat-only, has no BTC/ETH concept).\n   * Handles all three combinations, crypto→crypto, crypto→fiat\n   * fiat→crypto, via prices denominated in USD (or the target fiat\n   * directly, which CoinGecko's `vs_currencies` also accepts), then\n   * caches the result as a same-shaped base table so getRateSync /\n   * convertSync keep working unchanged for crypto pairs too.\n   */\n  private async getCryptoRate(fromUpper: string, toUpper: string, signal?: AbortSignal): Promise<number> {\n    const { signal: fetchSignal, cleanup } = createTimeoutSignal(\n      signal,\n      CurrencyExchangeService.FETCH_TIMEOUT_MS,\n      \"Crypto price API fetch\",\n    );\n\n    try {\n      const fromIsCrypto = this.isCryptoCode(fromUpper);\n      const toIsCrypto = this.isCryptoCode(toUpper);\n      let rate: number;\n\n      if (fromIsCrypto && toIsCrypto) {\n        const fromId = CurrencyExchangeService.CRYPTO_IDS[fromUpper];\n        const toId = CurrencyExchangeService.CRYPTO_IDS[toUpper];\n        const data = await this.fetchCoinGeckoPrices([fromId, toId], \"usd\", fetchSignal);\n        const fromUsd = data[fromId]?.usd;\n        const toUsd = data[toId]?.usd;\n        if (typeof fromUsd !== \"number\") throw ErrorFactory.validation(CurrencyErrorCodes.UNKNOWN_CODE, `Unknown currency: ${fromUpper}`, { code: fromUpper });\n        if (typeof toUsd !== \"number\") throw ErrorFactory.validation(CurrencyErrorCodes.UNKNOWN_CODE, `Unknown currency: ${toUpper}`, { code: toUpper });\n        rate = fromUsd / toUsd;\n      } else if (fromIsCrypto) {\n        const fromId = CurrencyExchangeService.CRYPTO_IDS[fromUpper];\n        const vs = toUpper.toLowerCase();\n        const data = await this.fetchCoinGeckoPrices([fromId], vs, fetchSignal);\n        const value = data[fromId]?.[vs];\n        if (typeof value !== \"number\") throw ErrorFactory.validation(CurrencyErrorCodes.UNKNOWN_CODE, `Unknown currency: ${toUpper}`, { code: toUpper });\n        rate = value;\n      } else {\n        const toId = CurrencyExchangeService.CRYPTO_IDS[toUpper];\n        const vs = fromUpper.toLowerCase();\n        const data = await this.fetchCoinGeckoPrices([toId], vs, fetchSignal);\n        const priceOfToInFrom = data[toId]?.[vs];\n        if (typeof priceOfToInFrom !== \"number\") throw ErrorFactory.validation(CurrencyErrorCodes.UNKNOWN_CODE, `Unknown currency: ${fromUpper}`, { code: fromUpper });\n        rate = 1 / priceOfToInFrom;\n      }\n\n      // Cache as a single-pair base table, same shape Frankfurter fetches\n      // produce, so getRateSync/convertSync's triangulation logic doesn't\n      // need to know or care which source a rate came from.\n      this.baseTables.set(fromUpper, {\n        fetchedAt: Date.now(),\n        rates: { [fromUpper]: 1, [toUpper]: rate },\n      });\n\n      return rate;\n    } finally {\n      cleanup();\n    }\n  }\n\n  private async fetchCoinGeckoPrices(ids: string[], vsCurrency: string, signal: AbortSignal): Promise<Record<string, Record<string, number>>> {\n    const url = `https://api.coingecko.com/api/v3/simple/price?ids=${ids.join(\",\")}&vs_currencies=${vsCurrency}`;\n    const response = await fetch(url, { signal });\n    if (!response.ok) throw ErrorFactory.external(CurrencyErrorCodes.CRYPTO_API_ERROR, `Crypto price API returned ${response.status}`, { status: response.status });\n    return response.json();\n  }\n\n  /**\n   * Seed a base rate table without a network fetch.\n   *\n   * Intended for tests and for future user-provided offline rates\n   * production live data always comes from {@link getRate}. Seeded rates\n   * obey the same freshness window as fetched ones.\n   *\n   * @param base - Base currency code (e.g. \"USD\").\n   * @param rates - Map of currency code → rate relative to the base.\n   */\n  primeRates(base: string, rates: Record<string, number>): void {\n    const baseUpper = base.toUpperCase();\n    this.baseTables.set(baseUpper, {\n      fetchedAt: Date.now(),\n      rates: { ...rates, [baseUpper]: 1 },\n    });\n  }\n\n  /**\n   * Drop every cached/primed rate table.\n   *\n   * Mainly for test isolation: {@link sharedCurrencyExchange} is a\n   * module-level singleton, so a rate primed or fetched by one test can\n   * silently leak into a later test in the same file. Also usable in\n   * production if a caller ever wants to force a full re-fetch.\n   */\n  clearRates(): void {\n    this.baseTables.clear();\n  }\n\n  /**\n   * Synchronous rate lookup: `1` for same-currency pairs, a cached LIVE\n   * rate if one was fetched within {@link RATE_FRESHNESS_MS}, otherwise\n   * `null`, callers fall through to the async fetch path and the\n   * expression shows Pending until real data arrives.\n   *\n   * There is deliberately no hardcoded fallback table: a stale made-up\n   * rate presented as a real conversion is worse than a Pending state.\n   */\n  getRateSync(from: string, to: string): number | null {\n    const fromUpper = from.toUpperCase();\n    const toUpper = to.toUpperCase();\n    if (fromUpper === toUpper) {\n      return 1;\n    }\n    const now = Date.now();\n    for (const table of this.baseTables.values()) {\n      if (now - table.fetchedAt > CurrencyExchangeService.RATE_FRESHNESS_MS) continue;\n      const fromRate = table.rates[fromUpper];\n      const toRate = table.rates[toUpper];\n      if (fromRate && toRate) {\n        return toRate / fromRate;\n      }\n    }\n    return null;\n  }\n\n  /** Convert `value` from `from` to `to` using a freshly-fetched live rate (see {@link getRate}). */\n  async convert(value: number, from: string, to: string): Promise<number> {\n    const rate = await this.getRate(from, to);\n    return value * rate;\n  }\n\n  /**\n   * Get all currently cached fresh rates, keyed \"FROM:TO\".\n   * @returns Snapshot of fresh live rates, or null when none are cached.\n   */\n  getAllRates(): Record<string, number> | null {\n    const now = Date.now();\n    const snapshot: Record<string, number> = {};\n    let any = false;\n    for (const [base, table] of this.baseTables) {\n      if (now - table.fetchedAt > CurrencyExchangeService.RATE_FRESHNESS_MS) continue;\n      for (const [code, rate] of Object.entries(table.rates)) {\n        snapshot[`${base}:${code}`] = rate;\n        any = true;\n      }\n    }\n    return any ? snapshot : null;\n  }\n\n  /**\n   * Check whether any fresh live rates are currently cached.\n   */\n  hasRates(): boolean {\n    return this.getAllRates() !== null;\n  }\n\n  /**\n   * Synchronous conversion using cached rates only\n   * Returns null if rate not in cache\n   */\n  convertSync(value: number, from: string, to: string): number | null {\n    const rate = this.getRateSync(from, to);\n    if (rate === null) return null;\n    return value * rate;\n  }\n\n  // ------------------------------------------------------------------------\n  // CURRENCY VALIDATION\n  // ------------------------------------------------------------------------\n\n  /**\n   * Check whether `code` is a recognized currency code (fiat or the\n   * cryptocurrencies in {@link CRYPTO_IDS}), a fixed allowlist, not a\n   * live lookup against any API.\n   */\n  isCurrency(code: string): boolean {\n    // Check against known currency codes\n    const knownCurrencies = [\n      \"USD\", \"EUR\", \"GBP\", \"JPY\", \"AUD\", \"CAD\", \"CHF\", \"CNY\", \"SEK\", \"NOK\",\n      \"DKK\", \"NZD\", \"KRW\", \"SGD\", \"HKD\", \"INR\", \"BRL\", \"ZAR\", \"MXN\", \"RUB\",\n      \"TRY\", \"SAR\", \"AED\", \"ILS\", \"PLN\", \"CZK\", \"HUF\", \"THB\", \"IDR\", \"MYR\",\n      \"PHP\", \"CLP\", \"COP\", \"ARS\", \"NGN\", \"EGP\", \"PKR\", \"BDT\", \"VND\", \"KES\",\n      \"MAD\", \"QAR\", \"KWD\", \"OMR\", \"BHD\", \"JOD\",\n      \"BTC\", \"ETH\", \"SOL\", \"XRP\", \"ADA\", \"DOGE\", \"DOT\",\n    ];\n    return knownCurrencies.includes(code.toUpperCase());\n  }\n\n}\n\n// ============================================================================\n// SINGLETON INSTANCE\n// ============================================================================\n\n/** The shared rate cache. See {@link CurrencyExchangeService} for why it is shared. */\nexport const currencyExchangeService = new CurrencyExchangeService();\n\n// Export for backward compatibility\n/** Alias for {@link currencyExchangeService}, kept for older imports. */\nexport const sharedCurrencyExchange = currencyExchangeService;\n\n// Default export\nexport default currencyExchangeService;\n"]}

package/dist/chunk-XVWCOTR6.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lexer/ExpressionLexer.ts"],"names":["input","text"],"mappings":"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","file":"chunk-XVWCOTR6.js","sourcesContent":["import { Token, tokenTypeId, registerAllTokenTypes } from '@solve-js/lexer/Token';\nimport { knownUnits } from '@solve-js/lexer/units';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { ErrorFactory } from '@solve-js/errors/UnifiedErrorFramework';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\n\n// Bootstrap all token types at module load\nregisterAllTokenTypes();\n\n// ── Markdown line classification (Phase B) ──────────────────────────────\n\n/** What a line is, structurally, before anything tries to evaluate it. */\nexport type MarkdownLineType =\n  | 'expression'\n  | 'prose'\n  | 'heading'\n  | 'blockquote'\n  | 'list'\n  | 'code_fence'\n  | 'math_fence'\n  | 'table'\n  | 'table_separator'\n  | 'hr'\n  | 'wikilink'\n  | 'comment'\n  | 'empty';\n\n/**\n * What a line is and whether it holds anything to evaluate.\n *\n * Produced by a character-level scan that never consults the keyword, unit or\n * operator tables, so any lexer gives the same answer for the same line. See\n * `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n */\nexport interface LineClassification {\n  /** The type of this markdown line */\n  type: MarkdownLineType;\n  /** Whether this line should be skipped (no expression evaluation) */\n  skip: boolean;\n  /** Whether the line contains inline solve markers (`s`...``) */\n  hasInlineSolve: boolean;\n}\n\n/** Inline solve position with precise coordinates */\nexport interface InlineSolveSpan {\n  /** Character offset of the `s`` marker */\n  start: number;\n  /** Character offset past the closing `` ` `` */\n  end: number;\n  /** The expression text between the backticks */\n  expression: string;\n  /** 1-based column of the `s`` marker */\n  columnNumber: number;\n  /** Token index of INLINE_SOLVE_START in the line's token array (set during tokenization). */\n  startTokenIndex?: number;\n  /** Token index of closing BACKTICK_OPEN in the line's token array (set during tokenization). */\n  endTokenIndex?: number;\n}\n\n/**\n * Result from a single line processed by scanDocument().\n * Combines line classification, tokenized tokens, and inline solve spans\n * into a single structure, eliminating the need for separate classifyLine()\n * findInlineSolves(), and per-line Lexer.reset() calls.\n */\nexport interface ScanLineResult {\n  /** The raw line text (without trailing newline). */\n  text: string;\n  /** 1-based line number within the document. */\n  lineNumber: number;\n  /** Character offset of the line start within the document. */\n  startOffset: number;\n  /** Character offset of the line end (before newline). */\n  endOffset: number;\n  /** The line classification. */\n  classification: LineClassification;\n  /** Tokenized tokens (empty array if line is skipped). */\n  tokens: Token[];\n  /** Inline solve spans found in this line (empty if none). */\n  inlineSolves: InlineSolveSpan[];\n}\n\n// ── Character class constants ─────────────────────────────────────────────\n// Used as the result of the CHAR_CLASS lookup table. V8 compiles the\n// outer switch on these small integer constants into a jump table.\nconst enum CharClass {\n  SKIP       = 0,  // Invalid / control / unicode fallback\n  WHITESPACE = 1,  // space, tab, \\n, \\r\n  DIGIT      = 2,  // 0-9\n  ALPHA      = 3,  // a-z, A-Z, _\n  DOT        = 4,  // . (could be decimal point or DOT token)\n  OPERATOR   = 5,  // + - * / ^ % ( ) [ ] { } , : ; = ? & | ~ ! < >\n  QUOTE      = 6,  // \"\n  HASH       = 7,  // # (comment)\n  DOLLAR     = 8,  // $\n  POUND      = 9,  // £ (U+00A3)\n  EURO       = 10, // € (U+20AC)\n  BACKTICK   = 11, // `\n}\n\n// ── Static character class table (built once at module load) ──────────────\nfunction buildCharClassTable(): Uint8Array {\n  const table = new Uint8Array(128);\n\n  // Digits 0-9\n  for (let i = 48; i <= 57; i++) table[i] = CharClass.DIGIT;\n\n  // Uppercase A-Z\n  for (let i = 65; i <= 90; i++) table[i] = CharClass.ALPHA;\n\n  // Lowercase a-z\n  for (let i = 97; i <= 122; i++) table[i] = CharClass.ALPHA;\n\n  // Underscore\n  table[95] = CharClass.ALPHA;\n\n  // Dot\n  table[46] = CharClass.DOT;\n\n  // Whitespace\n  table[32] = CharClass.WHITESPACE;  // space\n  table[9]  = CharClass.WHITESPACE;  // tab\n  table[10] = CharClass.WHITESPACE;  // \\n\n  table[13] = CharClass.WHITESPACE;  // \\r\n\n  // Operators / punctuation\n  table[33] = CharClass.OPERATOR;  // !\n  table[37] = CharClass.OPERATOR;  // %\n  table[38] = CharClass.OPERATOR;  // &\n  table[40] = CharClass.OPERATOR;  // (\n  table[41] = CharClass.OPERATOR;  // )\n  table[42] = CharClass.OPERATOR;  // *\n  table[43] = CharClass.OPERATOR;  // +\n  table[44] = CharClass.OPERATOR;  // ,\n  table[45] = CharClass.OPERATOR;  // -\n  table[47] = CharClass.OPERATOR;  // /\n  table[58] = CharClass.OPERATOR;  // :\n  table[59] = CharClass.OPERATOR;  // ;\n  table[60] = CharClass.OPERATOR;  // <\n  table[61] = CharClass.OPERATOR;  // =\n  table[62] = CharClass.OPERATOR;  // >\n  table[63] = CharClass.OPERATOR;  // ?\n  table[91] = CharClass.OPERATOR;  // [\n  table[93] = CharClass.OPERATOR;  // ]\n  table[94] = CharClass.OPERATOR;  // ^\n  table[123] = CharClass.OPERATOR; // {\n  table[124] = CharClass.OPERATOR; // |\n  table[125] = CharClass.OPERATOR; // }\n  table[126] = CharClass.OPERATOR; // ~\n  // \"@\" was previously unclassified (defaulted to CharClass.SKIP, silently\n  // dropped before ever reaching OP_MAP). See OP_MAP's own \"@\" entry doc\n  // comment for why this is being activated now.\n  table[64] = CharClass.OPERATOR;  // @\n\n  // Other\n  table[34] = CharClass.QUOTE;    // \"\n  table[35] = CharClass.HASH;     // #\n  table[36] = CharClass.DOLLAR;   // $\n  table[96] = CharClass.BACKTICK; // `\n\n  return table;\n}// ── Monomorphic Token class ───────────────────────────────────────────────\n// V8 assigns a single stable HiddenClass because all properties are\n// initialized in the constructor and never added/removed afterwards.\n// This enables fast property access (inline cache hits) and allows\n// allocation in V8's nursery (cheap GC).\n// All 9 fields are always set, no optional fields, no different shapes.\n/**\n * A token, as the lexer produces it.\n *\n * A class rather than an object literal because tokens are created on every\n * keystroke and a shared hidden class keeps that path predictable for the\n * engine running it.\n */\nexport class LexerToken implements Token {\n  constructor(\n    public type: string,\n    public typeId: number,\n    public value: string,\n    public text: string,\n    public offset: number,\n    public lineBreaks: number,\n    public line: number,\n    public col: number,\n  ) {}\n}\n\n// ── Two-character operator lookup ─────────────────────────────────────────\n// Maps first-char → (second-char → token type). Used for operators like\n// ==, !=, >=, <=, **, <<, >>.\ninterface TwoCharOpMap {\n  [firstChar: number]: { [secondChar: number]: string };\n}\nconst TWO_CHAR_OPS: TwoCharOpMap = {\n  61: { 61: 'EQUALITY', 62: 'THEREFORE' },  // ==, => (opposite char order from >='s GTE below — no collision)\n  33: { 61: 'NEQ' },       // !=\n  62: { 61: 'GTE' },       // >=\n  60: { 61: 'LTE' },       // <=\n  38: { 38: 'LOGICAL_AND' }, // &&\n  124: { 124: 'LOGICAL_OR' }, // ||\n  // Note: ** is NOT a single token, the existing moo lexer emits two\n  // separate STAR tokens, and the parser consumes them that way.\n  // 42: { 42: 'EXPONENT' },  // **, disabled for moo compatibility\n};\n// Note: LSHIFT (<<) and RSHIFT (>>) are handled separately because\n// 60 is also used for LTE, so we check LTE first then LSHIFT.\n\n// ── Single-character operator lookup ──────────────────────────────────────\nconst OP_MAP: Record<number, string> = {\n  43: 'PLUS',     // +\n  45: 'MINUS',    // -\n  42: 'STAR',     // *\n  47: 'SLASH',    // /\n  94: 'CARET',    // ^\n  37: 'PERCENT',  // %\n  40: 'LPAREN',   // (\n  41: 'RPAREN',   // )\n  91: 'LBRACKET', // [\n  93: 'RBRACKET', // ]\n  123: 'LBRACE',  // {\n  125: 'RBRACE',  // }\n  44: 'COMMA',    // ,\n  58: 'COLON',    // :\n  59: 'SEMICOLON',// ;\n  61: 'EQUALS',   // =\n  63: 'QUESTION', // ?\n  33: 'BANG',     // !\n  38: 'BIT_AND',  // &\n  124: 'BIT_OR',  // |\n  60: 'LT',       // <\n  62: 'GT',       // >\n  126: 'BIT_NOT', // ~\n  // \"@\", activates the token type name already dormant-reserved for this\n  // exact purpose (see Token.ts's OVER/RATE_AT doc comment and\n  // normalizer/TokenNormalizer.ts's NON_WORD_NAMES, both of which already\n  // anticipated \"AT\" as a future \"@\" symbol token before this addition).\n  // Backs the time package's video-timecode literal's alternate fps\n  // separator (`01:02:03:04 @ 30fps`, equivalent to `... at 30fps`). See\n  // packages/time/parselets/VideoTimecodeParselet.ts.\n  64: 'AT',       // @\n};\n\n/**\n * Plugin interface for extending the ExpressionLexer with custom tokens.\n *\n * Plugins can register:\n * - `keywords`: Map identifier strings to custom token types (checked after locale keywords).\n * - `operators`: Map multi-character operator sequences to custom token types.\n * - `units`: Register additional unit identifiers (checked alongside built-in units).\n *\n * Multi-word phrase matching has been moved to the TokenNormalizer post-lexer\n * stage. To register phrase patterns, use `IEnginePackage.normalizerRules` instead.\n *\n * All registrations are additive, built-in patterns still work.\n */\nexport interface LexerVocabulary {\n  /**\n   * Keyword → tokenType mappings. Each key is a lowercase identifier that,\n   * when encountered, will emit the specified token type instead of IDENT.\n   * These are checked AFTER the locale's built-in keywordMap, so locale\n   * keywords take priority.\n   */\n  keywords?: Record<string, string>;\n\n  /**\n   * Multi-character operator → tokenType mappings. Each key is the exact\n   * character sequence (e.g., \"::\", \"->\", \"=>\") and the value is the token\n   * type to emit. Two-character operators take priority during matching.\n   * Built-in operators (==, !=, >=, <=, <<, >>) always take priority.\n   */\n  operators?: Record<string, string>;\n\n  /**\n   * Additional unit identifiers to recognize (e.g., \"gp\", \"osrs\", \"tile\").\n   * These are checked alongside the built-in `knownUnits` set.\n   */\n  units?: string[];\n\n  /**\n   * Whole-line patterns matched against the RAW line text, BEFORE any\n   * per-character tokenization begins.\n   *\n   * Every other extension point in this file (`keywords`/`operators`/\n   * `units`, plus `IEnginePackage.phrases`/`normalizerRules`) transforms\n   * a token STREAM -- they all assume the line is, at some granularity,\n   * valid Solve syntax. This hook exists for the one shape that isn't:\n   * a package whose grammar captures arbitrary free-form text terminated\n   * by a fixed marker (e.g. a natural-language query ending in `= ?`),\n   * where the text itself (\"distance to the moon\") would never tokenize\n   * or parse as a normal expression and must be captured verbatim\n   * instead -- see `packages/knowledge/` for the reference use.\n   *\n   * Each entry's `pattern` is tested (via `RegExp.exec`) against the\n   * full, untrimmed line text. If it matches AND capture group 1 is\n   * non-empty after trimming, the ENTIRE line becomes a single\n   * synthetic token of `tokenType` whose `value`/`text` is the trimmed\n   * capture group -- the character-by-character scanner never runs for\n   * that line. Patterns are tried in registration order; the first\n   * match wins. A package registering a rule here still needs a\n   * `prefixParselets` entry for `tokenType` to actually consume the\n   * resulting token.\n   *\n   * Because this bypasses tokenization entirely, a matching line can\n   * contain characters that would otherwise be lexer errors (unmatched\n   * quotes, stray symbols, ...) -- by design, since the whole point is\n   * to hand the package raw text the normal pipeline was never meant to\n   * parse.\n   */\n  rawLinePatterns?: Array<{ pattern: RegExp; tokenType: string }>;\n}\n\n// ── Expression gating (L1) ──────────────────────────────────────────────\n// Pre-computed Set of character codes that indicate an expression might\n// be present. Used by hasExpressionIndicators() to gate prose lines\n// before full tokenization.\n//\n// NOTE: Currently unused, L1 prose gating was removed from classifyFromPositions()\n// because it incorrectly skipped keyword-only lines (\"pi\"), single identifiers\n// (\"hello\"), and short alpha lines. Retained for future re-implementation with\n// keyword-awareness and proper test coverage.\nconst EXPRESSION_INDICATOR_CODES = (() => {\n  const set = new Set<number>();\n  // Digits 0-9\n  for (let i = 48; i <= 57; i++) set.add(i);\n  // Operators / punctuation\n  // Note: colon (58) is intentionally excluded, it's common in prose\n  // (e.g., \"Subject: Hello world\") and would cause false-positive\n  // expression classification. Variable assignment lines like\n  // \":myVar = 5\" are still caught by '=' and digit indicators.\n  const opCodes = [43, 45, 42, 47, 94, 37, 40, 41, 91, 93, 123, 125, 61, 60, 62, 33, 38, 124, 126, 59, 63];\n  for (const c of opCodes) set.add(c);\n  // Currency\n  set.add(36);   // $\n  set.add(0x00A3); // £\n  set.add(0x20AC); // €\n  set.add(0x00A5); // ¥\n  set.add(0x20BD); // ₽\n  set.add(0x20A9); // ₩\n  // Backtick (inline solve)\n  set.add(96);   // `\n  // Dot (could be decimal)\n  set.add(46);   // .\n  // Hash (comment, still an expression indicator)\n  set.add(35);   // #\n  return set;\n})();\n\n// ── ExpressionLexer ───────────────────────────────────────────────────────\n/**\n * Character-by-character tokenizer for expression text.\n *\n * Scans a raw line/expression string into a stream of typed tokens\n * (numbers, identifiers, operators, units, keywords, ...), handling\n * markdown-line classification (`classifyLine`), inline `` s`...` `` solve\n * spans, and package-contributed vocabulary (registered via\n * {@link registerVocabulary}/{@link unregisterVocabulary}, keywords\n * operators, and units a package wants recognized as their own token\n * types rather than falling through to generic identifiers).\n *\n * Most consumers should use the higher-level {@link Lexer} wrapper, which\n * adds streaming `next()`/`peek()` access over this class's scan results.\n */\nexport class ExpressionLexer {\n  private static readonly CHAR_CLASS = buildCharClassTable();\n  /**\n   * Configured TokenLookup from TokenClassRegistry. When set, replaces\n   * the internal keyword map and unit set with registry-built equivalents.\n   * Enables data-driven keyword/unit registration across locale keywords,\n   * provider keywords, and plugins.\n   *\n   * Set at construction time via the constructor parameter. Plugin-registered\n   * keywords/units (via registerVocabulary()) are checked alongside\n   * the configuredLookup, neither source is bypassed.\n   */\tprivate configuredLookup: TokenLookup | null = null;\n\n\t// Instance state\n  private input: string = '';\n  private pos: number = 0;\n  private len: number = 0;\n\n  // Line / column tracking (1-indexed)\n  private line: number = 1;\n  private lineStartPos: number = 0;\n\n  // Keyword map: lowercase identifier → token type (locale keywords only)\n  private keywordMap: Map<string, string>;\n\n  // ── Merged lookup collections (keywordMap + pluginKeywordMap, knownUnits + pluginUnits)\n  private mergedKeywords: Map<string, string>;\n  private mergedUnits: Set<string>;\n\n  // Plugin-extensible keyword map (merged with locale keywordMap)\n  private pluginKeywordMap: Map<string, string> = new Map();\n\n  // Plugin-extensible two-char operators: firstChar → (secondChar → tokenType)\n  private pluginOperators: Map<number, Map<number, string>> = new Map();\n\n  // Plugin-extensible units (merged with knownUnits)\n  private pluginUnits: Set<string> = new Set();\t// Fast-path guards: skip plugin lookups entirely when no plugins registered\n\tprivate hasPluginOps = false;\n\n  // Locale for function-identifier lookups\n  private localeCode: string;\n  private locale: ILocale;\n\n  /**\n   * Inline solve spans collected during the most recent tokenization pass.\n   * Populated by [Symbol.iterator]() and consumed by scanDocument().\n   */\n  _inlineSolveSpans: InlineSolveSpan[] = [];\n\n  // Plugin-extensible raw-line patterns. See LexerVocabulary.rawLinePatterns.\n  private pluginRawLinePatterns: Array<{ pattern: RegExp; tokenType: string }> = [];\n\n  /**\n   * If a `rawLinePatterns` rule matches the FULL text most recently passed\n   * to {@link reset}, this holds the single synthetic token that\n   * {@link tokenizeAll} should return instead of running the\n   * character-by-character scanner. Cleared (re-evaluated) on every\n   * {@link reset} call. `null` when no plugin registered any raw-line\n   * patterns, or none matched, the overwhelmingly common case, checked\n   * with a `length === 0` guard before ever touching this field so a\n   * plugin-free lexer pays zero cost for the feature.\n   */\n  private pendingRawLineToken: Token | null = null;\n\n  /**\n   * Test `text` against every registered `rawLinePatterns` rule, in\n   * registration order. Returns a synthetic token for the first rule\n   * whose `pattern` matches AND whose capture group 1 is non-empty after\n   * trimming; returns `null` if no rule matches (the normal\n   * character-by-character scanner should run instead).\n   */\n  private matchRawLine(text: string): Token | null {\n    for (const rule of this.pluginRawLinePatterns) {\n      const m = rule.pattern.exec(text);\n      if (m && typeof m[1] === 'string') {\n        const value = m[1].trim();\n        if (value.length > 0) {\n          return new LexerToken(rule.tokenType, tokenTypeId(rule.tokenType), value, value, 0, 0, this.line, 1);\n        }\n      }\n    }\n    return null;\n  }\n\n  /** Rebuild merged keyword and unit collections after plugin registration. */\n  private rebuildMergedCollections(): void {\n    this.mergedKeywords = new Map([...this.keywordMap, ...this.pluginKeywordMap]);\n    this.mergedUnits = new Set([...knownUnits, ...this.pluginUnits]);\n  }\n\n  constructor(localeCode = 'en', lookup?: TokenLookup) {\n    this.localeCode = localeCode;\n    this.locale = getLocale(localeCode);\n    this.configuredLookup = lookup ?? null;\n    this.keywordMap = new Map<string, string>();\n    for (const [k, v] of Object.entries(this.locale.keywordMap)) {\n      this.keywordMap.set(k.toLowerCase(), v);\n    }\n    this.mergedKeywords = new Map(this.keywordMap);\n    this.mergedUnits = new Set(knownUnits);\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   *\n   * All registrations are additive, built-in patterns still work.\n   * Keywords, operators, and units from the plugin are merged\n   * with existing ones. Calling multiple times adds more entries.\n   *\n   * Note: multi-word phrases are now handled by the TokenNormalizer\n   * (see `IEnginePackage.normalizerRules`), not the lexer.\n   *\n   * Built-in tokens CANNOT be overridden. Throws a EngineError if the\n   * plugin attempts to register a keyword, operator, or unit\n   * that conflicts with a built-in one.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const [keyword, tokenType] of Object.entries(plugin.keywords)) {\n        const lower = keyword.toLowerCase();\n        // Guard: prevent overriding built-in locale keywords\n        if (this.keywordMap.has(lower)) {\n          throw ErrorFactory.config(\n            'PLUGIN_KEYWORD_COLLISION',\n            `Plugin keyword \"${keyword}\" conflicts with built-in keyword ` +\n            `(type: ${this.keywordMap.get(lower)}). Built-in keywords cannot be overridden.`,\n            { keyword, builtinType: this.keywordMap.get(lower) }\n          );\n        }\n        this.pluginKeywordMap.set(lower, tokenType);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      this.hasPluginOps = true;\n      for (const [chars, tokenType] of Object.entries(plugin.operators)) {\n        // Only support 2-char operators for the fast path\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n\n          // Guard: prevent overriding built-in two-char operators (==, !=, >=, <=)\n          const builtInSecondMap = TWO_CHAR_OPS[first];\n          if (builtInSecondMap && builtInSecondMap[second] !== undefined) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: ${builtInSecondMap[second]}). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: builtInSecondMap[second] }\n            );\n          }\n          // Guard: prevent overriding LSHIFT (<<) and RSHIFT (>>)\n          if (first === 60 && second === 60) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: LSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'LSHIFT' }\n            );\n          }\n          if (first === 62 && second === 62) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: RSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'RSHIFT' }\n            );\n          }\n          // Guard: prevent overriding comment sequences (//)\n          if (first === 47 && second === 47) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in comment sequence. ` +\n              `Comment sequences cannot be overridden.`,\n              { operator: chars, builtinType: 'COMMENT' }\n            );\n          }\n\n          let inner = this.pluginOperators.get(first);\n          if (!inner) {\n            inner = new Map();\n            this.pluginOperators.set(first, inner);\n          }\n          inner.set(second, tokenType);\n        }\n      }\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        // Guard: prevent overriding built-in units\n        if (knownUnits.has(unit)) {\n          throw ErrorFactory.config(\n            'PLUGIN_UNIT_COLLISION',\n            `Plugin unit \"${unit}\" conflicts with a built-in unit. ` +\n            `Built-in units cannot be overridden.`,\n            { unit }\n          );\n        }\n        this.pluginUnits.add(unit);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      this.pluginRawLinePatterns.push(...plugin.rawLinePatterns);\n    }\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   *\n   * This is the inverse of registerVocabulary(). All keywords, operators,\n   * and units registered by the plugin are removed. After\n   * unregistration, those tokens will revert to their default behavior\n   * (e.g., keywords become IDENT, operators become ERROR).\n   *\n   * Calling unregisterVocabulary with a plugin that was never registered\n   * is safe, it simply has no effect.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const keyword of Object.keys(plugin.keywords)) {\n        this.pluginKeywordMap.delete(keyword.toLowerCase());\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      for (const chars of Object.keys(plugin.operators)) {\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n          const inner = this.pluginOperators.get(first);\n          if (inner) {\n            inner.delete(second);\n            if (inner.size === 0) {\n              this.pluginOperators.delete(first);\n            }\n          }\n        }\n      }\n      this.hasPluginOps = this.pluginOperators.size > 0;\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        this.pluginUnits.delete(unit);\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      const toRemove = new Set(plugin.rawLinePatterns);\n      this.pluginRawLinePatterns = this.pluginRawLinePatterns.filter((r) => !toRemove.has(r));\n    }\n  }\n\n  reset(input: string): void {\n    this.input = input;\n    this.pos = 0;\n    this.len = input.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n    this.pendingRawLineToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(input) : null;\n  }\n\n  /**\n   * Scan a full document text in a single pass, classifying each line and\n   * tokenizing non-skipped lines.\n   *\n   * Replaces the separate classifyLine() + findInlineSolves() + per-line\n   * reset() + tokenizeAll() pattern with a single character-by-character\n   * walk through the entire document. Key benefits:\n   *\n   * - **Single reset()**: `this.pos`, `this.len`, `this.line`, and\n   *   `this.lineStartPos` are set once for the whole document, not per-line.\n   * - **Single classification**: classifyLine() runs once per line inline;\n   *   skipped lines are jumped over without tokenization.\n   * - **Shared tokenization**: Non-skipped lines are tokenized using the\n   *   existing state machine, yielding Token[] without per-line reset().\n   * - **Inline solve detection**: findInlineSolves() is called only for\n   *   lines that classifyLine() marks as having inline solves.\n   *\n   * Tokenization is scoped to each line by temporarily restricting\n   * `this.len` to the line end position, so the [Symbol.iterator]\n   * generator naturally stops at the line boundary. After tokenization,\n   * `this.len` is restored and `this.pos` advances past the newline.\n   *\n   * @param text The full document text (with newlines).\n   * @returns Array of ScanLineResult, one per line, in document order.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    this.input = text;\n    this.pos = 0;\n    this.len = text.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n\n    const results: ScanLineResult[] = [];\n    const input = this.input;\n    const docLen = this.len;\n\n    while (this.pos < docLen) {\n      const lineStart = this.pos;\n\n      // ── Find end of current line (newline boundary) ───────────────\n      let lineEnd = this.pos;\n      while (lineEnd < docLen) {\n        const cc = input.charCodeAt(lineEnd);\n        if (cc === 10 || cc === 13) break;  // \\n or \\r\n        lineEnd++;\n      }\n\n      const lineNumber = this.line;\n\n      // ── Classify the line ─────────────────────────────────────────\n      // Uses classifyFromPositions() to read from this.input directly\n      // avoids allocating a substring and keeps classification reads\n      // within the same memory region as tokenization.\n      const classification = this.classifyFromPositions(lineStart, lineEnd);\n\n      // ── Slice line text for ScanLineResult.text ────────────────\n      // Hoisted above tokenization (rather than after, as originally) so the\n      // raw-line-pattern check below can test the exact substring a plugin\n      // registered via `LexerVocabulary.rawLinePatterns`. See reset()/\n      // tokenizeAll() for the single-expression-string equivalent of this\n      // same check.\n      const lineText = input.slice(lineStart, lineEnd);\n\n      // ── Tokenize non-skipped lines ────────────────────────────────\n      let tokens: Token[] = [];\n      if (!classification.skip) {\n        const rawToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(lineText) : null;\n        if (rawToken) {\n          tokens = [rawToken];\n        } else {\n          // Scope tokenization to just this line by temporarily restricting len.\n          // The [Symbol.iterator]() generator captures `this.len` at call time,\n          // so creating the iterator AFTER setting this.len = lineEnd ensures\n          // tokenization stops at the line boundary. After tokenization,\n          // this.pos will be at lineEnd (the newline position).\n          const savedLen = this.len;\n          this.len = lineEnd;\n          tokens = Array.from(this);\n          this.len = savedLen;\n          // this.pos is now at lineEnd, advance past newline below\n        }\n      }\n\n      // ── Detect inline solves ──────────────────────────────────────\n      // Two data sources are merged:\n      //   1. _inlineSolveSpans, token indices collected inline during\n      //      [Symbol.iterator](). Provides correct startTokenIndex /\n      //      endTokenIndex. Also handles \\` escape (skips the pair\n      //      instead of closing the span early).\n      //   2. findInlineSolves(), character-level string scan for\n      //      expression text. Still needed because token-based\n      //      reconstruction loses whitespace (the lexer skips spaces),\n      //      which breaks multi-word expressions like\n      //      \"2 weeks in days\" → \"2weeksindays\" (wrong tokenization).\n      let inlineSolves: InlineSolveSpan[] = [];\n      if (classification.hasInlineSolve) {\n        if (!classification.skip && tokens.length > 0) {\n          const charSpans = this.findInlineSolves(lineText);\n          inlineSolves = this._inlineSolveSpans.map((span, i) => ({\n            start: charSpans[i]?.start ?? 0,\n            end: charSpans[i]?.end ?? 0,\n            expression: charSpans[i]?.expression ?? '',\n            columnNumber: charSpans[i]?.columnNumber ?? span.columnNumber,\n            startTokenIndex: span.startTokenIndex,\n            endTokenIndex: span.endTokenIndex,\n          }));\n        } else {\n          // Skipped lines weren't tokenized, fall back to string scan\n          inlineSolves = this.findInlineSolves(lineText);\n        }\n      }\n\n      results.push({\n        text: lineText,\n        lineNumber,\n        startOffset: lineStart,\n        endOffset: lineEnd,\n        classification,\n        tokens,\n        inlineSolves,\n      });\n\n      // ── Advance past newline ─────────────────────────────────────\n      this.pos = lineEnd;\n      if (this.pos < docLen) {\n        const nlChar = input.charCodeAt(this.pos);\n        if (nlChar === 13) {  // \\r\n          this.pos++;\n          if (this.pos < docLen && input.charCodeAt(this.pos) === 10) {\n            this.pos++;  // skip \\n in \\r\\n\n          }\n        } else if (nlChar === 10) {  // \\n\n          this.pos++;\n        }\n      }\n      this.line++;\n      this.lineStartPos = this.pos;\n    }\n\n    return results;\n  }\n\n  /**\n   * Tokenize an expression string into an array of Tokens.\n   *\n   * Delegates to the lazy [Symbol.iterator]() generator and collects all\n   * yielded tokens via Array.from(). For memory-sensitive use cases, prefer\n   * iterating the lexer directly with for...of to avoid array allocation.\n   *\n   * Optimizations:\n   *  - CHAR_CLASS jump table (Uint8Array) → switch on small integers\n   *  - Direct character-code dispatch (c0 cached pattern)\n   *  - Mathematical digit parsing (integer math, not slice+parseFloat)\n   *  - Inline operator tokenizer with two-char peek-ahead\n   *  - Whitespace eliminated in-lexer (never emitted)\n   *  - 0-char and 1-char fast paths\n   */\n  tokenizeAll(): Token[] {\n    if (this.pendingRawLineToken) {\n      this._inlineSolveSpans = [];\n      return [this.pendingRawLineToken];\n    }\n    return Array.from(this);\n  }\n\n  // ── Lazy iterator ─────────────────────────────────────────────────────\n  /**\n   * Lazy token-by-token generator. Yields each token without allocating an\n   * intermediate Token[] array. Supports for...of and spread usage.\n   *\n   * Usage:\n   *   for (const t of lexer) { ... }  // lazy, no array allocation\n   *   const tokens = [...lexer];       // materializes via spread\n   *   const tokens = lexer.tokenizeAll(); // materializes via Array.from()\n   *\n   * IMPORTANT: This generator captures `this.len` ONCE at creation time\n   * (const len = this.len). `scanDocument()` relies on this behavior to\n   * scope tokenization to a single line by temporarily restricting\n   * `this.len` to the line end position before creating the iterator.\n   * Do NOT refactor to re-read `this.len` mid-loop without also updating\n   * `scanDocument()`.\n   */\n  *[Symbol.iterator](): Generator<Token, void, undefined> {\n    const len = this.len;\n\n    // ── 0-char fast path ────────────────────────────────────────────────\n    if (len === 0) { this._inlineSolveSpans = []; return; }\n\n    // Inline solve tracking state, collected inline during tokenization\n    let tokenIndex = 0;\n    let openSpan: { startTokenIndex: number; startColumn: number } | null = null;\n    const collectedSpans: InlineSolveSpan[] = [];\n\n    // ── 1-char fast path ────────────────────────────────────────────────\n    if (len === 1) {\n      const c0 = this.input.charCodeAt(0);\n      const cc = ExpressionLexer.CHAR_CLASS[c0] ?? CharClass.SKIP;\n\n      switch (cc) {\n        case CharClass.DIGIT:\n        case CharClass.DOT:\n          yield new LexerToken('NUMBER', tokenTypeId('NUMBER'), this.input, this.input, 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        case CharClass.ALPHA: {\n          const input = this.input;\n          const identLower = input.toLowerCase();\n          // Use pre-merged collections (built-in + plugin), single lookup each\n          if (this.mergedUnits.has(input)) {\n            yield new LexerToken('UNIT', tokenTypeId('UNIT'), input, input, 0, 0, 1, 1);\n          } else {\n            const kwType = this.mergedKeywords.get(identLower);\n            if (kwType) {\n              yield new LexerToken(kwType, tokenTypeId(kwType), input, input, 0, 0, 1, 1);\n            } else {\n              yield new LexerToken('IDENT', tokenTypeId('IDENT'), input, input, 0, 0, 1, 1);\n            }\n          }\n          tokenIndex++;\n          break;\n        }\n\n        case CharClass.OPERATOR: {\n          const opType = OP_MAP[c0];\n          if (opType) {\n            yield new LexerToken(opType, tokenTypeId(opType), this.input, this.input, 0, 0, 1, 1);\n            tokenIndex++;\n          }\n          break;\n        }\n\n        case CharClass.QUOTE:\n          // Delegate to tokenizeString for correctness (handles unterminated)\n          this.pos = 0;\n          yield this.tokenizeString();\n          tokenIndex++;\n          break;\n\n        case CharClass.HASH:\n          // Delegate to tokenizeComment for correctness\n          this.pos = 0;\n          yield this.tokenizeComment();\n          tokenIndex++;\n          break;\n\n        case CharClass.DOLLAR:\n          yield new LexerToken('DOLLAR', tokenTypeId('DOLLAR'), '$', '$', 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        case CharClass.BACKTICK:\n          // s` is 2 chars, openSpan can never be set in the 1-char fast path\n          yield new LexerToken('BACKTICK_OPEN', tokenTypeId('BACKTICK_OPEN'), '`', '`', 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        default: {\n          // CharClass.SKIP, includes non-ASCII characters (code >= 128)\n          if (c0 === 0x00D7) {  // × → STAR\n            yield new LexerToken('STAR', tokenTypeId('STAR'), '\\u00D7', '\\u00D7', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00F7) {  // ÷ → SLASH\n            yield new LexerToken('SLASH', tokenTypeId('SLASH'), '\\u00F7', '\\u00F7', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x2260) {  // ≠ → NEQ\n            yield new LexerToken('NEQ', tokenTypeId('NEQ'), '\\u2260', '\\u2260', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00A3) {  // £\n            yield new LexerToken('POUND', tokenTypeId('POUND'), '\\u00A3', '\\u00A3', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AC) {  // €\n            yield new LexerToken('EURO', tokenTypeId('EURO'), '\\u20AC', '\\u20AC', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00A5) {  // ¥\n            yield new LexerToken('YEN', tokenTypeId('YEN'), '¥', '¥', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20BD) {  // ₽\n            yield new LexerToken('RUBLE', tokenTypeId('RUBLE'), '₽', '₽', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20A9) {  // ₩\n            yield new LexerToken('WON', tokenTypeId('WON'), '₩', '₩', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B9) {  // ₹ (Indian rupee) — see uom/CurrencyAliases.ts\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₹', '₹', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20BA) {  // ₺ (Turkish lira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₺', '₺', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B4) {  // ₴ (Ukrainian hryvnia)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₴', '₴', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AA) {  // ₪ (Israeli new shekel)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₪', '₪', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AB) {  // ₫ (Vietnamese dong)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₫', '₫', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20A6) {  // ₦ (Nigerian naira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₦', '₦', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B1) {  // ₱ (Philippine peso)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₱', '₱', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 >= 128) {\n            // Unknown unicode, treat as IDENT for forward compatibility\n            yield new LexerToken('IDENT', tokenTypeId('IDENT'), this.input, this.input, 0, 0, 1, 1);\n            tokenIndex++;\n          }\n          break;\n        }\n      }\n      this._inlineSolveSpans = collectedSpans;\n      return;\n    }\n\n    const input = this.input;\n\n    // ── Main tokenization loop ──────────────────────────────────────────\n    while (this.pos < len) {\n      const c0 = input.charCodeAt(this.pos);\n      const cc = ExpressionLexer.CHAR_CLASS[c0] ?? CharClass.SKIP;\n\n      // ── Escaped backtick inside inline solve ────────────────────────\n      // \\` is treated as an escaped backtick, skip both characters\n      // without closing the inline solve span. Without this, the\n      // backtick would close the span early, producing wrong expression\n      // text for expressions like s`hello \\` world`.\n      if (openSpan && c0 === 92 && this.pos + 1 < len && input.charCodeAt(this.pos + 1) === 96) {\n        this.pos += 2;  // skip \\ and `\n        continue;\n      }\n\n      switch (cc) {\n        // ── Whitespace, skip entirely, track newlines ────────────────\n        case CharClass.WHITESPACE:\n          this.pos++;\n          if (c0 === 10) {  // \\n\n            this.line++;\n            this.lineStartPos = this.pos;\n          } else if (c0 === 13) {  // \\r\n            this.line++;\n            if (this.pos < len && input.charCodeAt(this.pos) === 10) {\n              this.pos++;  // skip \\n in \\r\\n\n            }\n            this.lineStartPos = this.pos;\n          }\n          break;\n\n        // ── Digit, inline number tokenizer ───────────────────────────\n        case CharClass.DIGIT:\n          yield this.tokenizeNumber();\n          tokenIndex++;\n          break;\n\n        // ── Alpha / underscore, identifier or keyword ────────────────\n        case CharClass.ALPHA: {\n          const token = this.tokenizeIdentifier();\n          if (token.type === 'INLINE_SOLVE_START') {\n            openSpan = { startTokenIndex: tokenIndex, startColumn: token.col };\n          }\n          yield token;\n          tokenIndex++;\n          break;\n        }\n\n        // ── Dot, could be decimal (.5) or DOT token ─────────────────\n        case CharClass.DOT:\n          if (this.pos + 1 < len) {\n            const nextCc = ExpressionLexer.CHAR_CLASS[input.charCodeAt(this.pos + 1)] ?? CharClass.SKIP;\n            if (nextCc === CharClass.DIGIT) {\n              yield this.tokenizeNumber();\n            } else {\n              const col = this.pos - this.lineStartPos + 1;\n              yield new LexerToken('DOT', tokenTypeId('DOT'), '.', '.', this.pos, 0, this.line, col);\n              this.pos++;\n            }\n          } else {\n            const col = this.pos - this.lineStartPos + 1;\n            yield new LexerToken('DOT', tokenTypeId('DOT'), '.', '.', this.pos, 0, this.line, col);\n            this.pos++;\n          }\n          tokenIndex++;\n          break;\n\n        // ── Operator / punctuation ────────────────────────────────────\n        case CharClass.OPERATOR:\n          yield this.tokenizeOperator();\n          tokenIndex++;\n          break;\n\n        // ── String literal ────────────────────────────────────────────\n        case CharClass.QUOTE:\n          yield this.tokenizeString();\n          tokenIndex++;\n          break;\n\n        // ── Comment (# or //) ─────────────────────────────────────────\n        case CharClass.HASH:\n          yield this.tokenizeComment();\n          tokenIndex++;\n          break;\n\n        // ── Dollar sign $ ─────────────────────────────────────────────\n        case CharClass.DOLLAR: {\n          const col = this.pos - this.lineStartPos + 1;\n          yield new LexerToken('DOLLAR', tokenTypeId('DOLLAR'), '$', '$', this.pos, 0, this.line, col);\n          this.pos++;\n          tokenIndex++;\n          break;\n        }\n\n        // ── Backtick ` ───────────────────────────────────────────────\n        case CharClass.BACKTICK: {\n          const col = this.pos - this.lineStartPos + 1;\n          yield new LexerToken('BACKTICK_OPEN', tokenTypeId('BACKTICK_OPEN'), '`', '`', this.pos, 0, this.line, col);\n          this.pos++;\n          if (openSpan) {\n            const span = openSpan;  // narrow for TS\n            collectedSpans.push({\n              start: 0, end: 0, expression: '',\n              columnNumber: span.startColumn,\n              startTokenIndex: span.startTokenIndex,\n              endTokenIndex: tokenIndex,\n            });\n            openSpan = null;\n          }\n          tokenIndex++;\n          break;\n        }\n\n        // ── Non-ASCII characters ─────────────────────────────────────\n        default: {\n          const col = this.pos - this.lineStartPos + 1;\n          if (c0 === 0x00D7) {  // × → STAR\n            yield new LexerToken('STAR', tokenTypeId('STAR'), '\\u00D7', '\\u00D7', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00F7) {  // ÷ → SLASH\n            yield new LexerToken('SLASH', tokenTypeId('SLASH'), '\\u00F7', '\\u00F7', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x2260) {  // ≠ → NEQ\n            yield new LexerToken('NEQ', tokenTypeId('NEQ'), '\\u2260', '\\u2260', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00A3) {  // £\n            yield new LexerToken('POUND', tokenTypeId('POUND'), '\\u00A3', '\\u00A3', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AC) {  // €\n            yield new LexerToken('EURO', tokenTypeId('EURO'), '\\u20AC', '\\u20AC', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00A5) {  // ¥\n            yield new LexerToken('YEN', tokenTypeId('YEN'), '¥', '¥', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20BD) {  // ₽\n            yield new LexerToken('RUBLE', tokenTypeId('RUBLE'), '₽', '₽', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20A9) {  // ₩\n            yield new LexerToken('WON', tokenTypeId('WON'), '₩', '₩', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B9) {  // ₹ (Indian rupee) — see uom/CurrencyAliases.ts\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₹', '₹', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20BA) {  // ₺ (Turkish lira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₺', '₺', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B4) {  // ₴ (Ukrainian hryvnia)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₴', '₴', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AA) {  // ₪ (Israeli new shekel)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₪', '₪', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AB) {  // ₫ (Vietnamese dong)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₫', '₫', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20A6) {  // ₦ (Nigerian naira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₦', '₦', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B1) {  // ₱ (Philippine peso)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₱', '₱', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 >= 128) {\n            // Unknown unicode, treat as IDENT for forward compatibility.\n            // tokenizeIdentifier() now includes cc >= 128 in its reading loop,\n            // so this properly advances past all consecutive Unicode chars.\n            yield this.tokenizeIdentifier();\n            tokenIndex++;\n          } else {\n            // Unknown ASCII, silently skip\n            this.pos++;\n          }\n          break;\n        }\n      }\n    }\n    this._inlineSolveSpans = collectedSpans;\n  }\n\n  // ── Inline number tokenizer ────────────────────────────────────────────\n  /**\n   * Character-by-character number parsing.\n   *\n   * Supports: integers, floats, scientific notation (1.5e10, 1.5e-10),\n   * hex (0xFF), binary (0b1010), octal (0o17), BigInt suffix (123n),\n   * thousands separators (1,234 or 1.234.567).\n   *\n   * Returns a LexerToken and advances `this.pos` past the number.\n   */\n  private tokenizeNumber(): Token {\n    const input = this.input;\n    const len = this.len;\n    let pos = this.pos;\n    const start = pos;\n    const startCol = pos - this.lineStartPos + 1;\n    let cc: number;\n\n    // ── Hex literal: 0x / 0X ───────────────────────────────────────────\n    if (input.charCodeAt(pos) === 48 && pos + 1 < len) {\n      const next = input.charCodeAt(pos + 1);\n      if (next === 0x78 || next === 0x58) {  // 'x' or 'X'\n        pos += 2;\n        while (\n          pos < len &&\n          ((cc = input.charCodeAt(pos)),\n            (cc >= 48 && cc <= 57) || (cc >= 65 && cc <= 70) || (cc >= 97 && cc <= 102))\n        ) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n      // ── Binary literal: 0b / 0B ─────────────────────────────────────\n      if (next === 0x62 || next === 0x42) {  // 'b' or 'B'\n        pos += 2;\n        while (pos < len && ((cc = input.charCodeAt(pos)), cc === 48 || cc === 49)) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n      // ── Octal literal: 0o / 0O ───────────────────────────────────────\n      if (next === 0x6F || next === 0x4F) {  // 'o' or 'O'\n        pos += 2;\n        while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 55)) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n    }\n\n    let hasIntPart = false;\n\n    // ── Integer part ───────────────────────────────────────────────────\n    while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n      hasIntPart = true;\n      pos++;\n    }\n\n    // ── Thousands separators, coalesce with digits ────────────────────\n    while (hasIntPart && pos < len && (input.charCodeAt(pos) === 44 || input.charCodeAt(pos) === 46)) {\n      if (pos + 4 <= len) {\n        const d1 = input.charCodeAt(pos + 1);\n        const d2 = input.charCodeAt(pos + 2);\n        const d3 = input.charCodeAt(pos + 3);\n        // A genuine thousands group is always exactly 3 digits, followed\n        // by either another separator, or a non-digit (end of number,\n        // operator, unit, EOF), never a 4th consecutive digit. Without\n        // this check, a plain decimal fraction with 4+ digits after the\n        // point, e.g. \"0.0001\", had its first 3 fractional digits\n        // misread as a \".\" thousands-group, silently truncating the\n        // number to \"0.000\" and leaving the remaining digit(s) as a\n        // separate, unrelated NUMBER token right after it (so\n        // \"0.0001 BTC to USD\" tokenized as \"0.000\", \"1\", \"BTC\", \"to\",\n        // \"USD\", two number literals instead of one, and evaluated to\n        // a bare 0 instead of a real BTC quantity).\n        const d4 = pos + 4 < len ? input.charCodeAt(pos + 4) : -1;\n        const isGroupOfExactlyThree = !(d4 >= 48 && d4 <= 57);\n        if (\n          d1 >= 48 && d1 <= 57 &&\n          d2 >= 48 && d2 <= 57 &&\n          d3 >= 48 && d3 <= 57 &&\n          isGroupOfExactlyThree\n        ) {\n          pos += 4;\n          hasIntPart = true;\n          continue;\n        }\n      }\n      break;\n    }\n\n    // ── Decimal part (.xxx) ───────────────────────────────────────────\n    let hasDecimal = false;\n    if (pos < len && input.charCodeAt(pos) === 46) {\n      if (pos + 1 < len) {\n        const nextCc = input.charCodeAt(pos + 1);\n        if (nextCc >= 48 && nextCc <= 57) {\n          hasDecimal = true;\n          pos++;\n          while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n            pos++;\n          }\n        }\n      }\n    }\n\n    // ── Exponent (e / E [+-]? \\n+) ────────────────────────────────────\n    let hasExponent = false;\n    if (pos < len) {\n      const ec = input.charCodeAt(pos);\n      if (ec === 0x65 || ec === 0x45) {  // 'e' or 'E'\n        if (pos + 1 < len) {\n          const next = input.charCodeAt(pos + 1);\n          if (\n            (next >= 48 && next <= 57) ||\n            next === 43 || next === 45  // + or -\n          ) {\n            hasExponent = true;\n            pos++;\n            if (next === 43 || next === 45) pos++;\n            while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n              pos++;\n            }\n          }\n        }\n      }\n    }\n\n    // ── BigInt suffix check ────────────────────────────────────────────\n    if (pos < len && input.charCodeAt(pos) === 110) {  // 'n'\n      if (hasIntPart && !hasDecimal && !hasExponent) {\n        pos++;\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('BIGINT', tokenTypeId('BIGINT'), text, text, start, 0, this.line, startCol);\n      }\n    }\n\n    // ── Emit NUMBER token ──────────────────────────────────────────────\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n  }\n\n  // ── Inline identifier / keyword tokenizer ──────────────────────────────\n  /**\n   * Reads [a-zA-Z_][a-zA-Z0-9_]* and resolves to:\n   *   - A unit type (via knownUnits, case-sensitive)\n   *   - A keyword type (via locale keywordMap, case-insensitive)\n   *   - IDENT if none of the above\n   *\n   * Multi-word phrases (e.g., \"to the power of\") are handled by the\n   * TokenNormalizer post-lexer pass, not the lexer.\n   */\n  private tokenizeIdentifier(): Token {\n    const input = this.input;\n    const len = this.len;\n    let pos = this.pos;\n    const start = pos;\n    const startCol = pos - this.lineStartPos + 1;\n    let cc: number;\n\n    // Read [a-zA-Z0-9_]* plus any Unicode (>= 128) including emoji surrogate pairs.\n    // Without this, non-ASCII characters cause an infinite loop: the default case\n    // calls tokenizeIdentifier(), the while loop doesn't match the Unicode char,\n    // pos never advances, and the outer loop re-reads the same char forever.\n    while (\n      pos < len &&\n      ((cc = input.charCodeAt(pos)),\n        (cc >= 48 && cc <= 57) ||   // 0-9\n        (cc >= 65 && cc <= 90) ||   // A-Z\n        (cc >= 97 && cc <= 122) ||  // a-z\n        cc === 95 ||                 // _\n        cc >= 128)                   // Unicode (accented chars, emoji, etc.)\n    ) {\n      pos++;\n    }\n\n    const identText = input.slice(start, pos);\n    const identLower = identText.toLowerCase();\n\n    // ── Inline solve marker: s` (lowercase 's' followed by backtick) ──\n    if (identLower === 's' && pos < len && input.charCodeAt(pos) === 96) {\n      pos++;\n      this.pos = pos;\n      const fullText = input.slice(start, pos);\n      return new LexerToken('INLINE_SOLVE_START', tokenTypeId('INLINE_SOLVE_START'), fullText, fullText, start, 0, this.line, startCol);\n    }\n\n    // ── Unit lookup (case-sensitive)\n    const isKnownUnit = this.mergedUnits.has(identText);\n    if (isKnownUnit) {\n      if (!this.isFollowedByLParen(pos)) {\n        this.pos = pos;\n        return new LexerToken('UNIT', tokenTypeId('UNIT'), identText, identText, start, 0, this.line, startCol);\n      }\n    }\n\n    // ── Keyword lookup (case-insensitive)\n    const localeKwType = this.mergedKeywords.get(identLower);\n    if (localeKwType) {\n      this.pos = pos;\n      return new LexerToken(localeKwType, tokenTypeId(localeKwType), identText, identText, start, 0, this.line, startCol);\n    }\n\n    // ── Fall through: emit IDENT\n    // Multi-word phrases are now handled by the TokenNormalizer post-lexer pass,\n    // which keeps the lexer slim and focused on single-token production.\n    this.pos = pos;\n    return new LexerToken('IDENT', tokenTypeId('IDENT'), identText, identText, start, 0, this.line, startCol);\n  }\n\n  /**\n   * Peek past in-expression whitespace (space, tab) from `pos` to check\n   * if the next significant character is '('.\n   */\n  private isFollowedByLParen(pos: number): boolean {\n    const len = this.len;\n    let lookPos = pos;\n    while (lookPos < len) {\n      const cc = this.input.charCodeAt(lookPos);\n      if (cc === 40) return true;\n      if (cc !== 32 && cc !== 9) break;\n      lookPos++;\n    }\n    return false;\n  }\n\n  // ── Inline operator tokenizer ─────────────────────────────────────────\n  /**\n   * Reads an operator/punctuation token.\n   * Handles two-char operators (==, !=, >=, <=, **) and the special\n   * cases << (LSHIFT) and >> (RSHIFT).\n   */\n  private tokenizeOperator(): Token {\n    const input = this.input;\n    const pos = this.pos;\n    const col = pos - this.lineStartPos + 1;\n    const c0 = input.charCodeAt(pos);\n    const len = this.len;\n\n    // ── Two-character operators ────────────────────────────────────────\n    if (pos + 1 < len) {\n      const c1 = input.charCodeAt(pos + 1);\n\n      // ==, !=, >=, <=\n      const secondMap = TWO_CHAR_OPS[c0];\n      if (secondMap) {\n        const twoCharType = secondMap[c1];\n        if (twoCharType) {\n          const text = input.slice(pos, pos + 2);\n          this.pos = pos + 2;\n          return new LexerToken(twoCharType, tokenTypeId(twoCharType), text, text, pos, 0, this.line, col);\n        }\n      }\n\n      // // comment\n      if (c0 === 47 && c1 === 47) {\n        let commentPos = pos + 2;\n        while (commentPos < len) {\n          const cc = input.charCodeAt(commentPos);\n          if (cc === 10 || cc === 13) break;\n          commentPos++;\n        }\n        const text = input.slice(pos, commentPos);\n        this.pos = commentPos;\n        return new LexerToken('COMMENT', tokenTypeId('COMMENT'), text, text, pos, 0, this.line, col);\n      }\n\n      // << (LSHIFT), >> (RSHIFT) and >>> (URSHIFT).\n      //\n      // >>> is tested before >>, or the two-char match would consume the first\n      // two angle brackets and leave a stray > for the parser to choke on.\n      if (c0 === 60 && c1 === 60) {\n        this.pos = pos + 2;\n        return new LexerToken('LSHIFT', tokenTypeId('LSHIFT'), '<<', '<<', pos, 0, this.line, col);\n      }\n      if (c0 === 62 && c1 === 62) {\n        if (input.charCodeAt(pos + 2) === 62) {\n          this.pos = pos + 3;\n          return new LexerToken('URSHIFT', tokenTypeId('URSHIFT'), '>>>', '>>>', pos, 0, this.line, col);\n        }\n        this.pos = pos + 2;\n        return new LexerToken('RSHIFT', tokenTypeId('RSHIFT'), '>>', '>>', pos, 0, this.line, col);\n      }\n\n      // ── Plugin-registered two-char operators ──────────────────────\n      if (this.hasPluginOps) {\n        const pluginInner = this.pluginOperators.get(c0);\n        if (pluginInner) {\n          const pluginType = pluginInner.get(c1);\n          if (pluginType) {\n            const text = input.slice(pos, pos + 2);\n            this.pos = pos + 2;\n            return new LexerToken(pluginType, tokenTypeId(pluginType), text, text, pos, 0, this.line, col);\n          }\n        }\n      }\n    }\n\n    // ── Single-character operator ──────────────────────────────────────\n    this.pos = pos + 1;\n    const opType = OP_MAP[c0];\n    const text = input.charAt(pos);\n    return new LexerToken(opType || 'ERROR', tokenTypeId(opType || 'ERROR'), text, text, pos, 0, this.line, col);\n  }\n\n  // ── String literal tokenizer ──────────────────────────────────────────\n  /**\n   * Reads a double-quoted string literal. Supports backslash escapes.\n   */\n  private tokenizeString(): Token {\n    const input = this.input;\n    const len = this.len;\n    const start = this.pos;\n    const startCol = start - this.lineStartPos + 1;\n    let pos = start + 1;\n    let lineBreaks = 0;\n\n    while (pos < len) {\n      const c0 = input.charCodeAt(pos);\n      if (c0 === 34) {\n        pos++;\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('STRING', tokenTypeId('STRING'), text, text, start, lineBreaks, this.line, startCol);\n      }\n      if (c0 === 92 && pos + 1 < len) {\n        pos += 2;\n        continue;\n      }\n      if (c0 === 10) {\n        this.line++;\n        this.lineStartPos = pos + 1;\n        lineBreaks++;\n      }\n      pos++;\n    }\n\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('STRING', tokenTypeId('STRING'), text, text, start, lineBreaks, this.line, startCol);\n  }\n\n  // ── Markdown line scanner (Phase B) ───────────────────────────────────\n\n  /**\n   * L1 expression gating: quickly determine if a line contains any\n   * characters that indicate an expression (digits, operators, currency,\n   * backticks, parentheses, etc.).\n   *\n   * Pure prose lines (e.g., \"The quick brown fox jumps over the lazy dog\")\n   * return false and can be skipped without full tokenization (L2).\n   *\n   * This is a fast character-by-character scan that stops at the first\n   * expression indicator. Called once per line in classifyFromPositions().\n   */\n  static hasExpressionIndicators(input: string, start: number, end: number): boolean {\n    const indicatorCodes = EXPRESSION_INDICATOR_CODES;\n    for (let i = start; i < end; i++) {\n      const cc = input.charCodeAt(i);\n      // Check digits and operators via pre-computed Set (O(1) lookup)\n      if (indicatorCodes.has(cc)) return true;\n      // Unicode math/currency symbols (≥ 128, not in the 128-byte table)\n      if (cc >= 128) {\n        // ×, ÷, ≠, £, €, ¥, ₽, ₩, common expression symbols\n        if (cc === 0x00D7 || cc === 0x00F7 || cc === 0x2260 ||\n            cc === 0x00A3 || cc === 0x20AC ||\n            cc === 0x00A5 || cc === 0x20BD || cc === 0x20A9) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Classify a line by its character positions within this.input.\n   * Reads directly from this.input using start/end boundaries.\n   * DOES NOT modify this.pos, purely a read-only classifier.\n   */\n  private classifyFromPositions(start: number, end: number): LineClassification {\n    const len = end;\n\n    if (start >= len) {\n      return { type: 'empty', skip: true, hasInlineSolve: false };\n    }\n\n    const input = this.input;\n    let pos = start;\n\n    while (pos < len) {\n      const cc = input.charCodeAt(pos);\n      if (cc !== 32 && cc !== 9) break;\n      pos++;\n    }\n\n    if (pos >= len) {\n      return { type: 'empty', skip: true, hasInlineSolve: false };\n    }\n\n    const c0 = input.charCodeAt(pos);\n    let hasInline: boolean | undefined;\n\n    // ── Heading: #{1,6} ' ' ──────────────────────────────────────────\n    if (c0 === 35) {\n      let hashCount = 1;\n      while (pos + hashCount < len && input.charCodeAt(pos + hashCount) === 35) {\n        hashCount++;\n      }\n      if (hashCount <= 6 && pos + hashCount < len && input.charCodeAt(pos + hashCount) === 32) {\n        return { type: 'heading', skip: true, hasInlineSolve: false };\n      }\n      return { type: 'heading', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Blockquote: > ' ' ────────────────────────────────────────────\n    if (c0 === 62) {\n      if (pos + 1 < len && input.charCodeAt(pos + 1) === 32) {\n        return { type: 'blockquote', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // ── Code fence: ``` or ~~~ ────────────────────────────────────────\n    if (c0 === 96 && pos + 2 < len && input.charCodeAt(pos + 1) === 96 && input.charCodeAt(pos + 2) === 96) {\n      return { type: 'code_fence', skip: true, hasInlineSolve: false };\n    }\n    if (c0 === 126 && pos + 2 < len && input.charCodeAt(pos + 1) === 126 && input.charCodeAt(pos + 2) === 126) {\n      return { type: 'code_fence', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Math fence: $$ ────────────────────────────────────────────────\n    if (c0 === 36 && pos + 1 < len && input.charCodeAt(pos + 1) === 36) {\n      return { type: 'math_fence', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Horizontal rule: ---, ***, ___ (3+ same char, then only whitespace)\n    if (c0 === 45 || c0 === 42 || c0 === 95) {\n      let count = 1;\n      while (pos + count < len && input.charCodeAt(pos + count) === c0) {\n        count++;\n      }\n      if (count >= 3) {\n        let trailPos = pos + count;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'hr', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n\n    // ── Unordered list: - ' ', * ' ', + ' ' ──────────────────────────\n    if ((c0 === 45 || c0 === 42 || c0 === 43) && pos + 1 < len && input.charCodeAt(pos + 1) === 32) {\n      if (hasInline === undefined) {\n        const idx = input.indexOf('s`', pos);\n        hasInline = idx !== -1 && idx < len;\n      }\n      return { type: 'list', skip: false, hasInlineSolve: hasInline };\n    }\n\n    // ── Ordered list: \\n+ '. ' ────────────────────────────────────────\n    if (c0 >= 48 && c0 <= 57) {\n      let digitPos = pos;\n      while (digitPos < len && input.charCodeAt(digitPos) >= 48 && input.charCodeAt(digitPos) <= 57) {\n        digitPos++;\n      }\n      if (digitPos < len && input.charCodeAt(digitPos) === 46) {\n        if (digitPos + 1 < len && input.charCodeAt(digitPos + 1) === 32) {\n          if (hasInline === undefined) {\n            const idx = input.indexOf('s`', pos);\n            hasInline = idx !== -1 && idx < len;\n          }\n          return { type: 'list', skip: false, hasInlineSolve: hasInline };\n        }\n      }\n    }\n\n    // ── Table / table separator: | ────────────────────────────────────\n    if (c0 === 124) {\n      let tPos = pos + 1;\n      while (tPos < len) {\n        const tc = input.charCodeAt(tPos);\n        if (tc !== 45 && tc !== 58 && tc !== 124 && tc !== 32 && tc !== 9 && tc !== 13) break;\n        tPos++;\n      }\n      if (tPos >= len) {\n        return { type: 'table_separator', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // ── Wikilink / embed: [[ or ![[ ───────────────────────────────────\n    if (c0 === 91 && pos + 1 < len && input.charCodeAt(pos + 1) === 91) {\n      const closePos = input.indexOf(']]', pos + 2);\n      if (closePos !== -1 && closePos < len) {\n        let trailPos = closePos + 2;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'wikilink', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n    if (c0 === 33 && pos + 2 < len && input.charCodeAt(pos + 1) === 91 && input.charCodeAt(pos + 2) === 91) {\n      const closePos = input.indexOf(']]', pos + 3);\n      if (closePos !== -1 && closePos < len) {\n        let trailPos = closePos + 2;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'wikilink', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n\n    // ── Comment: // ──────────────────────────────────────────────────\n    if (c0 === 47 && pos + 1 < len && input.charCodeAt(pos + 1) === 47) {\n      return { type: 'comment', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Default: expression or prose line ─────────────────────────────\n    if (c0 === 62) {\n      let trail = pos + 1;\n      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;\n      if (trail >= len) return { type: 'blockquote', skip: true, hasInlineSolve: false };\n    }\n    if (c0 === 45 || c0 === 42 || c0 === 43) {\n      let trail = pos + 1;\n      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;\n      if (trail >= len) return { type: 'list', skip: false, hasInlineSolve: false };\n    }\n    if (hasInline === undefined) {\n      const idx = input.indexOf('s`', pos);\n      hasInline = idx !== -1 && idx < len;\n    }\n\n    // Return expression, all non-markdown-structure lines are tokenized.\n    // (L1 prose gating removed: it incorrectly skipped keyword-only lines\n    // like \"pi\", single identifiers like \"hello\", and any line without\n    // digits/operators/currency. Can be re-added with keyword-awareness\n    // and proper test coverage.)\n    return { type: 'expression', skip: false, hasInlineSolve: hasInline };\n  }\n\n  /**\n   * Classify a single line of markdown text.\n   */\n  classifyLine(lineText: string): LineClassification {\n    const savedInput = this.input;\n    const savedLen = this.len;\n    const savedPos = this.pos;\n    this.input = lineText;\n    this.len = lineText.length;\n    this.pos = 0;\n    const result = this.classifyFromPositions(0, lineText.length);\n    this.input = savedInput;\n    this.len = savedLen;\n    this.pos = savedPos;\n    return result;\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes, locale keywords\n   * (`pi`, `sqrt`, `convert`, ...) merged with any plugin-contributed ones\n   * from `registerVocabulary()` (e.g. a package's custom keywords), mapped to\n   * the token type they lex to. A snapshot copy, not a live reference\n   * mutating the return value has no effect on the lexer.\n   */\n  getKeywords(): Record<string, string> {\n    return Object.fromEntries(this.mergedKeywords);\n  }\n\n  /**\n   * Find all inline solve markers in a line with precise coordinate mapping.\n   */\n  findInlineSolves(lineText: string): InlineSolveSpan[] {\n    const results: InlineSolveSpan[] = [];\n    const len = lineText.length;\n    let pos = 0;\n\n    while (pos < len) {\n      const sPos = lineText.indexOf('s`', pos);\n      if (sPos === -1) break;\n\n      const exprStart = sPos + 2;\n\n      let exprEnd = exprStart;\n      while (exprEnd < len) {\n        const cc = lineText.charCodeAt(exprEnd);\n        if (cc === 92 && exprEnd + 1 < len) {\n          exprEnd += 2;\n          continue;\n        }\n        if (cc === 96) break;\n        exprEnd++;\n      }\n\n      if (exprEnd >= len) {\n        exprEnd = len;\n      }\n\n      const expression = lineText.slice(exprStart, exprEnd);\n      const end = exprEnd < len ? exprEnd + 1 : exprEnd;\n\n      results.push({\n        start: sPos,\n        end,\n        expression,\n        columnNumber: sPos + 1,\n      });\n\n      pos = end;\n    }\n\n    return results;\n  }\n\n  // ── Comment tokenizer ─────────────────────────────────────────────────\n  /**\n   * Reads a comment: # to end of line, or // to end of line.\n   */\n  private tokenizeComment(): Token {\n    const input = this.input;\n    const len = this.len;\n    const start = this.pos;\n    const startCol = start - this.lineStartPos + 1;\n    let pos = this.pos;\n\n    if (pos + 1 < len && input.charCodeAt(pos + 1) === 47) {\n      pos += 2;\n    } else {\n      pos++;\n    }\n\n    while (pos < len) {\n      const c0 = input.charCodeAt(pos);\n      if (c0 === 10 || c0 === 13) break;\n      pos++;\n    }\n\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('COMMENT', tokenTypeId('COMMENT'), text, text, start, 0, this.line, startCol);\n  }\n}"]}