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

package/dist/packages.js

@@ -0,0 +1,24 @@
+export { ARITHMETIC_PACKAGE, BIGINT_PACKAGE, BUILTIN_PACKAGES, CONDITIONALS_PACKAGE, CONVERTERS_PACKAGE, CURRENCY_PACKAGE, DATETIME_PACKAGE, DICE_PACKAGE, FINANCE_PACKAGE, FUNCTION_PACKAGE, LINES_PACKAGE, MAPREDUCE_PACKAGE, MATHPHRASES_PACKAGE, MATRIX_PACKAGE, PERCENTAGE_PACKAGE, SYMBOLIC_PACKAGE, TIME_PACKAGE, UOM_PACKAGE, VARIABLES_PACKAGE, VECTOR_PACKAGE, WEATHER_PACKAGE, createKnowledgePackage, createStocksPackage } from './chunk-3PPFLFH4.js';
+import './chunk-5YEMOYSE.js';
+import './chunk-64W6GLLZ.js';
+import './chunk-PFSDGGYL.js';
+import './chunk-EPOXXJBK.js';
+import './chunk-NLNDMWZC.js';
+import './chunk-4QADQTWS.js';
+import './chunk-GCM5JHMX.js';
+import './chunk-DM3LMRBC.js';
+import './chunk-75JP4BZX.js';
+import './chunk-Z4X2RWOF.js';
+import './chunk-RFYD5TJE.js';
+import './chunk-34RRD7PC.js';
+import './chunk-BVAR5J2F.js';
+import './chunk-NH2O2AUR.js';
+import './chunk-XVWCOTR6.js';
+import './chunk-RIN643A3.js';
+import './chunk-GOLDJNMZ.js';
+import './chunk-LIPPNDBE.js';
+import './chunk-4MG4XKO2.js';
+import './chunk-6RDSQURE.js';
+import './chunk-YLJ4XMA6.js';
+//# sourceMappingURL=packages.js.map
+//# sourceMappingURL=packages.js.map

package/dist/packages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"packages.js"}

package/dist/parser.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var chunkNMCRQP3Z_cjs = require('./chunk-NMCRQP3Z.cjs');
+require('./chunk-47LRVGOT.cjs');
+var chunkC4XZV6E7_cjs = require('./chunk-C4XZV6E7.cjs');
+var chunkMZOVP3WI_cjs = require('./chunk-MZOVP3WI.cjs');
+require('./chunk-GW32KPCU.cjs');
+require('./chunk-3YNVWKR2.cjs');
+require('./chunk-M4N5GA5Z.cjs');
+require('./chunk-B7LXJ6LC.cjs');
+
+
+
+Object.defineProperty(exports, "ParseletRegistry", {
+  enumerable: true,
+  get: function () { return chunkNMCRQP3Z_cjs.ParseletRegistry; }
+});
+Object.defineProperty(exports, "Parser", {
+  enumerable: true,
+  get: function () { return chunkNMCRQP3Z_cjs.PrecedenceParser; }
+});
+Object.defineProperty(exports, "PrecedenceParser", {
+  enumerable: true,
+  get: function () { return chunkNMCRQP3Z_cjs.PrecedenceParser; }
+});
+Object.defineProperty(exports, "sharedParseletRegistry", {
+  enumerable: true,
+  get: function () { return chunkNMCRQP3Z_cjs.sharedParseletRegistry; }
+});
+Object.defineProperty(exports, "BindingPower", {
+  enumerable: true,
+  get: function () { return chunkC4XZV6E7_cjs.BindingPower; }
+});
+Object.defineProperty(exports, "BytecodeBuilder", {
+  enumerable: true,
+  get: function () { return chunkC4XZV6E7_cjs.BytecodeBuilder; }
+});
+Object.defineProperty(exports, "buildBindingPowerTable", {
+  enumerable: true,
+  get: function () { return chunkC4XZV6E7_cjs.buildBindingPowerTable; }
+});
+Object.defineProperty(exports, "invalidateBindingPowerTable", {
+  enumerable: true,
+  get: function () { return chunkC4XZV6E7_cjs.invalidateBindingPowerTable; }
+});
+Object.defineProperty(exports, "OpCode", {
+  enumerable: true,
+  get: function () { return chunkMZOVP3WI_cjs.OpCode; }
+});
+Object.defineProperty(exports, "getOpCodeName", {
+  enumerable: true,
+  get: function () { return chunkMZOVP3WI_cjs.getOpCodeName; }
+});
+//# sourceMappingURL=parser.cjs.map
+//# sourceMappingURL=parser.cjs.map

package/dist/parser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"parser.cjs"}

package/dist/parser.d.cts

@@ -0,0 +1,46 @@
+export { I as InfixParselet, P as ParseletRegistry, a as Parser, a as PrecedenceParser, b as PrefixParselet, s as sharedParseletRegistry } from './Parselet-CK8cQu2a.cjs';
+export { B as BytecodeBuilder, a as BytecodeProgram, O as OpCode, g as getOpCodeName } from './BytecodeBuilder-3egMyuDi.cjs';
+import './Token-0jpvUdPY.cjs';
+import './pipeline-DPUQt7yL.cjs';
+import './Value-KtAQNHur.cjs';
+
+/**
+ * Named precedence levels for the Pratt parser, from loosest (`Lowest`) to
+ * tightest (`Call`) binding. A custom infix parselet compares its own
+ * binding power against the current expression's to decide whether to
+ * consume the next operator (higher power binds tighter, e.g. `*` over `+`).
+ *
+ * Package authors reference these when registering an infix parselet via
+ * `IPackageRegistry.registerInfixParselet`. See the built-in packages for
+ * examples of picking an appropriate level (e.g. arithmetic `+`/`-` use
+ * `Sum`, `*`/`/` use `Product`).
+ */
+declare const BindingPower: {
+    readonly Lowest: 0;
+    readonly Assignment: 10;
+    readonly LogicalOr: 12;
+    readonly LogicalAnd: 14;
+    readonly Conditional: 20;
+    readonly Sum: 30;
+    readonly BitwiseXor: 35;
+    readonly Product: 40;
+    readonly Exponent: 50;
+    readonly Prefix: 60;
+    readonly Postfix: 70;
+    readonly Call: 80;
+};
+/**
+ * Build the Uint8Array binding power table indexed by token typeId.
+ * Idempotent, returns cached table on subsequent calls.
+ *
+ * Must be called after all token types are registered (via registerAllTokenTypes())
+ * and after plugin providers have registered their token types.
+ */
+declare function buildBindingPowerTable(): Uint8Array;
+/**
+ * Invalidate the cached BP table, call when plugins register new token types
+ * that should participate in the built-in fast path.
+ */
+declare function invalidateBindingPowerTable(): void;
+
+export { BindingPower, buildBindingPowerTable, invalidateBindingPowerTable };

package/dist/parser.d.ts

@@ -0,0 +1,46 @@
+export { I as InfixParselet, P as ParseletRegistry, a as Parser, a as PrecedenceParser, b as PrefixParselet, s as sharedParseletRegistry } from './Parselet-ConOIdRO.js';
+export { B as BytecodeBuilder, a as BytecodeProgram, O as OpCode, g as getOpCodeName } from './BytecodeBuilder-3egMyuDi.js';
+import './Token-0jpvUdPY.js';
+import './pipeline-CrsRPmsv.js';
+import './Value-KtAQNHur.js';
+
+/**
+ * Named precedence levels for the Pratt parser, from loosest (`Lowest`) to
+ * tightest (`Call`) binding. A custom infix parselet compares its own
+ * binding power against the current expression's to decide whether to
+ * consume the next operator (higher power binds tighter, e.g. `*` over `+`).
+ *
+ * Package authors reference these when registering an infix parselet via
+ * `IPackageRegistry.registerInfixParselet`. See the built-in packages for
+ * examples of picking an appropriate level (e.g. arithmetic `+`/`-` use
+ * `Sum`, `*`/`/` use `Product`).
+ */
+declare const BindingPower: {
+    readonly Lowest: 0;
+    readonly Assignment: 10;
+    readonly LogicalOr: 12;
+    readonly LogicalAnd: 14;
+    readonly Conditional: 20;
+    readonly Sum: 30;
+    readonly BitwiseXor: 35;
+    readonly Product: 40;
+    readonly Exponent: 50;
+    readonly Prefix: 60;
+    readonly Postfix: 70;
+    readonly Call: 80;
+};
+/**
+ * Build the Uint8Array binding power table indexed by token typeId.
+ * Idempotent, returns cached table on subsequent calls.
+ *
+ * Must be called after all token types are registered (via registerAllTokenTypes())
+ * and after plugin providers have registered their token types.
+ */
+declare function buildBindingPowerTable(): Uint8Array;
+/**
+ * Invalidate the cached BP table, call when plugins register new token types
+ * that should participate in the built-in fast path.
+ */
+declare function invalidateBindingPowerTable(): void;
+
+export { BindingPower, buildBindingPowerTable, invalidateBindingPowerTable };

package/dist/parser.js

@@ -0,0 +1,10 @@
+export { ParseletRegistry, PrecedenceParser as Parser, PrecedenceParser, sharedParseletRegistry } from './chunk-SDGRK7EP.js';
+import './chunk-G535KJEG.js';
+export { BindingPower, BytecodeBuilder, buildBindingPowerTable, invalidateBindingPowerTable } from './chunk-5YEMOYSE.js';
+export { OpCode, getOpCodeName } from './chunk-75JP4BZX.js';
+import './chunk-RIN643A3.js';
+import './chunk-GOLDJNMZ.js';
+import './chunk-6RDSQURE.js';
+import './chunk-YLJ4XMA6.js';
+//# sourceMappingURL=parser.js.map
+//# sourceMappingURL=parser.js.map

package/dist/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"parser.js"}

package/dist/pipeline-CrsRPmsv.d.ts

@@ -0,0 +1,285 @@
+import { M as MatrixData, R as RangeData, S as SymbolicNode } from './Value-KtAQNHur.js';
+
+/** Base event, all events include a timestamp relative to pipeline start */
+interface BaseEvent {
+    readonly type: string;
+    readonly elapsedNs: number;
+    readonly expression: string;
+}
+/** Emitted after each token is produced by the lexer */
+interface TokenEmittedEvent extends BaseEvent {
+    readonly type: "token_emitted";
+    readonly token: {
+        readonly type: string;
+        readonly value: string;
+        readonly offset: number;
+        readonly line: number;
+        readonly col: number;
+    };
+}
+/** Emitted when the parser resolves a parselet for a token */
+interface ParseletMatchedEvent extends BaseEvent {
+    readonly type: "parselet_matched";
+    readonly tokenType: string;
+    readonly tokenValue: string;
+    readonly parseletCategory: string;
+    readonly parseletType: string;
+    readonly isPrefix: boolean;
+    readonly bindingPower?: number;
+    readonly tokenOffset: number;
+}
+/** Emitted after bytecode is built */
+interface BytecodeBuiltEvent extends BaseEvent {
+    readonly type: "bytecode_built";
+    readonly opcodesLength: number;
+    readonly numbersLength: number;
+    readonly stringsLength: number;
+    readonly isCached: boolean;
+}
+/** Emitted after each VM opcode execution (only when vmTrace is enabled) */
+interface VmStepEvent extends BaseEvent {
+    readonly type: "vm_step";
+    readonly opcode: number;
+    readonly opcodeName: string;
+    readonly ip: number;
+    readonly stackDepth: number;
+    readonly instructionNumber: number;
+    readonly stack: ReadonlyArray<{
+        readonly type: number;
+        readonly value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode;
+        readonly unit?: string;
+    }>;
+}
+/** Emitted when the VM halts with a result */
+interface VmHaltEvent extends BaseEvent {
+    readonly type: "vm_halt";
+    readonly result?: {
+        readonly type: number;
+        readonly value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode;
+        readonly unit?: string;
+    };
+}
+/** Emitted on cache hit */
+interface CacheHitEvent extends BaseEvent {
+    readonly type: "cache_hit";
+    readonly cache: "bytecode" | "line";
+    readonly key: string;
+}
+/** Emitted on cache miss */
+interface CacheMissEvent extends BaseEvent {
+    readonly type: "cache_miss";
+    readonly cache: "bytecode" | "line";
+    readonly key: string;
+}
+/** Emitted when a pipeline evaluation begins */
+interface PipelineStartEvent extends BaseEvent {
+    readonly type: "pipeline_start";
+    readonly inputType: string;
+}
+/** Emitted when a pipeline evaluation completes */
+interface PipelineEndEvent extends BaseEvent {
+    readonly type: "pipeline_end";
+    readonly success: boolean;
+    readonly error?: string;
+    readonly totalTokens: number;
+    readonly totalOpcodes: number;
+}
+/** Emitted when the normalizer begins its pass */
+interface NormalizerStartEvent extends BaseEvent {
+    readonly type: "normalizer_start";
+    readonly inputTokenCount: number;
+}
+/** Emitted when the normalizer fuses tokens */
+interface TokenFusedEvent extends BaseEvent {
+    readonly type: "token_fused";
+    readonly ruleName: string;
+    readonly sourceTokenCount: number;
+    readonly fusedTokenType: string;
+    readonly fusedTokenValue: string;
+}
+/** Emitted when the normalizer completes its pass */
+interface NormalizerEndEvent extends BaseEvent {
+    readonly type: "normalizer_end";
+    readonly outputTokenCount: number;
+    readonly fusionsCount: number;
+}
+/** Union of all event types */
+type DiagnosticEvent = TokenEmittedEvent | NormalizerStartEvent | TokenFusedEvent | NormalizerEndEvent | ParseletMatchedEvent | BytecodeBuiltEvent | VmStepEvent | VmHaltEvent | CacheHitEvent | CacheMissEvent | PipelineStartEvent | PipelineEndEvent;
+/** Categorized parselet info */
+interface CategorizedParselet {
+    readonly tokenType: string;
+    readonly tokenValue: string;
+    readonly parseletCategory: string;
+    readonly parseletType: string;
+    readonly isPrefix: boolean;
+    readonly bindingPower?: number;
+    readonly tokenOffset: number;
+}
+/** Structured diagnostic report */
+interface DiagnosticReport {
+    readonly events: readonly DiagnosticEvent[];
+    readonly parselets: readonly CategorizedParselet[];
+    readonly summary: {
+        readonly totalTokens: number;
+        readonly totalParselets: number;
+        readonly totalOpcodes: number;
+        readonly cacheHit: boolean;
+        readonly elapsedNs: number;
+        readonly parseCategories: ReadonlyMap<string, number>;
+    };
+    readonly metadata: {
+        readonly expression: string;
+        readonly inputType: string;
+        readonly timestamp: number;
+        readonly vmTraceEnabled: boolean;
+    };
+    /** Serialize to a JSON-safe plain object */
+    toJSON(): DiagnosticReportJSON;
+}
+/** JSON-serializable representation of a DiagnosticReport */
+interface DiagnosticReportJSON {
+    readonly events: readonly DiagnosticEvent[];
+    readonly parselets: readonly CategorizedParselet[];
+    readonly summary: {
+        readonly totalTokens: number;
+        readonly totalParselets: number;
+        readonly totalOpcodes: number;
+        readonly cacheHit: boolean;
+        readonly elapsedNs: number;
+        readonly parseCategories: Record<string, number>;
+    };
+    readonly metadata: {
+        readonly expression: string;
+        readonly inputType: string;
+        readonly timestamp: number;
+        readonly vmTraceEnabled: boolean;
+    };
+}
+/** JSON-serializable representation of a DiagnosticReport */
+interface DiagnosticReportJSON {
+    readonly events: readonly DiagnosticEvent[];
+    readonly parselets: readonly CategorizedParselet[];
+    readonly summary: {
+        readonly totalTokens: number;
+        readonly totalParselets: number;
+        readonly totalOpcodes: number;
+        readonly cacheHit: boolean;
+        readonly elapsedNs: number;
+        readonly parseCategories: Record<string, number>;
+    };
+    readonly metadata: {
+        readonly expression: string;
+        readonly inputType: string;
+        readonly timestamp: number;
+        readonly vmTraceEnabled: boolean;
+    };
+}
+
+/**
+ * Interface for collecting diagnostic data during pipeline execution.
+ *
+ * All methods are implemented as concrete no-ops so subclasses only
+ * need to override the ones they care about. This avoids optional
+ * method issues with TypeScript's strict mode.
+ *
+ * The parameters are named `_event` because these base implementations
+ * deliberately ignore them. Overrides are free to name theirs `event` and use
+ * it; TypeScript does not match parameter names when checking overrides.
+ */
+declare abstract class DiagnosticCollector {
+    onPipelineStart(_event: DiagnosticEvent & {
+        type: "pipeline_start";
+    }): void;
+    onTokenEmitted(_event: DiagnosticEvent & {
+        type: "token_emitted";
+    }): void;
+    onNormalizerStart(_event: DiagnosticEvent & {
+        type: "normalizer_start";
+    }): void;
+    onTokenFused(_event: DiagnosticEvent & {
+        type: "token_fused";
+    }): void;
+    onNormalizerEnd(_event: DiagnosticEvent & {
+        type: "normalizer_end";
+    }): void;
+    onParseletMatched(_event: DiagnosticEvent & {
+        type: "parselet_matched";
+    }): void;
+    onBytecodeBuilt(_event: DiagnosticEvent & {
+        type: "bytecode_built";
+    }): void;
+    onVmStep(_event: DiagnosticEvent & {
+        type: "vm_step";
+    }): void;
+    onVmHalt(_event: DiagnosticEvent & {
+        type: "vm_halt";
+    }): void;
+    onCacheHit(_event: DiagnosticEvent & {
+        type: "cache_hit";
+    }): void;
+    onCacheMiss(_event: DiagnosticEvent & {
+        type: "cache_miss";
+    }): void;
+    onPipelineEnd(_event: DiagnosticEvent & {
+        type: "pipeline_end";
+    }): void;
+    abstract getReport(): DiagnosticReport | undefined;
+    abstract reset(): void;
+}
+
+/**
+ * Dispatches diagnostic events to all registered collectors.
+ *
+ * Performance guarantee: when no collectors are registered (production mode),
+ * every dispatch method is a branch on `this.collectors.length === 0` which
+ * modern JS engines will predict and eliminate. The overhead is a single
+ * comparison per call, effectively zero.
+ */
+declare class DiagnosticPipeline {
+    private collectors;
+    register(collector: DiagnosticCollector): void;
+    unregister(collector: DiagnosticCollector): void;
+    clear(): void;
+    get hasCollectors(): boolean;
+    get collectorCount(): number;
+    firePipelineStart(event: DiagnosticEvent & {
+        type: "pipeline_start";
+    }): void;
+    fireTokenEmitted(event: DiagnosticEvent & {
+        type: "token_emitted";
+    }): void;
+    fireNormalizerStart(event: DiagnosticEvent & {
+        type: "normalizer_start";
+    }): void;
+    fireTokenFused(event: DiagnosticEvent & {
+        type: "token_fused";
+    }): void;
+    fireNormalizerEnd(event: DiagnosticEvent & {
+        type: "normalizer_end";
+    }): void;
+    fireParseletMatched(event: DiagnosticEvent & {
+        type: "parselet_matched";
+    }): void;
+    fireBytecodeBuilt(event: DiagnosticEvent & {
+        type: "bytecode_built";
+    }): void;
+    fireVmStep(event: DiagnosticEvent & {
+        type: "vm_step";
+    }): void;
+    fireVmHalt(event: DiagnosticEvent & {
+        type: "vm_halt";
+    }): void;
+    fireCacheHit(event: DiagnosticEvent & {
+        type: "cache_hit";
+    }): void;
+    fireCacheMiss(event: DiagnosticEvent & {
+        type: "cache_miss";
+    }): void;
+    firePipelineEnd(event: DiagnosticEvent & {
+        type: "pipeline_end";
+    }): void;
+    collectReports(): DiagnosticReport[];
+    reset(): void;
+}
+
+export { DiagnosticPipeline as D, type DiagnosticReportJSON as a };