solve-engine 1.1.0 → 1.2.0

package/dist/{chunk-QFTDTX6K.cjs → chunk-G2YPPLGX.cjs}

@@ -8,6 +8,10 @@ var TokenTypes = {
   IDENT: "IDENT",
   PLUS: "PLUS",
   MINUS: "MINUS",
+  // Compound assignment for running totals: `total += 100`, `total -= 40`.
+  // Handled by the engine's compound-assignment interception, not a parselet.
+  PLUS_EQUALS: "PLUS_EQUALS",
+  MINUS_EQUALS: "MINUS_EQUALS",
   STAR: "STAR",
   SLASH: "SLASH",
   // The uncertainty operator, `±` (U+00B1) or the ASCII `+/-`. The symbol is
@@ -102,6 +106,19 @@ var TokenTypes = {
   UNTIL: "UNTIL",
   SINCE: "SINCE",
   BETWEEN: "BETWEEN",
+  // Bill split (finance package). Retyped from the ordinary words "split",
+  // "ways" and "people" by BillSplitNormalizerRule, but only inside the full
+  // split shape, so those words stay usable as variable names and prose
+  // everywhere else (the same contextual-claim discipline as the recurring
+  // schedule and at-rate rules).
+  // The verb-first `split <amount> between N` form (prefix).
+  SPLIT: "SPLIT",
+  // The amount-first `<amount> split N ways` form (infix). A separate,
+  // infix-only token so implicit multiplication does not read it as the start
+  // of a new value and insert a `*` before it, which the dual-role SPLIT would.
+  SPLIT_WAYS: "SPLIT_WAYS",
+  WAYS: "WAYS",
+  PEOPLE: "PEOPLE",
   FROM: "FROM",
   INCREASE: "INCREASE",
   DECREASE: "DECREASE",
@@ -248,6 +265,11 @@ var TokenTypes = {
   // would otherwise be a heading/comment; the colour package's parselet turns
   // it into a colour value. See ExpressionLexer.matchHexColourEnd().
   HEX_COLOUR: "HEX_COLOUR",
+  // A bounded mid-line `#tag` annotation (`1200 #housing`). Stripped from
+  // evaluation by the tags package's strip rule, or consumed by its aggregate
+  // rule (`total of #housing`). A line-start `#` is a heading, and `# ` (space)
+  // or `//` is still a free-text comment.
+  TAG: "TAG",
   // A colour function call fused by the colour package's normalizer, e.g.
   // `rgb(`/`lighten(`. Carries the function name; see ColourCallParselet.
   COLOUR_CALL: "COLOUR_CALL",
@@ -315,6 +337,11 @@ var TokenTypes = {
   WHAT_WAS: "WHAT_WAS",
   VALUE_OF: "VALUE_OF",
   WORTH_IN: "WORTH_IN",
+  // Savings goals (finance). Fused whole-phrase triggers, so "how", "much",
+  // "save" and "reach" stay ordinary variable names, the same reason as the
+  // other finance phrases above.
+  SAVINGS_HOW_LONG: "SAVINGS_HOW_LONG",
+  SAVINGS_HOW_MUCH: "SAVINGS_HOW_MUCH",
   // Bare single-word keyword (not phrase-fused) -- "assuming" has
   // near-zero plausibility as a variable name, the same accepted-risk
   // category as this codebase's existing bare "over"/"at" keywords
@@ -453,5 +480,5 @@ exports.registerAllTokenTypes = registerAllTokenTypes;
 exports.registerTokenType = registerTokenType;
 exports.tokenTypeId = tokenTypeId;
 exports.tokenTypeName = tokenTypeName;
-//# sourceMappingURL=chunk-QFTDTX6K.cjs.map
-//# sourceMappingURL=chunk-QFTDTX6K.cjs.map
+//# sourceMappingURL=chunk-G2YPPLGX.cjs.map
+//# sourceMappingURL=chunk-G2YPPLGX.cjs.map

package/dist/chunk-G2YPPLGX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-G2YPPLGX.cjs","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  // Compound assignment for running totals: `total += 100`, `total -= 40`.\n  // Handled by the engine's compound-assignment interception, not a parselet.\n  PLUS_EQUALS: \"PLUS_EQUALS\",\n  MINUS_EQUALS: \"MINUS_EQUALS\",\n  STAR: \"STAR\",\n  SLASH: \"SLASH\",\n  // The uncertainty operator, `±` (U+00B1) or the ASCII `+/-`. The symbol is\n  // lexed directly (ExpressionLexer.ts, alongside `×`/`÷`), and the ASCII\n  // spelling is fused from PLUS SLASH MINUS by a normalizer rule (see\n  // packages/uncertainty/). Registered here rather than left to be lazily\n  // minted so its id is stable, the same reasoning as the algebra verbs below.\n  PLUS_MINUS: \"PLUS_MINUS\",\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  // Bill split (finance package). Retyped from the ordinary words \"split\",\n  // \"ways\" and \"people\" by BillSplitNormalizerRule, but only inside the full\n  // split shape, so those words stay usable as variable names and prose\n  // everywhere else (the same contextual-claim discipline as the recurring\n  // schedule and at-rate rules).\n  // The verb-first `split <amount> between N` form (prefix).\n  SPLIT: \"SPLIT\",\n  // The amount-first `<amount> split N ways` form (infix). A separate,\n  // infix-only token so implicit multiplication does not read it as the start\n  // of a new value and insert a `*` before it, which the dual-role SPLIT would.\n  SPLIT_WAYS: \"SPLIT_WAYS\",\n  WAYS: \"WAYS\",\n  PEOPLE: \"PEOPLE\",\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  // Successive percentage change (packages/percentage/UpDownParselet.ts):\n  // `X up N%` grows, `X down N%` shrinks, chainable with `then` and\n  // repeatable with `N times`. Retyped from a bare `up`/`down` IDENT only\n  // when a percentage immediately follows (PercentUpDownNormalizerRule), so\n  // prose that merely mentions the words is untouched. Declared here rather\n  // than minted lazily for the same reason as the algebra verbs below: a\n  // normalizer rule and its parselet must agree on the id.\n  PCT_UP: \"PCT_UP\",\n  PCT_DOWN: \"PCT_DOWN\",\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  // A `#hex` colour literal (`#ff0000`), recognised by the lexer where `#`\n  // would otherwise be a heading/comment; the colour package's parselet turns\n  // it into a colour value. See ExpressionLexer.matchHexColourEnd().\n  HEX_COLOUR: \"HEX_COLOUR\",\n  // A bounded mid-line `#tag` annotation (`1200 #housing`). Stripped from\n  // evaluation by the tags package's strip rule, or consumed by its aggregate\n  // rule (`total of #housing`). A line-start `#` is a heading, and `# ` (space)\n  // or `//` is still a free-text comment.\n  TAG: \"TAG\",\n  // A colour function call fused by the colour package's normalizer, e.g.\n  // `rgb(`/`lighten(`. Carries the function name; see ColourCallParselet.\n  COLOUR_CALL: \"COLOUR_CALL\",\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  // Savings goals (finance). Fused whole-phrase triggers, so \"how\", \"much\",\n  // \"save\" and \"reach\" stay ordinary variable names, the same reason as the\n  // other finance phrases above.\n  SAVINGS_HOW_LONG: \"SAVINGS_HOW_LONG\",\n  SAVINGS_HOW_MUCH: \"SAVINGS_HOW_MUCH\",\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  // Business-day arithmetic in words, \"N working/business days after|from|\n  // before <date>\" (infix, the count is the left operand) and \"working/\n  // business days between <date> and <date>\" (prefix). Full phrases for the\n  // same reason as WORKDAYS_IN above: \"working\"/\"business\" are ordinary words,\n  // so only the complete phrase is claimed, never the bare leading word. See\n  // WorkdayOffsetParselet.ts / WorkdaysBetweenParselet.ts.\n  WORKDAYS_AFTER: \"WORKDAYS_AFTER\",\n  WORKDAYS_BEFORE: \"WORKDAYS_BEFORE\",\n  WORKDAYS_BETWEEN: \"WORKDAYS_BETWEEN\",\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  // ── Goal seek (packages/goalseek/) ──\n  // \"solve line 4 for rate = 900\" -- fused by GoalSeekNormalizerRule when the\n  // bare word \"solve\" is immediately followed by a LINE_REF (never a bare\n  // lexer keyword, so \":solve = 2\" and the existing \"solve(...)\" call form\n  // both stay untouched, since neither is \"solve\" directly before a LINE_REF).\n  GOAL_SEEK: \"GOAL_SEEK\",\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"]}

package/dist/{chunk-HVRVSI2Z.cjs → chunk-GDEU72RG.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkXA4CKRML_cjs = require('./chunk-XA4CKRML.cjs');
-var chunkJ45BCEZ4_cjs = require('./chunk-J45BCEZ4.cjs');
-var chunkQFTDTX6K_cjs = require('./chunk-QFTDTX6K.cjs');
+var chunkHWHU642X_cjs = require('./chunk-HWHU642X.cjs');
+var chunkMI7OTUHL_cjs = require('./chunk-MI7OTUHL.cjs');
+var chunkG2YPPLGX_cjs = require('./chunk-G2YPPLGX.cjs');
 var chunkOUHT5Z36_cjs = require('./chunk-OUHT5Z36.cjs');
-var chunkB4HBEFTB_cjs = require('./chunk-B4HBEFTB.cjs');
+var chunkMIGXCBXT_cjs = require('./chunk-MIGXCBXT.cjs');
 
 // src/parser/registry/ParseletRegistry.ts
 function bindingPowersOf(parselet) {
@@ -49,7 +49,7 @@ var ParseletRegistry = class {
       );
     }
     this.prefixParselets.set(tokenType, parselet);
-    this.prefixById.set(chunkQFTDTX6K_cjs.tokenTypeId(tokenType), parselet);
+    this.prefixById.set(chunkG2YPPLGX_cjs.tokenTypeId(tokenType), parselet);
   }
   /** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */
   registerInfix(tokenType, parselet) {
@@ -60,7 +60,7 @@ var ParseletRegistry = class {
       );
     }
     this.infixParselets.set(tokenType, parselet);
-    this.infixById.set(chunkQFTDTX6K_cjs.tokenTypeId(tokenType), parselet);
+    this.infixById.set(chunkG2YPPLGX_cjs.tokenTypeId(tokenType), parselet);
   }
   /**
    * Iterate all registered prefix parselets for diagnostic display.
@@ -79,7 +79,7 @@ var ParseletRegistry = class {
     for (const [tokenType, parselet] of this.prefixParselets) {
       result.push({
         tokenType,
-        bindingPower: bindingPowersOf(parselet).bindingPower ?? chunkJ45BCEZ4_cjs.BindingPower.Prefix,
+        bindingPower: bindingPowersOf(parselet).bindingPower ?? chunkMI7OTUHL_cjs.BindingPower.Prefix,
         category: parselet.category
       });
     }
@@ -205,8 +205,8 @@ var _PrecedenceParser = class _PrecedenceParser {
       this.depth = 0;
       return;
     }
-    const LPAREN_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.LPAREN);
-    const RPAREN_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.RPAREN);
+    const LPAREN_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.LPAREN);
+    const RPAREN_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.RPAREN);
     let openCount = 0;
     for (let i = 0; i < tokens.length; i++) {
       if (tokens[i].typeId === LPAREN_ID) openCount++;
@@ -222,11 +222,11 @@ var _PrecedenceParser = class _PrecedenceParser {
   balanceParens(tokens, openCount) {
     const result = tokens.slice();
     if (openCount > 0) {
-      const RPAREN_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.RPAREN);
+      const RPAREN_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.RPAREN);
       for (let i = 0; i < openCount; i++) {
         const lastToken = tokens[tokens.length - 1];
         result.push({
-          type: chunkQFTDTX6K_cjs.TokenTypes.RPAREN,
+          type: chunkG2YPPLGX_cjs.TokenTypes.RPAREN,
           typeId: RPAREN_ID,
           value: ")",
           text: ")",
@@ -237,10 +237,10 @@ var _PrecedenceParser = class _PrecedenceParser {
         });
       }
     } else if (openCount < 0) {
-      const LPAREN_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.LPAREN);
+      const LPAREN_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.LPAREN);
       for (let i = 0; i < -openCount; i++) {
         result.unshift({
-          type: chunkQFTDTX6K_cjs.TokenTypes.LPAREN,
+          type: chunkG2YPPLGX_cjs.TokenTypes.LPAREN,
           typeId: LPAREN_ID,
           value: "(",
           text: "(",
@@ -271,7 +271,7 @@ var _PrecedenceParser = class _PrecedenceParser {
     this.depth++;
     if (this.depth > this.maxDepth) {
       this.depth--;
-      throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
         "NESTING_DEPTH_EXCEEDED",
         `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,
         { maxDepth: this.maxDepth, currentDepth: this.depth }
@@ -280,7 +280,7 @@ var _PrecedenceParser = class _PrecedenceParser {
     const token = this.consume();
     if (!token) {
       this.depth--;
-      throw chunkB4HBEFTB_cjs.ErrorFactory.parsing("UNEXPECTED_END", "Unexpected end of expression");
+      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing("UNEXPECTED_END", "Unexpected end of expression");
     }
     this.parsePrefix(token);
     const tokens = this.tokens;
@@ -355,17 +355,17 @@ var _PrecedenceParser = class _PrecedenceParser {
         if (raw.startsWith("0x") || raw.startsWith("0X")) {
           v = parseInt(raw, 16);
           if (Number.isNaN(v)) {
-            throw chunkB4HBEFTB_cjs.ErrorFactory.parsing("INVALID_NUMBER_LITERAL", `Invalid hex literal: "${raw}"`, { raw });
+            throw chunkMIGXCBXT_cjs.ErrorFactory.parsing("INVALID_NUMBER_LITERAL", `Invalid hex literal: "${raw}"`, { raw });
           }
         } else if (raw.startsWith("0b") || raw.startsWith("0B")) {
           v = parseInt(raw.slice(2), 2);
           if (Number.isNaN(v)) {
-            throw chunkB4HBEFTB_cjs.ErrorFactory.parsing("INVALID_NUMBER_LITERAL", `Invalid binary literal: "${raw}"`, { raw });
+            throw chunkMIGXCBXT_cjs.ErrorFactory.parsing("INVALID_NUMBER_LITERAL", `Invalid binary literal: "${raw}"`, { raw });
           }
         } else if (raw.startsWith("0o") || raw.startsWith("0O")) {
           v = parseInt(raw.slice(2), 8);
           if (Number.isNaN(v)) {
-            throw chunkB4HBEFTB_cjs.ErrorFactory.parsing("INVALID_NUMBER_LITERAL", `Invalid octal literal: "${raw}"`, { raw });
+            throw chunkMIGXCBXT_cjs.ErrorFactory.parsing("INVALID_NUMBER_LITERAL", `Invalid octal literal: "${raw}"`, { raw });
           }
         } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {
           v = parseFloat(raw.split(".").join(""));
@@ -394,7 +394,7 @@ var _PrecedenceParser = class _PrecedenceParser {
       }
       case _PrecedenceParser.BIGINT_ID: {
         builder.emitOpcode(11 /* PUSH_BIGINT */);
-        builder.emitString(chunkJ45BCEZ4_cjs.bigIntLiteralDigits(token.value, this.localeCode));
+        builder.emitString(chunkMI7OTUHL_cjs.bigIntLiteralDigits(token.value, this.localeCode));
         return;
       }
       case _PrecedenceParser.STRING_ID: {
@@ -424,11 +424,11 @@ var _PrecedenceParser = class _PrecedenceParser {
       case _PrecedenceParser.LPAREN_ID: {
         this.parseExpression(0, builder);
         let count = 1;
-        while (this.match(chunkQFTDTX6K_cjs.TokenTypes.COMMA)) {
+        while (this.match(chunkG2YPPLGX_cjs.TokenTypes.COMMA)) {
           this.parseExpression(0, builder);
           count++;
         }
-        this.consume(chunkQFTDTX6K_cjs.TokenTypes.RPAREN);
+        this.consume(chunkG2YPPLGX_cjs.TokenTypes.RPAREN);
         if (count > 1) {
           builder.emitOpcode(152 /* MAT_NEW */);
           builder.emitIndex(1);
@@ -438,12 +438,12 @@ var _PrecedenceParser = class _PrecedenceParser {
       }
       // ── Unary operators ───────────────────────────────────────────────────
       case _PrecedenceParser.MINUS_ID: {
-        this.parseExpression(chunkJ45BCEZ4_cjs.BindingPower.Prefix, builder);
+        this.parseExpression(chunkMI7OTUHL_cjs.BindingPower.Prefix, builder);
         builder.emitOpcode(26 /* NEG */);
         return;
       }
       case _PrecedenceParser.PLUS_ID: {
-        this.parseExpression(chunkJ45BCEZ4_cjs.BindingPower.Prefix, builder);
+        this.parseExpression(chunkMI7OTUHL_cjs.BindingPower.Prefix, builder);
         builder.emitOpcode(27 /* POS */);
         return;
       }
@@ -451,7 +451,7 @@ var _PrecedenceParser = class _PrecedenceParser {
       case _PrecedenceParser.KEYWORD_ID:    }
     const prefixParselet = this.registry.getPrefix(typeId);
     if (!prefixParselet) {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
         "NO_PREFIX_PARSELET",
         `No prefix parselet found for token: ${token.type} ("${token.value}")`,
         { tokenType: token.type, tokenValue: token.value }
@@ -540,7 +540,7 @@ var _PrecedenceParser = class _PrecedenceParser {
       return;
     }
     const afterClose = this.tokens[closeIdx + 1];
-    if (afterClose?.type === chunkQFTDTX6K_cjs.TokenTypes.EQUALS) {
+    if (afterClose?.type === chunkG2YPPLGX_cjs.TokenTypes.EQUALS) {
       this.parseUserFunctionDefinition(nameToken, builder);
     } else {
       this.parseUserFunctionCall(nameToken, builder);
@@ -557,40 +557,40 @@ var _PrecedenceParser = class _PrecedenceParser {
    */
   consumeParamName() {
     const token = this.peek();
-    if (token?.type === chunkQFTDTX6K_cjs.TokenTypes.IDENT || token?.type === chunkQFTDTX6K_cjs.TokenTypes.UNIT) {
+    if (token?.type === chunkG2YPPLGX_cjs.TokenTypes.IDENT || token?.type === chunkG2YPPLGX_cjs.TokenTypes.UNIT) {
       this.consume();
       return token.value;
     }
-    throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+    throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
       "USER_FUNCTION_INVALID_PARAM_NAME",
       `Expected a parameter name but got "${token?.type ?? "end of input"}"${token ? ` ("${token.value}")` : ""}`,
       { actualType: token?.type }
     );
   }
   parseUserFunctionDefinition(nameToken, builder) {
-    this.consume(chunkQFTDTX6K_cjs.TokenTypes.LPAREN);
+    this.consume(chunkG2YPPLGX_cjs.TokenTypes.LPAREN);
     const params = [];
-    if (this.peek()?.type !== chunkQFTDTX6K_cjs.TokenTypes.RPAREN) {
+    if (this.peek()?.type !== chunkG2YPPLGX_cjs.TokenTypes.RPAREN) {
       params.push(this.consumeParamName());
-      while (this.match(chunkQFTDTX6K_cjs.TokenTypes.COMMA)) {
+      while (this.match(chunkG2YPPLGX_cjs.TokenTypes.COMMA)) {
         params.push(this.consumeParamName());
       }
     }
-    this.consume(chunkQFTDTX6K_cjs.TokenTypes.RPAREN);
-    this.consume(chunkQFTDTX6K_cjs.TokenTypes.EQUALS);
+    this.consume(chunkG2YPPLGX_cjs.TokenTypes.RPAREN);
+    this.consume(chunkG2YPPLGX_cjs.TokenTypes.EQUALS);
     if (params.length === 0) {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
         "USER_FUNCTION_NO_PARAMS",
         `"${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)`,
         { name: nameToken.value }
       );
     }
-    const bodyBuilder = new chunkJ45BCEZ4_cjs.BytecodeBuilder();
-    this.parseExpression(chunkJ45BCEZ4_cjs.BindingPower.Lowest, bodyBuilder);
+    const bodyBuilder = new chunkMI7OTUHL_cjs.BytecodeBuilder();
+    this.parseExpression(chunkMI7OTUHL_cjs.BindingPower.Lowest, bodyBuilder);
     this.setBuilder(builder);
     const bodyProgram = bodyBuilder.build();
     if (bodyProgram.hasAsync) {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
         "FUNCTION_BODY_MUST_BE_SYNCHRONOUS",
         `"${nameToken.value}(...)"'s body calls an async operation (weather, stocks, currency, ...) \u2014 user-defined function bodies must be synchronous`,
         { name: nameToken.value }
@@ -603,17 +603,17 @@ var _PrecedenceParser = class _PrecedenceParser {
     builder.emitString(`${nameToken.value}(${params.join(", ")}) defined`);
   }
   parseUserFunctionCall(nameToken, builder) {
-    this.consume(chunkQFTDTX6K_cjs.TokenTypes.LPAREN);
+    this.consume(chunkG2YPPLGX_cjs.TokenTypes.LPAREN);
     let argCount = 0;
-    if (this.peek()?.type !== chunkQFTDTX6K_cjs.TokenTypes.RPAREN) {
-      this.parseExpression(chunkJ45BCEZ4_cjs.BindingPower.Lowest, builder);
+    if (this.peek()?.type !== chunkG2YPPLGX_cjs.TokenTypes.RPAREN) {
+      this.parseExpression(chunkMI7OTUHL_cjs.BindingPower.Lowest, builder);
       argCount++;
-      while (this.match(chunkQFTDTX6K_cjs.TokenTypes.COMMA)) {
-        this.parseExpression(chunkJ45BCEZ4_cjs.BindingPower.Lowest, builder);
+      while (this.match(chunkG2YPPLGX_cjs.TokenTypes.COMMA)) {
+        this.parseExpression(chunkMI7OTUHL_cjs.BindingPower.Lowest, builder);
         argCount++;
       }
     }
-    this.consume(chunkQFTDTX6K_cjs.TokenTypes.RPAREN);
+    this.consume(chunkG2YPPLGX_cjs.TokenTypes.RPAREN);
     builder.emitOpcode(151 /* CALL_USER_FUNCTION */);
     builder.emitString(nameToken.value);
     builder.emitByte(argCount);
@@ -624,15 +624,15 @@ var _PrecedenceParser = class _PrecedenceParser {
   consume(expectedType) {
     const token = this.tokens[this.current];
     if (!token) {
-      throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
         "UNEXPECTED_END_OF_INPUT",
         "Unexpected end of input"
       );
     }
     if (expectedType !== void 0) {
-      const expectedId = chunkQFTDTX6K_cjs.tokenTypeId(expectedType);
+      const expectedId = chunkG2YPPLGX_cjs.tokenTypeId(expectedType);
       if (token.typeId !== expectedId) {
-        throw chunkB4HBEFTB_cjs.ErrorFactory.parsing(
+        throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
           "UNEXPECTED_TOKEN_TYPE",
           `Expected token type "${expectedType}" but got "${token.type}" ("${token.value}")`,
           { expectedType, actualType: token.type, actualValue: token.value }
@@ -644,7 +644,7 @@ var _PrecedenceParser = class _PrecedenceParser {
   }
   match(expectedType) {
     const token = this.peek();
-    if (token && token.typeId === chunkQFTDTX6K_cjs.tokenTypeId(expectedType)) {
+    if (token && token.typeId === chunkG2YPPLGX_cjs.tokenTypeId(expectedType)) {
       this.advance();
       return true;
     }
@@ -682,7 +682,7 @@ var _PrecedenceParser = class _PrecedenceParser {
   fireParseletMatched(parselet, token, isPrefix, bindingPower) {
     const pipeline = this.diagnosticPipeline;
     const event = {
-      type: chunkXA4CKRML_cjs.DiagnosticEventType.ParseletMatched,
+      type: chunkHWHU642X_cjs.DiagnosticEventType.ParseletMatched,
       elapsedNs: 0,
       expression: this.currentExpression,
       tokenType: token.type,
@@ -700,49 +700,49 @@ var _PrecedenceParser = class _PrecedenceParser {
  * Static binding power table, built once at module load, shared across all instances.
  * Index = tokenTypeId, value = binding power (0 = not a built-in infix).
  */
-_PrecedenceParser.BP_TABLE = chunkJ45BCEZ4_cjs.buildBindingPowerTable();
+_PrecedenceParser.BP_TABLE = chunkMI7OTUHL_cjs.buildBindingPowerTable();
 // ── Pre-computed token type IDs for inline dispatch ────────────────────────
 // Prefix built-ins
-_PrecedenceParser.NUMBER_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.NUMBER);
-_PrecedenceParser.BIGINT_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIGINT);
-_PrecedenceParser.STRING_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.STRING);
-_PrecedenceParser.IDENT_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.IDENT);
-_PrecedenceParser.LPAREN_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.LPAREN);
-_PrecedenceParser.RPAREN_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.RPAREN);
-_PrecedenceParser.MINUS_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.MINUS);
-_PrecedenceParser.PLUS_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.PLUS);
-_PrecedenceParser.KEYWORD_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.KEYWORD);
+_PrecedenceParser.NUMBER_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.NUMBER);
+_PrecedenceParser.BIGINT_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIGINT);
+_PrecedenceParser.STRING_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.STRING);
+_PrecedenceParser.IDENT_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.IDENT);
+_PrecedenceParser.LPAREN_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.LPAREN);
+_PrecedenceParser.RPAREN_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.RPAREN);
+_PrecedenceParser.MINUS_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.MINUS);
+_PrecedenceParser.PLUS_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.PLUS);
+_PrecedenceParser.KEYWORD_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.KEYWORD);
 // Infix built-ins (Tier 1, full inline emission)
-_PrecedenceParser.STAR_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.STAR);
-_PrecedenceParser.SLASH_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.SLASH);
-_PrecedenceParser.MOD_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.MOD);
-_PrecedenceParser.CARET_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.CARET);
-_PrecedenceParser.LSHIFT_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.LSHIFT);
-_PrecedenceParser.RSHIFT_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.RSHIFT);
-_PrecedenceParser.URSHIFT_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.URSHIFT);
-_PrecedenceParser.BIT_AND_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIT_AND);
-_PrecedenceParser.BIT_OR_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIT_OR);
-_PrecedenceParser.BIT_XOR_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIT_XOR);
-_PrecedenceParser.PERCENT_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.PERCENT);
-_PrecedenceParser.OF_ID = chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.OF);
+_PrecedenceParser.STAR_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.STAR);
+_PrecedenceParser.SLASH_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.SLASH);
+_PrecedenceParser.MOD_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.MOD);
+_PrecedenceParser.CARET_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.CARET);
+_PrecedenceParser.LSHIFT_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.LSHIFT);
+_PrecedenceParser.RSHIFT_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.RSHIFT);
+_PrecedenceParser.URSHIFT_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.URSHIFT);
+_PrecedenceParser.BIT_AND_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIT_AND);
+_PrecedenceParser.BIT_OR_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIT_OR);
+_PrecedenceParser.BIT_XOR_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIT_XOR);
+_PrecedenceParser.PERCENT_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.PERCENT);
+_PrecedenceParser.OF_ID = chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.OF);
 /**
  * Inline opcode map for Tier 1 infix operators.
  * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).
  */
 _PrecedenceParser.INFIX_OPCODE = {
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.PLUS)]: 20 /* ADD */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.MINUS)]: 21 /* SUB */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.STAR)]: 22 /* MUL */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.SLASH)]: 23 /* DIV */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.MOD)]: 24 /* MOD */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.CARET)]: 25 /* EXP */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.LSHIFT)]: 30 /* LSHIFT */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.RSHIFT)]: 31 /* RSHIFT */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.URSHIFT)]: 32 /* URSHIFT */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIT_AND)]: 33 /* BIT_AND */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIT_OR)]: 34 /* BIT_OR */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.BIT_XOR)]: 35 /* BIT_XOR */,
-  [chunkQFTDTX6K_cjs.tokenTypeId(chunkQFTDTX6K_cjs.TokenTypes.OF)]: 22 /* MUL */
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.PLUS)]: 20 /* ADD */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.MINUS)]: 21 /* SUB */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.STAR)]: 22 /* MUL */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.SLASH)]: 23 /* DIV */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.MOD)]: 24 /* MOD */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.CARET)]: 25 /* EXP */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.LSHIFT)]: 30 /* LSHIFT */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.RSHIFT)]: 31 /* RSHIFT */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.URSHIFT)]: 32 /* URSHIFT */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIT_AND)]: 33 /* BIT_AND */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIT_OR)]: 34 /* BIT_OR */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.BIT_XOR)]: 35 /* BIT_XOR */,
+  [chunkG2YPPLGX_cjs.tokenTypeId(chunkG2YPPLGX_cjs.TokenTypes.OF)]: 22 /* MUL */
 };
 // ═══════════════════════════════════════════════════════════════════════════════
 // The "Tier-1 shape-exception" pattern
@@ -794,7 +794,7 @@ _PrecedenceParser.CARET_SUFFIX_RULES = [
     name: "transpose (^T)",
     matches: (p) => {
       const next = p.peek();
-      return next?.type === chunkQFTDTX6K_cjs.TokenTypes.IDENT && next.value === "T";
+      return next?.type === chunkG2YPPLGX_cjs.TokenTypes.IDENT && next.value === "T";
     },
     emit: (p, builder) => {
       p.advance();
@@ -809,7 +809,7 @@ _PrecedenceParser.CARET_SUFFIX_RULES = [
       const next = p.peek();
       if (next?.typeId !== _PrecedenceParser.MINUS_ID) return false;
       const afterMinus = p.peekAt(1);
-      return afterMinus?.type === chunkQFTDTX6K_cjs.TokenTypes.NUMBER && afterMinus.value === "1";
+      return afterMinus?.type === chunkG2YPPLGX_cjs.TokenTypes.NUMBER && afterMinus.value === "1";
     },
     emit: (p, builder) => {
       p.advance();
@@ -825,5 +825,5 @@ var PrecedenceParser = _PrecedenceParser;
 exports.ParseletRegistry = ParseletRegistry;
 exports.PrecedenceParser = PrecedenceParser;
 exports.sharedParseletRegistry = sharedParseletRegistry;
-//# sourceMappingURL=chunk-HVRVSI2Z.cjs.map
-//# sourceMappingURL=chunk-HVRVSI2Z.cjs.map
+//# sourceMappingURL=chunk-GDEU72RG.cjs.map
+//# sourceMappingURL=chunk-GDEU72RG.cjs.map