solve-engine 1.0.2 → 1.1.1

package/dist/chunk-2TZKENDH.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vm/AllocationBudget.ts","../src/vm/Value.ts"],"names":["ErrorFactory","ValueType","v"],"mappings":"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","file":"chunk-2TZKENDH.cjs","sourcesContent":["/**\n * The ceiling on how much memory one evaluation is allowed to ask for.\n *\n * The VM's other two counters bound how many opcodes run and how deep the value\n * stack gets, and both are checked BETWEEN opcodes. That leaves a hole the size\n * of a single opcode: whatever one opcode allocates in a loop of its own is\n * invisible to both, so twenty-four characters of input (`map(10*x,\n * 0:2000000000)`) could allocate until V8 aborted the process, which no\n * `try`/`catch` in the host can contain. Per-site caps close one hole each and\n * do not compose: two collections that are individually legal are legal\n * together, and an operation whose result is the PRODUCT of two legal inputs (a\n * matrix multiply) is bounded by neither of them.\n *\n * This is the counter that composes. Everything an evaluation materialises is\n * charged against one running tally, so the bound is on the total rather than\n * on any single step, and a new opcode inherits it by allocating through\n * {@link chargedArray} or by building a Value through a constructor that\n * already charges ({@link matrixValue}).\n *\n * The tally is module state rather than something threaded through every\n * signature. `executeBytecode()` opens an evaluation and every charge inside\n * that window lands on it, which is what lets a helper five call levels down\n * (`vm/MatrixOps.ts`'s `collectionToValues()`) charge without the four frames\n * in between passing a parameter along, and what keeps a charge down to an add\n * and a compare. This mirrors the value arena in `vm/Value.ts`, which is\n * ambient for the same reason and rests on the same fact: `executeBytecode()`\n * is synchronous, so exactly one evaluation is ever in flight in a realm.\n *\n * An \"element\" is one thing a user's input caused to exist: a `Value` in an\n * expanded collection, a cell in a matrix. They are counted rather than\n * measured in bytes, because a count is the quantity every call site already\n * has in hand before it allocates, and asking V8 how big something is costs\n * more than the allocation being guarded.\n *\n * A second tally lives here for the same structural reason and not because it\n * counts the same thing: {@link chargeFunctionCall} bounds how many\n * user-defined-function calls one evaluation may make in total. Surviving\n * reentry is the whole property both need, and this module is where reentry is\n * already tracked.\n *\n * @module AllocationBudget\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport type { VM } from \"@solve-js/vm/OpRegistry\";\n\n/**\n * How deep the evaluation is: 0 outside one, higher inside a reentrant call.\n *\n * `executeBytecode()` re-enters itself for a user-defined function call, a map\n * or reduce transform body, and an algebra verb's bound-unknown body. Only the\n * outermost entry clears the tally, so a runaway recursion cannot refresh its\n * own allowance the way it can refresh `maxInstructions` (each reentrant call\n * gets a fresh local instruction count, which is why function recursion needed\n * a separate guard of its own).\n */\nlet depth = 0;\n\n/** Elements charged so far in the evaluation currently in flight. */\nlet used = 0;\n\n/** The in-flight evaluation's ceiling, read from its VM when the evaluation opened. */\nlet limit = Number.POSITIVE_INFINITY;\n\n/** User-defined-function calls made so far in the evaluation currently in flight. */\nlet calls = 0;\n\n/** The in-flight evaluation's call ceiling, read from its VM when the evaluation opened. */\nlet callLimit = Number.POSITIVE_INFINITY;\n\n/**\n * The refusal itself, built in one place so the wording of the engine's most\n * likely \"this is too big\" message is not reinvented per site.\n */\nfunction exceeded(requested: number, what: string, alreadyUsed: number): Error {\n\treturn ErrorFactory.execution({\n\t\tcode: \"ALLOCATION_LIMIT_EXCEEDED\",\n\t\tmessage:\n\t\t\t`Evaluating this expression would materialise ${requested.toLocaleString(\"en-US\")} ${what}, ` +\n\t\t\t`past the limit of ${limit.toLocaleString(\"en-US\")} elements for one evaluation`,\n\t\texpected: `at most ${limit.toLocaleString(\"en-US\")} elements materialised while evaluating one expression`,\n\t\tfound: `a request for ${requested.toLocaleString(\"en-US\")} more ${what}, on top of ${alreadyUsed.toLocaleString(\"en-US\")} already materialised`,\n\t\tsuggestion: \"use a smaller collection or matrix, or raise the engine's vm.maxAllocatedElements setting\",\n\t\tcontext: { requested, what, used: alreadyUsed, limit },\n\t});\n}\n\n/**\n * Open an evaluation, taking its ceiling from the VM about to run it.\n *\n * @param vm - The VM running this program. Only consulted on the outermost\n * entry, so a reentrant call costs one increment.\n */\nexport function beginEvaluation(vm: VM): void {\n\tif (depth++ === 0) {\n\t\tused = 0;\n\t\tlimit = vm.getMaxAllocatedElements();\n\t\tcalls = 0;\n\t\tcallLimit = vm.getMaxFunctionCalls();\n\t}\n}\n\n/** Close the innermost evaluation. Always call from a `finally`, so a throw cannot leave one open. */\nexport function endEvaluation(): void {\n\tif (depth > 0) depth--;\n}\n\n/**\n * Record elements materialised by the evaluation in flight.\n *\n * Each thing is charged exactly once, where it comes into existence: a matrix\n * in `matrixValue()`, an expanded collection where it is expanded. A site that\n * knows a size in advance and whose result will be charged on birth uses\n * {@link checkAllocation} instead, so that refusing early does not mean\n * counting twice.\n *\n * Outside an evaluation this is a plain no-op rather than an error:\n * `matrixValue()` and the `vm/MatrixOps.ts` helpers are exported and get called\n * by tests, by the formatter and by hosts with no evaluation in flight, and\n * none of those is user input being executed.\n *\n * @param count - How many elements now exist.\n * @param what - What they are, in the plural and in a user's words (\"matrix\n * cells\", \"collection elements\"). Quoted verbatim in the error, so it should\n * name the thing rather than the code that makes it.\n * @throws `ALLOCATION_LIMIT_EXCEEDED` when this evaluation has had enough.\n * Recoverable: it describes this expression, not the engine.\n */\nexport function chargeAllocation(count: number, what: string): void {\n\tif (depth === 0) return;\n\t// Written as a negated `>=` so that NaN takes this branch. A NaN count would\n\t// otherwise be added to the tally and make every later `used > limit`\n\t// comparison false, silently switching the guard off for the rest of the\n\t// evaluation, which is the one failure mode a safety limit must not have.\n\tif (!(count >= 0)) throw exceeded(count, what, used);\n\tused += count;\n\tif (used > limit) throw exceeded(count, what, used - count);\n}\n\n/**\n * Refuse an allocation this evaluation cannot afford, without recording it.\n *\n * For the sites that know how big a result will be BEFORE building it and whose\n * result is charged later, when it is born. A matrix product is the case that\n * matters: its size is the product of two operands that are each affordable, so\n * it has to be refused from the shapes alone, before `matrixMultiply()` takes\n * the memory. Charging here as well as at birth would bill every matrix twice\n * and halve the ceiling the host asked for.\n *\n * @param count - How many elements the result would have.\n * @param what - What they are, in the plural. See {@link chargeAllocation}.\n * @throws `ALLOCATION_LIMIT_EXCEEDED` when the evaluation could not afford them.\n */\nexport function checkAllocation(count: number, what: string): void {\n\tif (depth === 0) return;\n\tif (!(count >= 0) || used + count > limit) throw exceeded(count, what, used);\n}\n\n/**\n * Check that an array is affordable, then allocate it.\n *\n * The intended way to build any user-sized array inside the VM whose contents\n * end up inside a Value that charges on birth, so that \"ask before you take\" is\n * a property of the allocator rather than something each new opcode has to be\n * told.\n *\n * @param count - Element count, checked before a single element exists.\n * @param what - What the elements are, in the plural. See {@link chargeAllocation}.\n * @returns An empty array of that length.\n * @throws `ALLOCATION_LIMIT_EXCEEDED` before allocating anything, when the\n * evaluation cannot afford it.\n */\nexport function checkedArray<T>(count: number, what: string): T[] {\n\tcheckAllocation(count, what);\n\treturn new Array<T>(count);\n}\n\n/**\n * Record one user-defined-function call, and refuse the one past the ceiling.\n *\n * Lives in this module rather than in the VM for the single reason the element\n * tally does: it has to survive `executeBytecode()` re-entering itself. A call\n * count kept per invocation would be reset by the very calls it is counting,\n * which is exactly what happens to `maxInstructions` and exactly why counting\n * instructions could never bound this.\n *\n * The thing being bounded is BREADTH, which no existing guard could see.\n * `maxFunctionRecursionDepth` bounds nesting, and a doubling chain\n * (`f22(v) = f21(v) + f21(v)`, twenty-two lines of it) nests only twenty-two\n * deep while making 2,097,152 calls, which was a fatal heap abort in under a\n * second. Depth 22 against a limit of 50 is comfortably legal, and it was.\n *\n * @throws `FUNCTION_CALL_LIMIT_EXCEEDED` when this evaluation has made\n * enough. Recoverable: the engine is fine, this line is not.\n */\nexport function chargeFunctionCall(): void {\n\tif (depth === 0) return;\n\tif (++calls > callLimit) {\n\t\tthrow ErrorFactory.execution({\n\t\t\tcode: \"FUNCTION_CALL_LIMIT_EXCEEDED\",\n\t\t\tmessage:\n\t\t\t\t`Evaluating this expression would make more than ${callLimit.toLocaleString(\"en-US\")} ` +\n\t\t\t\t`user-defined-function calls, which is the limit for one evaluation`,\n\t\t\texpected: `at most ${callLimit.toLocaleString(\"en-US\")} function calls while evaluating one expression`,\n\t\t\tfound: \"a call past that limit, from a chain of functions that each call others more than once\",\n\t\t\tsuggestion: \"check for a function that calls itself (or a chain of them) more times than intended, or raise the engine's vm.maxFunctionCalls setting\",\n\t\t\tcontext: { calls, callLimit },\n\t\t});\n\t}\n}\n\n/**\n * Elements charged so far in the evaluation in flight, or in the one that just\n * finished. For tests and for a host reporting on a refusal.\n *\n * @returns The running tally.\n */\nexport function allocationUsed(): number {\n\treturn used;\n}\n\n/**\n * User-defined-function calls made so far in the evaluation in flight, or in\n * the one that just finished. For tests and for a host reporting on a refusal.\n *\n * @returns The running tally.\n */\nexport function functionCallsUsed(): number {\n\treturn calls;\n}\n\n/**\n * Drop all in-flight evaluation state.\n *\n * For tests that need a known starting point, and as a repair for a host that\n * somehow lost an `endEvaluation()`. Ordinary execution never needs it:\n * `executeBytecode()` pairs its own begin and end in a `finally`, and the\n * outermost begin clears the tally regardless of what came before.\n */\nexport function resetAllocationTracking(): void {\n\tdepth = 0;\n\tused = 0;\n\tlimit = Number.POSITIVE_INFINITY;\n\tcalls = 0;\n\tcallLimit = Number.POSITIVE_INFINITY;\n}\n","import { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { chargeAllocation } from \"@solve-js/vm/AllocationBudget\";\nimport type { SymbolicNode, Rational } from \"@solve-js/symbolic\";\nimport type { DecimalData } from \"@solve-js/decimal\";\n\n/**\n * A single matrix cell. `boolean` covers element-wise comparison results\n * (`[1,6;3,8] < [5,2;7,4]` produces a Matrix of booleans, not numbers). A\n * `SymbolicNode` cell is a free-variable algebraic entry, e.g. `s =\n * [sx,0,0;0,sy,0;0,0,1]` where `sx`/`sy` are never assigned, so those\n * cells store a real `SymbolicNode` (a bare `var` node initially) rather\n * than degrading to `0`. See `MatrixOps.ts`'s `entryToSymbolic()`/\n * `symbolicToEntry()` for the two-way conversion every symbolic-aware\n * matrix op (multiply, inverse, determinant) uses.\n */\nexport type MatrixEntry = number | boolean | SymbolicNode;\n\n/**\n * A general rows×cols matrix, a vector is just a 1×N (row) or N×1 (column)\n * matrix. `data` is COLUMN-MAJOR (`data[row + col*rows]`), matching the\n * spec's own `a[index]` column-major indexing semantics directly (no\n * translation needed for single-index reads). `hasSymbolic` lets every\n * numeric matrix op fast-path the all-numeric case with one boolean check,\n * mirroring `binaryOp()`'s existing Number+Number fast path, computed by\n * `matrixValue()` itself (true the moment any cell is a `SymbolicNode`\n * object rather than a plain number/boolean), not something callers set\n * by hand.\n */\nexport interface MatrixData {\n\treadonly rows: number;\n\treadonly cols: number;\n\treadonly data: readonly MatrixEntry[];\n\treadonly hasSymbolic: boolean;\n}\n\n/** A first-class integer range `min:max`, both bounds inclusive. */\nexport interface RangeData {\n\treadonly min: number;\n\treadonly max: number;\n}\n\n/**\n * How a colour was authored, and therefore how it should display. It never\n * changes the channels: a colour is always stored as canonical sRGB (`r`,`g`,`b`\n * integers 0-255, `a` in 0-1), and `format` only decides whether `formatValue`\n * renders it as `#rrggbb`, `rgb(...)`, `hsl(...)` or a named keyword.\n */\nexport type ColourFormat = \"hex\" | \"rgb\" | \"rgba\" | \"hsl\" | \"hsla\" | \"named\";\n\n/**\n * A colour value. Canonical channels are sRGB (`r`,`g`,`b` are integers 0-255,\n * `a` is 0-1); HSL is never stored, it is derived on demand for display and for\n * hue/saturation/lightness operations, then re-quantised back to RGBA. A\n * `lighten` followed by an equal `darken` returns to within one rounding step of\n * the original (integer channels re-quantise each way), and does not drift on\n * repetition, rather than storing both HSL and RGB and letting them disagree.\n * `format`\n * records the authored/display form; `name` carries the CSS keyword only when\n * `format === \"named\"` (e.g. `\"rebeccapurple\"`). Lives in a {@link Value}'s\n * `value` slot exactly as {@link MatrixData}/{@link RangeData} do.\n */\nexport interface ColourData {\n\treadonly r: number;\n\treadonly g: number;\n\treadonly b: number;\n\treadonly a: number;\n\treadonly format: ColourFormat;\n\treadonly name?: string;\n}\n\n/**\n * Discriminated union tag for {@link Value} objects.\n *\n * Determines the runtime type of a Value and how its `value` field should\n * be interpreted. Used by the VM for type-aware dispatch in arithmetic,\n * comparison, and conversion operations.\n */\nexport enum ValueType {\n\t/** Plain 64-bit floating point number (IEEE 754 double) */\n\tNumber = 0,\n\tHex = 1,\n\tBigInt = 2,\n\tString = 3,\n\tDatetime = 4,\n\tPercentage = 5,\n\tUom = 6,\n\t/** General rows×cols matrix (a vector is a 1×N or N×1 matrix). Value is {@link MatrixData}. */\n\tMatrix = 7,\n\t/** A first-class integer range `min:max`, both inclusive. Value is {@link RangeData}. */\n\tRange = 8,\n\t/** A symbolic/algebraic expression tree (free-variable formula, not a concrete number). Value is a `SymbolicNode` (`@solve-js/symbolic`). */\n\tSymbolic = 9,\n\t/** Boolean true/false. Value is `boolean`. */\n\tBoolean = 10,\n\t/** Unit of measurement token (lexer only, not a runtime value). */\n\tUnit = 11,\n\t/** Async result pending resolution. Value stores the queryKey string. */\n\tPending = 12,\n\t/** Plugin-raised error propagated through the DAG. Value stores error code, unit stores message. */\n\tError = 13,\n\t/** A colour (hex/rgb/hsl/named). Value is {@link ColourData}. */\n\tColour = 14,\n}\n\n// ── ValueArena ────────────────────────────────────────────────────────────\n// Phase 5.3: Bump-allocator arena for zero-allocation Value reuse during scroll.\n// Instead of allocating new Value objects per instruction, we pre-allocate a\n// block and bump an index. A single arena.reset() per scroll frame recycles all\n// Values, no per-value release overhead, no GC pressure during 60fps scrolling.\n\n/**\n * Bump-allocator arena for zero-allocation Value reuse during scroll.\n *\n * Instead of allocating new Value objects per instruction, pre-allocates a\n * block and bumps an index. `arena.reset()` per scroll frame recycles all\n * Values, no per-value release overhead, no GC pressure during 60fps scrolling.\n *\n * Only active during Tier 2 scroll execution (ThreeTierEvaluator).\n */\nexport class ValueArena {\n\tprivate arena: Value[] = [];\n\tprivate index: number = 0;\n\t/** The block size to come back down to. Kept so {@link reset} can. */\n\tprivate readonly initialSize: number;\n\n\t/**\n\t * How much more than the last cycle needed the arena may go on holding\n\t * before it gives the difference back, and how much of it it keeps when it\n\t * does.\n\t *\n\t * A bump allocator that grows to serve one expensive line is working as\n\t * intended; one that never comes down is a leak wearing a cache's clothes.\n\t * `map(x*1, 1:100000)` is an ordinary line by every limit the engine has,\n\t * and it took the arena from 512 Values to 300,004, about 24MB that stayed\n\t * live through two forced full collections and through every later `1 + 1`,\n\t * because `acquire()` handles overflow with `push()` and `reset()` only\n\t * zeroed the bump index. The instance is module-level and survives\n\t * `disableValueArena()` on purpose, so that high-water mark was for the\n\t * life of the process.\n\t *\n\t * Keeping twice what the last cycle used, and only shrinking once holding\n\t * four times that, is what stops the release from becoming a different\n\t * performance bug: a steady scroll uses about the same number of Values\n\t * every frame, so it never meets the condition at all, and an alternating\n\t * heavy/light document degrades at worst to allocating the Values it would\n\t * have allocated with no arena in the first place.\n\t */\n\tprivate static readonly SHRINK_WHEN_HOLDING_TIMES = 4;\n\tprivate static readonly KEEP_TIMES = 2;\n\n\t/** Pre-allocate initial block. 512 Values covers ~30-line viewport comfortably. */\n\tconstructor(initialSize: number = 512) {\n\t\tthis.initialSize = initialSize;\n\t\tfor (let i = 0; i < initialSize; i++) {\n\t\t\tthis.arena.push(new Value(ValueType.Number, 0));\n\t\t}\n\t}\n\n\t/** Bump-allocate a recycled Value. Falls back to allocation only for overflow. */\n\tacquire(type: ValueType, value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SymbolicNode, unit?: string): Value {\n\t\tif (this.index < this.arena.length) {\n\t\t\tconst v = this.arena[this.index++];\n\t\t\tv.recycle(type, value, unit);\n\t\t\treturn v;\n\t\t}\n\t\t// Arena overflow, allocate fresh (rare, only for very complex expressions)\n\t\tconst v = new Value(type, value, unit);\n\t\tthis.arena.push(v);\n\t\tthis.index++;\n\t\treturn v;\n\t}\n\n\t/**\n\t * Reset for the next scroll frame, releasing a block the last frame turned\n\t * out not to need.\n\t *\n\t * Still O(1) in the ordinary case: one comparison against what the cycle\n\t * that just ended used, and the truncation only on the frame after an\n\t * unusually expensive one. Reading the usage here rather than at\n\t * `disableValueArena()` is what makes the policy \"the first cycle that does\n\t * not need the block gives it back\", which is the first thing a host does\n\t * after the line that grew it.\n\t */\n\treset(): void {\n\t\tconst usedLastCycle = this.index;\n\t\tthis.index = 0;\n\t\tif (this.arena.length <= this.initialSize) return;\n\t\tif (this.arena.length <= usedLastCycle * ValueArena.SHRINK_WHEN_HOLDING_TIMES) return;\n\t\t// Never below the initial block, and never above what is already held,\n\t\t// so this only ever truncates.\n\t\tthis.arena.length = Math.max(this.initialSize, usedLastCycle * ValueArena.KEEP_TIMES);\n\t}\n\n\t/** Current arena utilization (for diagnostics). */\n\tget usage(): number { return this.index; }\n\tget capacity(): number { return this.arena.length; }\n}\n\n// Module-level arena toggle. Single-threaded JS, so global state is safe.\n// The arena is ONLY active during Tier 2 scroll execution, the ThreeTierEvaluator\n// enables it before evaluating visible lines and disables it after.\n//\n// The arena INSTANCE survives disable(): constructing a ValueArena allocates\n// its whole initial block (512 Values), so dropping it on every disable would\n// pay that allocation cost again on the next enable, more garbage than the\n// arena saves. Instead, an `_arenaActive` flag gates use of the long-lived\n// instance; enable() just resets the bump index.\nlet _arena: ValueArena | null = null;\nlet _arenaActive = false;\n\n/** Enable the Value arena for zero-allocation scroll execution. */\nexport function enableValueArena(size?: number): ValueArena {\n\tif (!_arena) _arena = new ValueArena(size);\n\t_arena.reset();\n\t_arenaActive = true;\n\treturn _arena;\n}\n\n/** Disable the arena (returns to normal GC-collected allocation). */\nexport function disableValueArena(): void {\n\t_arenaActive = false;\n}\n\n/** Check if arena is active (used by STORE_VAR / HALT to decide cloning). */\nexport function isArenaActive(): boolean {\n\treturn _arenaActive;\n}\n\n/**\n * Allocate a Value that persists beyond the current arena cycle.\n * Used for values stored in variables (STORE_VAR) and final expression results\n * (HALT return), these must survive arena.reset() in the next scroll frame.\n */\nexport function persistentValue(v: Value): Value {\n\tconst p = new Value(v.type, v.value, v.unit);\n\t// The exact sidecar has to survive being stored in a variable, or a\n\t// referenced money value would silently drop back to the double: \"a = $0.10,\n\t// b = $0.20, a + b\" must still be exact across the STORE_VAR round trip.\n\tif (v.exact !== undefined) p.exact = v.exact;\n\t// The rational sidecar survives the same round trip, so \"a = 1/3, a + a + a\"\n\t// is exactly 1 rather than the drifted double a stored fraction would carry.\n\tif (v.rational !== undefined) p.rational = v.rational;\n\t// The uncertainty sidecar survives too, so \"a = 12.3 +/- 0.5, a * 4\" still\n\t// propagates the tolerance across the STORE_VAR round trip.\n\tif (v.uncertainty !== undefined) p.uncertainty = v.uncertainty;\n\treturn p;\n}\n\n// ── Dev-mode immutability guard (Part II, L5, Value model hardening) ──\n//\n// Value is documented immutable by convention, not enforcement: the arena\n// mutates objects in place via recycle() (by design, for Tier-2 scroll\n// performance), so Value can never be unconditionally frozen. This guard\n// freezes a Value ONLY when it is safe to do so, i.e. NOT while the arena\n// is active, since an arena-active Value may still be recycled later in\n// the same scroll frame. It is a no-op outside development builds (matches\n// the existing `process.env.NODE_ENV === \"development\"` convention used by\n// the app-layer logger) so there is zero runtime cost in production.\nconst isDevelopmentBuild = process.env.NODE_ENV === \"development\";\n\n/**\n * Freeze a Value in development builds, catching accidental external\n * mutation of \"immutable\" results early. Safe to call unconditionally\n * it is a no-op in production and a no-op whenever the arena is active\n * (an arena-active Value may still be recycle()'d before this scroll\n * frame ends, and freezing it would make recycle() throw).\n *\n * Intended for values leaving a public evaluation boundary\n * (ExpressionEngine.evaluateLine* / evaluateExpression), not for values\n * still moving through internal VM/arena machinery.\n */\nexport function freezeIfDev<T extends Value>(value: T): T {\n\tif (isDevelopmentBuild && !isArenaActive()) {\n\t\t// toNumber() lazily memoizes _cachedNumber for bigint/string values\n\t\t// (Number/Hex are already eagerly cached by the constructor), warm\n\t\t// it now so a later toNumber() call on the frozen object doesn't\n\t\t// try to write to a frozen field.\n\t\tvalue.toNumber();\n\t\tObject.freeze(value);\n\t}\n\treturn value;\n}\n\n/**\n * Universal runtime value for the solve-js VM.\n *\n * Carries a {@link ValueType} discriminant, a polymorphic `value` payload,\n * and an optional `unit` string (for UoM values). Treated as immutable after\n * construction, the arena reuses objects internally via `recycle()`, but\n * external code should never mutate Value fields.\n *\n * A cached `_cachedNumber` avoids repeated `toNumber()` computation on\n * hot paths (ADD/SUB/MUL in the VM dispatch loop).\n */\nexport class Value {\n\t// Cached numeric representation, computed once on first toNumber() call.\n\t// Cleared on recycle() when the arena reuses this Value for a new value.\n\tprivate _cachedNumber: number | undefined;\n\n\t// Fields are NOT readonly, the arena reuses Value objects by calling\n\t// recycle() which overwrites all fields. External code should treat Values\n\t// as immutable after construction (arena handles mutation internally).\n\tpublic type: ValueType;\n\tpublic value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SymbolicNode;\n\tpublic unit?: string;\n\t/** Set by async resolvers when a fetch timed out, the result is a fallback (typically 0). */\n\tpublic timedOut?: boolean;\n\t/**\n\t * The exact base-ten value this Value stands for, when it has one.\n\t *\n\t * A sidecar rather than a replacement for `value`: money and decimal-point\n\t * literals set it to a {@link DecimalData} so that same-currency arithmetic\n\t * and display can be exact (\"$0.10 + $0.20\" is \"$0.30\", not\n\t * \"$0.30000000000000004\"), while `value` stays the nearest double so every\n\t * existing consumer that reads `.value` or `toNumber()` is unchanged. The\n\t * plain Number-times-Number fast paths deliberately ignore it, which is why\n\t * a bare \"0.1 + 0.2\" still answers the double it always did: exactness is\n\t * carried only where a unit-bearing operand asks for it. Cleared by\n\t * {@link recycle} so a reused arena Value never inherits a stale exact.\n\t */\n\tpublic exact?: DecimalData;\n\t/**\n\t * The exact rational value this Value stands for, when it has one.\n\t *\n\t * The second sidecar, the same shape as {@link exact} and for the same\n\t * reason: a fraction has no exact base-ten form (`1/3` is not any decimal),\n\t * so exact fraction arithmetic needs a numerator/denominator pair rather\n\t * than a coefficient and a scale. Integer division seeds it (\"1/3\" carries\n\t * the {@link Rational} 1/3), and `+`, `-`, `*`, `/` between rational-bearing\n\t * numbers keep it reduced, so \"1/49 * 49\" is exactly 1 and \"5/6 - 1/6 - 1/6\n\t * - 1/6 - 1/6 - 1/6\" is exactly 0 rather than the 1.6e-16 the doubles drift\n\t * to. `value` still holds the nearest double, recomputed from the exact\n\t * rational so accumulation error never creeps in, which is why the default\n\t * display and every `.value`/`toNumber()` reader are unchanged. Only a\n\t * fraction written with \"/\" carries it, so a decimal literal (\"0.1\") and a\n\t * transcendental result (\"sqrt(2)\") stay the plain doubles they were.\n\t * Cleared by {@link recycle} alongside {@link exact}.\n\t */\n\tpublic rational?: Rational;\n\t/**\n\t * The one-sigma uncertainty (standard error) this value carries, when it\n\t * has one.\n\t *\n\t * The third sidecar, the same shape as {@link exact} and {@link rational}\n\t * and for the same reason: a measurement written `12.3 ± 0.5` is still the\n\t * number 12.3 everywhere it is read as one, so the type stays\n\t * {@link ValueType.Number} and `value` stays the center, while this non\n\t * negative field carries the tolerance. The `±` (or ASCII `+/-`) operator\n\t * seeds it, and `+`, `-`, `*`, `/` propagate it in quadrature for\n\t * independent errors (see `vm/VMConversion.ts`'s `uncertainOp`). Everything\n\t * else (a comparison, a transcendental function, a unit conversion) reads\n\t * the center through `toNumber()` and drops the tolerance, which is why a\n\t * value with no uncertainty behaves exactly as a plain number always did.\n\t * Cleared by {@link recycle} alongside the other two sidecars.\n\t */\n\tpublic uncertainty?: number;\n\t/**\n\t * The number of decimal places this value should DISPLAY at, when it has been\n\t * given an explicit precision.\n\t *\n\t * A display sidecar, not a value one: `value` is unchanged, so every\n\t * `.value`/`toNumber()` reader and all arithmetic behave exactly as before,\n\t * and a value with no `decimalPlaces` formats the way it always did (the\n\t * global two-place default with trailing zeros trimmed). It is set only by an\n\t * explicit precision request, `<x> to N dp` and `round(x, N)`, so that\n\t * `3.14159 to 4 dp` shows `3.1416` and `1.5 to 2 dp` shows `1.50` rather than\n\t * the value being rounded but then displayed at the default two places. It is\n\t * NOT propagated through arithmetic (a later `+ 1` re-decides precision),\n\t * which is why nothing that did not ask for a precision is affected. Cleared\n\t * by {@link recycle} alongside the other sidecars.\n\t */\n\tpublic decimalPlaces?: number;\n\n\tconstructor(\n\t\ttype: ValueType,\n\t\tvalue: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SymbolicNode,\n\t\tunit?: string\n\t) {\n\t\tthis.type = type;\n\t\tthis.value = value;\n\t\tthis.unit = unit;\n\t\t// Eagerly cache for Number and Hex types (the most common case).\n\t\t// This avoids a method call + type-check on first toNumber().\n\t\tif (typeof value === 'number') {\n\t\t\tthis._cachedNumber = value;\n\t\t}\n\t}\n\n\t/**\n\t * Phase 5.3: Reset all fields for arena reuse.\n\t * Called by ValueArena.acquire(), zero allocation, just field assignment.\n\t */\n\trecycle(type: ValueType, value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SymbolicNode, unit?: string): void {\n\t\tthis.type = type;\n\t\tthis.value = value;\n\t\tthis.unit = unit;\n\t\t// Clear cache, value changed, cached number is stale.\n\t\t// Re-eager-cache for Number type (most common).\n\t\tthis._cachedNumber = typeof value === 'number' ? value : undefined;\n\t\t// Clear timeout flag, recycled Values shouldn't inherit stale metadata.\n\t\tthis.timedOut = undefined;\n\t\t// Clear the exact sidecar for the same reason: a reused Value that once\n\t\t// held money must not carry that money's decimal into a plain number.\n\t\tthis.exact = undefined;\n\t\t// The rational sidecar clears with it: a reused Value that once held a\n\t\t// fraction must not carry that fraction into a plain number.\n\t\tthis.rational = undefined;\n\t\t// The uncertainty sidecar clears the same way: a reused Value that once\n\t\t// carried a tolerance must not lend it to a plain number.\n\t\tthis.uncertainty = undefined;\n\t\t// The display-precision sidecar clears too: a reused Value that once had\n\t\t// an explicit `to N dp` must not display a plain number at that precision.\n\t\tthis.decimalPlaces = undefined;\n\t}\n\n\tisNumber(): this is Value & { value: number } {\n\t\treturn this.type === ValueType.Number;\n\t}\n\n\tisHex(): this is Value & { value: number } {\n\t\treturn this.type === ValueType.Hex;\n\t}\n\n\tisBigInt(): this is Value & { value: bigint } {\n\t\treturn this.type === ValueType.BigInt;\n\t}\n\n\tisString(): this is Value & { value: string } {\n\t\treturn this.type === ValueType.String;\n\t}\n\n\tisMatrix(): this is Value & { value: MatrixData } {\n\t\treturn this.type === ValueType.Matrix;\n\t}\n\n\t/** A Matrix shaped like a vector, 1×N (row) or N×1 (column). */\n\tisVectorShape(): boolean {\n\t\tif (this.type !== ValueType.Matrix) return false;\n\t\tconst m = this.value as MatrixData;\n\t\treturn m.rows === 1 || m.cols === 1;\n\t}\n\n\tisRange(): this is Value & { value: RangeData } {\n\t\treturn this.type === ValueType.Range;\n\t}\n\n\tisColour(): this is Value & { value: ColourData } {\n\t\treturn this.type === ValueType.Colour;\n\t}\n\n\tisSymbolic(): this is Value & { value: SymbolicNode } {\n\t\treturn this.type === ValueType.Symbolic;\n\t}\n\n\ttoNumber(): number {\n\t\t// Pending/Error have no numeric representation at all, 0 (established\n\t\t// convention). A genuinely multi-cell Matrix has no single numeric\n\t\t// representation either (real callers branch on `.isMatrix()` BEFORE\n\t\t// reaching this fallback. See e.g. VM.ts's MUL/comparison dispatch)\n\t\t// but a 1x1 Matrix, the shape `float(x)`'s legacy sugar produces, see\n\t\t// packages/vector/parselets/FloatParselet.ts, IS a scalar in every\n\t\t// meaningful sense, so it degrades to that single cell's numeric value\n\t\t// rather than 0 (this exact case used to work \"by accident\" pre-Matrix,\n\t\t// since `parseFloat([2].toString())` happened to yield `2`).\n\t\tif (this.type === ValueType.Pending) return 0;\n\t\tif (this.type === ValueType.Error) return 0;\n\t\tif (this.type === ValueType.Matrix) {\n\t\t\tconst m = this.value as MatrixData;\n\t\t\tif (m.rows === 1 && m.cols === 1 && typeof m.data[0] === \"number\") return m.data[0];\n\t\t\treturn 0;\n\t\t}\n\t\tif (this.type === ValueType.Range) return 0;\n\t\t// A colour is a struct of channels, not a scalar; like Matrix/Range it has\n\t\t// no single numeric reading. Callers branch on `.isColour()` first.\n\t\tif (this.type === ValueType.Colour) return 0;\n\t\t// A symbolic expression has no single concrete numeric value by\n\t\t// definition (it's a free-variable formula), 0, matching the\n\t\t// Pending/Error/Range convention. Real callers branch on\n\t\t// `.isSymbolic()` BEFORE reaching this fallback (see\n\t\t// `VMConversion.ts`'s `binaryOp()`).\n\t\tif (this.type === ValueType.Symbolic) return 0;\n\t\t// A boolean has an obvious numeric reading and no branch used to give it\n\t\t// one, so it fell through to `parseFloat(true)` -> NaN -> 0, and BOTH\n\t\t// booleans read as zero: `true == false` answered true, and every\n\t\t// arithmetic path that mixes a boolean with a number (\"true and 5\")\n\t\t// contributed nothing. 1/0 is the reading every language with a numeric\n\t\t// boolean coercion uses, and the one `if 1 then` already implies.\n\t\tif (this.type === ValueType.Boolean) return this.value === true ? 1 : 0;\n\n\t\tif (this._cachedNumber !== undefined) return this._cachedNumber;\n\n\t\tif (typeof this.value === 'bigint') {\n\t\t\tthis._cachedNumber = Number(this.value);\n\t\t\treturn this._cachedNumber;\n\t\t}\n\t\t// Prevent silent NaN propagation from non-numeric strings\n\t\tconst result = parseFloat(this.value as string);\n\t\tthis._cachedNumber = isNaN(result) ? 0 : result;\n\t\treturn this._cachedNumber;\n\t}\n\n\tisNaN(): boolean {\n\t\tif (this.type === ValueType.Pending) return false;\n\t\tif (this.type === ValueType.Error) return false;\n\t\tif (this.type === ValueType.Matrix) {\n\t\t\tconst m = this.value as MatrixData;\n\t\t\tif (m.rows === 1 && m.cols === 1 && typeof m.data[0] === \"number\") return isNaN(m.data[0]);\n\t\t\treturn false;\n\t\t}\n\t\tif (this.type === ValueType.Range) return false;\n\t\tif (this.type === ValueType.Colour) return false;\n\t\tif (this.type === ValueType.Symbolic) return false;\n\t\t// Matches toNumber()'s boolean reading above. Without this a Boolean\n\t\t// reached the string branch at the bottom and `parseFloat(true)` made\n\t\t// every boolean report itself as NaN.\n\t\tif (this.type === ValueType.Boolean) return false;\n\t\tif (typeof this.value === 'number') return isNaN(this.value);\n\t\tif (typeof this.value === 'bigint') return false;\n\t\treturn isNaN(parseFloat(this.value as string));\n\t}\n}\n\n/**\n * Create a Number-typed Value. Uses the arena when active for zero-allocation.\n * This is the most common factory, over 90% of all Value creations.\n */\nexport function numberValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Number, n);\n\treturn new Value(ValueType.Number, n);\n}\n\n/**\n * A Number that also carries the exact decimal it was written as.\n *\n * The type stays {@link ValueType.Number} and `value` stays the nearest double,\n * so this Value behaves exactly like any other number everywhere it is read as\n * one. The `exact` sidecar only matters when it later meets a currency: that is\n * what lets \"$0.70 * 1.10\" be exact while \"0.1 + 0.2\" stays the double it was.\n * Decimal-point literals are compiled to this (see the PUSH_DECIMAL opcode).\n */\nexport function numberValueExact(n: number, exact: DecimalData): Value {\n\tconst v = numberValue(n);\n\tv.exact = exact;\n\treturn v;\n}\n\n/**\n * A Number that also carries the exact rational it evaluates to.\n *\n * The rational counterpart of {@link numberValueExact}: the type stays\n * {@link ValueType.Number} and `value` stays the nearest double (recomputed\n * from the rational, so a chain of fraction operations never accumulates\n * float error), so this reads as an ordinary number everywhere. The `rational`\n * sidecar is what keeps the next fraction operation and any `as fraction`\n * exact. Integer division produces this (see the DIV opcode).\n */\nexport function numberValueRational(n: number, rational: Rational): Value {\n\tconst v = numberValue(n);\n\tv.rational = rational;\n\treturn v;\n}\n\n/**\n * A Number that also carries a one-sigma uncertainty (standard error).\n *\n * The uncertainty counterpart of {@link numberValueExact}: the type stays\n * {@link ValueType.Number} and `value` stays the center, so this reads as an\n * ordinary number everywhere. The `uncertainty` sidecar is what lets `+`, `-`,\n * `*`, `/` propagate the tolerance in quadrature. The `±` operator produces\n * this (see the MAKE_UNCERTAIN opcode), as does any of those four ops when an\n * operand already carries one. The magnitude is stored as given, callers pass a\n * non-negative value (`Math.abs` at the seam, quadrature results are already\n * non-negative).\n */\nexport function numberValueUncertain(n: number, uncertainty: number): Value {\n\tconst v = numberValue(n);\n\tv.uncertainty = uncertainty;\n\treturn v;\n}\n\n/** Which base a {@link ValueType.Hex} value is displayed in. */\nexport type DisplayBase = \"hex\" | \"bin\" | \"oct\";\n\n/**\n * Create a Hex-typed Value: a **number** that displays in another base.\n *\n * The type is numeric on purpose, and that is the whole point of it. A base is\n * a way of writing a quantity, not a different kind of quantity, so `0xFF + 1`\n * has to be 256. Returning a string instead makes it 1, because a string reads\n * as zero in arithmetic, and nothing about that failure is visible at the point\n * of use.\n *\n * @param n - The number itself, in full precision. A `bigint` is accepted for\n * the same reason the type is numeric at all: `12345678901234567890n as hex`\n * has an exact answer, and forcing it through a double first rendered\n * 0xAB54A98CEB1F0800 for a value ending 0AD2.\n * @param base - How to display it, defaulting to hexadecimal. Carried in the\n * `unit` slot, which is free for this type.\n */\nexport function hexValue(n: number | bigint, base: DisplayBase = \"hex\"): Value {\n\tconst tag = base === \"hex\" ? undefined : base;\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Hex, n, tag);\n\treturn new Value(ValueType.Hex, n, tag);\n}\n\n/** Create a BigInt-typed Value (arbitrary-precision integer). */\nexport function bigIntValue(n: bigint): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.BigInt, n);\n\treturn new Value(ValueType.BigInt, n);\n}\n\n/** Create a String-typed Value. */\nexport function stringValue(s: string): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.String, s);\n\treturn new Value(ValueType.String, s);\n}\n\n/** Create a Unit-of-Measurement Value (typed number with unit annotation). */\nexport function uomValue(n: number, unit: string): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Uom, n, unit);\n\treturn new Value(ValueType.Uom, n, unit);\n}\n\n/**\n * A unit-of-measurement Value that also carries an exact decimal magnitude.\n *\n * This is how money keeps its precision: `value` is the nearest double (so\n * `toNumber()` and every existing Uom path are unchanged), and `exact` is the\n * decimal the amount really is. Same-currency arithmetic reads `exact` to stay\n * exact, and the formatter reads it to round a half-cent the way a ledger does\n * rather than the way `toFixed` does on a double.\n */\nexport function uomValueExact(n: number, unit: string, exact: DecimalData): Value {\n\tconst v = uomValue(n, unit);\n\tv.exact = exact;\n\treturn v;\n}\n\n// ── Rate, \"quantity per unit of something\" (SoulverCore: `$99/week`\n// `3 hours/day`, `30 fps`). Represented as a `ValueType.Uom` (no new\n// ValueType, a rate IS a unit-of-measurement, just a compound one) whose\n// `unit` string is `\"<numerator>/<denominator>\"`. The numerator is an\n// opaque label (may be a real convertible unit like \"USD\"/\"km\", or a bare\n// tag like \"frames\" that the `convert` package doesn't know about, rate\n// arithmetic never needs to convert the numerator, only compare it for\n// equality when combining two rates). The denominator MUST be a unit\n// `convertUnit()`/`getMeasure()` (uom/UomConverter.ts) recognizes, since\n// that's the part rate arithmetic actually rescales. See `vm/VM.ts`'s\n// `RATE_CONVERT`/`RATE_MUL`/`RATE_DIV` opcodes for the operations built on\n// this representation.\n\n/** Create a Rate value: `magnitude` of `numeratorUnit` per one `denominatorUnit`. */\nexport function rateValue(magnitude: number, numeratorUnit: string, denominatorUnit: string): Value {\n\treturn uomValue(magnitude, `${numeratorUnit}/${denominatorUnit}`);\n}\n\n/** Whether `unit` is a compound rate unit (`\"X/Y\"`) rather than a plain unit. */\nexport function isRateUnit(unit: string | undefined): unit is string {\n\treturn typeof unit === \"string\" && unit.includes(\"/\");\n}\n\n/**\n * Split a rate unit string into its numerator/denominator halves.\n * @throws if `unit` isn't a rate unit, check with {@link isRateUnit} first.\n */\nexport function splitRateUnit(unit: string): { numerator: string; denominator: string } {\n\tconst idx = unit.indexOf(\"/\");\n\tif (idx < 0) {\n\t\tthrow ErrorFactory.internal(\n\t\t\t\"INVALID_RATE_UNIT\",\n\t\t\t`splitRateUnit: \"${unit}\" is not a rate unit (expected \"numerator/denominator\")`,\n\t\t\t{ unit },\n\t\t);\n\t}\n\treturn { numerator: unit.slice(0, idx), denominator: unit.slice(idx + 1) };\n}\n\n/** Join a numerator/denominator pair back into a rate unit string. */\nexport function joinRateUnit(numeratorUnit: string, denominatorUnit: string): string {\n\treturn `${numeratorUnit}/${denominatorUnit}`;\n}\n\n// ── Video timecode, \"HH:MM:SS:FF at a given fps\" (SoulverCore: video\n// editing timecode literals, e.g. `01:02:03:04 at 30fps`). Represented the\n// same way Rate is above: NOT a new ValueType, just a `ValueType.Uom` whose\n// `unit` string is `\"timecode@<fps>\"` and whose numeric `value` is the\n// TOTAL FRAME COUNT since 00:00:00:00 at that fps, e.g. \"00:00:01:00 at\n// 30fps\" is `Uom(30, \"timecode@30\")`.\n//\n// Storing the total frame count (rather than four separate H/M/S/F fields)\n// means ordinary integer addition/subtraction on the numeric value is\n// ALREADY correct carry/borrow-aware arithmetic with zero extra logic\n// e.g. \"frame 29 + 2 frames\" at 30fps is just `29 + 2 = 31`, and 31 total\n// frames at 30fps IS frame 1 of the next second, with no explicit carry\n// step required. Carry/borrow only needs to be reconstructed when\n// converting a total frame count back into HH:MM:SS:FF display notation\n// see `packages/time/timecode/TimecodeMath.ts`'s `framesToTimecodeString()`.\n// See `vm/VM.ts`'s ADD/SUB dispatch for the arithmetic built on this\n// representation (timecode + frames, + duration, + timecode, - timecode).\n\nconst TIMECODE_UNIT_PREFIX = \"timecode@\";\n\n/** Build a timecode Uom unit string embedding its frame rate, e.g. `timecodeUnit(30)` -> `\"timecode@30\"`. */\nexport function timecodeUnit(fps: number): string {\n\treturn `${TIMECODE_UNIT_PREFIX}${fps}`;\n}\n\n/** Whether `unit` is a compound video-timecode unit (`\"timecode@<fps>\"`). */\nexport function isTimecodeUnit(unit: string | undefined): unit is string {\n\treturn typeof unit === \"string\" && unit.startsWith(TIMECODE_UNIT_PREFIX);\n}\n\n/**\n * Extract the fps from a timecode unit string.\n * @throws if `unit` isn't a timecode unit, check with {@link isTimecodeUnit} first.\n */\nexport function timecodeFps(unit: string): number {\n\tif (!isTimecodeUnit(unit)) {\n\t\tthrow ErrorFactory.internal(\n\t\t\t\"INVALID_TIMECODE_UNIT\",\n\t\t\t`timecodeFps: \"${unit}\" is not a timecode unit (expected \"timecode@<fps>\")`,\n\t\t\t{ unit },\n\t\t);\n\t}\n\treturn parseFloat(unit.slice(TIMECODE_UNIT_PREFIX.length));\n}\n\n/**\n * Create a Matrix value from an explicit shape + column-major data array.\n * `data.length` must equal `rows*cols`, callers building a matrix from\n * row-major source syntax (e.g. the `[1,2;3,4]` literal) must transpose\n * into column-major order before calling this; see `MatrixOps.ts`'s\n * `rowMajorToColumnMajor()`.\n */\nexport function matrixValue(rows: number, cols: number, data: readonly MatrixEntry[]): Value {\n\t// Every matrix in the engine is born here, which makes this the one place\n\t// that can charge for one without each producer having to remember to. The\n\t// charge lands after `data` exists, so it is a backstop rather than a\n\t// refusal: it cannot stop a single allocation that is already fatal (the\n\t// sites whose size is knowable in advance charge before allocating, see\n\t// `vm/VM.ts`'s matrix cases), but it does stop the second one, and it means\n\t// an opcode added later inherits the bound without being told about it.\n\t// Free in relative terms: the hasSymbolic scan just below is already O(n)\n\t// over the same cells.\n\tchargeAllocation(data.length, \"matrix cells\");\n\t// A SymbolicNode cell is the only object-typed MatrixEntry variant\n\t// (number/boolean are primitives), a cheap, always-correct way to\n\t// derive hasSymbolic without asking every caller to track it by hand.\n\t// The `\"kind\" in cell` half is a tripwire, not redundancy. MatrixEntry is\n\t// `number | boolean | SymbolicNode`, so an object cell should always be a\n\t// node; requiring the discriminant means a Rational that escaped\n\t// MatrixOps.ts's symbolicToEntry() shows up as a wrong result rather than as\n\t// a matrix that silently believes it is symbolic.\n\tconst hasSymbolic = data.some(cell => typeof cell === \"object\" && cell !== null && \"kind\" in cell);\n\tconst m: MatrixData = { rows, cols, data, hasSymbolic };\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Matrix, m);\n\treturn new Value(ValueType.Matrix, m);\n}\n\n/** A 1×N row-vector Matrix, row-major and column-major storage are identical for a single row. */\nexport function rowVectorValue(data: readonly number[]): Value {\n\treturn matrixValue(1, data.length, data);\n}\n\n/** An N×1 column-vector Matrix, row-major and column-major storage are identical for a single column. */\nexport function colVectorValue(data: readonly number[]): Value {\n\treturn matrixValue(data.length, 1, data);\n}\n\n/** Create a Range value, a first-class integer range `min:max`, both bounds inclusive. */\nexport function rangeValue(min: number, max: number): Value {\n\tconst r: RangeData = { min, max };\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Range, r);\n\treturn new Value(ValueType.Range, r);\n}\n\n/**\n * Create a Colour value from canonical sRGB channels plus a display format.\n * Arena-backed like the other synchronous factories; the `ColourData` struct in\n * the `value` slot is immutable, so arena recycle is safe with no extra clearing\n * (matching {@link matrixValue}/{@link rangeValue}).\n */\nexport function colourValue(c: ColourData): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Colour, c);\n\treturn new Value(ValueType.Colour, c);\n}\n\n/** Create a Symbolic value, a free-variable algebraic expression tree (`symbolic/SymbolicNode.ts`'s `SymbolicNode`), not a concrete number. */\nexport function symbolicValue(node: SymbolicNode): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Symbolic, node);\n\treturn new Value(ValueType.Symbolic, node);\n}\n\n\n\n/** Create a Boolean-typed Value. */\nexport function boolValue(b: boolean): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Boolean, b);\n\treturn new Value(ValueType.Boolean, b);\n}\n\n/** Create a Datetime-typed Value (Unix timestamp in milliseconds). */\nexport function datetimeValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Datetime, n);\n\treturn new Value(ValueType.Datetime, n);\n}\n\n/** Create a Percentage-typed Value (stored as fraction, e.g. 0.5 for 50%). */\nexport function percentageValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Percentage, n);\n\treturn new Value(ValueType.Percentage, n);\n}\n\n/**\n * Create a Pending value, signals that an async result is not yet resolved.\n * The value field stores the queryKey string for deduplication and diagnostics.\n * Pending values should NEVER be stored in the arena (they persist across\n * scroll frames until resolution completes).\n */\nexport function pendingValue(queryKey: string): Value {\n\treturn new Value(ValueType.Pending, queryKey);\n}\n\n/**\n * Create an Error value, propagated through the DAG when a plugin raises an error.\n * The value field stores the EngineError code, unit stores the message.\n * Downstream consumers (lines that depend on errored data) bubble this up.\n * Should NEVER be stored in the arena.\n */\nexport function errorValue(code: string, message: string): Value {\n\treturn new Value(ValueType.Error, code, message);\n}\n\n/**\n * The first operand carrying a fault rather than a quantity, if any does.\n *\n * `Error` and `Pending` both read as the number 0 through {@link Value.toNumber},\n * by a convention that only holds up as long as nothing asks. Every opcode and\n * builtin that reaches for an operand's number without asking its type first\n * therefore computes with a zero it cannot tell apart from a real one, and\n * hands back an answer dressed in whatever type it was going to produce\n * anyway. That is how `(5 kg to m) to s` came to answer `0.00 s`: the failed\n * conversion is an Error, the second conversion read it as zero, and the unit\n * the reader asked for made the result look like a conversion that worked.\n *\n * Operands are checked left to right, matching evaluation order, and the\n * faulted Value is returned AS IT IS rather than replaced with a fresh one, so\n * the original code and message (or the pending query key) reach the caller\n * unchanged. `binaryOp` (vm/VMConversion.ts) and `OpCode.EXP` already did this\n * inline; this is the same rule for every other site, in one place so a site\n * added later can adopt it in a line.\n *\n * Three operands cover every call site in the VM (`MAT_INDEX2` and `MAT_SLICE`\n * are the widest). A variadic signature would allocate an arguments array on\n * paths that run per instruction; see {@link faultedIn} for the list case.\n *\n * @returns The faulted operand, or `null` when all of them carry a value.\n */\nexport function faultedOperand(a: Value, b?: Value, c?: Value): Value | null {\n\tif (a.type === ValueType.Error || a.type === ValueType.Pending) return a;\n\tif (b !== undefined && (b.type === ValueType.Error || b.type === ValueType.Pending)) return b;\n\tif (c !== undefined && (c.type === ValueType.Error || c.type === ValueType.Pending)) return c;\n\treturn null;\n}\n\n/**\n * {@link faultedOperand} over an already-built list, for the call sites that\n * have one (a builtin's arguments, a plugin function's).\n *\n * @returns The first faulted element, or `null` when every element carries a value.\n */\nexport function faultedIn(values: readonly Value[]): Value | null {\n\tfor (let i = 0; i < values.length; i++) {\n\t\tconst v = values[i];\n\t\tif (v.type === ValueType.Error || v.type === ValueType.Pending) return v;\n\t}\n\treturn null;\n}\n"]}

package/dist/chunk-3OWCDIPN.js

@@ -0,0 +1,215 @@
+import { autoFormatIntegerOrFloat } from './chunk-UKQHXPGW.js';
+import { formatColour } from './chunk-5HRB36DK.js';
+import { columnMajorToRowMajor, formatSymbolic, CURRENCY_DISPLAY, decimalToFixed } from './chunk-NNQ2TYDF.js';
+import { getLocale } from './chunk-XBTEO4OB.js';
+
+// src/format/FormattingSettings.ts
+var DEFAULT_FORMATTING_SETTINGS = {
+  floatResult: {
+    decimalPlaces: 2,
+    enableSeperator: true
+  },
+  numberResult: {
+    decimalSeparatorLocale: "en-US"
+  },
+  hexResult: {
+    enablePadding: false,
+    paddingZeros: 0
+  },
+  unitOfMeasurementResult: {
+    decimalPlaces: 2
+  },
+  percentageResult: {
+    decimalPlaces: 2
+  }
+};
+
+// src/format/FormatEngine.ts
+function formatNumber(value, locale, settings, decimalPlaces) {
+  const sep = settings.floatResult.enableSeperator;
+  const loc = settings.numberResult.decimalSeparatorLocale;
+  if (decimalPlaces !== void 0 && Number.isFinite(value)) {
+    const formatted2 = value.toLocaleString(loc || "en-US", {
+      minimumFractionDigits: decimalPlaces,
+      maximumFractionDigits: decimalPlaces,
+      useGrouping: sep
+    });
+    return `${locale.display.resultPrefix}${formatted2}`;
+  }
+  const dp = settings.floatResult.decimalPlaces;
+  const formatted = autoFormatIntegerOrFloat(value, dp, sep, loc);
+  return `${locale.display.resultPrefix}${formatted}`;
+}
+function formatUncertain(center, uncertainty, locale, settings) {
+  const dp = settings.floatResult.decimalPlaces;
+  const useGrouping = settings.floatResult.enableSeperator;
+  const loc = settings.numberResult.decimalSeparatorLocale || "en-US";
+  const spreadMax = Math.max(dp, 1);
+  const centerText = center.toLocaleString(loc, { useGrouping, minimumFractionDigits: 0, maximumFractionDigits: dp });
+  const spreadText = Math.abs(uncertainty).toLocaleString(loc, { useGrouping, minimumFractionDigits: 1, maximumFractionDigits: spreadMax });
+  return `${locale.display.resultPrefix}${centerText} \xB1 ${spreadText}`;
+}
+function formatHex(value, settings, base) {
+  if (typeof value === "number" && !Number.isFinite(value)) return `= ${value}`;
+  const negative = typeof value === "bigint" ? value < 0n : value < 0;
+  const sign = negative ? "-" : "";
+  const digits = (radix) => typeof value === "bigint" ? (negative ? -value : value).toString(radix) : Math.abs(Math.trunc(value)).toString(radix);
+  if (base === "bin") return `= ${sign}0b${digits(2)}`;
+  if (base === "oct") return `= ${sign}0o${digits(8)}`;
+  const padding = settings.hexResult.enablePadding ? settings.hexResult.paddingZeros : 0;
+  const hex = digits(16).toUpperCase().padStart(padding, "0");
+  return `= ${sign}0x${hex}`;
+}
+var MAX_DISPLAYED_BIGINT_DIGITS = 2e4;
+function formatBigInt(value) {
+  const magnitude = value < 0n ? -value : value;
+  if (Number.isFinite(Number(magnitude))) return `= ${value}`;
+  const bits = magnitude.toString(16).length * 4;
+  if (bits * Math.LN2 / Math.LN10 <= MAX_DISPLAYED_BIGINT_DIGITS) return `= ${value}`;
+  const log10 = bits * Math.LN2 / Math.LN10;
+  const exponent = Math.floor(log10);
+  const mantissa = Math.pow(10, log10 - exponent);
+  const sign = value < 0n ? "-" : "";
+  return `= ${sign}~${mantissa.toFixed(3)}e+${exponent} (an exact integer of about ${(exponent + 1).toLocaleString("en-US")} digits, too large to print)`;
+}
+function formatString(value) {
+  return `= ${value}`;
+}
+function formatBoolean(value) {
+  return `= ${value}`;
+}
+function formatDatetime(value, locale) {
+  const d = new Date(value);
+  const dateStr = d.toLocaleDateString(locale.code, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;
+  if (isMidnight) return `= ${dateStr}`;
+  return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;
+}
+function formatMsDuration(ms) {
+  const sign = ms < 0 ? "-" : "";
+  const totalSeconds = Math.round(Math.abs(ms) / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const mm = String(minutes).padStart(2, "0");
+  if (seconds === 0) return `${sign}${hours}:${mm}`;
+  const ss = String(seconds).padStart(2, "0");
+  return `${sign}${hours}:${mm}:${ss}`;
+}
+function formatUom(value, unit, locale, settings, exact) {
+  if (unit === "ms") return `= ${formatMsDuration(value)}`;
+  const dp = settings.unitOfMeasurementResult.decimalPlaces;
+  const timeSpanUnits = ["days", "weeks", "hours", "minutes", "seconds", "day", "week", "hour", "minute", "second"];
+  const isTimeSpan = unit && timeSpanUnits.includes(unit);
+  let formatted;
+  if (isTimeSpan && value === Math.floor(value)) {
+    formatted = value.toString();
+  } else {
+    formatted = value.toFixed(dp);
+  }
+  const currencyDisplay = unit ? CURRENCY_DISPLAY[unit.toUpperCase()] : void 0;
+  if (currencyDisplay) {
+    const moneyText = exact ? decimalToFixed(exact, dp) : formatted;
+    const sep = currencyDisplay.spaced ? " " : "";
+    const withSymbol = currencyDisplay.position === "prefix" ? `${currencyDisplay.symbol}${sep}${moneyText}` : `${moneyText}${sep}${currencyDisplay.symbol}`;
+    return `= ${withSymbol}`;
+  }
+  const genericText = exact ? decimalToFixed(exact, dp) : formatted;
+  return `= ${genericText} ${unit || ""}`.trim();
+}
+function formatMatrixEntry(entry, settings) {
+  if (typeof entry === "boolean") return entry ? "true" : "false";
+  if (typeof entry === "object" && entry !== null) return formatSymbolic(entry);
+  const dp = settings.floatResult.decimalPlaces;
+  const sep = settings.floatResult.enableSeperator;
+  const loc = settings.numberResult.decimalSeparatorLocale;
+  return autoFormatIntegerOrFloat(entry, dp, sep, loc);
+}
+function formatMatrix(m, locale, settings) {
+  const rowMajor = columnMajorToRowMajor(m);
+  const rows = [];
+  for (let r = 0; r < m.rows; r++) {
+    const cells = [];
+    for (let c = 0; c < m.cols; c++) {
+      cells.push(formatMatrixEntry(rowMajor[r * m.cols + c], settings));
+    }
+    rows.push(cells.join(", "));
+  }
+  return `${locale.display.resultPrefix}[${rows.join("; ")}]`;
+}
+function formatMatrixAligned(m, settings) {
+  const us = settings || DEFAULT_FORMATTING_SETTINGS;
+  const rowMajor = columnMajorToRowMajor(m);
+  const cells = [];
+  for (let r = 0; r < m.rows; r++) {
+    const row = [];
+    for (let c = 0; c < m.cols; c++) {
+      row.push(formatMatrixEntry(rowMajor[r * m.cols + c], us));
+    }
+    cells.push(row);
+  }
+  const colWidth = [];
+  for (let c = 0; c < m.cols; c++) {
+    let width = 0;
+    for (let r = 0; r < m.rows; r++) width = Math.max(width, cells[r][c].length);
+    colWidth.push(width);
+  }
+  return cells.map((row) => `[ ${row.map((cell, c) => cell.padStart(colWidth[c])).join("  ")} ]`).join("\n");
+}
+function formatRange(min, max, locale) {
+  return `${locale.display.resultPrefix}${min}:${max}`;
+}
+function formatPercentage(value, locale, settings) {
+  const dp = settings.percentageResult.decimalPlaces;
+  const formatted = (value * 100).toFixed(dp);
+  return `= ${formatted}${locale.display.percentageSuffix}`;
+}
+function formatUnit(value, unit) {
+  return `= ${value} ${unit || ""}`.trim();
+}
+function formatValue(value, settings) {
+  const us = settings || DEFAULT_FORMATTING_SETTINGS;
+  const localeCode = us.numberResult.decimalSeparatorLocale || "en";
+  const locale = getLocale(localeCode);
+  switch (value.type) {
+    case 0 /* Number */:
+      if (value.uncertainty !== void 0) {
+        return formatUncertain(value.value, value.uncertainty, locale, us);
+      }
+      return formatNumber(value.value, locale, us, value.decimalPlaces);
+    case 1 /* Hex */:
+      return formatHex(value.value, us, value.unit);
+    case 2 /* BigInt */:
+      return formatBigInt(value.value);
+    case 3 /* String */:
+      return formatString(value.value);
+    case 10 /* Boolean */:
+      return formatBoolean(value.value);
+    case 4 /* Datetime */:
+      return formatDatetime(value.value, locale);
+    case 6 /* Uom */:
+      return formatUom(value.value, value.unit, locale, us, value.exact);
+    case 7 /* Matrix */:
+      return formatMatrix(value.value, locale, us);
+    case 8 /* Range */: {
+      const r = value.value;
+      return formatRange(r.min, r.max, locale);
+    }
+    case 14 /* Colour */:
+      return `${locale.display.resultPrefix}${formatColour(value.value)}`;
+    case 9 /* Symbolic */:
+      return formatSymbolic(value.value);
+    case 5 /* Percentage */:
+      return formatPercentage(value.value, locale, us);
+    case 11 /* Unit */:
+      return formatUnit(value.value, value.unit);
+    case 13 /* Error */:
+      return value.unit ?? String(value.value);
+    default:
+      return `= ${String(value.value)}`;
+  }
+}
+
+export { DEFAULT_FORMATTING_SETTINGS, formatMatrixAligned, formatValue };
+//# sourceMappingURL=chunk-3OWCDIPN.js.map
+//# sourceMappingURL=chunk-3OWCDIPN.js.map

package/dist/chunk-3OWCDIPN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format/FormattingSettings.ts","../src/format/FormatEngine.ts"],"names":["formatted"],"mappings":"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","file":"chunk-3OWCDIPN.js","sourcesContent":["/**\n * Minimal formatting settings interface for the engine\n * This allows the engine to format values without depending on app-specific settings\n */\nexport interface FormattingSettings {\n  floatResult: {\n    decimalPlaces: number;\n    enableSeperator: boolean;\n  };\n  numberResult: {\n    decimalSeparatorLocale: string;\n  };\n  hexResult: {\n    enablePadding: boolean;\n    paddingZeros: number;\n  };\n  unitOfMeasurementResult: {\n    decimalPlaces: number;\n  };\n  percentageResult: {\n    decimalPlaces: number;\n  };\n}\n\n/** Formatting used when a host supplies none. */\nexport const DEFAULT_FORMATTING_SETTINGS: FormattingSettings = {\n  floatResult: {\n    decimalPlaces: 2,\n    enableSeperator: true,\n  },\n  numberResult: {\n    decimalSeparatorLocale: \"en-US\",\n  },\n  hexResult: {\n    enablePadding: false,\n    paddingZeros: 0,\n  },\n  unitOfMeasurementResult: {\n    decimalPlaces: 2,\n  },\n  percentageResult: {\n    decimalPlaces: 2,\n  },\n};\n","import { Value, ValueType, type MatrixData, type MatrixEntry, type RangeData, type ColourData } from \"@solve-js/vm/Value\";\nimport { formatColour } from \"@solve-js/packages/colour/ColourMath\";\nimport { decimalToFixed, type DecimalData } from \"@solve-js/decimal\";\nimport { getLocale, type ILocale } from \"@solve-js/constants/locales\";\nimport { autoFormatIntegerOrFloat } from \"@solve-js/utilities/Number\";\nimport { FormattingSettings, DEFAULT_FORMATTING_SETTINGS } from \"./FormattingSettings\";\nimport { CURRENCY_DISPLAY } from \"@solve-js/uom/CurrencyAliases\";\nimport { columnMajorToRowMajor } from \"@solve-js/vm/MatrixOps\";\nimport { formatSymbolic, type SymbolicNode } from \"@solve-js/symbolic\";\n\nfunction formatNumber(value: number, locale: ILocale, settings: FormattingSettings, decimalPlaces?: number): string {\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  // An explicit precision (`3.14159 to 4 dp`, `round(1.5, 2)`) shows EXACTLY that\n  // many places with trailing zeros kept, where the default trims them and shows\n  // an integer with none. The value was already rounded to this precision when\n  // it was set (see VMBuiltins' roundToPlaces, exact where an exact decimal was\n  // there), so rendering it to the same place count reproduces that rounding.\n  if (decimalPlaces !== undefined && Number.isFinite(value)) {\n    const formatted = value.toLocaleString(loc || \"en-US\", {\n      minimumFractionDigits: decimalPlaces,\n      maximumFractionDigits: decimalPlaces,\n      useGrouping: sep,\n    });\n    return `${locale.display.resultPrefix}${formatted}`;\n  }\n  const dp = settings.floatResult.decimalPlaces;\n  const formatted = autoFormatIntegerOrFloat(value, dp, sep, loc);\n  return `${locale.display.resultPrefix}${formatted}`;\n}\n\n/**\n * Renders a measurement that carries a one-sigma uncertainty as\n * `center ± spread`, e.g. `49.2 ± 2.0`.\n *\n * The center is shown the way any number is, whole numbers as integers and\n * trailing zeros trimmed, so a tolerance-free-looking center still reads\n * cleanly (\"30 ± 2.24\", not \"30.00 ± 2.24\"). The spread is shown to the same\n * decimal-place budget but always keeps at least one fractional digit, which is\n * what distinguishes it as a tolerance and gives \"± 2.0\" rather than \"± 2\".\n * Both use `Intl` with `maximumFractionDigits`, so the trailing-zero trimming is\n * locale-correct (a comma-decimal locale is not string-sliced on \".\").\n *\n * The symbol is always the `±` glyph on output, even when the input was the\n * ASCII `+/-`, since the glyph is the conventional notation and unambiguous to\n * read back.\n */\nfunction formatUncertain(center: number, uncertainty: number, locale: ILocale, settings: FormattingSettings): string {\n  const dp = settings.floatResult.decimalPlaces;\n  const useGrouping = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale || \"en-US\";\n  // The spread needs room for at least one fractional digit, so a zero-decimal\n  // budget cannot leave minimumFractionDigits above maximumFractionDigits.\n  const spreadMax = Math.max(dp, 1);\n  const centerText = center.toLocaleString(loc, { useGrouping, minimumFractionDigits: 0, maximumFractionDigits: dp });\n  const spreadText = Math.abs(uncertainty).toLocaleString(loc, { useGrouping, minimumFractionDigits: 1, maximumFractionDigits: spreadMax });\n  return `${locale.display.resultPrefix}${centerText} ± ${spreadText}`;\n}\n\n/**\n * Renders a number in whichever base it is tagged with.\n *\n * The zero padding is a hexadecimal setting and stays one. Applying it to a\n * binary rendering would pad `0b101` out to the same digit count as a hex\n * value, which is a different quantity of zeros and not what the setting asks\n * for.\n */\nfunction formatHex(value: number | bigint, settings: FormattingSettings, base?: string): string {\n  // An infinity or a NaN has no digits in any base, and asking for them\n  // produced `0xINFINITY`, a literal that reads back as nothing at all. Render\n  // the value itself, which is what every other non-finite result shows.\n  if (typeof value === \"number\" && !Number.isFinite(value)) return `= ${value}`;\n\n  // Truncate and take the sign off before converting. `Number.toString(radix)`\n  // does neither: it renders -255 as \"-ff\", which lands the minus inside the\n  // literal as `0x-FF`, and it renders 255.7 as \"ff.b3333333333\", inventing\n  // fractional hex digits for a notation that has no use for them. Both were\n  // visible on `as hex` until the builtins started sharing this path.\n  //\n  // A bigint needs neither truncation nor a Math call, and must not be routed\n  // through one: passing it to Math.trunc() throws, and converting it to a\n  // double first is exactly the precision loss it is carried as a bigint to\n  // avoid.\n  const negative = typeof value === \"bigint\" ? value < 0n : value < 0;\n  const sign = negative ? \"-\" : \"\";\n  const digits = (radix: number): string =>\n    typeof value === \"bigint\"\n      ? (negative ? -value : value).toString(radix)\n      : Math.abs(Math.trunc(value)).toString(radix);\n\n  if (base === \"bin\") return `= ${sign}0b${digits(2)}`;\n  if (base === \"oct\") return `= ${sign}0o${digits(8)}`;\n  const padding = settings.hexResult.enablePadding ? settings.hexResult.paddingZeros : 0;\n  const hex = digits(16).toUpperCase().padStart(padding, \"0\");\n  return `= ${sign}0x${hex}`;\n}\n\n/**\n * How many decimal digits of an exact integer this will render in full.\n *\n * A little above the ~19,729 digits of the largest bigint the VM will build\n * (`vm/VM.ts`'s MAX_EXACT_POW_BITS / MAX_EXACT_SHIFT_BITS, 65,536 bits), so\n * every value the engine can produce through `^` or `<<` still prints exactly\n * and this ceiling only ever meets a value that came from somewhere else.\n */\nconst MAX_DISPLAYED_BIGINT_DIGITS = 20000;\n\n/**\n * Renders an exact integer, or describes it when writing it out is itself the\n * expensive operation.\n *\n * This used to be a bare `= ${value}` template, which renders whatever it is\n * handed: `1n << 100000000` took 8.5 seconds here turning a 12.5MB integer\n * into a thirty-million-character string, and a host has no way to opt out,\n * since displaying the answer is what it asked the engine for. The VM's own\n * ceiling on `<<` and `^` now stops that value existing, so this is the\n * backstop for every other way a large bigint can arrive (repeated `x * x`,\n * a Value a host built itself), and it costs one comparison for every value\n * that is not absurd.\n *\n * The digit count is estimated from the bit length rather than measured, since\n * measuring means doing the conversion this exists to avoid. Bit length comes\n * off the hexadecimal form, which is linear in the size of the value where the\n * decimal form is not.\n */\nfunction formatBigInt(value: bigint): string {\n  const magnitude = value < 0n ? -value : value;\n  // Every bigint a person actually reads takes this line and nothing else:\n  // anything a double can hold is at most 309 digits, so it is printable\n  // without measuring it at all.\n  if (Number.isFinite(Number(magnitude))) return `= ${value}`;\n  const bits = magnitude.toString(16).length * 4;\n  if (bits * Math.LN2 / Math.LN10 <= MAX_DISPLAYED_BIGINT_DIGITS) return `= ${value}`;\n  const log10 = bits * Math.LN2 / Math.LN10;\n  const exponent = Math.floor(log10);\n  const mantissa = Math.pow(10, log10 - exponent);\n  const sign = value < 0n ? \"-\" : \"\";\n  return `= ${sign}~${mantissa.toFixed(3)}e+${exponent} (an exact integer of about ${(exponent + 1).toLocaleString(\"en-US\")} digits, too large to print)`;\n}\n\nfunction formatString(value: string): string {\n  return `= ${value}`;\n}\n\nfunction formatBoolean(value: boolean): string {\n  return `= ${value}`;\n}\n\n/**\n * Renders a Datetime value locale-aware, the previous implementation\n * called `d.toLocaleString()` with no arguments, which always uses the JS\n * runtime's own default locale and never actually consulted `locale.code`\n * despite receiving it as a parameter (both branches of its old\n * `dateFormat === \"default\"` check were byte-for-byte identical, dead\n * groundwork for a distinction that was never implemented). Concretely,\n * this meant every configured locale (including the shipped German one)\n * always displayed weekday/month names in English. See GitHub issue #77.\n *\n * Uses `weekday`/`month`: \"long\" for a spelled-out date (\"Monday,\n * November 17, 2025\" / \"lundi 17 novembre 2025\") since that's what a\n * literal weekday name is for; a bare numeric date doesn't need\n * localizing beyond the decimal/thousands separators `formatNumber()`\n * already handles. The time-of-day portion is only appended when it's\n * not exactly local midnight, bare date literals (\"today\", \"17/11/2025\")\n * always anchor to local midnight, and showing \"00:00:00\" on every one of\n * those would be noise, not information.\n */\nfunction formatDatetime(value: number, locale: ILocale): string {\n  const d = new Date(value);\n  const dateStr = d.toLocaleDateString(locale.code, { weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\" });\n  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;\n  if (isMidnight) return `= ${dateStr}`;\n  return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;\n}\n\n/**\n * Renders a millisecond duration as clock-style `H:MM` (or `H:MM:SS` when\n * there's a non-zero seconds component). `ms` is never a user-typeable\n * unit (confirmed: it appears nowhere in `lexer/units.ts`), it's only\n * ever produced by subtracting two clock times/datetimes (`9:30 - 8:30`,\n * `VM.ts`'s Datetime SUB case), so this is a safe, narrow special case,\n * not a general change to how durations display.\n */\nfunction formatMsDuration(ms: number): string {\n  const sign = ms < 0 ? \"-\" : \"\";\n  const totalSeconds = Math.round(Math.abs(ms) / 1000);\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const seconds = totalSeconds % 60;\n  const mm = String(minutes).padStart(2, \"0\");\n  if (seconds === 0) return `${sign}${hours}:${mm}`;\n  const ss = String(seconds).padStart(2, \"0\");\n  return `${sign}${hours}:${mm}:${ss}`;\n}\n\nfunction formatUom(value: number, unit: string | undefined, locale: ILocale, settings: FormattingSettings, exact?: DecimalData): string {\n  if (unit === \"ms\") return `= ${formatMsDuration(value)}`;\n\n  const dp = settings.unitOfMeasurementResult.decimalPlaces;\n\n  // For TimeSpan values (days, weeks, hours, etc.), format as integer if the value is a whole number\n  const timeSpanUnits = [\"days\", \"weeks\", \"hours\", \"minutes\", \"seconds\", \"day\", \"week\", \"hour\", \"minute\", \"second\"];\n  const isTimeSpan = unit && timeSpanUnits.includes(unit);\n\n  let formatted: string;\n  if (isTimeSpan && value === Math.floor(value)) {\n    // For whole number TimeSpan values, format as integer\n    formatted = value.toString();\n  } else {\n    // For other values, use the configured decimal places\n    formatted = value.toFixed(dp);\n  }\n\n  // Currency display: symbol + culturally-conventional placement (e.g.\n  // \"$100.00\" prefix vs \"100.00 kr\" suffix) instead of the generic\n  // \"amount CODE\" fallback below. See uom/CurrencyAliases.ts's\n  // CURRENCY_DISPLAY table for the exact set covered and the reasoning\n  // behind each placement choice. Any currency code NOT in that table\n  // (most of the ~150 `CurrencyExchange.isCurrency()` recognizes) falls\n  // through to the unchanged \"amount CODE\" format below.\n  const currencyDisplay = unit ? CURRENCY_DISPLAY[unit.toUpperCase()] : undefined;\n  if (currencyDisplay) {\n    // An exact money amount rounds from its decimal, not from the double: a\n    // half-cent like \"$1.005\" reads as \"$1.01\" here, where \"(1.005).toFixed(2)\"\n    // answers \"1.00\" because the double it is handed already sits below the\n    // value the user typed. Amounts with no exact decimal (a currency\n    // conversion, whose rate is a double) keep the toFixed rendering above.\n    const moneyText = exact ? decimalToFixed(exact, dp) : formatted;\n    const sep = currencyDisplay.spaced ? \" \" : \"\";\n    const withSymbol = currencyDisplay.position === \"prefix\"\n      ? `${currencyDisplay.symbol}${sep}${moneyText}`\n      : `${moneyText}${sep}${currencyDisplay.symbol}`;\n    return `= ${withSymbol}`;\n  }\n\n  // The unit is written as the symbol the value carries. There used to be a\n  // `unitOfMeasurementResult.unitNames` setting here whose two branches were\n  // the same expression, so it never changed anything, and it was removed\n  // rather than implemented: the engine has no unit-name data to render from.\n  // The generated unit table maps a spelling to [measure, ratio] only, and\n  // names cannot be recovered from it, because units that differ by an OFFSET\n  // share a ratio, so \"20 C\" would come back as \"20 kelvins\". A real\n  // implementation needs a hand-authored name per unit plus pluralization and\n  // per-locale spelling (metre against meter), which is a feature rather than\n  // the repair of a dead ternary.\n  //\n  // An exact currency with no symbol in the display table above (one of the\n  // less common ISO codes) still rounds from its decimal here, so \"1.005 UYW\"\n  // reads the same way \"$1.005\" does. Non-currency Uoms never carry an exact,\n  // so this leaves \"1.50 kg\" exactly as it was.\n  const genericText = exact ? decimalToFixed(exact, dp) : formatted;\n  return `= ${genericText} ${unit || \"\"}`.trim();\n}\n\nfunction formatMatrixEntry(entry: MatrixEntry, settings: FormattingSettings): string {\n  if (typeof entry === \"boolean\") return entry ? \"true\" : \"false\";\n  if (typeof entry === \"object\" && entry !== null) return formatSymbolic(entry);\n  const dp = settings.floatResult.decimalPlaces;\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  return autoFormatIntegerOrFloat(entry, dp, sep, loc);\n}\n\n/**\n * Renders a Matrix matching its own literal syntax: a single row (1xN,\n * including plain vectors) as `[a, b, c]`, a single column (Nx1) as\n * `[a; b; c]`, and a general shape as `[r0c0, r0c1; r1c0, r1c1]`, row-major\n * textual output read back out of the column-major storage\n * (`columnMajorToRowMajor()`), matching how `[1,2;3,4]` is written.\n */\nfunction formatMatrix(m: MatrixData, locale: ILocale, settings: FormattingSettings): string {\n  const rowMajor = columnMajorToRowMajor(m);\n  const rows: string[] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const cells: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      cells.push(formatMatrixEntry(rowMajor[r * m.cols + c], settings));\n    }\n    rows.push(cells.join(\", \"));\n  }\n  return `${locale.display.resultPrefix}[${rows.join(\"; \")}]`;\n}\n\n/**\n * Render a matrix as a multi-line, column-aligned block: one row per line (the\n * newline is where {@link formatValue}'s compact form writes `;`), each column\n * right-padded to its widest cell, and every row wrapped in `[ ... ]`. For\n * display where a grid reads better than a line, e.g. a docs notepad or a REPL:\n *\n * ```text\n * [  1   2 ]\n * [ 30   4 ]\n * ```\n *\n * This is deliberately separate from {@link formatValue}, whose single-line\n * matrix form stays the stable, assertable text the API and the worker DTO use.\n * A 1xN row vector is one line; an Nx1 column vector is N lines.\n */\nexport function formatMatrixAligned(m: MatrixData, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const rowMajor = columnMajorToRowMajor(m);\n  const cells: string[][] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const row: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      row.push(formatMatrixEntry(rowMajor[r * m.cols + c], us));\n    }\n    cells.push(row);\n  }\n  const colWidth: number[] = [];\n  for (let c = 0; c < m.cols; c++) {\n    let width = 0;\n    for (let r = 0; r < m.rows; r++) width = Math.max(width, cells[r][c].length);\n    colWidth.push(width);\n  }\n  return cells\n    .map((row) => `[ ${row.map((cell, c) => cell.padStart(colWidth[c])).join(\"  \")} ]`)\n    .join(\"\\n\");\n}\n\nfunction formatRange(min: number, max: number, locale: ILocale): string {\n  return `${locale.display.resultPrefix}${min}:${max}`;\n}\n\nfunction formatPercentage(value: number, locale: ILocale, settings: FormattingSettings): string {\n  // ValueType.Percentage stores a fraction (0.25 for 25%). See Value.ts's\n  // documented contract and the sole producer, VM.ts's TO_PERCENTAGE opcode\n  // (`right/left - 1`, e.g. 0.25 for \"800 to 1000\"). Multiply by 100 before\n  // formatting; without this every percentage-change result displayed as\n  // e.g. \"0.25%\" instead of \"25.00%\".\n  const dp = settings.percentageResult.decimalPlaces;\n  const formatted = (value * 100).toFixed(dp);\n  return `= ${formatted}${locale.display.percentageSuffix}`;\n}\n\nfunction formatUnit(value: number, unit: string | undefined): string {\n  return `= ${value} ${unit || \"\"}`.trim();\n}\n\n/**\n * Render an evaluated {@link Value} as a display string, dispatching on\n * `value.type` to the type-specific formatter (number, hex, datetime, unit\n * of measurement, matrix, range, percentage, ...).\n *\n * Most branches produce a `\"= \"`-prefixed result string (matching the\n * plugin's inline-result convention); `ValueType.Error` is the one\n * exception, it returns the human-readable error message directly\n * (stored in `value.unit`), not an `\"= \"`-prefixed string.\n *\n * @param value - The evaluated value to format.\n * @param settings - Locale/precision/separator options; defaults to\n *   {@link DEFAULT_FORMATTING_SETTINGS} when omitted.\n * @example\n * ```typescript\n * const [value] = engine.evaluateExpression(\"10 USD to GBP\");\n * formatValue(value); // \"= £7.85\" (exact output depends on live exchange rates)\n * ```\n */\nexport function formatValue(value: Value, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const localeCode = us.numberResult.decimalSeparatorLocale || \"en\";\n  const locale = getLocale(localeCode);\n\n  switch (value.type) {\n    case ValueType.Number:\n      // A measurement with a tolerance renders as \"center ± spread\"; every\n      // other number is unchanged, so a plain value is byte-for-byte what it was.\n      if (value.uncertainty !== undefined) {\n        return formatUncertain(value.value as number, value.uncertainty, locale, us);\n      }\n      return formatNumber(value.value as number, locale, us, value.decimalPlaces);\n    case ValueType.Hex:\n      return formatHex(value.value as number | bigint, us, value.unit);\n    case ValueType.BigInt:\n      return formatBigInt(value.value as bigint);\n    case ValueType.String:\n      return formatString(value.value as string);\n    case ValueType.Boolean:\n      return formatBoolean(value.value as boolean);\n    case ValueType.Datetime:\n      return formatDatetime(value.value as number, locale);\n    case ValueType.Uom:\n      return formatUom(value.value as number, value.unit, locale, us, value.exact);\n    case ValueType.Matrix:\n      return formatMatrix(value.value as MatrixData, locale, us);\n    case ValueType.Range: {\n      const r = value.value as RangeData;\n      return formatRange(r.min, r.max, locale);\n    }\n    case ValueType.Colour:\n      return `${locale.display.resultPrefix}${formatColour(value.value as ColourData)}`;\n    case ValueType.Symbolic:\n      return formatSymbolic(value.value as SymbolicNode);\n    case ValueType.Percentage:\n      return formatPercentage(value.value as number, locale, us);\n    case ValueType.Unit:\n      return formatUnit(value.value as number, value.unit);\n    case ValueType.Error:\n      // errorValue(code, message) stores the human-readable message in\n      // `.unit` (code goes in `.value`), falling through to the default\n      // case here previously displayed the raw code (e.g.\n      // \"CURRENCY_RATE_UNAVAILABLE\") instead of the actual message.\n      return value.unit ?? String(value.value);\n    default:\n      return `= ${String(value.value)}`;\n  }\n}\n"]}

package/dist/{chunk-VB37OC6I.js → chunk-4D6NIHE2.js}

@@ -8,6 +8,12 @@ var TokenTypes = {
   MINUS: "MINUS",
   STAR: "STAR",
   SLASH: "SLASH",
+  // The uncertainty operator, `±` (U+00B1) or the ASCII `+/-`. The symbol is
+  // lexed directly (ExpressionLexer.ts, alongside `×`/`÷`), and the ASCII
+  // spelling is fused from PLUS SLASH MINUS by a normalizer rule (see
+  // packages/uncertainty/). Registered here rather than left to be lazily
+  // minted so its id is stable, the same reasoning as the algebra verbs below.
+  PLUS_MINUS: "PLUS_MINUS",
   CARET: "CARET",
   PERCENT: "PERCENT",
   LSHIFT: "LSHIFT",
@@ -159,6 +165,15 @@ var TokenTypes = {
   IS: "IS",
   PCT_ON: "PCT_ON",
   PCT_OFF: "PCT_OFF",
+  // Successive percentage change (packages/percentage/UpDownParselet.ts):
+  // `X up N%` grows, `X down N%` shrinks, chainable with `then` and
+  // repeatable with `N times`. Retyped from a bare `up`/`down` IDENT only
+  // when a percentage immediately follows (PercentUpDownNormalizerRule), so
+  // prose that merely mentions the words is untouched. Declared here rather
+  // than minted lazily for the same reason as the algebra verbs below: a
+  // normalizer rule and its parselet must agree on the id.
+  PCT_UP: "PCT_UP",
+  PCT_DOWN: "PCT_DOWN",
   OF_WHAT: "OF_WHAT",
   OFF_WHAT: "OFF_WHAT",
   ON_WHAT: "ON_WHAT",
@@ -227,6 +242,13 @@ var TokenTypes = {
   // for discoverability even though tokenTypeId() would lazily register
   // it anyway on first use.
   COMMENT: "COMMENT",
+  // A `#hex` colour literal (`#ff0000`), recognised by the lexer where `#`
+  // 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 colour function call fused by the colour package's normalizer, e.g.
+  // `rgb(`/`lighten(`. Carries the function name; see ColourCallParselet.
+  COLOUR_CALL: "COLOUR_CALL",
   // Vector types (referenced in locale keywordMap as vec2→VEC2, etc.)
   VEC2: "VEC2",
   VEC3: "VEC3",
@@ -342,6 +364,15 @@ var TokenTypes = {
   // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like
   // UNTIL_UNIT/SINCE_UNIT above.
   BETWEEN_UNIT: "BETWEEN_UNIT",
+  // Business-day arithmetic in words, "N working/business days after|from|
+  // before <date>" (infix, the count is the left operand) and "working/
+  // business days between <date> and <date>" (prefix). Full phrases for the
+  // same reason as WORKDAYS_IN above: "working"/"business" are ordinary words,
+  // so only the complete phrase is claimed, never the bare leading word. See
+  // WorkdayOffsetParselet.ts / WorkdaysBetweenParselet.ts.
+  WORKDAYS_AFTER: "WORKDAYS_AFTER",
+  WORKDAYS_BEFORE: "WORKDAYS_BEFORE",
+  WORKDAYS_BETWEEN: "WORKDAYS_BETWEEN",
   // Postfix day-type predicates, "<date> is a weekend" / "is a workday".
   IS_WEEKEND: "IS_WEEKEND",
   IS_WORKDAY: "IS_WORKDAY",
@@ -384,7 +415,13 @@ var TokenTypes = {
   // keyword collision this codebase already regressed on once.
   TOTAL_ABOVE: "TOTAL_ABOVE",
   SUM_ABOVE: "SUM_ABOVE",
-  AVERAGE_ABOVE: "AVERAGE_ABOVE"
+  AVERAGE_ABOVE: "AVERAGE_ABOVE",
+  // ── Goal seek (packages/goalseek/) ──
+  // "solve line 4 for rate = 900" -- fused by GoalSeekNormalizerRule when the
+  // bare word "solve" is immediately followed by a LINE_REF (never a bare
+  // lexer keyword, so ":solve = 2" and the existing "solve(...)" call form
+  // both stay untouched, since neither is "solve" directly before a LINE_REF).
+  GOAL_SEEK: "GOAL_SEEK"
 };
 var _nextTokenTypeId = 0;
 var _tokenTypeNameToId = /* @__PURE__ */ new Map();
@@ -410,5 +447,5 @@ function registerAllTokenTypes() {
 }
 
 export { TokenTypes, registerAllTokenTypes, registerTokenType, tokenTypeId, tokenTypeName };
-//# sourceMappingURL=chunk-VB37OC6I.js.map
-//# sourceMappingURL=chunk-VB37OC6I.js.map
+//# sourceMappingURL=chunk-4D6NIHE2.js.map
+//# sourceMappingURL=chunk-4D6NIHE2.js.map

package/dist/chunk-4D6NIHE2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-4D6NIHE2.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  // 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  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 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  // 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"]}