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

package/dist/chunk-5YEMOYSE.js

@@ -0,0 +1,264 @@
+import { TokenTypes, tokenTypeId } from './chunk-RIN643A3.js';
+import { ErrorFactory } from './chunk-6RDSQURE.js';
+
+// src/parser/BytecodeBuilder.ts
+var MAX_CONSTANT_POOL_INDEX = 255;
+var BytecodeBuilder = class {
+  constructor() {
+    this.opcodes = [];
+    this.numbers = [];
+    this.strings = [];
+    this.stringIndex = /* @__PURE__ */ new Map();
+    this._hasAsync = false;
+    this.userFunctionBodies = [];
+    this.anonymousBodies = [];
+  }
+  /** Emit an {@link OpCode} instruction. */
+  emitOpcode(op) {
+    this.opcodes.push(op);
+    if (op === 50 /* CALL_PLUGIN */) {
+      this._hasAsync = true;
+    }
+  }
+  /**
+   * Emit a numeric literal: appends `n` to the program's constant pool and
+   * writes its index into the opcode stream (read back by the VM as e.g.
+   * `PUSH_NUMBER <idx>`).
+   *
+   * Numeric constants are NOT deduplicated (unlike {@link emitString})
+   * every call appends a new entry, so an expression with more than
+   * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences
+   * throws rather than silently wrapping the index (see
+   * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).
+   *
+   * @throws If the constant pool would exceed 256 entries.
+   */
+  emitNumber(n) {
+    const idx = this.numbers.length;
+    if (idx > MAX_CONSTANT_POOL_INDEX) {
+      throw ErrorFactory.parsing(
+        "TOO_MANY_NUMERIC_CONSTANTS",
+        `Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} numeric literals, exceeding the bytecode constant pool's limit.`,
+        { limit: MAX_CONSTANT_POOL_INDEX + 1 }
+      );
+    }
+    this.numbers.push(n);
+    this.opcodes.push(idx);
+  }
+  /**
+   * Emit a string literal: interns `s` into the program's string pool
+   * (deduplicated via `stringIndex`) and writes its index into the opcode
+   * stream. Subject to the same constant-pool bound as {@link emitNumber},
+   * but since strings ARE deduplicated, only distinct string values count
+   * against the limit.
+   *
+   * @throws If the string pool would exceed 256 distinct entries.
+   */
+  emitString(s) {
+    let idx = this.stringIndex.get(s);
+    if (idx === void 0) {
+      idx = this.strings.length;
+      if (idx > MAX_CONSTANT_POOL_INDEX) {
+        throw ErrorFactory.parsing(
+          "TOO_MANY_STRING_CONSTANTS",
+          `Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} distinct string literals, exceeding the bytecode constant pool's limit.`,
+          { limit: MAX_CONSTANT_POOL_INDEX + 1 }
+        );
+      }
+      this.strings.push(s);
+      this.stringIndex.set(s, idx);
+    }
+    this.opcodes.push(idx);
+  }
+  /**
+   * Emit a raw numeric operand (0-255) following an opcode, e.g. a
+   * plugin-function index for `CALL_PLUGIN`, or an argument count. Unlike
+   * {@link emitOpcode}, this does not go through the `OpCode` enum, so
+   * package authors use this (not an unsafe cast to `OpCode`) to push
+   * operands their own opcode handler expects to read positionally.
+   */
+  emitIndex(idx) {
+    this.opcodes.push(idx);
+  }
+  /** Emit a raw byte (0-255), used for fixed small operands like argument counts. */
+  emitByte(b) {
+    this.opcodes.push(b);
+  }
+  /** Number of opcodes/operands emitted so far, used to compute jump targets before {@link patchJump}. */
+  get currentLength() {
+    return this.opcodes.length;
+  }
+  /**
+   * Register a compiled user-defined-function body, returning its index
+   * into this program's `userFunctionBodies` side-table, the caller emits
+   * that index as `DEFINE_USER_FUNCTION`'s operand via {@link emitIndex}.
+   * Subject to the same {@link MAX_CONSTANT_POOL_INDEX} bound as
+   * {@link emitNumber}/{@link emitString} (the index itself is a single
+   * opcode-stream byte), in practice a single line defines at most a
+   * handful of functions, so this limit is never realistically reached.
+   *
+   * @throws If more than 256 function bodies are registered on one program.
+   */
+  emitUserFunctionBody(name, params, program) {
+    const idx = this.userFunctionBodies.length;
+    if (idx > MAX_CONSTANT_POOL_INDEX) {
+      throw ErrorFactory.parsing(
+        "TOO_MANY_FUNCTION_DEFINITIONS",
+        `More than ${MAX_CONSTANT_POOL_INDEX + 1} function definitions on one line, exceeding the bytecode constant pool's limit.`,
+        { limit: MAX_CONSTANT_POOL_INDEX + 1 }
+      );
+    }
+    this.userFunctionBodies.push({ name, params, program });
+    return idx;
+  }
+  /**
+   * Register a compiled `map`/`reduce` anonymous transform body, returning
+   * its index into this program's `anonymousBodies` side-table, the
+   * caller emits that index as `MAP_INVOKE`/`REDUCE_INVOKE`'s operand via
+   * {@link emitIndex}. Same {@link MAX_CONSTANT_POOL_INDEX} bound as
+   * {@link emitUserFunctionBody}.
+   *
+   * @throws If more than 256 anonymous bodies are registered on one program.
+   */
+  emitAnonymousBody(params, program) {
+    const idx = this.anonymousBodies.length;
+    if (idx > MAX_CONSTANT_POOL_INDEX) {
+      throw ErrorFactory.parsing(
+        "TOO_MANY_ANONYMOUS_BODIES",
+        `More than ${MAX_CONSTANT_POOL_INDEX + 1} map/reduce transform expressions on one line, exceeding the bytecode constant pool's limit.`,
+        { limit: MAX_CONSTANT_POOL_INDEX + 1 }
+      );
+    }
+    this.anonymousBodies.push({ params, program });
+    return idx;
+  }
+  /** Overwrite a previously-emitted placeholder operand at `position` with the real jump `target`, once known. */
+  patchJump(position, target) {
+    this.opcodes[position] = target;
+  }
+  /**
+   * Build the accumulated opcodes/numbers/strings into a BytecodeProgram.
+   * Creates new TypedArrays, the builder can be reused after this call.
+   */
+  build() {
+    return {
+      opcodes: new Uint8Array(this.opcodes),
+      numbers: new Float64Array(this.numbers),
+      // Defensive copy: .length = 0 in reset() would clear a shared reference.
+      // Strings are rare (only UoM/datetime parselets emit them), so the copy
+      // cost is negligible.
+      strings: [...this.strings],
+      constants: /* @__PURE__ */ new Map(),
+      hasAsync: this._hasAsync,
+      userFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : void 0,
+      anonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : void 0
+    };
+  }
+  /**
+   * Build directly into a pre-allocated buffer for zero-copy VM consumption.
+   *
+   * When `buf` is provided and large enough, writes into it and returns
+   * subarray **views** (not copies), the returned TypedArrays share the
+   * buffer's underlying ArrayBuffer. The caller MUST NOT mutate the buffer
+   * until the returned BytecodeProgram is no longer needed.
+   *
+   * If the caller intends to cache the result, they must copy the TypedArrays
+   * (e.g. `new Uint8Array(program.opcodes)`) before reusing the buffer pool.
+   *
+   * When `buf` is omitted or too small, allocates fresh TypedArrays.
+   */
+  buildInto(buf) {
+    const opLen = this.opcodes.length;
+    const numLen = this.numbers.length;
+    const reuseOpcodes = buf && buf.opcodes.length >= opLen;
+    const reuseNumbers = buf && buf.numbers.length >= numLen;
+    const opcodes = reuseOpcodes ? new Uint8Array(buf.opcodes.buffer, buf.opcodes.byteOffset, opLen) : new Uint8Array(opLen);
+    const numbers = reuseNumbers ? new Float64Array(buf.numbers.buffer, buf.numbers.byteOffset, numLen) : new Float64Array(numLen);
+    for (let i = 0; i < opLen; i++) opcodes[i] = this.opcodes[i];
+    for (let i = 0; i < numLen; i++) numbers[i] = this.numbers[i];
+    return {
+      opcodes,
+      numbers,
+      strings: [...this.strings],
+      constants: /* @__PURE__ */ new Map(),
+      hasAsync: this._hasAsync,
+      userFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : void 0,
+      anonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : void 0
+    };
+  }
+  reset() {
+    this.opcodes.length = 0;
+    this.numbers.length = 0;
+    this.strings.length = 0;
+    this.stringIndex.clear();
+    this._hasAsync = false;
+    this.userFunctionBodies.length = 0;
+    this.anonymousBodies.length = 0;
+  }
+};
+
+// src/parser/BindingPower.ts
+var BindingPower = {
+  Lowest: 0,
+  Assignment: 10,
+  LogicalOr: 12,
+  // `or`, `||` — loosest of the boolean-logic operators
+  LogicalAnd: 14,
+  // `&&` — binds tighter than `or` ("a or b and c" = "a or (b and c)")
+  Conditional: 20,
+  // comparisons (`==`, `<`, `>=`, ...) — tighter than and/or, looser than arithmetic
+  Sum: 30,
+  BitwiseXor: 35,
+  Product: 40,
+  Exponent: 50,
+  Prefix: 60,
+  Postfix: 70,
+  Call: 80
+};
+var BUILTIN_INFIX_BP = {
+  // Arithmetic (infix, left-associative)
+  [TokenTypes.PLUS]: BindingPower.Sum,
+  [TokenTypes.MINUS]: BindingPower.Sum,
+  [TokenTypes.STAR]: BindingPower.Product,
+  [TokenTypes.SLASH]: BindingPower.Product,
+  [TokenTypes.MOD]: BindingPower.Product,
+  // Arithmetic (infix, RIGHT-associative, PrecedenceParser handles this specially)
+  [TokenTypes.CARET]: BindingPower.Exponent,
+  // Bitwise (infix, left-associative)
+  [TokenTypes.LSHIFT]: BindingPower.BitwiseXor,
+  [TokenTypes.RSHIFT]: BindingPower.BitwiseXor,
+  [TokenTypes.BIT_AND]: BindingPower.BitwiseXor,
+  [TokenTypes.BIT_OR]: BindingPower.BitwiseXor,
+  [TokenTypes.BIT_XOR]: BindingPower.BitwiseXor,
+  // Postfix (no right operand, PrecedenceParser handles this specially)
+  [TokenTypes.PERCENT]: BindingPower.Postfix,
+  // Percentage keyword (infix, left-associative: "50% of 200" → MUL)
+  [TokenTypes.OF]: BindingPower.Product
+};
+var _bpTable = null;
+function buildBindingPowerTable() {
+  if (_bpTable) return _bpTable;
+  let maxId = 0;
+  for (const name of Object.keys(BUILTIN_INFIX_BP)) {
+    const id = tokenTypeId(name);
+    if (id > maxId) maxId = id;
+  }
+  for (const name of Object.values(TokenTypes)) {
+    const id = tokenTypeId(name);
+    if (id > maxId) maxId = id;
+  }
+  const table = new Uint8Array(maxId + 1);
+  for (const [name, bp] of Object.entries(BUILTIN_INFIX_BP)) {
+    const id = tokenTypeId(name);
+    table[id] = bp;
+  }
+  _bpTable = table;
+  return table;
+}
+function invalidateBindingPowerTable() {
+  _bpTable = null;
+}
+
+export { BindingPower, BytecodeBuilder, buildBindingPowerTable, invalidateBindingPowerTable };
+//# sourceMappingURL=chunk-5YEMOYSE.js.map
+//# sourceMappingURL=chunk-5YEMOYSE.js.map

package/dist/chunk-5YEMOYSE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser/BytecodeBuilder.ts","../src/parser/BindingPower.ts"],"names":[],"mappings":"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","file":"chunk-5YEMOYSE.js","sourcesContent":["import { OpCode } from \"@solve-js/parser/OpCode\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * `BytecodeProgram.opcodes` is a `Uint8Array`, every operand written into\n * it (including constant-pool indices from {@link BytecodeBuilder.emitNumber}/\n * {@link BytecodeBuilder.emitString}) is truncated to a single byte on\n * `build()`. Exceeding this silently wraps the index (e.g. entry 300 reads\n * back as entry 44), producing a wrong result with no error. See\n * {@link BytecodeBuilder.emitNumber} for the guard that turns this into a\n * thrown error instead.\n */\nconst MAX_CONSTANT_POOL_INDEX = 255;\n\n/**\n * Compiled bytecode program produced by {@link BytecodeBuilder}.\n * Ready for consumption by {@link executeBytecode} without further processing.\n */\nexport interface BytecodeProgram {\n\topcodes: Uint8Array;\n\tnumbers: Float64Array;\n\tstrings: string[];\n\tconstants?: Map<number, number>;\n\t/**\n\t * Whether the program contains any async opcodes (CALL_PLUGIN, etc.).\n\t * Set during compilation by the BytecodeBuilder. Allows the engine\n\t * to skip the O(n) resolver preflight check in O(1) for purely\n\t * synchronous expressions like `2 + 2`.\n\t */\n\thasAsync: boolean;\n\t/**\n\t * User-defined-function bodies compiled alongside this program (one\n\t * entry per `name(params) = body` definition on this line). See\n\t * {@link BytecodeBuilder.emitUserFunctionBody}. `OpCode.DEFINE_USER_FUNCTION`'s\n\t * operand is an index into this array, resolved at VM-execution time\n\t * (not parse time) so a diagnostic/lookahead parse that never actually\n\t * executes the definition line has no side effect on `vm.userFunctions`.\n\t */\n\tuserFunctionBodies?: UserFunctionDef[];\n\t/**\n\t * Anonymous function bodies compiled alongside this program, one entry\n\t * per `map`/`reduce` inline transform expression (e.g. the `10*x` in\n\t * `map(10*x, [0,1,500])`). See {@link BytecodeBuilder.emitAnonymousBody}.\n\t * Deliberately a SEPARATE side-table from `userFunctionBodies`, not\n\t * routed through `vm.userFunctions` at all: an inline body has no name\n\t * and must never leak into the persistent name-keyed registry the way\n\t * a real `f(x) = ...` definition does.\n\t */\n\tanonymousBodies?: AnonymousBodyDef[];\n}\n\n/**\n * An anonymous transform body for `map`/`reduce`'s inline-expression form\n * (e.g. `10*x` in `map(10*x, [0,1,500])`, or `acc+x` in `reduce(acc+x,\n * [1,2,3])`). Structurally identical to {@link UserFunctionDef} minus the\n * `name`. See `OpCode.MAP_INVOKE`/`REDUCE_INVOKE` and\n * `vm/VM.ts`'s handlers, which build a call frame from `params`/`args`\n * exactly like `CALL_USER_FUNCTION` does, just without ever registering\n * the body in `vm.userFunctions`.\n */\nexport interface AnonymousBodyDef {\n\tparams: string[];\n\tprogram: BytecodeProgram;\n}\n\n/**\n * A user-defined, parameterized, reusable function's compiled form\n * (`f(x) = 2*x + 1`). See `OpCode.DEFINE_USER_FUNCTION`/`CALL_USER_FUNCTION`\n * and `vm/VM.ts`'s `VM.defineUserFunction`/`getUserFunction`.\n *\n * `program` is the body compiled to its OWN independent `BytecodeProgram`,\n * not a fragment of the definition line's own bytecode. Parameter names\n * inside the body compile to ORDINARY `LOAD_VAR <name>` opcodes, no\n * parse-time rewriting, because parameter resolution happens dynamically\n * at the VM level: `CALL_USER_FUNCTION` pushes a name-keyed call frame\n * (`Map<string, Value>`) before re-executing `program`, and `VM.getVar()`\n * checks the innermost call frame before falling back to the flat\n * document-variable store. This is why a `UNIT`-collision parameter name\n * (e.g. `h` in `area(w, h) = w * h`, which lexes as the \"hour\" unit) needs\n * no special handling anywhere, it's just another `LOAD_VAR \"h\"`, resolved\n * the same way as any other name.\n */\nexport interface UserFunctionDef {\n\tname: string;\n\tparams: string[];\n\tprogram: BytecodeProgram;\n}\n\n/**\n * Direct-to-bytecode compiler for the Pratt parser.\n *\n * Accumulates opcodes, numeric constants, and string references during parsing,\n * then produces a {@link BytecodeProgram} for VM execution. Supports:\n * - Standard build via {@link build}\n * - Zero-copy build into pre-allocated buffers via {@link buildInto}\n * - In-place reset for reuse without reallocation\n */\nexport class BytecodeBuilder {\n\tprivate opcodes: number[] = [];\n\tprivate numbers: number[] = [];\n\tprivate strings: string[] = [];\n\tprivate stringIndex = new Map<string, number>();\n\tprivate _hasAsync = false;\n\tprivate userFunctionBodies: UserFunctionDef[] = [];\n\tprivate anonymousBodies: AnonymousBodyDef[] = [];\n\n\t/** Emit an {@link OpCode} instruction. */\n\temitOpcode(op: OpCode): void {\n\t\tthis.opcodes.push(op);\n\t\tif (op === OpCode.CALL_PLUGIN) {\n\t\t\tthis._hasAsync = true;\n\t\t}\n\t}\n\n\t/**\n\t * Emit a numeric literal: appends `n` to the program's constant pool and\n\t * writes its index into the opcode stream (read back by the VM as e.g.\n\t * `PUSH_NUMBER <idx>`).\n\t *\n\t * Numeric constants are NOT deduplicated (unlike {@link emitString})\n\t * every call appends a new entry, so an expression with more than\n\t * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences\n\t * throws rather than silently wrapping the index (see\n\t * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).\n\t *\n\t * @throws If the constant pool would exceed 256 entries.\n\t */\n\temitNumber(n: number): void {\n\t\tconst idx = this.numbers.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_NUMERIC_CONSTANTS\",\n\t\t\t\t`Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} numeric literals, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.numbers.push(n);\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/**\n\t * Emit a string literal: interns `s` into the program's string pool\n\t * (deduplicated via `stringIndex`) and writes its index into the opcode\n\t * stream. Subject to the same constant-pool bound as {@link emitNumber},\n\t * but since strings ARE deduplicated, only distinct string values count\n\t * against the limit.\n\t *\n\t * @throws If the string pool would exceed 256 distinct entries.\n\t */\n\temitString(s: string): void {\n\t\tlet idx = this.stringIndex.get(s);\n\t\tif (idx === undefined) {\n\t\t\tidx = this.strings.length;\n\t\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\t\"TOO_MANY_STRING_CONSTANTS\",\n\t\t\t\t\t`Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} distinct string literals, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t\t);\n\t\t\t}\n\t\t\tthis.strings.push(s);\n\t\t\tthis.stringIndex.set(s, idx);\n\t\t}\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/**\n\t * Emit a raw numeric operand (0-255) following an opcode, e.g. a\n\t * plugin-function index for `CALL_PLUGIN`, or an argument count. Unlike\n\t * {@link emitOpcode}, this does not go through the `OpCode` enum, so\n\t * package authors use this (not an unsafe cast to `OpCode`) to push\n\t * operands their own opcode handler expects to read positionally.\n\t */\n\temitIndex(idx: number): void {\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/** Emit a raw byte (0-255), used for fixed small operands like argument counts. */\n\temitByte(b: number): void {\n\t\tthis.opcodes.push(b);\n\t}\n\n\t/** Number of opcodes/operands emitted so far, used to compute jump targets before {@link patchJump}. */\n\tget currentLength(): number {\n\t\treturn this.opcodes.length;\n\t}\n\n\t/**\n\t * Register a compiled user-defined-function body, returning its index\n\t * into this program's `userFunctionBodies` side-table, the caller emits\n\t * that index as `DEFINE_USER_FUNCTION`'s operand via {@link emitIndex}.\n\t * Subject to the same {@link MAX_CONSTANT_POOL_INDEX} bound as\n\t * {@link emitNumber}/{@link emitString} (the index itself is a single\n\t * opcode-stream byte), in practice a single line defines at most a\n\t * handful of functions, so this limit is never realistically reached.\n\t *\n\t * @throws If more than 256 function bodies are registered on one program.\n\t */\n\temitUserFunctionBody(name: string, params: string[], program: BytecodeProgram): number {\n\t\tconst idx = this.userFunctionBodies.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_FUNCTION_DEFINITIONS\",\n\t\t\t\t`More than ${MAX_CONSTANT_POOL_INDEX + 1} function definitions on one line, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.userFunctionBodies.push({ name, params, program });\n\t\treturn idx;\n\t}\n\n\t/**\n\t * Register a compiled `map`/`reduce` anonymous transform body, returning\n\t * its index into this program's `anonymousBodies` side-table, the\n\t * caller emits that index as `MAP_INVOKE`/`REDUCE_INVOKE`'s operand via\n\t * {@link emitIndex}. Same {@link MAX_CONSTANT_POOL_INDEX} bound as\n\t * {@link emitUserFunctionBody}.\n\t *\n\t * @throws If more than 256 anonymous bodies are registered on one program.\n\t */\n\temitAnonymousBody(params: string[], program: BytecodeProgram): number {\n\t\tconst idx = this.anonymousBodies.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_ANONYMOUS_BODIES\",\n\t\t\t\t`More than ${MAX_CONSTANT_POOL_INDEX + 1} map/reduce transform expressions on one line, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.anonymousBodies.push({ params, program });\n\t\treturn idx;\n\t}\n\n\t/** Overwrite a previously-emitted placeholder operand at `position` with the real jump `target`, once known. */\n\tpatchJump(position: number, target: number): void {\n\t\tthis.opcodes[position] = target;\n\t}\n\n\t/**\n\t * Build the accumulated opcodes/numbers/strings into a BytecodeProgram.\n\t * Creates new TypedArrays, the builder can be reused after this call.\n\t */\n\tbuild(): BytecodeProgram {\n\t\treturn {\n\t\t\topcodes: new Uint8Array(this.opcodes),\n\t\t\tnumbers: new Float64Array(this.numbers),\n\t\t\t// Defensive copy: .length = 0 in reset() would clear a shared reference.\n\t\t\t// Strings are rare (only UoM/datetime parselets emit them), so the copy\n\t\t\t// cost is negligible.\n\t\t\tstrings: [...this.strings],\n\t\t\tconstants: new Map(),\n\t\t\thasAsync: this._hasAsync,\n\t\t\tuserFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : undefined,\n\t\t\tanonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : undefined,\n\t\t};\n\t}\n\n\t/**\n\t * Build directly into a pre-allocated buffer for zero-copy VM consumption.\n\t *\n\t * When `buf` is provided and large enough, writes into it and returns\n\t * subarray **views** (not copies), the returned TypedArrays share the\n\t * buffer's underlying ArrayBuffer. The caller MUST NOT mutate the buffer\n\t * until the returned BytecodeProgram is no longer needed.\n\t *\n\t * If the caller intends to cache the result, they must copy the TypedArrays\n\t * (e.g. `new Uint8Array(program.opcodes)`) before reusing the buffer pool.\n\t *\n\t * When `buf` is omitted or too small, allocates fresh TypedArrays.\n\t */\n\tbuildInto(buf?: { opcodes: Uint8Array; numbers: Float64Array }): BytecodeProgram {\n\t\tconst opLen = this.opcodes.length;\n\t\tconst numLen = this.numbers.length;\n\n\t\tconst reuseOpcodes = buf && buf.opcodes.length >= opLen;\n\t\tconst reuseNumbers = buf && buf.numbers.length >= numLen;\n\n\t\t// Subarray views that share the buffer's ArrayBuffer (zero-copy)\n\t\tconst opcodes = reuseOpcodes\n\t\t\t? new Uint8Array(buf!.opcodes.buffer, buf!.opcodes.byteOffset, opLen)\n\t\t\t: new Uint8Array(opLen);\n\t\tconst numbers = reuseNumbers\n\t\t\t? new Float64Array(buf!.numbers.buffer, buf!.numbers.byteOffset, numLen)\n\t\t\t: new Float64Array(numLen);\n\n\t\t// Write data into the views\n\t\tfor (let i = 0; i < opLen; i++) opcodes[i] = this.opcodes[i];\n\t\tfor (let i = 0; i < numLen; i++) numbers[i] = this.numbers[i];\n\n\t\treturn {\n\t\t\topcodes,\n\t\t\tnumbers,\n\t\t\tstrings: [...this.strings],\n\t\t\tconstants: new Map(),\n\t\t\thasAsync: this._hasAsync,\n\t\t\tuserFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : undefined,\n\t\t\tanonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : undefined,\n\t\t};\n\t}\n\n\treset(): void {\n\t\t// Retain backing stores with .length = 0 to avoid reallocation on growth.\n\t\t// = [] discards the ArrayBuffer, forcing V8 to reallocate on every push()\n\t\t// threshold (4→8→16→32...). For a 50-opcode expression, that's 3-4 copies.\n\t\tthis.opcodes.length = 0;\n\t\tthis.numbers.length = 0;\n\t\tthis.strings.length = 0;\n\t\tthis.stringIndex.clear();\n\t\tthis._hasAsync = false;\n\t\tthis.userFunctionBodies.length = 0;\n\t\tthis.anonymousBodies.length = 0;\n\t}\n}\n","/**\n * Named precedence levels for the Pratt parser, from loosest (`Lowest`) to\n * tightest (`Call`) binding. A custom infix parselet compares its own\n * binding power against the current expression's to decide whether to\n * consume the next operator (higher power binds tighter, e.g. `*` over `+`).\n *\n * Package authors reference these when registering an infix parselet via\n * `IPackageRegistry.registerInfixParselet`. See the built-in packages for\n * examples of picking an appropriate level (e.g. arithmetic `+`/`-` use\n * `Sum`, `*`/`/` use `Product`).\n */\nexport const BindingPower = {\n  Lowest: 0,\n  Assignment: 10,\n  LogicalOr: 12,   // `or`, `||` — loosest of the boolean-logic operators\n  LogicalAnd: 14,  // `&&` — binds tighter than `or` (\"a or b and c\" = \"a or (b and c)\")\n  Conditional: 20, // comparisons (`==`, `<`, `>=`, ...) — tighter than and/or, looser than arithmetic\n  Sum: 30,\n  BitwiseXor: 35,\n  Product: 40,\n  Exponent: 50,\n  Prefix: 60,\n  Postfix: 70,\n  Call: 80,\n} as const;\n\n/**\n * Set the binding power of a named operator.\n *\n * Binding power is what decides precedence in the Pratt parser: a higher number\n * binds tighter, so `*` outranks `+`. Changing one changes how every existing\n * expression using that operator parses, which is why packages should allocate\n * a new name rather than adjust a built-in.\n *\n * @param name - Operator name.\n * @param power - Higher binds tighter.\n */\nexport function setBindingPower(name: string, power: number): void {\n  (BindingPower as Record<string, number>)[name] = power;\n}\n\n/**\n * Read the binding power of a named operator.\n *\n * @param name - Operator name.\n * @returns Its binding power, or 0 when the name is unknown, which makes an\n * unregistered operator terminate an expression rather than swallow the rest\n * of it.\n */\nexport function getBindingPower(name: string): number {\n  return (BindingPower as Record<string, number>)[name] ?? 0;\n}\n\n// ── Built-in Infix Operator Binding Power Table ──────────────────────────────\n// Pre-computed Uint8Array lookup indexed by token typeId.\n// value > 0  → built-in infix operator with that binding power\n// value = 0  → not a built-in infix, fall through to Tier 2 parselet registry\n//\n// Built at module load via buildBindingPowerTable(). The table is sparse\n// most entries are 0 since only ~15 of 80+ token types are infix operators.\n//\n// Performance: Uint8Array[typeId] is a single typed array load, no Map.get()\n// no string hashing, no property chain. V8 eliminates bounds checks when typeId\n// is known to be within array length.\n\nimport { TokenTypes } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\n\n/**\n * Mapping of token type names → binding powers for built-in infix operators.\n * Only operators listed here get the Tier 1 fast path in PrecedenceParser.\n * All other infix tokens use the Tier 2 parselet registry fallback.\n */\nconst BUILTIN_INFIX_BP: Record<string, number> = {\n  // Arithmetic (infix, left-associative)\n  [TokenTypes.PLUS]:     BindingPower.Sum,\n  [TokenTypes.MINUS]:    BindingPower.Sum,\n  [TokenTypes.STAR]:     BindingPower.Product,\n  [TokenTypes.SLASH]:    BindingPower.Product,\n  [TokenTypes.MOD]:      BindingPower.Product,\n\n  // Arithmetic (infix, RIGHT-associative, PrecedenceParser handles this specially)\n  [TokenTypes.CARET]:    BindingPower.Exponent,\n\n  // Bitwise (infix, left-associative)\n  [TokenTypes.LSHIFT]:   BindingPower.BitwiseXor,\n  [TokenTypes.RSHIFT]:   BindingPower.BitwiseXor,\n  [TokenTypes.BIT_AND]:  BindingPower.BitwiseXor,\n  [TokenTypes.BIT_OR]:   BindingPower.BitwiseXor,\n  [TokenTypes.BIT_XOR]:  BindingPower.BitwiseXor,\n\n  // Postfix (no right operand, PrecedenceParser handles this specially)\n  [TokenTypes.PERCENT]:  BindingPower.Postfix,\n\n  // Percentage keyword (infix, left-associative: \"50% of 200\" → MUL)\n  [TokenTypes.OF]:       BindingPower.Product,\n};\n\n// Note: These token types are intentionally NOT in the BP_TABLE, they stay in\n// the Tier 2 parselet registry because they require complex handling:\n//   IN, TO    → UoM conversion parselets (peek at target unit token, complex logic)\n//   DOT       → Property access (chained OBJ_GET, needs left-token tracking)\n//   EQUALS    → Assignment (VariableParselet handles :var = expr pattern)\n//   EQUALITY, NEQ, GTE, LTE → Comparison ops (need dedicated VM opcodes, task 2.15a)\n//   COMMA     → Argument separator (function calls, array/object literals)\n\n/** Cached BP_TABLE, built once at module load, immutable thereafter. */\nlet _bpTable: Uint8Array | null = null;\n\n/**\n * Build the Uint8Array binding power table indexed by token typeId.\n * Idempotent, returns cached table on subsequent calls.\n *\n * Must be called after all token types are registered (via registerAllTokenTypes())\n * and after plugin providers have registered their token types.\n */\nexport function buildBindingPowerTable(): Uint8Array {\n  if (_bpTable) return _bpTable;\n\n  // Size to the largest registered typeId + 1\n  let maxId = 0;\n  for (const name of Object.keys(BUILTIN_INFIX_BP)) {\n    const id = tokenTypeId(name);\n    if (id > maxId) maxId = id;\n  }\n  // Also scan all TokenTypes to ensure table covers all registered IDs\n  for (const name of Object.values(TokenTypes)) {\n    const id = tokenTypeId(name);\n    if (id > maxId) maxId = id;\n  }\n\n  const table = new Uint8Array(maxId + 1);\n  for (const [name, bp] of Object.entries(BUILTIN_INFIX_BP)) {\n    const id = tokenTypeId(name);\n    table[id] = bp;\n  }\n\n  _bpTable = table;\n  return table;\n}\n\n/**\n * Invalidate the cached BP table, call when plugins register new token types\n * that should participate in the built-in fast path.\n */\nexport function invalidateBindingPowerTable(): void {\n  _bpTable = null;\n}\n"]}