solve-engine 1.0.2 → 1.1.0

package/dist/chunk-UQ3UIZJC.js.map

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

package/dist/chunk-VB37OC6I.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-VB37OC6I.js","sourcesContent":["/**\n * Lexer token produced by {@link ExpressionLexer} and consumed by parsers.\n *\n * Each token carries:\n * - `type`: string name (e.g. \"NUMBER\", \"PLUS\") for diagnostics and parselet lookup\n * - `typeId`: integer ID for O(1) comparison in parser hot paths\n * - `value`/`text`: the token's semantic value and raw source text\n * - `offset`/`line`/`col`: source position for error messages and highlighting\n */\nexport interface Token {\n\t/** String token type (e.g., \"NUMBER\", \"PLUS\", \"IDENT\"). Used by ParseletRegistry string-keyed maps and error messages. */\n\ttype: string;\n\t/** Integer token type ID for fast comparison in Parser hot path.\n\t * Populated by the Lexer via registerTokenType(). Use tokenTypeId(type) to get a type's ID. */\n\ttypeId: number;\n\tvalue: string;\n\ttext: string;\n\toffset: number;\n\tlineBreaks: number;\n\tline: number;\n\tcol: number;\n\t/**\n\t * End offset of the source text this token was fused from, exclusive.\n\t *\n\t * Only set on tokens the normalizer built by fusing several lexer tokens\n\t * into one, and only there because those are the tokens whose `value` no\n\t * longer describes the text they came from. `10 frames` fuses into a\n\t * FRAME_COUNT whose value is `10`, so `offset + value.length` would cover\n\t * two characters of a nine-character phrase.\n\t *\n\t * Evaluation never reads this. It exists so that a consumer painting a line\n\t * (see `LanguageService.getSemanticTokens`) can highlight a fused phrase as\n\t * the one thing the parser will see rather than as its parts.\n\t */\n\tsourceEnd?: number;\n}\n\n/**\n * Canonical token type name constants.\n * All token types used by the lexer, parser, and VM are defined here.\n * Custom/plugin token types should be registered via {@link registerTokenType}.\n */\nexport const TokenTypes = {\n  NUMBER: \"NUMBER\",\n  BIGINT: \"BIGINT\",\n  STRING: \"STRING\",\n  IDENT: \"IDENT\",\n  PLUS: \"PLUS\",\n  MINUS: \"MINUS\",\n  STAR: \"STAR\",\n  SLASH: \"SLASH\",\n  CARET: \"CARET\",\n  PERCENT: \"PERCENT\",\n  LSHIFT: \"LSHIFT\",\n  RSHIFT: \"RSHIFT\",\n  URSHIFT: \"URSHIFT\",\n  LPAREN: \"LPAREN\",\n  RPAREN: \"RPAREN\",\n  LBRACKET: \"LBRACKET\",\n  RBRACKET: \"RBRACKET\",\n  LBRACE: \"LBRACE\",\n  RBRACE: \"RBRACE\",\n  COMMA: \"COMMA\",\n  DOT: \"DOT\",\n  COLON: \"COLON\",\n  SEMICOLON: \"SEMICOLON\",\n  EQUALS: \"EQUALS\",\n  DOLLAR: \"DOLLAR\",\n  POUND: \"POUND\",\n  EURO: \"EURO\",\n  YEN: \"YEN\",\n  RUBLE: \"RUBLE\",\n  WON: \"WON\",\n  QUESTION: \"QUESTION\",\n  BANG: \"BANG\",\n  BIT_AND: \"BIT_AND\",\n  BIT_OR: \"BIT_OR\",\n  BIT_NOT: \"BIT_NOT\",\n  KEYWORD: \"KEYWORD\",\n  EOF: \"EOF\",\n  ERROR: \"ERROR\",\n  WS: \"WS\",\n  NEWLINE: \"NEWLINE\",\n  DATETIME_LITERAL: \"DATETIME_LITERAL\",\n  DURATION: \"DURATION\",\n  UNIT: \"UNIT\",\n  ROLL: \"ROLL\",\n  PI: \"PI\",\n  E: \"E\",\n  MOD: \"MOD\",\n  // The English word \"and\", which is NOT the same thing as \"+\" even though it\n  // adds. It used to map straight onto PLUS in the locale keyword map, which\n  // made \"3 and 4\" evaluate to 7 correctly and then quietly broke every phrase\n  // that uses \"and\" as a list separator: \"average of 36, 42, 19 and 81\" parsed\n  // its last argument as \"19 + 81\" and returned 178/3 rather than 178/4.\n  //\n  // Giving it its own type lets a parselet tell the two apart. It is still an\n  // infix addition (see ArithmeticPackage.ts) so \"3 and 4\" is unchanged, but it\n  // binds at BindingPower.Conjunction, looser than both Sum and Conditional, so\n  // a phrase parselet can parse an argument at Conjunction and get \"1 + 2\"\n  // whole while still stopping at \"and\", and so \"5 > 3 and 2 > 1\" reads as the\n  // conjunction of two comparisons rather than \"5 > (3 and 2) > 1\".\n  AND_CONJ: \"AND_CONJ\",\n  OF: \"OF\",\n  INCREASE_BY: \"INCREASE_BY\",\n  DECREASE_BY: \"DECREASE_BY\",\n  // Percentage solve-for-unknown (packages/percentage/), \"N% of what is\n  // X\" solves N% * base = X for base. Fused as a full 3-word phrase (see\n  // PercentagePackage.ts's `phrases` field) rather than a bare \"what\"\n  // keyword, \"what\" is common enough as a variable name to be worth the\n  // same phrase-fusion treatment this codebase gives \"total\"/\"average\"/etc.\n  OF_WHAT_IS: \"OF_WHAT_IS\",\n  // Sibling solve-for-unknown forms accounting for a +/-1 offset, \"N% on\n  // what is X\" (increase) / \"N% off what is X\" (decrease). Same\n  // phrase-fusion reasoning as OF_WHAT_IS above.\n  ON_WHAT_IS: \"ON_WHAT_IS\",\n  OFF_WHAT_IS: \"OFF_WHAT_IS\",\n  NOW: \"NOW\",\n  TODAY: \"TODAY\",\n  TOMORROW: \"TOMORROW\",\n  YESTERDAY: \"YESTERDAY\",\n  DURATION_DAY: \"DURATION_DAY\",\n  DURATION_WEEK: \"DURATION_WEEK\",\n  DURATION_MONTH: \"DURATION_MONTH\",\n  DURATION_YEAR: \"DURATION_YEAR\",\n  DURATION_HOUR: \"DURATION_HOUR\",\n  DURATION_MINUTE: \"DURATION_MINUTE\",\n  DURATION_SECOND: \"DURATION_SECOND\",\n  FUNC: \"FUNC\",\n  CONVERT: \"CONVERT\",\n  TO: \"TO\",\n  BEST: \"BEST\",\n  NEXT: \"NEXT\",\n  LAST: \"LAST\",\n  UNTIL: \"UNTIL\",\n  SINCE: \"SINCE\",\n  BETWEEN: \"BETWEEN\",\n  FROM: \"FROM\",\n  INCREASE: \"INCREASE\",\n  DECREASE: \"DECREASE\",\n  UNICODE_MATH: \"UNICODE_MATH\",\n  TIMES_BY: \"TIMES_BY\",\n  MULTIPLY_BY: \"MULTIPLY_BY\",\n  DIVIDE_BY: \"DIVIDE_BY\",\n  NEQ: \"NEQ\",\n  IN: \"IN\",\n  BIT_XOR: \"BIT_XOR\",\n  EQUALITY: \"EQUALITY\",\n  GTE: \"GTE\",\n  LTE: \"LTE\",\n  LT: \"LT\",\n  GT: \"GT\",\n  LOGICAL_AND: \"LOGICAL_AND\",\n  LOGICAL_OR: \"LOGICAL_OR\",\n  OR: \"OR\",\n  TRUE: \"TRUE\",\n  FALSE: \"FALSE\",\n  IF: \"IF\",\n  THEN: \"THEN\",\n  ELSE: \"ELSE\",\n  AS: \"AS\",\n  CONVERTER_NAME: \"CONVERTER_NAME\",\n  // Rounding (packages/converters/). \"rounded\" is a bare keyword: it is a\n  // past participle with no plausible use as a :variableName, the same\n  // accepted-risk category as \"between\"/\"from\". TO_NEAREST and\n  // DECIMAL_PLACES are fused, since \"to\" already means percentage change.\n  ROUNDED: \"ROUNDED\",\n  TO_NEAREST: \"TO_NEAREST\",\n  DECIMAL_PLACES: \"DECIMAL_PLACES\",\n  // Fused two-word phrase tokens (see MathPhrasesPackage.ts's `phrases`\n  // field), deliberately NOT bare single-word keywords: \"average\"\n  // \"total\", \"count\", etc. are common variable names, and this codebase\n  // has a tested policy that colon-prefixed variable names can't be\n  // keyword-shaped words (see VariableParselet.ts's doc comment). Fusing\n  // the full \"<word> of\"/\"<word> between\" phrase means the bare word\n  // itself never becomes its own token type, so \":total = ...\" keeps\n  // working exactly as before.\n  AVERAGE_OF: \"AVERAGE_OF\",\n  MEDIAN_OF: \"MEDIAN_OF\",\n  TOTAL_OF: \"TOTAL_OF\",\n  COUNT_OF: \"COUNT_OF\",\n  LARGER_OF: \"LARGER_OF\",\n  SMALLER_OF: \"SMALLER_OF\",\n  HALF_OF: \"HALF_OF\",\n  MIDPOINT_BETWEEN: \"MIDPOINT_BETWEEN\",\n  REMAINDER_OF: \"REMAINDER_OF\",\n  NTH_ROOT: \"NTH_ROOT\",\n  LOG_PHRASE: \"LOG_PHRASE\",\n  LOG_BASE: \"LOG_BASE\",\n  GCD_OF: \"GCD_OF\",\n  LCM_OF: \"LCM_OF\",\n  SQUARE_ROOT_OF: \"SQUARE_ROOT_OF\",\n  CUBE_ROOT_OF: \"CUBE_ROOT_OF\",\n  RANDOM_NUMBER: \"RANDOM_NUMBER\",\n  IS_TO: \"IS_TO\",\n  // Bare \"is\", the trigger for the solve-for-the-unknown percentage family\n  // (packages/percentage/IsWhatParselet.ts). Safe as a bare keyword: it is a\n  // verb, not a plausible :variableName, and the \"is to\" proportion phrase is\n  // fused earlier so it still wins.\n  IS: \"IS\",\n  PCT_ON: \"PCT_ON\",\n  PCT_OFF: \"PCT_OFF\",\n  OF_WHAT: \"OF_WHAT\",\n  OFF_WHAT: \"OFF_WHAT\",\n  ON_WHAT: \"ON_WHAT\",\n  // CLAMP stays a bare single-word keyword: \"clamp X between Y and Z\" has\n  // the value X between the trigger and \"between\", so it can't be\n  // phrase-fused like the others above (same structural reason\n  // ClampParselet.ts is hand-written instead of PhrasePattern-based).\n  // Matches this codebase's existing accepted risk for \"between\"/\"from\"/\n  // \"next\"/\"last\"/\"best\", also bare, also can't be used as `:name`.\n  CLAMP: \"CLAMP\",\n  // map/reduce/sum/prod (packages/mapreduce/), bare single-word keywords\n  // each with its own dedicated parselet (custom argument grammar: a bare\n  // builtin/user-function name, an inline transform expression, or\n  // `name=collection` zipped pairs, none of which fit the ordinary\n  // FunctionCallParselet path, so these can't just reuse the generic FUNC\n  // token type the way sqrt/abs/... do).\n  MAP: \"MAP\",\n  REDUCE: \"REDUCE\",\n  SUM_FN: \"SUM_FN\",\n  PROD_FN: \"PROD_FN\",\n  // The algebra verbs (packages/symbolic/), fused from an ordinary IDENT only\n  // when immediately followed by `(`, so `factor`/`solve`/`expand` stay usable\n  // as variable names. Declared here rather than left to be minted on first use\n  // by `tokenTypeId()`, which is what {@link registerAllTokenTypes} exists for:\n  // a lazily-minted id depends on what else happened to be minted before it, so\n  // in a single-process run the id a normalizer rule produces can stop matching\n  // the id the parselet was registered under. Every token type a built-in\n  // package relies on belongs in this table.\n  EXPAND_FN: \"EXPAND_FN\",\n  FACTOR_FN: \"FACTOR_FN\",\n  SOLVE_FN: \"SOLVE_FN\",\n  DER_FN: \"DER_FN\",\n  INTEGRAL_FN: \"INTEGRAL_FN\",\n  TAYLOR_FN: \"TAYLOR_FN\",\n  JACOBIAN_FN: \"JACOBIAN_FN\",\n  CONJ_FN: \"CONJ_FN\",\n  RE_FN: \"RE_FN\",\n  IM_FN: \"IM_FN\",\n  CANCEL_FN: \"CANCEL_FN\",\n  APART_FN: \"APART_FN\",\n  // The imaginary-literal suffix, fused from a number followed immediately by\n  // `i`. Same registration reasoning as the verbs above.\n  IMAGINARY: \"IMAGINARY\",\n  // `=>`, \"therefore\"/solve operator. The algebra itself lives in symbolic/;\n  // packages/symbolic/ carries the grammar surface for the named operations.\n  // A genuine 2-char lexer token (ExpressionLexer.ts's TWO_CHAR_OPS table),\n  // same mechanism as ==/!=/>=/<=, not a normalizer-level fusion, \"=\" then\n  // \">\" is the opposite char order from GTE's \">=\", so there's no collision.\n  THEREFORE: \"THEREFORE\",\n  // Timezone query phrases (see TimePackage.ts's `phrases` field). Same\n  // phrase-fusion reasoning as above: \"time\"/\"date\"/\"difference\" are\n  // common variable names, so the fused trigger is the full phrase.\n  // CITY_NAME is the fused-token type for multi-word city/country names\n  // (e.g. \"new york\"). See timezones/CityZones.ts's MULTI_WORD_CITY_ZONES.\n  TIME_IN: \"TIME_IN\",\n  DATE_IN: \"DATE_IN\",\n  TIME_DIFFERENCE_BETWEEN: \"TIME_DIFFERENCE_BETWEEN\",\n  CITY_NAME: \"CITY_NAME\",\n  BACKTICK_OPEN: \"BACKTICK_OPEN\",\n  INLINE_SOLVE_START: \"INLINE_SOLVE_START\",\n  // Comment marker, `#` or `//` to end of line. Emitted by\n  // ExpressionLexer.tokenizeComment()/tokenizeOperator() but never reaches\n  // a parselet: ExpressionEngine.prepareExpression() filters COMMENT\n  // tokens out of the stream before normalization/parsing (see\n  // ExpressionEngine.ts's \"Filter COMMENT tokens\" comments). Listed here\n  // for discoverability even though tokenTypeId() would lazily register\n  // it anyway on first use.\n  COMMENT: \"COMMENT\",\n  // Vector types (referenced in locale keywordMap as vec2→VEC2, etc.)\n  VEC2: \"VEC2\",\n  VEC3: \"VEC3\",\n  VEC4: \"VEC4\",\n  FLOAT: \"FLOAT\",\n  GLOBAL: \"GLOBAL\",\n  // ── Finance (packages/finance/) ──\n  // OVER/RATE_AT are bare single-word keywords (not phrase-fused): both are\n  // prepositions with near-zero plausibility as a variable name (nobody\n  // writes \":over = 5\" or \":at = 3\"), the same accepted-risk category as\n  // this codebase's existing bare \"between\"/\"from\"/\"next\"/\"last\"/\"best\"\n  // keywords (see VariableParselet.ts's doc comment). RATE_AT is deliberately\n  // NOT named \"AT\", that name is already reserved (dormant) for a future\n  // \"@\" symbol token in TokenNormalizer.NON_WORD_NAMES; reusing it here would\n  // create an unintended coupling if \"@\" is ever wired up.\n  OVER: \"OVER\",\n  RATE_AT: \"RATE_AT\",\n  // The investment grammar's connectives (packages/finance/), same\n  // accepted-risk category as OVER/RATE_AT above. \"after\"/\"for\" are\n  // prepositions; \"compounding\", \"invested\" and \"returned\" are participles,\n  // and none is a plausible `:variableName`.\n  //\n  // \"after\" and \"for\" are the pivots Soulver's own documented syntax uses,\n  // `$1,000 after 3 years at 7%` and `$1,000 for 3 years at 7% compounding\n  // monthly`. This package originally substituted \"over\" for both and said so\n  // in CompoundInterestParselet.ts's doc comment; the documented spellings now\n  // work as well, and \"over\" is kept so nothing that already parsed stops.\n  AFTER: \"AFTER\",\n  PRESENT_VALUE_OF: \"PRESENT_VALUE_OF\",\n  ANNUAL_RETURN_ON: \"ANNUAL_RETURN_ON\",\n  FOR_DURATION: \"FOR_DURATION\",\n  COMPOUNDING: \"COMPOUNDING\",\n  INVESTED: \"INVESTED\",\n  RETURNED: \"RETURNED\",\n  // Fused phrase tokens (see FinancePackage.ts's `phrases` field)\n  // deliberately NOT bare single-word keywords: \"interest\", \"tax\", \"vat\",\n  // \"repayment\", \"principal\" etc. are all common, plausible variable names\n  // (a shipped playground example uses \":total = :subtotal + :tax\". See\n  // MathPhrasesPackage.ts's doc comment for the regression this caused\n  // once already). Fusing the full \"<word> on\"/\"<word> off\" phrase means\n  // the bare leading word itself never becomes its own token type, so\n  // \":tax = ...\" keeps working exactly as before.\n  COMPOUND_INTEREST_ON: \"COMPOUND_INTEREST_ON\",\n  INTEREST_ON: \"INTEREST_ON\",\n  DAILY_REPAYMENT_ON: \"DAILY_REPAYMENT_ON\",\n  MONTHLY_REPAYMENT_ON: \"MONTHLY_REPAYMENT_ON\",\n  ANNUAL_REPAYMENT_ON: \"ANNUAL_REPAYMENT_ON\",\n  TOTAL_REPAYMENT_ON: \"TOTAL_REPAYMENT_ON\",\n  DAILY_LOAN_INTEREST_ON: \"DAILY_LOAN_INTEREST_ON\",\n  MONTHLY_LOAN_INTEREST_ON: \"MONTHLY_LOAN_INTEREST_ON\",\n  ANNUAL_LOAN_INTEREST_ON: \"ANNUAL_LOAN_INTEREST_ON\",\n  TOTAL_LOAN_INTEREST_ON: \"TOTAL_LOAN_INTEREST_ON\",\n  TAX_ON: \"TAX_ON\",\n  TAX_OFF: \"TAX_OFF\",\n  TAX_IN_PHRASE: \"TAX_IN_PHRASE\",\n  // Inflation-adjusted value (packages/finance/) -- fused phrase\n  // tokens (see FinancePackage.ts's `phrases` field), same reasoning\n  // as the tax/interest phrases above: \"what\"/\"was\"/\"value\"/\"worth\"\n  // are all plausible variable names, so only the full phrases are\n  // ever claimed as keywords, never the bare leading word.\n  WHAT_IS: \"WHAT_IS\",\n  WHAT_WAS: \"WHAT_WAS\",\n  VALUE_OF: \"VALUE_OF\",\n  WORTH_IN: \"WORTH_IN\",\n  // Bare single-word keyword (not phrase-fused) -- \"assuming\" has\n  // near-zero plausibility as a variable name, the same accepted-risk\n  // category as this codebase's existing bare \"over\"/\"at\" keywords\n  // (see the OVER/RATE_AT comment above). Registered so its bare word\n  // is a recognized phrase-starter (`canStartPhrase`), which suppresses\n  // implicit-multiply insertion between the futureYear NUMBER and this\n  // word in \"value of $X in <year> assuming N% inflation\" -- without\n  // this, \"<year> assuming\" was silently rewritten to \"<year> *\n  // assuming\" before parsing ever ran.\n  ASSUMING: \"ASSUMING\",\n  // Fused by a custom NormalizerRule (not `phrases`), carrying the\n  // year as its value -- see\n  // finance/normalizer/InYearDollarsNormalizerRule.ts.\n  IN_YEAR_DOLLARS: \"IN_YEAR_DOLLARS\",\n  // Cooking/UoM (packages/uom/) -- fused ingredient name (single- or\n  // multi-word, e.g. \"butter\"/\"olive oil\") carrying the matched name\n  // as its value. NOT a bare-word phrase-trie keyword -- see\n  // uom/normalizer/IngredientNameNormalizerRule.ts's doc comment for\n  // why this is a context-sensitive NormalizerRule instead (so a bare\n  // `:butter = 5` variable definition is completely unaffected).\n  INGREDIENT_NAME: \"INGREDIENT_NAME\",\n  // ── Datetime, workdays/weekdays/timestamps (packages/datetime/) ──\n  // Fused phrase tokens (see DatetimePackage.ts's `phrases` field)\n  // deliberately NOT bare single-word keywords: \"workdays\"/\"weekday\"/\n  // \"timestamp\"/\"date\" are all plausible variable names, same\n  // reasoning/regression risk as MathPhrasesPackage.ts's \"total\" note and\n  // FinancePackage.ts's \"tax\" note above. Fusing the full phrase means the\n  // bare leading word itself never becomes its own token type, so e.g.\n  // \":timestamp = 5\" keeps working.\n  WORKDAYS_IN: \"WORKDAYS_IN\",\n  WEEKDAY_ON: \"WEEKDAY_ON\",\n  CURRENT_TIMESTAMP: \"CURRENT_TIMESTAMP\",\n  TO_DATE: \"TO_DATE\",\n  TO_TIMESTAMP: \"TO_TIMESTAMP\",\n  // Natural-question forms over the same date fields, \"what day is it in\n  // 30 days\", \"what month is it on 25/12/2026\", \"what week is it\". Each is\n  // a fully-fused phrase for the same reason as WEEKDAY_ON above: claiming\n  // bare \"day\"/\"month\"/\"week\" as keywords would break \":day = 5\" and\n  // collide with the UNIT tokens of the same name.\n  WEEKDAY_IN: \"WEEKDAY_IN\",\n  MONTH_ON: \"MONTH_ON\",\n  MONTH_IN: \"MONTH_IN\",\n  WEEK_ON: \"WEEK_ON\",\n  DAYS_IN_PERIOD: \"DAYS_IN_PERIOD\",\n  IN_TWO_UNITS: \"IN_TWO_UNITS\",\n  PER_UNIT: \"PER_UNIT\",\n  AT_RATE: \"AT_RATE\",\n  WEEK_IN: \"WEEK_IN\",\n  // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like\n  // UNTIL_UNIT/SINCE_UNIT above.\n  BETWEEN_UNIT: \"BETWEEN_UNIT\",\n  // Postfix day-type predicates, \"<date> is a weekend\" / \"is a workday\".\n  IS_WEEKEND: \"IS_WEEKEND\",\n  IS_WORKDAY: \"IS_WORKDAY\",\n  // ── Time, video timecode (packages/time/) ──\n  // Fused from a raw `HH:MM:SS:FF` token sequence (see\n  // packages/time/normalizer/VideoTimecodeNormalizerRule.ts) and from\n  // `NUMBER frames` (see FrameCountNormalizerRule.ts), not a bare-keyword\n  // collision risk the way the datetime tokens above are, since neither\n  // fusion claims a plain English word as its own token type.\n  VIDEO_TIMECODE: \"VIDEO_TIMECODE\",\n  FRAME_COUNT: \"FRAME_COUNT\",\n  // \"@\". See ExpressionLexer.ts's OP_MAP entry for why this was\n  // previously dormant/unproduced despite being anticipated by name here\n  // and in TokenNormalizer.ts's NON_WORD_NAMES.\n  AT: \"AT\",\n  // Generic token for every currency symbol added AFTER the original\n  // DOLLAR/POUND/EURO/YEN/RUBLE/WON set (each of which kept its own\n  // specific token type for backward compatibility). See\n  // uom/CurrencyAliases.ts's CURRENCY_SYMBOL_ALIASES and\n  // ExpressionLexer.ts's dispatch for the full symbol list. One shared\n  // type avoids needing a new TokenTypes entry + TokenCategoryMap entry +\n  // CurrencyPackage.ts prefixParselets entry per additional symbol.\n  CURRENCY_SYMBOL: \"CURRENCY_SYMBOL\",\n  // ── Cross-line data access (packages/lines/) ──\n  // \"prev\" -- bare keyword (nothing to phrase-fuse against, same shape as\n  // CLAMP -- accepted collision risk per that package's own precedent).\n  PREV: \"PREV\",\n  // \"line1\" / \"line 1\" / \"l1\" -- fused by LineRefNormalizerRule (never a\n  // bare lexer keyword, so \":line = 5\"/\":l = 5\" stay untouched). Carries\n  // the parsed line number as its .value.\n  LINE_REF: \"LINE_REF\",\n  // \"sum(\" / \"total(\" -- fused ONLY when immediately followed by LPAREN\n  // (see LineRefNormalizerRule's lookahead guard), so \":sum = 100\" and\n  // MathPhrases' \"total of X, Y\" (no paren after \"of\") are unaffected.\n  SUM_RANGE_CALL: \"SUM_RANGE_CALL\",\n  AVERAGE_RANGE_CALL: \"AVERAGE_RANGE_CALL\",\n  // \"total above\" / \"sum above\" / \"average above\" -- phrase-fused (see\n  // LinesPackage.ts's `phrases` field), a deliberate departure from\n  // Numi/Numbr's bare \"total\"/\"sum\" wording to avoid the exact bare-\n  // keyword collision this codebase already regressed on once.\n  TOTAL_ABOVE: \"TOTAL_ABOVE\",\n  SUM_ABOVE: \"SUM_ABOVE\",\n  AVERAGE_ABOVE: \"AVERAGE_ABOVE\",\n} as const;\n\n/**\n * A token's kind, as a string.\n *\n * Deliberately open rather than an enum: a package registers its own token\n * types at runtime, and a closed set would make that impossible.\n */\nexport type TokenType = (typeof TokenTypes)[keyof typeof TokenTypes];\n\n// ── Integer Token Type ID System ──────────────────────────────────────────────\n// Enables O(1) integer comparison in Parser hot path instead of string hashing.\n\n/** Auto-incrementing integer ID for each token type. */\nlet _nextTokenTypeId = 0;\n\n/** String → integer ID lookup. Populated lazily via registerTokenType(). */\nconst _tokenTypeNameToId = new Map<string, number>();\n\n/** Integer ID → string lookup. For debug/error messages. */\nconst _tokenTypeIdToName = new Map<number, string>();\n\n/**\n * Register a token type name and get back its integer ID.\n * Idempotent, returns existing ID if already registered.\n * Call once per token type at module initialization time.\n */\nexport function registerTokenType(name: string): number {\n\tconst existing = _tokenTypeNameToId.get(name);\n\tif (existing !== undefined) return existing;\n\tconst id = _nextTokenTypeId++;\n\t_tokenTypeNameToId.set(name, id);\n\t_tokenTypeIdToName.set(id, name);\n\treturn id;\n}\n\n/**\n * Get the integer ID for a token type name.\n * Lazily registers unknown token types on first access, enabling plugin providers\n * to define custom token types (VEC2, VEC3, etc.) without pre-registration.\n * All built-in TokenTypes are pre-registered via registerAllTokenTypes().\n */\nexport function tokenTypeId(name: string): number {\n\treturn registerTokenType(name);  // registerTokenType is idempotent\n}\n\n/**\n * Get the string name for a token type ID (for error messages and debugging).\n * Returns `UNKNOWN_${id}` if the ID is not registered.\n */\nexport function tokenTypeName(id: number): string {\n\treturn _tokenTypeIdToName.get(id) ?? `UNKNOWN_${id}`;\n}\n\n/**\n * Bootstrap all known token types from TokenTypes at module load.\n * Call this once after TokenTypes is defined.\n */\nexport function registerAllTokenTypes(): void {\n\tfor (const name of Object.values(TokenTypes)) {\n\t\tregisterTokenType(name);\n\t}\n}\n"]}