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

package/dist/vm.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var chunk6NTVRDQV_cjs = require('./chunk-6NTVRDQV.cjs');
+var chunkM4Q47KHF_cjs = require('./chunk-M4Q47KHF.cjs');
 require('./chunk-47LRVGOT.cjs');
-var chunkJ73SJHR3_cjs = require('./chunk-J73SJHR3.cjs');
+var chunk2NPS5DQ3_cjs = require('./chunk-2NPS5DQ3.cjs');
 require('./chunk-FEAIOR7N.cjs');
-require('./chunk-XJCMXB2E.cjs');
+require('./chunk-2MV4HBKC.cjs');
 require('./chunk-MZOVP3WI.cjs');
 require('./chunk-VEKIWQ3F.cjs');
-require('./chunk-HTXVVJRA.cjs');
+require('./chunk-4CVLFLOB.cjs');
 var chunkOC6LTXYS_cjs = require('./chunk-OC6LTXYS.cjs');
-require('./chunk-QNJ4ACRT.cjs');
-require('./chunk-53B6KDDJ.cjs');
+require('./chunk-NJTXJ5AG.cjs');
+require('./chunk-MBNQVDVC.cjs');
 require('./chunk-M4N5GA5Z.cjs');
 require('./chunk-B7LXJ6LC.cjs');
 
@@ -193,47 +193,47 @@ var VMCheckpointer = class {
 
 Object.defineProperty(exports, "DependencyGraph", {
   enumerable: true,
-  get: function () { return chunk6NTVRDQV_cjs.DependencyGraph; }
+  get: function () { return chunkM4Q47KHF_cjs.DependencyGraph; }
 });
 Object.defineProperty(exports, "ScopeManager", {
   enumerable: true,
-  get: function () { return chunk6NTVRDQV_cjs.ScopeManager; }
+  get: function () { return chunkM4Q47KHF_cjs.ScopeManager; }
 });
 Object.defineProperty(exports, "createVM", {
   enumerable: true,
-  get: function () { return chunk6NTVRDQV_cjs.createVM; }
+  get: function () { return chunkM4Q47KHF_cjs.createVM; }
 });
 Object.defineProperty(exports, "executeBytecode", {
   enumerable: true,
-  get: function () { return chunk6NTVRDQV_cjs.executeBytecode; }
+  get: function () { return chunkM4Q47KHF_cjs.executeBytecode; }
 });
 Object.defineProperty(exports, "OpRegistry", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.OpRegistry; }
+  get: function () { return chunk2NPS5DQ3_cjs.OpRegistry; }
 });
 Object.defineProperty(exports, "allocatePluginFunctionIndex", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.allocatePluginFunctionIndex; }
+  get: function () { return chunk2NPS5DQ3_cjs.allocatePluginFunctionIndex; }
 });
 Object.defineProperty(exports, "binaryOp", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.binaryOp; }
+  get: function () { return chunk2NPS5DQ3_cjs.binaryOp; }
 });
 Object.defineProperty(exports, "builtinFunctions", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.builtinFunctions; }
+  get: function () { return chunk2NPS5DQ3_cjs.builtinFunctions; }
 });
 Object.defineProperty(exports, "pluginFunctionRegistry", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.pluginFunctionRegistry; }
+  get: function () { return chunk2NPS5DQ3_cjs.pluginFunctionRegistry; }
 });
 Object.defineProperty(exports, "sharedOpRegistry", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.sharedOpRegistry; }
+  get: function () { return chunk2NPS5DQ3_cjs.sharedOpRegistry; }
 });
 Object.defineProperty(exports, "unifyUom", {
   enumerable: true,
-  get: function () { return chunkJ73SJHR3_cjs.unifyUom; }
+  get: function () { return chunk2NPS5DQ3_cjs.unifyUom; }
 });
 Object.defineProperty(exports, "Value", {
   enumerable: true,

package/dist/vm.js

@@ -1,14 +1,14 @@
-export { DependencyGraph, ScopeManager, createVM, executeBytecode } from './chunk-QWY3VEZN.js';
+export { DependencyGraph, ScopeManager, createVM, executeBytecode } from './chunk-3MNKQZ77.js';
 import './chunk-G535KJEG.js';
-export { OpRegistry, allocatePluginFunctionIndex, binaryOp, builtinFunctions, pluginFunctionRegistry, sharedOpRegistry, unifyUom } from './chunk-4QADQTWS.js';
+export { OpRegistry, allocatePluginFunctionIndex, binaryOp, builtinFunctions, pluginFunctionRegistry, sharedOpRegistry, unifyUom } from './chunk-KHJUSHFU.js';
 import './chunk-GCM5JHMX.js';
-import './chunk-DM3LMRBC.js';
+import './chunk-UKPGSAZW.js';
 import './chunk-75JP4BZX.js';
 import './chunk-Z4X2RWOF.js';
-import './chunk-34RRD7PC.js';
+import './chunk-CYFK5SY2.js';
 export { Value, ValueType, bigIntValue, colVectorValue, hexValue, matrixValue, numberValue, rangeValue, rowVectorValue, stringValue, uomValue } from './chunk-BVAR5J2F.js';
-import './chunk-NH2O2AUR.js';
-import './chunk-4MG4XKO2.js';
+import './chunk-WC5FFSHB.js';
+import './chunk-PCPX42KL.js';
 import './chunk-6RDSQURE.js';
 import './chunk-YLJ4XMA6.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solve-engine",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "description": "The expression evaluation engine behind Solve — lexer, parser, bytecode VM, and an extensible package system.",
   "keywords": [
     "expression-evaluator",
@@ -221,5 +221,6 @@
     "tsup": "8.5.1",
     "typescript": "5.9.3"
   },
+  "//sideEffects": "Load-bearing claim, not boilerplate. tsup's splitting emits bare chunk imports at the top of dist/index.js, and this field tells Rollup, webpack and Vite they may delete them, which esbuild reports as [ignored-bare-import] once per import during `npm run size`. The engine does have module-level work to lose: registerAllTokenTypes(), _PrecedenceParser.BP_TABLE and its cached token ids, and several process-wide registries. It is safe because every chunk doing that work is also imported for its bindings somewhere, so no bundler can drop it. That is a property of how tsup currently splits the code rather than a design guarantee, so `npm run smoke:bundled` (scripts/check-tree-shaking.mjs) proves it on every run of `npm run verify` instead of assuming it, and its header explains the two fixes if it ever stops holding.",
   "sideEffects": false
 }

package/dist/NormalizerRule-BrVoVjmP.d.cts

@@ -1,163 +0,0 @@
-import { T as Token } from './Token-0jpvUdPY.cjs';
-
-/**
- * NormalizerRule, pluggable token normalization rule for the
- * TokenNormalizer post-lexer pass.
- *
- * ## Purpose
- * After the ExpressionLexer produces raw tokens (numbers, identifiers,
- * operators, etc.), the TokenNormalizer applies domain-specific rules
- * to transform the token stream before parsing. This keeps the lexer
- * focused on single-token production and moves multi-token pattern
- * matching into a dedicated normalization layer.
- *
- * ## How rules work
- * Rules are applied in priority order (highest first). At each token
- * position, the normalizer tries every rule in priority order until one
- * matches. Matched tokens are consumed and replaced; unmatched tokens
- * pass through unchanged.
- *
- * ## What rules can do
- * - **Phrase fusion**: Merge consecutive words into compound tokens
- *   (e.g., `"to" "the" "power" "of"` → `CARET`)
- * - **Implicit operators**: Insert missing operators between tokens
- *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)
- * - **Domain transformations**: Coalesce item names, currency pairs, etc.
- *
- * ## Why a separate file?
- * This is a duplicate-free copy of the interface defined in
- * TokenNormalizer.ts. Storing it in a separate file avoids circular
- * imports, TokenNormalizer imports NormalizerRule, and rule factories
- * import TokenNormalizer's `createFusedToken`.
- *
- * @module NormalizerRule
- */
-
-/**
- * Result of a successful rule match attempt against the token stream.
- *
- * When a {@link NormalizerRule.match} function finds a pattern at the
- * current position, it returns a NormalizerMatch describing how many
- * tokens to consume and what to replace them with.
- *
- * @example
- * ```ts
- * // The phrase "to the power of" (5 tokens) becomes a single CARET token
- * const match: NormalizerMatch = {
- *   consumed: 5,
- *   replacement: [caretToken],
- * };
- * ```
- */
-interface NormalizerMatch {
-    /**
-     * Number of tokens consumed from the stream at the match position.
-     * Must be ≥ 1, a match always advances the cursor.
-     */
-    consumed: number;
-    /**
-     * Replacement tokens to insert at the match position.
-     * May be empty (deletion), a single token (fusion), or multiple
-     * tokens (expansion/splitting).
-     */
-    replacement: Token[];
-    /**
-     * Human-readable rule name for diagnostic fusion tracking.
-     * When set, the normalizer uses this instead of the rule's `name`
-     * in {@link TokenFusion} records. Used by {@link PhraseTrie} to
-     * report which specific phrase matched (e.g., "phrase:to the power of").
-     */
-    ruleName?: string;
-}
-/**
- * A pluggable normalization rule registered with the TokenNormalizer.
- *
- * Each rule has a {@link name}, {@link priority}, and {@link match} function.
- * The match function receives the current token stream and a position,
- * and returns a {@link NormalizerMatch} on success or `null` on failure.
- *
- * ## Priority ordering
- * Higher priority rules are tried first at each position. This allows
- * long phrases (priority 100, e.g. "to the power of") to match before
- * shorter fragments (priority 80, e.g. "power of").
- *
- * ## Match contract
- * - Must be pure (no side effects, no mutation of input tokens)
- * - Must return `null` for any position that doesn't match
- * - Consumed tokens must be consecutive starting at `pos`
- * - Replacement tokens must be valid for downstream parsing
- *
- * @example
- * ```ts
- * // A phrase fusion rule that converts "to the power of" into CARET
- * const phraseRule: NormalizerRule = {
- *   name: 'phrase:to the power of',
- *   priority: 100,
- *   match: (tokens, pos) => {
- *     if (pos + 4 > tokens.length) return null;
- *     const phrase = tokens.slice(pos, pos + 5)
- *       .map(t => t.value.toLowerCase()).join(' ');
- *     if (phrase === 'to the power of') {
- *       return {
- *         consumed: 5,
- *         replacement: [createFusedToken('CARET', 'to the power of', tokens.slice(pos, pos + 5))],
- *       };
- *     }
- *     return null;
- *   },
- * };
- * ```
- */
-interface NormalizerRule {
-    /**
-     * Human-readable name for debugging and diagnostic display.
-     * Convention: `"category:description"`, e.g. `"phrase:to the power of"`.
-     */
-    readonly name: string;
-    /**
-     * Priority for ordering rules. Higher values are tried first.
-     * Recommended ranges:
-     * - 100: Long multi-word phrase fusion (e.g., "to the power of")
-     * - 80:  Short phrase fusion (e.g., "power of", "times by")
-     * - 50:  Implicit operator insertion (e.g., implicit multiply)
-     * - 20:  Domain-specific transformations
-     */
-    readonly priority: number;
-    /**
-     * Attempt to match a pattern starting at position `pos` in the token stream.
-     *
-     * @param tokens - The current token stream (may be partially normalized from prior passes)
-     * @param pos    - The current position to attempt matching from
-     * @returns A {@link NormalizerMatch} if the pattern is found, or `null` if no match
-     */
-    match(tokens: Token[], pos: number): NormalizerMatch | null;
-}
-/**
- * Record of a token fusion event performed by the normalizer.
- *
- * When a rule merges multiple source tokens into fewer replacement tokens,
- * the normalizer fires a {@link NormalizerOptions.onFusion | fusion callback}
- * with this record. The playground uses these records to render the
- * fusion detail table showing exactly which tokens were merged and by
- * which rule.
- *
- * @example
- * ```ts
- * // "to" "the" "power" "of" fused into CARET "^"
- * const fusion: TokenFusion = {
- *   rule: "phrase:to the power of",
- *   sourceTokens: [toToken, theToken, powerToken, ofToken],
- *   fusedToken: caretToken,
- * };
- * ```
- */
-interface TokenFusion {
-    /** The name of the rule that triggered this fusion (e.g., "phrase:to the power of") */
-    rule: string;
-    /** The original tokens before fusion, always ≥ 2 tokens */
-    sourceTokens: Token[];
-    /** The resulting fused token with its new type and combined value */
-    fusedToken: Token;
-}
-
-export type { NormalizerRule as N, TokenFusion as T, NormalizerMatch as a };

package/dist/NormalizerRule-CEjf1FyD.d.ts

@@ -1,163 +0,0 @@
-import { T as Token } from './Token-0jpvUdPY.js';
-
-/**
- * NormalizerRule, pluggable token normalization rule for the
- * TokenNormalizer post-lexer pass.
- *
- * ## Purpose
- * After the ExpressionLexer produces raw tokens (numbers, identifiers,
- * operators, etc.), the TokenNormalizer applies domain-specific rules
- * to transform the token stream before parsing. This keeps the lexer
- * focused on single-token production and moves multi-token pattern
- * matching into a dedicated normalization layer.
- *
- * ## How rules work
- * Rules are applied in priority order (highest first). At each token
- * position, the normalizer tries every rule in priority order until one
- * matches. Matched tokens are consumed and replaced; unmatched tokens
- * pass through unchanged.
- *
- * ## What rules can do
- * - **Phrase fusion**: Merge consecutive words into compound tokens
- *   (e.g., `"to" "the" "power" "of"` → `CARET`)
- * - **Implicit operators**: Insert missing operators between tokens
- *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)
- * - **Domain transformations**: Coalesce item names, currency pairs, etc.
- *
- * ## Why a separate file?
- * This is a duplicate-free copy of the interface defined in
- * TokenNormalizer.ts. Storing it in a separate file avoids circular
- * imports, TokenNormalizer imports NormalizerRule, and rule factories
- * import TokenNormalizer's `createFusedToken`.
- *
- * @module NormalizerRule
- */
-
-/**
- * Result of a successful rule match attempt against the token stream.
- *
- * When a {@link NormalizerRule.match} function finds a pattern at the
- * current position, it returns a NormalizerMatch describing how many
- * tokens to consume and what to replace them with.
- *
- * @example
- * ```ts
- * // The phrase "to the power of" (5 tokens) becomes a single CARET token
- * const match: NormalizerMatch = {
- *   consumed: 5,
- *   replacement: [caretToken],
- * };
- * ```
- */
-interface NormalizerMatch {
-    /**
-     * Number of tokens consumed from the stream at the match position.
-     * Must be ≥ 1, a match always advances the cursor.
-     */
-    consumed: number;
-    /**
-     * Replacement tokens to insert at the match position.
-     * May be empty (deletion), a single token (fusion), or multiple
-     * tokens (expansion/splitting).
-     */
-    replacement: Token[];
-    /**
-     * Human-readable rule name for diagnostic fusion tracking.
-     * When set, the normalizer uses this instead of the rule's `name`
-     * in {@link TokenFusion} records. Used by {@link PhraseTrie} to
-     * report which specific phrase matched (e.g., "phrase:to the power of").
-     */
-    ruleName?: string;
-}
-/**
- * A pluggable normalization rule registered with the TokenNormalizer.
- *
- * Each rule has a {@link name}, {@link priority}, and {@link match} function.
- * The match function receives the current token stream and a position,
- * and returns a {@link NormalizerMatch} on success or `null` on failure.
- *
- * ## Priority ordering
- * Higher priority rules are tried first at each position. This allows
- * long phrases (priority 100, e.g. "to the power of") to match before
- * shorter fragments (priority 80, e.g. "power of").
- *
- * ## Match contract
- * - Must be pure (no side effects, no mutation of input tokens)
- * - Must return `null` for any position that doesn't match
- * - Consumed tokens must be consecutive starting at `pos`
- * - Replacement tokens must be valid for downstream parsing
- *
- * @example
- * ```ts
- * // A phrase fusion rule that converts "to the power of" into CARET
- * const phraseRule: NormalizerRule = {
- *   name: 'phrase:to the power of',
- *   priority: 100,
- *   match: (tokens, pos) => {
- *     if (pos + 4 > tokens.length) return null;
- *     const phrase = tokens.slice(pos, pos + 5)
- *       .map(t => t.value.toLowerCase()).join(' ');
- *     if (phrase === 'to the power of') {
- *       return {
- *         consumed: 5,
- *         replacement: [createFusedToken('CARET', 'to the power of', tokens.slice(pos, pos + 5))],
- *       };
- *     }
- *     return null;
- *   },
- * };
- * ```
- */
-interface NormalizerRule {
-    /**
-     * Human-readable name for debugging and diagnostic display.
-     * Convention: `"category:description"`, e.g. `"phrase:to the power of"`.
-     */
-    readonly name: string;
-    /**
-     * Priority for ordering rules. Higher values are tried first.
-     * Recommended ranges:
-     * - 100: Long multi-word phrase fusion (e.g., "to the power of")
-     * - 80:  Short phrase fusion (e.g., "power of", "times by")
-     * - 50:  Implicit operator insertion (e.g., implicit multiply)
-     * - 20:  Domain-specific transformations
-     */
-    readonly priority: number;
-    /**
-     * Attempt to match a pattern starting at position `pos` in the token stream.
-     *
-     * @param tokens - The current token stream (may be partially normalized from prior passes)
-     * @param pos    - The current position to attempt matching from
-     * @returns A {@link NormalizerMatch} if the pattern is found, or `null` if no match
-     */
-    match(tokens: Token[], pos: number): NormalizerMatch | null;
-}
-/**
- * Record of a token fusion event performed by the normalizer.
- *
- * When a rule merges multiple source tokens into fewer replacement tokens,
- * the normalizer fires a {@link NormalizerOptions.onFusion | fusion callback}
- * with this record. The playground uses these records to render the
- * fusion detail table showing exactly which tokens were merged and by
- * which rule.
- *
- * @example
- * ```ts
- * // "to" "the" "power" "of" fused into CARET "^"
- * const fusion: TokenFusion = {
- *   rule: "phrase:to the power of",
- *   sourceTokens: [toToken, theToken, powerToken, ofToken],
- *   fusedToken: caretToken,
- * };
- * ```
- */
-interface TokenFusion {
-    /** The name of the rule that triggered this fusion (e.g., "phrase:to the power of") */
-    rule: string;
-    /** The original tokens before fusion, always ≥ 2 tokens */
-    sourceTokens: Token[];
-    /** The resulting fused token with its new type and combined value */
-    fusedToken: Token;
-}
-
-export type { NormalizerRule as N, TokenFusion as T, NormalizerMatch as a };