opensquid 0.5.395

package/dist/runtime/evaluator/expression/parser.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Expression parser — Task H.1.2 (chevrotain v11 CstParser).
+ *
+ * Builds a CST from lexer.ts (H.1.1) tokens; CST→AST visitor lives in H.1.3.
+ *
+ * Grammar (9 rules — precedence via nesting depth, low→high `||<&&<!<cmp`):
+ *   expression  := orExpr
+ *   orExpr      := andExpr ( '||' andExpr )*
+ *   andExpr     := notExpr ( '&&' notExpr )*
+ *   notExpr     := '!'? compareExpr
+ *   compareExpr := primary ( (==|!=|<|<=|>|>=) primary )?
+ *   primary     := '(' expression ')' | literal | callOrPath
+ *   callOrPath  := Identifier ( '(' args ')' | pathSegment* )?
+ *   pathSegment := '.' Identifier | '[' (NumberLit | StringLit) ']'
+ *   literal     := StringLit | NumberLit | True | False | Null
+ *
+ * Left-associativity via `MANY`: chevrotain LL(k) rejects left-recursion at
+ * `performSelfAnalysis()`. The idiomatic shape `lhs ( OP rhs )*` lets the
+ * visitor left-fold the children. No chained comparison: single `OPTION` on
+ * compareExpr; `a < b < c` surfaces as a parse error under recoveryEnabled:false.
+ *
+ * Singleton per chevrotain perf guide — one instance reused (state reset via
+ * `parser.input = tokens`). Fresh instance per call would re-run
+ * performSelfAnalysis() (~5ms). Audit-grep `new ExpressionParser` = 1 match.
+ *
+ * LL(1) disjointness audit — all OR/OPTION sites have disjoint first-tokens:
+ * primary {LParen|literal|Identifier}; callOrPath OPTION {LParen|Dot/LBracket};
+ * pathSegment {Dot|LBracket}; literal {5 distinct kinds}; compareExpr {6 ops}.
+ *
+ * CST navigation hints for H.1.3 visitor:
+ *   - LABEL'd sub-rules live under `children.lhs`/`children.rhs`;
+ *     un-labeled sub-rules use the sub-rule name as the key.
+ *   - `MANY` collects same-LABEL children into an array (e.g.
+ *     `orExpr.children.rhs` is `CstNode[]` length 0..N).
+ *   - `callOrPath.children` has `Identifier` (always) plus either
+ *     `LParen`+`arg[]`+`RParen` (call) or `pathSegment[]` (path). Distinguish
+ *     by presence of `LParen`. Args use `LABEL:'arg'` →
+ *     `children.arg` is `CstNode[]` of expressions.
+ *
+ * Pinned to chevrotain ^11.0.0 — same engine constraint as lexer.ts.
+ */
+import { CstParser, type CstNode, type IToken } from 'chevrotain';
+declare class ExpressionParser extends CstParser {
+    constructor();
+    expression: import("chevrotain").ParserMethod<[], CstNode>;
+    private orExpr;
+    private andExpr;
+    private notExpr;
+    private compareExpr;
+    private primary;
+    private callOrPath;
+    private pathSegment;
+    private literal;
+}
+declare const parserInstance: ExpressionParser;
+/** Parse error — `offset` is start-offset of the offending token (-1 if none). */
+export interface ParseError {
+    message: string;
+    offset: number;
+}
+/** Result of a parse attempt — cst always present (may be partial on error). */
+export interface ParseResult {
+    cst: CstNode;
+    errors: ParseError[];
+}
+/**
+ * Parse a token stream into a CST. Caller invokes the lexer first and passes
+ * the `{ tokens }` result (matches `ILexingResult` shape so callers can pass
+ * `lexer.tokenize(input)` directly). recoveryEnabled:false means we stop at
+ * the first error and surface it via the snapshot below.
+ */
+export declare function parseToCst(tokens: {
+    tokens: IToken[];
+}): ParseResult;
+export { parserInstance };
+//# sourceMappingURL=parser.d.ts.map

package/dist/runtime/evaluator/expression/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AA2BlE,cAAM,gBAAiB,SAAQ,SAAS;;IAM/B,UAAU,iDAEd;IAEH,OAAO,CAAC,MAAM,CAMX;IAEH,OAAO,CAAC,OAAO,CAMZ;IAEH,OAAO,CAAC,OAAO,CAGZ;IAEH,OAAO,CAAC,WAAW,CAahB;IAEH,OAAO,CAAC,OAAO,CAYZ;IAEH,OAAO,CAAC,UAAU,CAqBf;IAEH,OAAO,CAAC,WAAW,CAmBhB;IAEH,OAAO,CAAC,OAAO,CAQZ;CACJ;AAGD,QAAA,MAAM,cAAc,kBAAyB,CAAC;AAE9C,kFAAkF;AAClF,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,WAAW,CAQpE;AAID,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/runtime/evaluator/expression/parser.js

@@ -0,0 +1,169 @@
+/**
+ * Expression parser — Task H.1.2 (chevrotain v11 CstParser).
+ *
+ * Builds a CST from lexer.ts (H.1.1) tokens; CST→AST visitor lives in H.1.3.
+ *
+ * Grammar (9 rules — precedence via nesting depth, low→high `||<&&<!<cmp`):
+ *   expression  := orExpr
+ *   orExpr      := andExpr ( '||' andExpr )*
+ *   andExpr     := notExpr ( '&&' notExpr )*
+ *   notExpr     := '!'? compareExpr
+ *   compareExpr := primary ( (==|!=|<|<=|>|>=) primary )?
+ *   primary     := '(' expression ')' | literal | callOrPath
+ *   callOrPath  := Identifier ( '(' args ')' | pathSegment* )?
+ *   pathSegment := '.' Identifier | '[' (NumberLit | StringLit) ']'
+ *   literal     := StringLit | NumberLit | True | False | Null
+ *
+ * Left-associativity via `MANY`: chevrotain LL(k) rejects left-recursion at
+ * `performSelfAnalysis()`. The idiomatic shape `lhs ( OP rhs )*` lets the
+ * visitor left-fold the children. No chained comparison: single `OPTION` on
+ * compareExpr; `a < b < c` surfaces as a parse error under recoveryEnabled:false.
+ *
+ * Singleton per chevrotain perf guide — one instance reused (state reset via
+ * `parser.input = tokens`). Fresh instance per call would re-run
+ * performSelfAnalysis() (~5ms). Audit-grep `new ExpressionParser` = 1 match.
+ *
+ * LL(1) disjointness audit — all OR/OPTION sites have disjoint first-tokens:
+ * primary {LParen|literal|Identifier}; callOrPath OPTION {LParen|Dot/LBracket};
+ * pathSegment {Dot|LBracket}; literal {5 distinct kinds}; compareExpr {6 ops}.
+ *
+ * CST navigation hints for H.1.3 visitor:
+ *   - LABEL'd sub-rules live under `children.lhs`/`children.rhs`;
+ *     un-labeled sub-rules use the sub-rule name as the key.
+ *   - `MANY` collects same-LABEL children into an array (e.g.
+ *     `orExpr.children.rhs` is `CstNode[]` length 0..N).
+ *   - `callOrPath.children` has `Identifier` (always) plus either
+ *     `LParen`+`arg[]`+`RParen` (call) or `pathSegment[]` (path). Distinguish
+ *     by presence of `LParen`. Args use `LABEL:'arg'` →
+ *     `children.arg` is `CstNode[]` of expressions.
+ *
+ * Pinned to chevrotain ^11.0.0 — same engine constraint as lexer.ts.
+ */
+import { CstParser } from 'chevrotain';
+import { allTokens, AndAnd, Bang, Comma, Dot, EqEq, False, Gt, Gte, Identifier, LBracket, LParen, Lt, Lte, NotEq, Null, NumberLit, OrOr, RBracket, RParen, StringLit, True, } from './lexer.js';
+class ExpressionParser extends CstParser {
+    constructor() {
+        super(allTokens, { recoveryEnabled: false });
+        this.performSelfAnalysis();
+    }
+    expression = this.RULE('expression', () => {
+        this.SUBRULE(this.orExpr);
+    });
+    orExpr = this.RULE('orExpr', () => {
+        this.SUBRULE(this.andExpr, { LABEL: 'lhs' });
+        this.MANY(() => {
+            this.CONSUME(OrOr);
+            this.SUBRULE2(this.andExpr, { LABEL: 'rhs' });
+        });
+    });
+    andExpr = this.RULE('andExpr', () => {
+        this.SUBRULE(this.notExpr, { LABEL: 'lhs' });
+        this.MANY(() => {
+            this.CONSUME(AndAnd);
+            this.SUBRULE2(this.notExpr, { LABEL: 'rhs' });
+        });
+    });
+    notExpr = this.RULE('notExpr', () => {
+        this.OPTION(() => this.CONSUME(Bang));
+        this.SUBRULE(this.compareExpr);
+    });
+    compareExpr = this.RULE('compareExpr', () => {
+        this.SUBRULE(this.primary, { LABEL: 'lhs' });
+        this.OPTION(() => {
+            this.OR([
+                { ALT: () => this.CONSUME(EqEq) },
+                { ALT: () => this.CONSUME(NotEq) },
+                { ALT: () => this.CONSUME(Lte) },
+                { ALT: () => this.CONSUME(Gte) },
+                { ALT: () => this.CONSUME(Lt) },
+                { ALT: () => this.CONSUME(Gt) },
+            ]);
+            this.SUBRULE2(this.primary, { LABEL: 'rhs' });
+        });
+    });
+    primary = this.RULE('primary', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(LParen);
+                    this.SUBRULE(this.expression);
+                    this.CONSUME(RParen);
+                },
+            },
+            { ALT: () => this.SUBRULE(this.literal) },
+            { ALT: () => this.SUBRULE(this.callOrPath) },
+        ]);
+    });
+    callOrPath = this.RULE('callOrPath', () => {
+        this.CONSUME(Identifier);
+        this.OPTION(() => {
+            this.OR([
+                // call: `name(args)` — distinguished by leading LParen in children.
+                {
+                    ALT: () => {
+                        this.CONSUME(LParen);
+                        this.OPTION1(() => {
+                            this.SUBRULE(this.expression, { LABEL: 'arg' });
+                            this.MANY(() => {
+                                this.CONSUME(Comma);
+                                this.SUBRULE2(this.expression, { LABEL: 'arg' });
+                            });
+                        });
+                        this.CONSUME(RParen);
+                    },
+                },
+                { ALT: () => this.MANY1(() => this.SUBRULE(this.pathSegment)) },
+            ]);
+        });
+    });
+    pathSegment = this.RULE('pathSegment', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(Dot);
+                    this.CONSUME(Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(LBracket);
+                    this.OR1([
+                        { ALT: () => this.CONSUME(NumberLit) },
+                        { ALT: () => this.CONSUME(StringLit) },
+                    ]);
+                    this.CONSUME(RBracket);
+                },
+            },
+        ]);
+    });
+    literal = this.RULE('literal', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(StringLit) },
+            { ALT: () => this.CONSUME(NumberLit) },
+            { ALT: () => this.CONSUME(True) },
+            { ALT: () => this.CONSUME(False) },
+            { ALT: () => this.CONSUME(Null) },
+        ]);
+    });
+}
+// Singleton per chevrotain perf guide.
+const parserInstance = new ExpressionParser();
+/**
+ * Parse a token stream into a CST. Caller invokes the lexer first and passes
+ * the `{ tokens }` result (matches `ILexingResult` shape so callers can pass
+ * `lexer.tokenize(input)` directly). recoveryEnabled:false means we stop at
+ * the first error and surface it via the snapshot below.
+ */
+export function parseToCst(tokens) {
+    parserInstance.input = tokens.tokens;
+    const cst = parserInstance.expression();
+    const errors = parserInstance.errors.map((e) => ({
+        message: e.message,
+        offset: e.token?.startOffset ?? -1,
+    }));
+    return { cst, errors };
+}
+// Exposed for tests that want to reference the singleton (the import itself
+// proves performSelfAnalysis() completed without throwing at module load).
+export { parserInstance };
+//# sourceMappingURL=parser.js.map

package/dist/runtime/evaluator/expression/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/parser.ts"],"names":[],"mappings":"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"}

package/dist/runtime/evaluator.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Process evaluator — interpreter loop for `ProcessStep[]`.
+ *
+ * A rule is a process: a flat sequence of primitive calls (Task 1.1 types,
+ * Task 1.2 registry). This module walks the array, dispatches each step
+ * through the registry, manages variable bindings (`as:` writes), evaluates
+ * `if:` conditions, applies `on_empty:` early-exit policy, and recognises the
+ * `verdict` primitive as the terminal step. The output is a `RuleResult`.
+ *
+ * What the evaluator deliberately is NOT:
+ *
+ *   - A string-eval engine. `if:` parsing is delegated to the chevrotain
+ *     grammar in `runtime/evaluator/expression/index.ts` (H.1.6 cutover);
+ *     this module never sees raw expression strings beyond the one-line
+ *     delegate at the bottom of the file. No `eval()` / `new Function()`
+ *     anywhere — audit-grepped on both this file and the expression dir.
+ *     The grammar supports logical ops (`||`, `&&`, `!`), parens, dotted
+ *     and bracket paths, function calls (5 allow-listed: `len`, `contains`,
+ *     `match`, `startsWith`, `endsWith`), and strict equality.
+ *
+ *   - A template engine. `{{name}}` interpolation runs against string
+ *     `args` values only; nested objects with template strings are NOT
+ *     walked in Phase 1. Unbound variables substitute the empty string.
+ *
+ *   - A scheduler. Steps run strictly in order. Concurrency would need a
+ *     primitive that fans out internally; the interpreter itself is serial.
+ *
+ * Purity: no module-level state. All variable scope lives in `ctx.bindings`,
+ * which the caller owns. A second `evaluateProcess` call against the same
+ * steps with a fresh ctx must produce the same result — tests rely on this.
+ *
+ * Durable execution (DURABLE.2):
+ *
+ *   When the caller passes a `checkpoint` option containing a CheckpointStore
+ *   + runId, every step whose primitive declares `durable: true` is wrapped:
+ *
+ *     1. Resolve `(call, interpolatedArgs)` → `inputsHash` via canonical JSON
+ *     2. Look up `checkpoints[runId][stepIdx]` (prefetched at entry)
+ *     3. If the row exists, has `status: 'completed'`, and `inputsHash`
+ *        matches → restore the row's `outputs` into `ctx.bindings[step.as]`,
+ *        skip the primitive call entirely
+ *     4. Else → execute the primitive, then `store.append(...)` the row
+ *
+ *   Non-durable primitives bypass the wrap entirely (no hash, no lookup, no
+ *   write) — the audit guarantee is that the only durable-execution overhead
+ *   on cheap primitives is one `if (def.durable)` branch per step.
+ *
+ *   Errored primitive results write a row with `status: 'errored'` so the
+ *   resumer can re-run that step on the next pass. The evaluator still
+ *   returns the error to the caller — the checkpoint write is best-effort
+ *   accounting, not a swallowed failure.
+ *
+ * Memoization (DURABLE.3):
+ *
+ *   When the caller passes a `memo` option containing a MemoCache, primitives
+ *   that declare `memoizable: true` (DURABLE.2 metadata) get an extra layer
+ *   AFTER the checkpoint-hit branch but BEFORE the primitive invoke:
+ *
+ *     1. Run the same `inputsHash` derivation.
+ *     2. If checkpoint hit → use it (covers same-run resume, exact-input).
+ *     3. Else look up `memoCache.get(fn, inputsHash)` — cross-run cache.
+ *     4. On memo hit → return value, write a checkpoint row (so a resume
+ *        of THIS run remembers the step) but DON'T re-invoke the primitive.
+ *     5. On memo miss → singleflight the invocation so 100 concurrent
+ *        misses on the same key → 1 primitive call. Set the cache + write
+ *        the checkpoint inside the singleflight body.
+ *
+ *   Memoization fires ONLY for `memoizable: true` primitives. Cheap
+ *   non-memoizable primitives (state_lookup, verdict, match_regex) flow
+ *   straight through — same as in DURABLE.2.
+ *
+ *   TTLs are caller-provided (per-primitive class defaults live in the
+ *   caller's `memo.ttlForFn(fn)` callback). The evaluator never invents a
+ *   TTL of its own — keeping the TTL policy with the caller lets pack
+ *   authors override per-fn defaults.
+ *
+ * Imports from: runtime/types.ts, runtime/result.ts, functions/registry.ts,
+ *   runtime/durable/checkpoint_store.ts, runtime/durable/canonical_json.ts,
+ *   runtime/durable/run_id.ts, runtime/durable/memo_cache.ts.
+ * Imported by: runtime/ (rule dispatcher in later phases).
+ */
+import type { FunctionRegistry, EvalCtx } from '../functions/registry.js';
+import type { CheckpointStore } from './durable/checkpoint_store.js';
+import type { MemoCache } from './durable/memo_cache.js';
+import type { ProcessStep, RuleResult } from './types.js';
+export interface CheckpointOptions {
+    store: CheckpointStore;
+    runId: string;
+}
+/**
+ * Memoization wiring (DURABLE.3). `cache` is the shared two-tier MemoCache;
+ * `ttlForFn` is an optional per-primitive TTL resolver — when omitted, all
+ * memoizable primitives use the cache's no-TTL behavior (entry lives until
+ * evicted by LRU or explicit `clear()`).
+ *
+ * Default TTLs (when callers wire a resolver):
+ *   - llm_classify         → 1h
+ *   - recall, embed        → 5m
+ *   - http_request         → 30s
+ *   - check_destination    → 1h
+ */
+export interface MemoOptions {
+    cache: MemoCache;
+    ttlForFn?: (fn: string) => number | undefined;
+}
+interface EvaluateOptions {
+    checkpoint?: CheckpointOptions;
+    memo?: MemoOptions;
+}
+export declare function evaluateProcess(steps: ProcessStep[], ctx: EvalCtx, registry: FunctionRegistry, options?: EvaluateOptions): Promise<RuleResult>;
+export {};
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/runtime/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/runtime/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAG1E,OAAO,KAAK,EAAiB,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAW,MAAM,YAAY,CAAC;AAgBnE,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,UAAU,eAAe;IACvB,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAsBD,wBAAsB,eAAe,CACnC,KAAK,EAAE,WAAW,EAAE,EACpB,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAqHrB"}