solve-engine 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/chunk-SDGRK7EP.js.map

@@ -0,0 +1 @@
+{"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-VEKIWQ3F.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+// src/utilities/TimeoutSignal.ts
+function createTimeoutSignal(callerSignal, timeoutMs, label) {
+  const controller = new AbortController();
+  if (callerSignal?.aborted) {
+    controller.abort(callerSignal.reason);
+    return { signal: controller.signal, cleanup: () => {
+    } };
+  }
+  const timeoutId = setTimeout(
+    () => controller.abort(new DOMException(`${label} timed out after ${timeoutMs}ms`, "TimeoutError")),
+    timeoutMs
+  );
+  let onCallerAbort;
+  if (callerSignal) {
+    onCallerAbort = () => {
+      clearTimeout(timeoutId);
+      try {
+        controller.abort(callerSignal.reason);
+      } catch {
+      }
+    };
+    callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timeoutId);
+      if (callerSignal && onCallerAbort) {
+        callerSignal.removeEventListener("abort", onCallerAbort);
+      }
+    }
+  };
+}
+
+exports.createTimeoutSignal = createTimeoutSignal;
+//# sourceMappingURL=chunk-VEKIWQ3F.cjs.map
+//# sourceMappingURL=chunk-VEKIWQ3F.cjs.map

package/dist/chunk-VEKIWQ3F.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utilities/TimeoutSignal.ts"],"names":[],"mappings":";;;AAYO,SAAS,mBAAA,CACf,YAAA,EACA,SAAA,EACA,KAAA,EAC+C;AAC/C,EAAA,MAAM,UAAA,GAAa,IAAI,eAAA,EAAgB;AAEvC,EAAA,IAAI,cAAc,OAAA,EAAS;AAC1B,IAAA,UAAA,CAAW,KAAA,CAAM,aAAa,MAAM,CAAA;AACpC,IAAA,OAAO,EAAE,MAAA,EAAQ,UAAA,CAAW,MAAA,EAAQ,SAAS,MAAM;AAAA,IAAsB,CAAA,EAAE;AAAA,EAC5E;AAEA,EAAA,MAAM,SAAA,GAAY,UAAA;AAAA,IACjB,MAAM,UAAA,CAAW,KAAA,CAAM,IAAI,YAAA,CAAa,CAAA,EAAG,KAAK,CAAA,iBAAA,EAAoB,SAAS,CAAA,EAAA,CAAA,EAAM,cAAc,CAAC,CAAA;AAAA,IAClG;AAAA,GACD;AAEA,EAAA,IAAI,aAAA;AACJ,EAAA,IAAI,YAAA,EAAc;AACjB,IAAA,aAAA,GAAgB,MAAM;AACrB,MAAA,YAAA,CAAa,SAAS,CAAA;AACtB,MAAA,IAAI;AAAE,QAAA,UAAA,CAAW,KAAA,CAAM,aAAa,MAAM,CAAA;AAAA,MAAG,CAAA,CAAA,MAAQ;AAAA,MAAwB;AAAA,IAC9E,CAAA;AACA,IAAA,YAAA,CAAa,iBAAiB,OAAA,EAAS,aAAA,EAAe,EAAE,IAAA,EAAM,MAAM,CAAA;AAAA,EACrE;AAEA,EAAA,OAAO;AAAA,IACN,QAAQ,UAAA,CAAW,MAAA;AAAA,IACnB,SAAS,MAAM;AACd,MAAA,YAAA,CAAa,SAAS,CAAA;AACtB,MAAA,IAAI,gBAAgB,aAAA,EAAe;AAClC,QAAA,YAAA,CAAa,mBAAA,CAAoB,SAAS,aAAa,CAAA;AAAA,MACxD;AAAA,IACD;AAAA,GACD;AACD","file":"chunk-VEKIWQ3F.cjs","sourcesContent":["/**\n * Multiplex an optional caller AbortSignal with a hard timeout into a single\n * AbortSignal suitable for fetch().\n *\n * Implemented manually rather than with AbortSignal.any()/AbortSignal.timeout()\n * (Chrome 116+) to stay compatible with the TypeScript lib targets used by\n * this project.\n *\n * Handles the already-aborted caller: addEventListener(\"abort\", …) on a signal\n * that has already fired never invokes the listener, so without the upfront\n * `aborted` check the fetch would proceed even though the caller cancelled.\n */\nexport function createTimeoutSignal(\n\tcallerSignal: AbortSignal | undefined,\n\ttimeoutMs: number,\n\tlabel: string,\n): { signal: AbortSignal; cleanup: () => void } {\n\tconst controller = new AbortController();\n\n\tif (callerSignal?.aborted) {\n\t\tcontroller.abort(callerSignal.reason);\n\t\treturn { signal: controller.signal, cleanup: () => { /* nothing armed */ } };\n\t}\n\n\tconst timeoutId = setTimeout(\n\t\t() => controller.abort(new DOMException(`${label} timed out after ${timeoutMs}ms`, \"TimeoutError\")),\n\t\ttimeoutMs,\n\t);\n\n\tlet onCallerAbort: (() => void) | undefined;\n\tif (callerSignal) {\n\t\tonCallerAbort = () => {\n\t\t\tclearTimeout(timeoutId);\n\t\t\ttry { controller.abort(callerSignal.reason); } catch { /* already aborted */ }\n\t\t};\n\t\tcallerSignal.addEventListener(\"abort\", onCallerAbort, { once: true });\n\t}\n\n\treturn {\n\t\tsignal: controller.signal,\n\t\tcleanup: () => {\n\t\t\tclearTimeout(timeoutId);\n\t\t\tif (callerSignal && onCallerAbort) {\n\t\t\t\tcallerSignal.removeEventListener(\"abort\", onCallerAbort);\n\t\t\t}\n\t\t},\n\t};\n}\n"]}

package/dist/chunk-W44QGY5J.cjs

@@ -0,0 +1,172 @@
+'use strict';
+
+var chunkM4N5GA5Z_cjs = require('./chunk-M4N5GA5Z.cjs');
+
+// package.json
+var version = "1.0.0-beta.1";
+
+// src/constants/version.ts
+var ENGINE_VERSION = version;
+
+// src/constants/Configuration.ts
+var DEFAULT_CONFIG = {
+  date: {
+    defaultOffsetDays: 0,
+    maxOffsetYears: 100,
+    minOffsetYears: -100,
+    defaultFormat: "YYYY-MM-DD"
+  },
+  dice: {
+    defaultSides: 6,
+    maxSides: 1e3,
+    maxDice: 100,
+    defaultDice: 1
+  },
+  performance: {
+    // Preserves the effective cache size the hardcoded (now-removed)
+    // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up
+    // doesn't silently shrink the default cache for existing consumers.
+    defaultCacheSize: 2e3,
+    maxDocumentLines: 1e4,
+    parseTimeoutMs: 5e3,
+    executionTimeoutMs: 1e4
+  },
+  validation: {
+    maxExpressionLength: 2e3,
+    maxComplexity: 500,
+    maxNestingDepth: 50,
+    autoBalanceParens: false
+  },
+  vm: {
+    maxStackDepth: 200,
+    maxInstructions: 5e4
+  },
+  worker: {
+    maxConcurrentWorkers: 4,
+    idleTimeoutMs: 3e4,
+    maxRetries: 3,
+    baseBackoffMs: 1e3
+  },
+  diagnostic: {
+    enabled: false,
+    vmTraceEnabled: false
+  }
+};
+function mergeEngineConfig(base, override) {
+  return {
+    date: { ...base.date, ...override.date },
+    dice: { ...base.dice, ...override.dice },
+    performance: { ...base.performance, ...override.performance },
+    validation: { ...base.validation, ...override.validation },
+    vm: { ...base.vm, ...override.vm },
+    worker: { ...base.worker, ...override.worker },
+    diagnostic: { ...base.diagnostic, ...override.diagnostic }
+  };
+}
+var ConfigManager = class {
+  constructor(config = {}) {
+    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);
+  }
+  /**
+   * Get configuration value by path
+   * 
+   * @param path - Dot-notation path to config value
+   * @returns Configuration value
+   */
+  get(path) {
+    const keys = path.split(".");
+    let current = this.config;
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        throw chunkM4N5GA5Z_cjs.ErrorFactory.config(
+          "CONFIG_PATH_NOT_FOUND",
+          `Configuration path not found: ${path}`,
+          { path }
+        );
+      }
+    }
+    return current;
+  }
+  /**
+   * Set configuration value by path
+   * 
+   * @param path - Dot-notation path to config value
+   * @param value - New value
+   */
+  set(path, value) {
+    const keys = path.split(".");
+    if (keys.length < 2) {
+      throw chunkM4N5GA5Z_cjs.ErrorFactory.config(
+        "INVALID_CONFIG_PATH",
+        `Invalid path: ${path}. Must be in format 'section.property'`,
+        { path }
+      );
+    }
+    const section = keys[0];
+    const property = keys[1];
+    if (!(section in this.config)) {
+      throw chunkM4N5GA5Z_cjs.ErrorFactory.config(
+        "CONFIG_SECTION_NOT_FOUND",
+        `Configuration section not found: ${section}`,
+        { section, path }
+      );
+    }
+    const sectionConfig = this.config[section];
+    if (sectionConfig && typeof sectionConfig === "object") {
+      sectionConfig[property] = value;
+    } else {
+      throw chunkM4N5GA5Z_cjs.ErrorFactory.config(
+        "CONFIG_PROPERTY_NOT_FOUND",
+        `Configuration property not found: ${path}`,
+        { path }
+      );
+    }
+  }
+  /**
+   * Get complete configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update multiple configuration values
+   */
+  update(config) {
+    this.config = mergeEngineConfig(this.config, config);
+  }
+  /**
+   * Reset to default configuration
+   */
+  reset() {
+    this.config = { ...DEFAULT_CONFIG };
+  }
+  /**
+   * Validate configuration values
+   */
+  validate() {
+    const errors = [];
+    if (this.config.performance.maxDocumentLines > 1e5) {
+      errors.push("maxDocumentLines cannot exceed 100,000");
+    }
+    if (this.config.date.maxOffsetYears > 1e3) {
+      errors.push("maxOffsetYears cannot exceed 1000");
+    }
+    if (this.config.dice.maxSides > 1e4) {
+      errors.push("maxSides cannot exceed 10,000");
+    }
+    return {
+      valid: errors.length === 0,
+      error: errors.join("; "),
+      warnings: []
+    };
+  }
+};
+
+exports.ConfigManager = ConfigManager;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.ENGINE_VERSION = ENGINE_VERSION;
+exports.mergeEngineConfig = mergeEngineConfig;
+//# sourceMappingURL=chunk-W44QGY5J.cjs.map
+//# sourceMappingURL=chunk-W44QGY5J.cjs.map

package/dist/chunk-W44QGY5J.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../package.json","../src/constants/version.ts","../src/constants/Configuration.ts"],"names":["ErrorFactory"],"mappings":"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","file":"chunk-W44QGY5J.cjs","sourcesContent":["{\n  \"name\": \"solve-engine\",\n  \"version\": \"1.0.0-beta.1\",\n  \"description\": \"The expression evaluation engine behind Solve — lexer, parser, bytecode VM, and an extensible package system.\",\n  \"keywords\": [\n    \"expression-evaluator\",\n    \"calculator\",\n    \"bytecode-vm\",\n    \"parser\",\n    \"lexer\",\n    \"dsl\",\n    \"markdown\",\n    \"obsidian\"\n  ],\n  \"license\": \"MIT\",\n  \"author\": \"Liam Riddell\",\n  \"homepage\": \"https://liamriddell.github.io/solve-engine/\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/LiamRiddell/solve-engine.git\",\n    \"directory\": \"packages/engine\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/LiamRiddell/solve-engine/issues\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=22\"\n  },\n  \"files\": [\n    \"dist\",\n    \"LICENSE\"\n  ],\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./engine\": {\n      \"import\": {\n        \"types\": \"./dist/engine.d.ts\",\n        \"default\": \"./dist/engine.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/engine.d.cts\",\n        \"default\": \"./dist/engine.cjs\"\n      }\n    },\n    \"./vm\": {\n      \"import\": {\n        \"types\": \"./dist/vm.d.ts\",\n        \"default\": \"./dist/vm.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/vm.d.cts\",\n        \"default\": \"./dist/vm.cjs\"\n      }\n    },\n    \"./format\": {\n      \"import\": {\n        \"types\": \"./dist/format.d.ts\",\n        \"default\": \"./dist/format.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/format.d.cts\",\n        \"default\": \"./dist/format.cjs\"\n      }\n    },\n    \"./language\": {\n      \"import\": {\n        \"types\": \"./dist/language.d.ts\",\n        \"default\": \"./dist/language.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/language.d.cts\",\n        \"default\": \"./dist/language.cjs\"\n      }\n    },\n    \"./packages\": {\n      \"import\": {\n        \"types\": \"./dist/packages.d.ts\",\n        \"default\": \"./dist/packages.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/packages.d.cts\",\n        \"default\": \"./dist/packages.cjs\"\n      }\n    },\n    \"./constants\": {\n      \"import\": {\n        \"types\": \"./dist/constants.d.ts\",\n        \"default\": \"./dist/constants.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/constants.d.cts\",\n        \"default\": \"./dist/constants.cjs\"\n      }\n    },\n    \"./lexer\": {\n      \"import\": {\n        \"types\": \"./dist/lexer.d.ts\",\n        \"default\": \"./dist/lexer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/lexer.d.cts\",\n        \"default\": \"./dist/lexer.cjs\"\n      }\n    },\n    \"./parser\": {\n      \"import\": {\n        \"types\": \"./dist/parser.d.ts\",\n        \"default\": \"./dist/parser.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/parser.d.cts\",\n        \"default\": \"./dist/parser.cjs\"\n      }\n    },\n    \"./normalizer\": {\n      \"import\": {\n        \"types\": \"./dist/normalizer.d.ts\",\n        \"default\": \"./dist/normalizer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/normalizer.d.cts\",\n        \"default\": \"./dist/normalizer.cjs\"\n      }\n    },\n    \"./variables\": {\n      \"import\": {\n        \"types\": \"./dist/variables.d.ts\",\n        \"default\": \"./dist/variables.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/variables.d.cts\",\n        \"default\": \"./dist/variables.cjs\"\n      }\n    },\n    \"./resolvers\": {\n      \"import\": {\n        \"types\": \"./dist/resolvers.d.ts\",\n        \"default\": \"./dist/resolvers.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/resolvers.d.cts\",\n        \"default\": \"./dist/resolvers.cjs\"\n      }\n    },\n    \"./errors\": {\n      \"import\": {\n        \"types\": \"./dist/errors.d.ts\",\n        \"default\": \"./dist/errors.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/errors.d.cts\",\n        \"default\": \"./dist/errors.cjs\"\n      }\n    },\n    \"./utilities\": {\n      \"import\": {\n        \"types\": \"./dist/utilities.d.ts\",\n        \"default\": \"./dist/utilities.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/utilities.d.cts\",\n        \"default\": \"./dist/utilities.cjs\"\n      }\n    },\n    \"./uom\": {\n      \"import\": {\n        \"types\": \"./dist/uom.d.ts\",\n        \"default\": \"./dist/uom.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/uom.d.cts\",\n        \"default\": \"./dist/uom.cjs\"\n      }\n    },\n    \"./services\": {\n      \"import\": {\n        \"types\": \"./dist/services.d.ts\",\n        \"default\": \"./dist/services.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/services.d.cts\",\n        \"default\": \"./dist/services.cjs\"\n      }\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"prepublishOnly\": \"npm run build && node ../../scripts/assert-publishable.mjs .\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"jest --config jest.config.cjs --no-coverage\",\n    \"typecheck\": \"tsgo --noEmit --skipLibCheck\",\n    \"typecheck:tsc\": \"tsc --noEmit --skipLibCheck\"\n  },\n  \"dependencies\": {\n    \"@tanstack/query-core\": \"^5.100.10\",\n    \"semver\": \"^7.6.0\",\n    \"tslib\": \"^2.6.1\"\n  },\n  \"devDependencies\": {\n    \"@jest/globals\": \"^30.4.1\",\n    \"@types/node\": \"^26.1.2\",\n    \"@types/semver\": \"^7.5.0\",\n    \"convert\": \"^7.0.0\",\n    \"jest\": \"^30.4.2\",\n    \"ts-jest\": \"^29.4.12\",\n    \"tsup\": \"8.5.1\",\n    \"typescript\": \"5.9.3\"\n  },\n  \"sideEffects\": false\n}\n","/**\n * The running engine's own semver version, sourced directly from this\n * package's package.json so it can never drift from what's actually\n * published. Exists so IEnginePackage.engineVersion range checks\n * (api/EngineVersionCompatibility.ts) have something real to check\n * against.\n */\nimport { version } from \"../../package.json\";\n\n/**\n * The running engine's version, taken from package.json.\n *\n * What a package's `engineVersion` range is checked against at registration.\n * A prerelease is compared by its coerced release version, so a 1.0.0 beta\n * satisfies `^1.0.0`. See `api/EngineVersionCompatibility.ts`.\n */\nexport const ENGINE_VERSION: string = version;\n","/**\n * Configuration Module for solve-js Engine\n * \n * This module provides the **single source of truth** for all engine configuration.\n * Every configurable aspect of the engine, from safety limits and performance\n * budgets to VM constraints and worker pool sizing, is defined here.\n * \n * ### Design principles\n * \n * 1. **Engine owns its config.** The engine defines its own config shape and defaults.\n *    Consumers (e.g., the Obsidian plugin) pass partial overrides; all unspecified\n *    fields fall back to `DEFAULT_CONFIG`.\n * \n * 2. **Self-documenting.** Every interface and field has descriptive JSDoc so the\n *    config is understandable at a glance, whether you're using the engine as an\n *    npm package or reading the source.\n * \n * 3. **Minimal consumer knowledge.** Consumers only need to pass `Partial<EngineConfig>`.\n *    They don't need to replicate the full config shape, just the fields they\n *    want to override.\n * \n * @module Configuration\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * Date-related configuration.\n * Controls the bounds and formatting for date/time expression evaluation\n * (e.g., `today + 20 days`, `last monday`).\n */\nexport interface DateConfig {\n  /** Default offset in days for relative date calculations when no offset is specified */\n  readonly defaultOffsetDays: number;\n  /** Maximum allowed positive offset in years (safety limit) */\n  readonly maxOffsetYears: number;\n  /** Maximum allowed negative offset in years (safety limit) */\n  readonly minOffsetYears: number;\n  /** Default date string format for display (moment.js format string) */\n  readonly defaultFormat: string;\n}\n\n/**\n * Dice-related configuration.\n * Controls dice expression evaluation (e.g., `roll(1, 100)`, `3d6`).\n */\nexport interface DiceConfig {\n  /** Default number of sides on a die when not specified */\n  readonly defaultSides: number;\n  /** Maximum allowed sides per die (prevents excessive allocation) */\n  readonly maxSides: number;\n  /** Maximum number of dice in a single roll expression */\n  readonly maxDice: number;\n  /** Default number of dice when not specified */\n  readonly defaultDice: number;\n}\n\n/**\n * Performance-related configuration.\n * Controls caching, timeouts, and processing limits to prevent runaway\n * resource consumption on large documents.\n */\nexport interface PerformanceConfig {\n  /**\n   * Maximum number of entries in {@link ExpressionEngine}'s bytecode cache\n   * (per-instance, keyed by expression text) before the oldest entry is\n   * evicted. Raise this for documents with many distinct expressions if\n   * repeated re-evaluation (e.g. scrolling) is re-parsing instead of\n   * hitting cache, bug fix (release hardening pass): this field used to\n   * be read nowhere; the cache size was a hardcoded, unconfigurable\n   * constant. Note this does NOT bound {@link LineCache}, which has no\n   * size limit of its own.\n   */\n  readonly defaultCacheSize: number;\n  /** Maximum number of document lines processed in a single pass */\n  readonly maxDocumentLines: number;\n  /** Maximum time (ms) allowed for parsing a single expression before timeout */\n  readonly parseTimeoutMs: number;\n  /** Maximum time (ms) allowed for executing a single expression before timeout */\n  readonly executionTimeoutMs: number;\n}\n\n/**\n * Validation / safety-limit configuration.\n * Protects against runaway expressions that could cause excessive memory use\n * or stack overflow. These limits are checked during lexing and parsing.\n */\n/** Bounds on untrusted input: expression length and nesting depth. */\nexport interface ValidationConfig {\n  /** Maximum expression length in characters. Prevents excessively long strings from entering the pipeline. */\n  readonly maxExpressionLength: number;\n  /** Maximum expression complexity score (`tokens + functionCalls×5 + nestingDepth×10`). Protects against deeply nested or combinatorially complex expressions. */\n  readonly maxComplexity: number;\n  /** Maximum parentheses nesting depth. Prevents stack overflow in the recursive-descent parser. */\n  readonly maxNestingDepth: number;\n  /**\n   * Auto-balance unmatched parentheses by appending missing closing parens\n   * or prepending missing opening parens. When disabled, unbalanced expressions\n   * cause parse errors instead of being silently corrected.\n   *\n   * Disabled by default for strict parsing. Enable for forgiving user input\n   * (e.g., chat-style calculators where users often omit closing parens).\n   * Has zero overhead when disabled, the O(n) paren-count scan is skipped.\n   */\n  readonly autoBalanceParens: boolean;\n}\n\n/**\n * Worker pool configuration.\n * Controls the parallel execution workers used for batch evaluation.\n */\nexport interface WorkerConfig {\n  /** Maximum number of concurrent Web Workers allowed */\n  readonly maxConcurrentWorkers: number;\n  /** Time (ms) a worker stays alive while idle before being terminated */\n  readonly idleTimeoutMs: number;\n  /** Maximum retry attempts for a failed worker operation */\n  readonly maxRetries: number;\n  /** Base backoff delay (ms) between retries (exponential backoff applied on top) */\n  readonly baseBackoffMs: number;\n}  /**\n   * Diagnostic / telemetry configuration.\n   * Controls the diagnostic event pipeline for profiling and debugging.\n   * All diagnostics are disabled by default for maximum production performance.\n   */\n  export interface DiagnosticConfig {\n    /** Master switch: enable the diagnostic pipeline (collectors receive events for all pipeline stages) */\n    readonly enabled: boolean;\n    /** Enable VM trace mode, emits per-opcode execution events (very verbose; disables some optimizations) */\n    readonly vmTraceEnabled: boolean;\n  }\n\n  /**\n   * Virtual Machine configuration.\n   * Controls the internal bytecode VM that executes compiled expressions.\n   */\n  export interface VMConfig {\n    /** Maximum stack depth (value slots) for VM execution, prevents stack overflow in recursive/pratt-parser generated bytecode */\n    readonly maxStackDepth: number;\n    /** Maximum opcodes executed per expression, halts runaway infinite loops */\n    readonly maxInstructions: number;\n  }\n\n/**\n * Complete engine configuration.\n *\n * Every field has a default in `DEFAULT_CONFIG`. To customize, pass a\n * `Partial<EngineConfig>` when constructing `ExpressionEngine`. Only the\n * sections/fields you supply are overridden; all others use their defaults.\n *\n * @example\n * ```typescript\n * import { ExpressionEngine } from \"solve-js\";\n *\n * const engine = new ExpressionEngine(\"en\", false, {\n *   validation: {\n *     maxExpressionLength: 1000,\n *     maxComplexity: 200,\n *   },\n *   // date, dice, performance, vm, worker, diagnostic all use defaults\n * });\n * ```\n */\nexport interface EngineConfig {\n    /** Date/time expression evaluation bounds and formatting */\n    readonly date: DateConfig;\n    /** Dice roll expression controls */\n    readonly dice: DiceConfig;\n    /** Performance budgets and cache sizing */\n    readonly performance: PerformanceConfig;\n    /** Safety limits for expression complexity */\n    readonly validation: ValidationConfig;\n    /** Internal bytecode VM configuration */\n    readonly vm: VMConfig;\n    /** Parallel worker pool configuration */\n    readonly worker: WorkerConfig;\n    /** Diagnostic pipeline configuration */\n    readonly diagnostic: DiagnosticConfig;\n  }\n\n/**\n * Default configuration values\n */\nexport const DEFAULT_CONFIG: EngineConfig = {\n   date: {\n     defaultOffsetDays: 0,\n     maxOffsetYears: 100,\n     minOffsetYears: -100,\n     defaultFormat: 'YYYY-MM-DD'\n   },\n   dice: {\n     defaultSides: 6,\n     maxSides: 1000,\n     maxDice: 100,\n     defaultDice: 1\n   },\n   performance: {\n     // Preserves the effective cache size the hardcoded (now-removed)\n     // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up\n     // doesn't silently shrink the default cache for existing consumers.\n     defaultCacheSize: 2000,\n     maxDocumentLines: 10000,\n     parseTimeoutMs: 5000,\n     executionTimeoutMs: 10000\n   },\n    validation: {\n      maxExpressionLength: 2000,\n      maxComplexity: 500,\n      maxNestingDepth: 50,\n      autoBalanceParens: false,\n    },\n    vm: {\n      maxStackDepth: 200,\n      maxInstructions: 50000,\n    },\n    worker: {\n      maxConcurrentWorkers: 4,\n      idleTimeoutMs: 30000,\n      maxRetries: 3,\n      baseBackoffMs: 1000,\n    },\n    diagnostic: {\n      enabled: false,\n      vmTraceEnabled: false,\n    },\n  };\n\n/**\n * Merge a partial config override onto a base `EngineConfig`, section by\n * section, `{ ...base.section, ...override.section }` for each of the 7\n * top-level sections, not a single top-level spread.\n *\n * A shallow `{ ...base, ...override }` at the TOP level replaces an entire\n * section wholesale the moment a caller overrides even one field in it\n * (e.g. `{ performance: { defaultCacheSize: 500 } }` would silently drop\n * every other `performance.*` field back to `undefined`, not to its\n * default). This function exists specifically so every config consumer\n * shares one correct merge instead of each hand-rolling (and risking) its\n * own. `ConfigManager` and `ExpressionEngine` both call this rather than\n * either duplicating the section list or instantiating a whole\n * `ConfigManager` just to reuse its private merge logic.\n */\nexport function mergeEngineConfig(\n  base: EngineConfig,\n  override: Partial<EngineConfig>\n): EngineConfig {\n  return {\n    date: { ...base.date, ...override.date },\n    dice: { ...base.dice, ...override.dice },\n    performance: { ...base.performance, ...override.performance },\n    validation: { ...base.validation, ...override.validation },\n    vm: { ...base.vm, ...override.vm },\n    worker: { ...base.worker, ...override.worker },\n    diagnostic: { ...base.diagnostic, ...override.diagnostic },\n  };\n}\n\n/**\n * Configuration manager for engine settings\n *\n * @example\n * ```typescript\n * const configManager = new ConfigManager();\n * configManager.set('performance.defaultCacheSize', 2000);\n * const cacheSize = configManager.get('performance.defaultCacheSize');\n * ```\n */\nexport class ConfigManager {\n  private config: EngineConfig;\n\n  constructor(config: Partial<EngineConfig> = {}) {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);\n  }\n\n  /**\n   * Get configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @returns Configuration value\n   */\n  get<T>(path: string): T {\n    const keys = path.split('.');\n    let current: unknown = this.config;\n\n    for (const key of keys) {\n      if (current && typeof current === 'object' && key in current) {\n        current = (current as Record<string, unknown>)[key];\n      } else {\n        throw ErrorFactory.config(\n          \"CONFIG_PATH_NOT_FOUND\",\n          `Configuration path not found: ${path}`,\n          { path }\n        );\n      }\n    }\n\n    return current as T;\n  }\n\n  /**\n   * Set configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @param value - New value\n   */\n  set<T>(path: string, value: T): void {\n    const keys = path.split('.');\n    if (keys.length < 2) {\n      throw ErrorFactory.config(\n        \"INVALID_CONFIG_PATH\",\n        `Invalid path: ${path}. Must be in format 'section.property'`,\n        { path }\n      );\n    }\n    \n    const section = keys[0];\n    const property = keys[1];\n    \n    if (!(section in this.config)) {\n      throw ErrorFactory.config(\n        \"CONFIG_SECTION_NOT_FOUND\",\n        `Configuration section not found: ${section}`,\n        { section, path }\n      );\n    }\n    \n    const sectionConfig = this.config[section as keyof EngineConfig];\n    if (sectionConfig && typeof sectionConfig === 'object') {\n      (sectionConfig as unknown as Record<string, unknown>)[property] = value;\n    } else {\n      throw ErrorFactory.config(\n        \"CONFIG_PROPERTY_NOT_FOUND\",\n        `Configuration property not found: ${path}`,\n        { path }\n      );\n    }\n  }\n\n  /**\n   * Get complete configuration\n   */\n  getConfig(): EngineConfig {\n    return { ...this.config };\n  }\n\n  /**\n   * Update multiple configuration values\n   */\n  update(config: Partial<EngineConfig>): void {\n    this.config = mergeEngineConfig(this.config, config);\n  }\n\n  /**\n   * Reset to default configuration\n   */\n  reset(): void {\n    this.config = { ...DEFAULT_CONFIG };\n  }\n\n  /**\n   * Validate configuration values\n   */\n  validate(): ValidationResult {\n    const errors: string[] = [];\n\n    // Validate performance config\n    if (this.config.performance.maxDocumentLines > 100000) {\n      errors.push('maxDocumentLines cannot exceed 100,000');\n    }\n\n    // Validate date config\n    if (this.config.date.maxOffsetYears > 1000) {\n      errors.push('maxOffsetYears cannot exceed 1000');\n    }\n\n    // Validate dice config\n    if (this.config.dice.maxSides > 10000) {\n      errors.push('maxSides cannot exceed 10,000');\n    }\n\n    return {\n      valid: errors.length === 0,\n      error: errors.join('; '),\n      warnings: []\n    };\n  }\n}\n\n/**\n * Result type for {@link ConfigManager.validate}.\n */\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n  warnings?: string[];\n}\n\n"]}

package/dist/chunk-WQTTOGXC.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+var chunkXJCMXB2E_cjs = require('./chunk-XJCMXB2E.cjs');
+var chunkOC6LTXYS_cjs = require('./chunk-OC6LTXYS.cjs');
+
+// src/parser/OperandWidth.ts
+var ONE_OPERAND = [
+  10 /* PUSH_NUMBER */,
+  11 /* PUSH_BIGINT */,
+  12 /* PUSH_HEX */,
+  13 /* PUSH_STRING */,
+  14 /* PUSH_BOOLEAN */,
+  60 /* LOAD_VAR */,
+  61 /* STORE_VAR */,
+  62 /* LOAD_GLOBAL_VAR */,
+  63 /* STORE_GLOBAL_VAR */,
+  150 /* DEFINE_USER_FUNCTION */
+];
+var TWO_OPERANDS = [
+  50 /* CALL_PLUGIN */,
+  51 /* CALL_BUILTIN */,
+  151 /* CALL_USER_FUNCTION */,
+  152 /* MAT_NEW */
+];
+var THREE_OPERANDS = [157 /* MAP_INVOKE */, 158 /* REDUCE_INVOKE */];
+var OPERAND_BYTES = (() => {
+  const widths = new Array(256).fill(0);
+  for (const op of ONE_OPERAND) widths[op] = 1;
+  for (const op of TWO_OPERANDS) widths[op] = 2;
+  for (const op of THREE_OPERANDS) widths[op] = 3;
+  return widths;
+})();
+[
+  ...ONE_OPERAND,
+  ...TWO_OPERANDS,
+  ...THREE_OPERANDS
+];
+function nextInstruction(opcodes, index) {
+  return index + 1 + (OPERAND_BYTES[opcodes[index]] ?? 0);
+}
+
+// src/uom/CurrencyResolver.ts
+var CURRENCY_NS = "currency";
+var CurrencyAsyncResolver = class {
+  constructor(exchange) {
+    this.namespace = CURRENCY_NS;
+    this.exchange = exchange ?? chunkXJCMXB2E_cjs.currencyExchangeService;
+  }
+  preflight(_tokens, bytecode, packageId, signal, queryClient) {
+    const { opcodes, strings } = bytecode;
+    const len = opcodes.length;
+    let i = 0;
+    let lastStrIdx = -1;
+    let prevStrIdx = -1;
+    while (i < len) {
+      const op = opcodes[i];
+      if (op === 13 /* PUSH_STRING */) {
+        prevStrIdx = lastStrIdx;
+        lastStrIdx = opcodes[i + 1];
+      }
+      const isCurrencyCombiningOp = op === 84 /* UOM_CONVERT_IN */ || op === 81 /* UOM_CONVERT_TO */ || op === 20 /* ADD */ || op === 21 /* SUB */ || op === 22 /* MUL */ || op === 23 /* DIV */;
+      if (isCurrencyCombiningOp) {
+        if (prevStrIdx >= 0 && lastStrIdx >= 0) {
+          const fromUnit = strings[prevStrIdx];
+          const toUnit = strings[lastStrIdx];
+          if (this.exchange.isCurrency(fromUnit) && this.exchange.isCurrency(toUnit) && fromUnit.toUpperCase() !== toUnit.toUpperCase()) {
+            const syncRate = this.exchange.getRateSync(fromUnit, toUnit);
+            if (syncRate === null) {
+              const fromUpper = fromUnit.toUpperCase();
+              const toUpper = toUnit.toUpperCase();
+              const cacheKey = [CURRENCY_NS, fromUpper, toUpper];
+              if (queryClient.getQueryData(cacheKey) !== void 0) {
+                i++;
+                continue;
+              }
+              const resolver = queryClient.fetchQuery({
+                queryKey: cacheKey,
+                queryFn: ({ signal: qSignal }) => {
+                  return this.exchange.getRate(fromUnit, toUnit, qSignal).then((rate) => chunkOC6LTXYS_cjs.numberValue(rate));
+                },
+                staleTime: 5 * 60 * 1e3
+              });
+              return { queryKey: cacheKey.join(":"), resolver, packageId, signal, metadata: { fromUnit, toUnit } };
+            }
+          }
+        }
+      }
+      i = nextInstruction(opcodes, i);
+    }
+    return null;
+  }
+  destroy() {
+  }
+};
+
+exports.CurrencyAsyncResolver = CurrencyAsyncResolver;
+exports.nextInstruction = nextInstruction;
+//# sourceMappingURL=chunk-WQTTOGXC.cjs.map
+//# sourceMappingURL=chunk-WQTTOGXC.cjs.map

package/dist/chunk-WQTTOGXC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser/OperandWidth.ts","../src/uom/CurrencyResolver.ts"],"names":["currencyExchangeService","numberValue"],"mappings":"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","file":"chunk-WQTTOGXC.cjs","sourcesContent":["/**\n * How many operand bytes follow each opcode, and how to step over one.\n *\n * Anything walking a bytecode stream without executing it needs this: the\n * resolver preflight scanners look for specific opcodes and must skip past\n * everything else without mistaking an operand byte for an instruction.\n *\n * It used to be a hand-copied switch in each of those scanners. They had\n * already drifted: two counted `CALL_PLUGIN` as three bytes wide and the third\n * omitted it from that arm, so a stream containing one desynchronised there and\n * every opcode after it was read at the wrong offset. Adding an opcode meant\n * remembering every copy, and nothing checked that you had.\n *\n * `__tests__/parser/OperandWidth.spec.ts` asserts every opcode has a width, so\n * a new one fails a test rather than silently defaulting to zero operands.\n */\n\nimport { OpCode } from \"@solve-js/parser/OpCode\";\n\n/**\n * Opcodes taking one operand byte.\n *\n * A constant-pool index, or a variable-name index.\n */\nconst ONE_OPERAND: readonly OpCode[] = [\n\tOpCode.PUSH_NUMBER,\n\tOpCode.PUSH_BIGINT,\n\tOpCode.PUSH_HEX,\n\tOpCode.PUSH_STRING,\n\tOpCode.PUSH_BOOLEAN,\n\tOpCode.LOAD_VAR,\n\tOpCode.STORE_VAR,\n\tOpCode.LOAD_GLOBAL_VAR,\n\tOpCode.STORE_GLOBAL_VAR,\n\tOpCode.DEFINE_USER_FUNCTION,\n];\n\n/**\n * Opcodes taking two operand bytes.\n *\n * A callable index plus an argument count, or a matrix's row and column counts.\n */\nconst TWO_OPERANDS: readonly OpCode[] = [\n\tOpCode.CALL_PLUGIN,\n\tOpCode.CALL_BUILTIN,\n\tOpCode.CALL_USER_FUNCTION,\n\tOpCode.MAT_NEW,\n];\n\n/**\n * Opcodes taking three operand bytes.\n *\n * The map and reduce invocations, which carry a body index alongside their\n * other operands.\n */\nconst THREE_OPERANDS: readonly OpCode[] = [OpCode.MAP_INVOKE, OpCode.REDUCE_INVOKE];\n\n/**\n * Operand byte count for every opcode, indexed by opcode value.\n *\n * A dense array rather than a map, because the preflight scanners run on every\n * keystroke and this is read once per instruction.\n */\nexport const OPERAND_BYTES: readonly number[] = (() => {\n\tconst widths = new Array<number>(256).fill(0);\n\tfor (const op of ONE_OPERAND) widths[op] = 1;\n\tfor (const op of TWO_OPERANDS) widths[op] = 2;\n\tfor (const op of THREE_OPERANDS) widths[op] = 3;\n\treturn widths;\n})();\n\n/**\n * Every opcode that takes at least one operand.\n *\n * Exported so a test can assert the table stays complete as opcodes are added.\n */\nexport const OPCODES_WITH_OPERANDS: readonly OpCode[] = [\n\t...ONE_OPERAND,\n\t...TWO_OPERANDS,\n\t...THREE_OPERANDS,\n];\n\n/**\n * Offset of the instruction after the one at `index`.\n *\n * @param opcodes - The bytecode stream.\n * @param index - Offset of an opcode, not of an operand byte. Passing an\n * operand offset yields nonsense, which is the failure mode this exists to\n * prevent: a caller stepping by hand and getting one width wrong reads the rest\n * of the stream misaligned.\n * @returns Offset of the next opcode. May be past the end when the instruction\n * at `index` is the last one, so callers loop while it is under `opcodes.length`.\n */\nexport function nextInstruction(opcodes: Uint8Array, index: number): number {\n\treturn index + 1 + (OPERAND_BYTES[opcodes[index]] ?? 0);\n}\n","/**\n * Currency async resolver, bridges CurrencyExchangeService to the\n * IAsyncResolver interface for the Suspense architecture.\n *\n * Uses TanStack Query (injected via queryClient) as the single cache layer.\n */\nimport type { QueryClient } from \"@tanstack/query-core\";\nimport type { Token } from \"@solve-js/lexer\";\nimport type { BytecodeProgram } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { numberValue } from \"@solve-js/vm/Value\";\nimport {\n\tcurrencyExchangeService,\n\tCurrencyExchangeService,\n} from \"@solve-js/uom/CurrencyExchange\";\nimport type { IAsyncResolver, AsyncCheckResult } from \"@solve-js/resolvers/ResolverRegistry\";\nimport { nextInstruction } from \"@solve-js/parser/OperandWidth\";\n\nconst CURRENCY_NS = \"currency\";\n\n/**\n * Fetches exchange rates before the VM runs, so a conversion has real numbers.\n *\n * Until rates arrive the line evaluates to a pending value rather than a\n * guessed one, and re-evaluates when they land.\n */\nexport class CurrencyAsyncResolver implements IAsyncResolver {\n\treadonly namespace = CURRENCY_NS;\n\n\tprivate exchange: CurrencyExchangeService;\n\n\tconstructor(exchange?: CurrencyExchangeService) {\n\t\tthis.exchange = exchange ?? currencyExchangeService;\n\t}\n\n\tpreflight(_tokens: Token[], bytecode: BytecodeProgram, packageId: string, signal: AbortSignal, queryClient: QueryClient): AsyncCheckResult | null {\n\t\tconst { opcodes, strings } = bytecode;\n\t\tconst len = opcodes.length;\n\t\tlet i = 0;\n\n\t\tlet lastStrIdx = -1;\n\t\tlet prevStrIdx = -1;\n\n\t\twhile (i < len) {\n\t\t\tconst op = opcodes[i] as OpCode;\n\n\t\t\tif (op === OpCode.PUSH_STRING) {\n\t\t\t\tprevStrIdx = lastStrIdx;\n\t\t\t\tlastStrIdx = opcodes[i + 1];\n\t\t\t}\n\n\t\t\t// Explicit \"X to Y\"/\"X in Y\" conversions (UOM_CONVERT_IN/_TO) are\n\t\t\t// the obvious case, but arithmetic directly on two differently-\n\t\t\t// denominated currency literals, \"0.01 BTC + 1 ETH\", needs the\n\t\t\t// exact same preflight fetch and previously never got it: this\n\t\t\t// scanner only looked for the CONVERT opcodes, so ADD/SUB/MUL/DIV\n\t\t\t// between two currency UOMs skipped preflight entirely, ran with\n\t\t\t// no cached rate, and fell through to the VM's silent-wrong-math\n\t\t\t// fallback instead of ever reaching a network fetch.\n\t\t\tconst isCurrencyCombiningOp =\n\t\t\t\top === OpCode.UOM_CONVERT_IN || op === OpCode.UOM_CONVERT_TO ||\n\t\t\t\top === OpCode.ADD || op === OpCode.SUB || op === OpCode.MUL || op === OpCode.DIV;\n\t\t\tif (isCurrencyCombiningOp) {\n\t\t\t\tif (prevStrIdx >= 0 && lastStrIdx >= 0) {\n\t\t\t\t\tconst fromUnit = strings[prevStrIdx];\n\t\t\t\t\tconst toUnit = strings[lastStrIdx];\n\n\t\t\t\t\tif (\n\t\t\t\t\t\tthis.exchange.isCurrency(fromUnit) &&\n\t\t\t\t\t\tthis.exchange.isCurrency(toUnit) &&\n\t\t\t\t\t\tfromUnit.toUpperCase() !== toUnit.toUpperCase()\n\t\t\t\t\t) {\n\t\t\t\t\t\tconst syncRate = this.exchange.getRateSync(fromUnit, toUnit);\n\t\t\t\t\t\tif (syncRate === null) {\n\t\t\t\t\t\t\tconst fromUpper = fromUnit.toUpperCase();\n\t\t\t\t\t\t\tconst toUpper = toUnit.toUpperCase();\n\n\t\t\t\t\t\t\t// Check TanStack Query cache\n\t\t\t\t\t\t\tconst cacheKey = [CURRENCY_NS, fromUpper, toUpper];\n\t\t\t\t\t\t\tif (queryClient.getQueryData(cacheKey) !== undefined) {\n\t\t\t\t\t\t\t\ti++;\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// Fetch via TanStack Query (dedup + retry automatic)\n\t\t\t\t\t\t\tconst resolver = queryClient.fetchQuery({\n\t\t\t\t\t\t\t\tqueryKey: cacheKey,\n\t\t\t\t\t\t\t\tqueryFn: ({ signal: qSignal }) => {\n\t\t\t\t\t\t\t\t\treturn this.exchange.getRate(fromUnit, toUnit, qSignal).then((rate) => numberValue(rate));\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tstaleTime: 5 * 60 * 1000,\n\t\t\t\t\t\t\t});\n\n\t\t\t\t\t\t\treturn { queryKey: cacheKey.join(\":\"), resolver, packageId, signal, metadata: { fromUnit, toUnit } };\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Step over this instruction and its operands. Shared table, because\n\t\t\t// three hand-copied versions of this had already drifted.\n\t\t\ti = nextInstruction(opcodes, i);\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tdestroy(): void {\n\t\t// Cache cleared by ResolverRegistry.unregister() via removeQueries({ queryKey: [\"currency\"] })\n\t}\n}\n"]}