opensquid 0.5.395

package/dist/runtime/escalate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalate.js","sourceRoot":"","sources":["../../src/runtime/escalate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAiDH;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAAkB;IACvD,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAC3F,MAAM,gBAAgB,GAAG,UAAmB,CAAC;IAE7C,sEAAsE;IACtE,mEAAmE;IACnE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,IAAI,OAAO,CAAC,MAAM,IAAI,SAAS,CAAC;QAC7D,IAAI,QAAQ,CAAC;QACb,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO;gBACL,SAAS,EAAE,KAAK;gBAChB,gBAAgB;gBAChB,SAAS,EAAE,IAAI;gBACf,WAAW,EAAE;oBACX,IAAI,EAAE,kBAAkB;oBACxB,MAAM,EAAE,iCAAiC,MAAM,CAAC,CAAC,CAAC,EAAE;iBACrD;aACF,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YACtB,OAAO;gBACL,SAAS,EAAE,KAAK;gBAChB,gBAAgB;gBAChB,SAAS,EAAE,IAAI;gBACf,WAAW,EAAE;oBACX,IAAI,EAAE,cAAc;oBACpB,MAAM,EAAE,yCAAyC,QAAQ,CAAC,MAAM,IAAI,SAAS,IAC3E,QAAQ,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,cAAc,QAAQ,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,EAClF,EAAE;iBACH;aACF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,0CAA0C;IAC1C,MAAM,OAAO,GAAG,kBAAkB,CAAC,OAAO,CAAC,gBAAgB,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/E,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO;YACL,SAAS,EAAE,KAAK;YAChB,gBAAgB;YAChB,SAAS,EAAE,IAAI;YACf,WAAW,EAAE;gBACX,IAAI,EAAE,sBAAsB;gBAC5B,MAAM,EAAE,2DAA2D,OAAO,IAAI,GAAG,oBAAoB;aACtG;SACF,CAAC;IACJ,CAAC;IAED,mEAAmE;IACnE,2DAA2D;IAC3D,MAAM,OAAO,GAAmB;QAC9B,IAAI,EAAE,qBAAqB,CAAC,OAAO,CAAC;QACpC,QAAQ,EAAE,gBAAgB;KAC3B,CAAC;IACF,MAAM,SAAS,GAAG,MAAM,kBAAkB,CAAC,SAAS,CAAC,gBAAgB,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAElG,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,gBAAgB,EAAE,SAAS,EAAE,CAAC;AAC1D,CAAC;AAED,8EAA8E;AAC9E,uEAAuE;AACvE,EAAE;AACF,0EAA0E;AAC1E,2EAA2E;AAC3E,yEAAyE;AACzE,wEAAwE;AACxE,eAAe;AACf,8EAA8E;AAE9E,SAAS,qBAAqB,CAAC,OAAgB;IAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1E,OAAO,GAAG,MAAM,cAAc,OAAO,CAAC,KAAK,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;AACrE,CAAC"}

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

@@ -0,0 +1,57 @@
+/**
+ * AST + CST→AST visitor — Task H.1.3 (chevrotain v11 visitor).
+ *
+ * Lowers the CST from parser.ts (H.1.2) into a 6-kind discriminated union
+ * (literal | name | path | call | unary | binary). Switches over
+ * `ASTNode['kind']` MUST end with `assertNever(node)` so a new kind breaks
+ * typecheck at every callsite. Nodes carry `offset: number` from the
+ * originating token's `startOffset`; binary nodes inherit the LHS offset so
+ * left-folded chains point at the leftmost operand. orExpr/andExpr fold
+ * left-to-right (`((a&&b)&&c)`). Strings strip outer quotes then process
+ * `\"` `\\` `\n` `\t` `\r` (unknown escapes pass through). `validateVisitor()`
+ * is REQUIRED — without it, visitor-method typos silently return undefined.
+ */
+import type { CstNode } from 'chevrotain';
+export type BinaryOp = '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||';
+export type PathSegment = {
+    kind: 'prop';
+    name: string;
+} | {
+    kind: 'index';
+    value: number | string;
+};
+export type ASTNode = {
+    kind: 'literal';
+    value: string | number | boolean | null;
+    offset: number;
+} | {
+    kind: 'name';
+    id: string;
+    offset: number;
+} | {
+    kind: 'path';
+    target: ASTNode;
+    segments: PathSegment[];
+    offset: number;
+} | {
+    kind: 'call';
+    name: string;
+    args: ASTNode[];
+    offset: number;
+} | {
+    kind: 'unary';
+    op: '!';
+    operand: ASTNode;
+    offset: number;
+} | {
+    kind: 'binary';
+    op: BinaryOp;
+    lhs: ASTNode;
+    rhs: ASTNode;
+    offset: number;
+};
+/** Throw on unhandled discriminator — call from any switch over `ASTNode['kind']`. */
+export declare function assertNever(x: never): never;
+/** Lower a parser CST into an AST. Throws if the CST shape is malformed. */
+export declare function cstToAst(cst: CstNode): ASTNode;
+//# sourceMappingURL=ast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/ast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAU,MAAM,YAAY,CAAC;AAMlD,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE3E,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE9C,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjF,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAE3C;AA0ID,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAG9C"}

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

@@ -0,0 +1,156 @@
+/**
+ * AST + CST→AST visitor — Task H.1.3 (chevrotain v11 visitor).
+ *
+ * Lowers the CST from parser.ts (H.1.2) into a 6-kind discriminated union
+ * (literal | name | path | call | unary | binary). Switches over
+ * `ASTNode['kind']` MUST end with `assertNever(node)` so a new kind breaks
+ * typecheck at every callsite. Nodes carry `offset: number` from the
+ * originating token's `startOffset`; binary nodes inherit the LHS offset so
+ * left-folded chains point at the leftmost operand. orExpr/andExpr fold
+ * left-to-right (`((a&&b)&&c)`). Strings strip outer quotes then process
+ * `\"` `\\` `\n` `\t` `\r` (unknown escapes pass through). `validateVisitor()`
+ * is REQUIRED — without it, visitor-method typos silently return undefined.
+ */
+import { parserInstance } from './parser.js';
+/** Throw on unhandled discriminator — call from any switch over `ASTNode['kind']`. */
+export function assertNever(x) {
+    throw new Error(`Unhandled AST kind: ${JSON.stringify(x)}`);
+}
+const BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
+class CstToAstVisitor extends BaseVisitor {
+    constructor() {
+        super();
+        this.validateVisitor();
+    }
+    // Typed wrappers around chevrotain's `any`-typed `visit()` — confine the
+    // unsafe surface to two callees. `no-unsafe-return` disabled at each
+    // return; per-method return annotation provides downstream type narrowing.
+    visitNode(child) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- chevrotain visit() returns any.
+        return this.visit(child);
+    }
+    visitSeg(child) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- chevrotain visit() returns any.
+        return this.visit(child);
+    }
+    expression(ctx) {
+        return this.visitNode(ctx.orExpr);
+    }
+    orExpr(ctx) {
+        return this.foldBinary(ctx, '||');
+    }
+    andExpr(ctx) {
+        return this.foldBinary(ctx, '&&');
+    }
+    // Shared left-fold for orExpr/andExpr (both have lhs + MANY rhs).
+    foldBinary(ctx, op) {
+        let acc = this.visitNode(ctx.lhs);
+        const rhs = ctx.rhs;
+        if (rhs) {
+            for (const r of rhs) {
+                acc = { kind: 'binary', op, lhs: acc, rhs: this.visitNode(r), offset: acc.offset };
+            }
+        }
+        return acc;
+    }
+    notExpr(ctx) {
+        const operand = this.visitNode(ctx.compareExpr);
+        const bang = ctx.Bang?.[0];
+        return bang ? { kind: 'unary', op: '!', operand, offset: bang.startOffset } : operand;
+    }
+    compareExpr(ctx) {
+        const lhs = this.visitNode(ctx.lhs);
+        const r = ctx.rhs;
+        if (!r)
+            return lhs;
+        const op = pickCompareOp(ctx);
+        return { kind: 'binary', op, lhs, rhs: this.visitNode(r), offset: lhs.offset };
+    }
+    primary(ctx) {
+        const sub = (ctx.expression ?? ctx.literal ?? ctx.callOrPath);
+        if (!sub)
+            throw new Error('primary: no alternative matched (parser invariant violated)');
+        return this.visitNode(sub);
+    }
+    callOrPath(ctx) {
+        const id = ctx.Identifier[0];
+        const offset = id.startOffset;
+        if (ctx.LParen) {
+            const args = (ctx.arg ?? []).map((a) => this.visitNode(a));
+            return { kind: 'call', name: id.image, args, offset };
+        }
+        const segs = ctx.pathSegment;
+        const name = { kind: 'name', id: id.image, offset };
+        if (!segs?.length)
+            return name;
+        return { kind: 'path', target: name, segments: segs.map((s) => this.visitSeg(s)), offset };
+    }
+    pathSegment(ctx) {
+        if (ctx.Dot)
+            return { kind: 'prop', name: ctx.Identifier[0].image };
+        const num = ctx.NumberLit?.[0];
+        if (num)
+            return { kind: 'index', value: Number(num.image) };
+        const str = ctx.StringLit?.[0];
+        if (str)
+            return { kind: 'index', value: parseStringLit(str.image) };
+        throw new Error('pathSegment: no alternative matched (parser invariant violated)');
+    }
+    literal(ctx) {
+        if (ctx.StringLit)
+            return litNode(ctx.StringLit[0], parseStringLit);
+        if (ctx.NumberLit)
+            return litNode(ctx.NumberLit[0], Number);
+        if (ctx.True)
+            return litNode(ctx.True[0], () => true);
+        if (ctx.False)
+            return litNode(ctx.False[0], () => false);
+        if (ctx.Null)
+            return litNode(ctx.Null[0], () => null);
+        throw new Error('literal: no alternative matched (parser invariant violated)');
+    }
+}
+function litNode(t, project) {
+    return { kind: 'literal', value: project(t.image), offset: t.startOffset };
+}
+// Pick the one compare op token populated under compareExpr's children.
+// Exactly one of the six is present when ctx.rhs is set (parser invariant).
+function pickCompareOp(ctx) {
+    if (ctx.EqEq)
+        return '==';
+    if (ctx.NotEq)
+        return '!=';
+    if (ctx.Lte)
+        return '<=';
+    if (ctx.Gte)
+        return '>=';
+    if (ctx.Lt)
+        return '<';
+    if (ctx.Gt)
+        return '>';
+    throw new Error('compareExpr: rhs present but no operator token (parser invariant violated)');
+}
+// Strip outer quotes + process JSON-ish escapes (\" \\ \n \t \r). Unknown
+// escapes pass through as the escaped character.
+const ESC = { n: '\n', t: '\t', r: '\r', '"': '"', '\\': '\\' };
+function parseStringLit(raw) {
+    const inner = raw.slice(1, -1);
+    let out = '';
+    for (let i = 0; i < inner.length; i++) {
+        const c = inner[i];
+        if (c !== '\\' || i === inner.length - 1) {
+            out += c;
+            continue;
+        }
+        const next = inner[++i];
+        out += ESC[next] ?? next;
+    }
+    return out;
+}
+const visitorInstance = new CstToAstVisitor();
+/** Lower a parser CST into an AST. Throws if the CST shape is malformed. */
+export function cstToAst(cst) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- chevrotain visit() returns any.
+    return visitorInstance.visit(cst);
+}
+//# sourceMappingURL=ast.js.map

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

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

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

@@ -0,0 +1,40 @@
+/**
+ * LRU parse cache for `if:` expression ASTs — Task H.1.5.
+ *
+ * Key = trimmed expression string. Value = `ASTNode` from `cstToAst()`.
+ * Two expressions with the same trimmed string parse to the same AST
+ * regardless of binding context (the AST is binding-independent), so the
+ * trimmed-string key is collision-safe (pre-research §6.2). DO NOT include
+ * binding schema in the key — that would defeat the cache's purpose and
+ * collapse hit-rate to ~0 because event-data bindings vary per call.
+ *
+ * Sizing: `max: 256` entries. Projected 12-month skill growth caps at ~100
+ * unique `if:` clauses across all installed packs (pre-research §6.1);
+ * 256 is 2.5× that with ~256KB memory ceiling. Bump later if telemetry
+ * shows eviction pressure.
+ *
+ * Lifecycle: process-lifetime cache, no invalidation in v1. Process restart
+ * clears naturally. If/when skill yaml hot-reload lands, callers MUST invoke
+ * `clear()` on reload — otherwise a stale AST will keep being evaluated
+ * against new binding schemas.
+ *
+ * lru-cache v11 API notes:
+ *   - `cache.size` is a property (not a method); `cache.max` is read-only.
+ *   - Hit/miss counters are NOT exposed; wrap `get`/`set` with manual
+ *     counting if perf debugging needs them. Skipped in v1 per §6.4.
+ */
+import type { ASTNode } from './ast.js';
+/** Max cached parse entries. See pre-research §6.1 for sizing rationale. */
+export declare const MAX_ENTRIES = 256;
+/** Look up a cached AST by its trimmed expression-string key. */
+export declare function getCached(key: string): ASTNode | undefined;
+/** Store a freshly-parsed AST under its trimmed expression-string key. */
+export declare function setCached(key: string, ast: ASTNode): void;
+/** Cache occupancy snapshot. `size` is current entries; `max` is the cap. */
+export declare function stats(): {
+    size: number;
+    max: number;
+};
+/** Drop all entries. Call from any hot-reload path (none in v1). */
+export declare function clear(): void;
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC,4EAA4E;AAC5E,eAAO,MAAM,WAAW,MAAM,CAAC;AAI/B,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAE1D;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAEzD;AAED,6EAA6E;AAC7E,wBAAgB,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAErD;AAED,oEAAoE;AACpE,wBAAgB,KAAK,IAAI,IAAI,CAE5B"}

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

@@ -0,0 +1,46 @@
+/**
+ * LRU parse cache for `if:` expression ASTs — Task H.1.5.
+ *
+ * Key = trimmed expression string. Value = `ASTNode` from `cstToAst()`.
+ * Two expressions with the same trimmed string parse to the same AST
+ * regardless of binding context (the AST is binding-independent), so the
+ * trimmed-string key is collision-safe (pre-research §6.2). DO NOT include
+ * binding schema in the key — that would defeat the cache's purpose and
+ * collapse hit-rate to ~0 because event-data bindings vary per call.
+ *
+ * Sizing: `max: 256` entries. Projected 12-month skill growth caps at ~100
+ * unique `if:` clauses across all installed packs (pre-research §6.1);
+ * 256 is 2.5× that with ~256KB memory ceiling. Bump later if telemetry
+ * shows eviction pressure.
+ *
+ * Lifecycle: process-lifetime cache, no invalidation in v1. Process restart
+ * clears naturally. If/when skill yaml hot-reload lands, callers MUST invoke
+ * `clear()` on reload — otherwise a stale AST will keep being evaluated
+ * against new binding schemas.
+ *
+ * lru-cache v11 API notes:
+ *   - `cache.size` is a property (not a method); `cache.max` is read-only.
+ *   - Hit/miss counters are NOT exposed; wrap `get`/`set` with manual
+ *     counting if perf debugging needs them. Skipped in v1 per §6.4.
+ */
+import { LRUCache } from 'lru-cache';
+/** Max cached parse entries. See pre-research §6.1 for sizing rationale. */
+export const MAX_ENTRIES = 256;
+const cache = new LRUCache({ max: MAX_ENTRIES });
+/** Look up a cached AST by its trimmed expression-string key. */
+export function getCached(key) {
+    return cache.get(key);
+}
+/** Store a freshly-parsed AST under its trimmed expression-string key. */
+export function setCached(key, ast) {
+    cache.set(key, ast);
+}
+/** Cache occupancy snapshot. `size` is current entries; `max` is the cap. */
+export function stats() {
+    return { size: cache.size, max: MAX_ENTRIES };
+}
+/** Drop all entries. Call from any hot-reload path (none in v1). */
+export function clear() {
+    cache.clear();
+}
+//# sourceMappingURL=cache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAIrC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC;AAE/B,MAAM,KAAK,GAAG,IAAI,QAAQ,CAAkB,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;AAElE,iEAAiE;AACjE,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACxB,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,SAAS,CAAC,GAAW,EAAE,GAAY;IACjD,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACtB,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,KAAK;IACnB,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC;AAChD,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,KAAK;IACnB,KAAK,CAAC,KAAK,EAAE,CAAC;AAChB,CAAC"}

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

@@ -0,0 +1,61 @@
+/**
+ * Function allow-list registry — Task H.1.5 + H.4 (ReDoS-hardened `match()`).
+ *
+ * ALLOW-LIST ONLY. The interpreter dispatches `call` nodes through this
+ * frozen registry; missing names throw `InterpreterRuntimeError('unknown
+ * function: <name>')`. To add a new function, follow the 5-point expansion
+ * checklist (pre-research §4.4):
+ *
+ *   1. **Cite a real skill** that needs it. Speculative adds rejected.
+ *   2. **Confirm pure** — deterministic + side-effect-free (no I/O, no time,
+ *      no random). Tests must include a determinism case.
+ *   3. **Document new attack surface** —
+ *        - Regex-accepting → use RE2 (ReDoS-immune by construction; follow
+ *          `match()` precedent).
+ *        - String-returning → bounded length (cap ~10k chars to prevent
+ *          step-cap evasion via huge strings).
+ *        - Object-returning → must `Object.create(null)` the result.
+ *   4. **Coercion table** documented per-input-type, every input → defined
+ *      output, `undefined`/`null` defined, never throw.
+ *   5. **≥3 tests** — happy + type-mismatch + edge (empty / null). Add a
+ *      fuzz/adversarial case for any function touching strings.
+ *
+ * Comparable sets (post-research §4.2):
+ *   - **Cerbos CEL:** size, contains, startsWith, endsWith, matches, in,
+ *     filter, map, exists, all, sort (+ arithmetic, IP, time, path).
+ *   - **GitHub Actions:** contains, startsWith, endsWith, format, join,
+ *     toJSON, fromJSON, hashFiles, success, failure, always, cancelled.
+ *   - Our 5 align with Cerbos's core string ops + GHA's core matchers. We
+ *     deliberately OMIT `format`/`join`/`toJSON` (handled by `{{var}}`
+ *     interpolation), `in` (sugar for `contains` with swapped args), and
+ *     arithmetic (no skill needs math in v1).
+ *
+ * Coercion + signature reference (pre-research §4.3):
+ *
+ *   | Name         | Signature                              | Type-mismatch |
+ *   | ------------ | -------------------------------------- | ------------- |
+ *   | len(x)       | string|array|object → number           | returns 0     |
+ *   | contains     | string × string → bool                 | returns false |
+ *   | startsWith   | string × string → bool                 | returns false |
+ *   | endsWith     | string × string → bool                 | returns false |
+ *   | match        | string × string → bool (RE2 grammar)   | returns false |
+ *
+ * Handlers do NOT throw on type-mismatch — they return `false`/`0` (matches
+ * the relational-op convention from `interpreter.ts:applyCompare`). Only
+ * the interpreter's unknown-function path throws `InterpreterRuntimeError`.
+ * Wrong arity is acceptable failure mode: missing args arrive as
+ * `undefined` and the type guards coerce to the default.
+ */
+/** Handler signature: positional args are passed evaluated and unmodified. */
+export type FnHandler = (...args: unknown[]) => unknown;
+/**
+ * Frozen allow-list registry. Built on a null-prototype base so author-
+ * supplied call names like `__proto__` / `constructor` / `toString` can't
+ * resolve to inherited Object.prototype methods on lookup. `Object.freeze`
+ * prevents bracket-assignment mutation at runtime; the audit grep on the
+ * registry name (see H.1.5 spec verification commands) enforces no late
+ * mutation at source-review time. Both layers are intentional — runtime
+ * + source-time defense.
+ */
+export declare const FUNCTIONS: Readonly<Record<string, FnHandler>>;
+//# sourceMappingURL=functions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAIH,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;AAkFxD;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAQzD,CAAC"}

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

@@ -0,0 +1,143 @@
+/**
+ * Function allow-list registry — Task H.1.5 + H.4 (ReDoS-hardened `match()`).
+ *
+ * ALLOW-LIST ONLY. The interpreter dispatches `call` nodes through this
+ * frozen registry; missing names throw `InterpreterRuntimeError('unknown
+ * function: <name>')`. To add a new function, follow the 5-point expansion
+ * checklist (pre-research §4.4):
+ *
+ *   1. **Cite a real skill** that needs it. Speculative adds rejected.
+ *   2. **Confirm pure** — deterministic + side-effect-free (no I/O, no time,
+ *      no random). Tests must include a determinism case.
+ *   3. **Document new attack surface** —
+ *        - Regex-accepting → use RE2 (ReDoS-immune by construction; follow
+ *          `match()` precedent).
+ *        - String-returning → bounded length (cap ~10k chars to prevent
+ *          step-cap evasion via huge strings).
+ *        - Object-returning → must `Object.create(null)` the result.
+ *   4. **Coercion table** documented per-input-type, every input → defined
+ *      output, `undefined`/`null` defined, never throw.
+ *   5. **≥3 tests** — happy + type-mismatch + edge (empty / null). Add a
+ *      fuzz/adversarial case for any function touching strings.
+ *
+ * Comparable sets (post-research §4.2):
+ *   - **Cerbos CEL:** size, contains, startsWith, endsWith, matches, in,
+ *     filter, map, exists, all, sort (+ arithmetic, IP, time, path).
+ *   - **GitHub Actions:** contains, startsWith, endsWith, format, join,
+ *     toJSON, fromJSON, hashFiles, success, failure, always, cancelled.
+ *   - Our 5 align with Cerbos's core string ops + GHA's core matchers. We
+ *     deliberately OMIT `format`/`join`/`toJSON` (handled by `{{var}}`
+ *     interpolation), `in` (sugar for `contains` with swapped args), and
+ *     arithmetic (no skill needs math in v1).
+ *
+ * Coercion + signature reference (pre-research §4.3):
+ *
+ *   | Name         | Signature                              | Type-mismatch |
+ *   | ------------ | -------------------------------------- | ------------- |
+ *   | len(x)       | string|array|object → number           | returns 0     |
+ *   | contains     | string × string → bool                 | returns false |
+ *   | startsWith   | string × string → bool                 | returns false |
+ *   | endsWith     | string × string → bool                 | returns false |
+ *   | match        | string × string → bool (RE2 grammar)   | returns false |
+ *
+ * Handlers do NOT throw on type-mismatch — they return `false`/`0` (matches
+ * the relational-op convention from `interpreter.ts:applyCompare`). Only
+ * the interpreter's unknown-function path throws `InterpreterRuntimeError`.
+ * Wrong arity is acceptable failure mode: missing args arrive as
+ * `undefined` and the type guards coerce to the default.
+ */
+import { RE2JS } from 're2js';
+/** `len(x)` — string char count, array length, object key count, else `0`. */
+const len = (x) => {
+    if (typeof x === 'string')
+        return x.length;
+    if (Array.isArray(x))
+        return x.length;
+    if (x !== null && typeof x === 'object')
+        return Object.keys(x).length;
+    return 0;
+};
+/** `contains(s, sub)` — substring test; false unless both args are strings. */
+const contains = (s, sub) => typeof s === 'string' && typeof sub === 'string' && s.includes(sub);
+/** `startsWith(s, p)` — prefix test; false unless both args are strings. */
+const startsWith = (s, p) => typeof s === 'string' && typeof p === 'string' && s.startsWith(p);
+/** `endsWith(s, p)` — suffix test; false unless both args are strings. */
+const endsWith = (s, p) => typeof s === 'string' && typeof p === 'string' && s.endsWith(p);
+/**
+ * `match(s, pattern)` — RE2 test; false on type-mismatch or invalid pattern.
+ *
+ * ReDoS-immune by construction (H.4, pre-research §12.1 rollback). Backed
+ * by `re2js` — a pure-JS port of Google's RE2 engine — which matches in
+ * linear time relative to input length. A pattern like `(a+)+$` against
+ * `"aaa…b"` no longer hangs the event loop; it returns `false` in <10ms
+ * regardless of input length.
+ *
+ * **PCRE features RE2 rejects** (`RE2JS.compile()` throws
+ * `RE2JSSyntaxException`, which the catch below converts to `false`):
+ *
+ *   - **Backreferences** — `\1`, `\2`, …  (e.g. `(\w+)\s+\1`)
+ *   - **Lookaheads** — `(?=...)`, `(?!...)`
+ *   - **Lookbehinds** — `(?<=...)`, `(?<!...)`
+ *   - **Possessive quantifiers** — `a++`, `a*+`, `a?+`
+ *   - **Atomic groups** — `(?>...)`
+ *   - **Embedded conditionals** — `(?(cond)yes|no)`
+ *
+ * These features all rely on backtracking, which is precisely the
+ * mechanism RE2 trades away to guarantee linear-time matching. Pack
+ * authors using `match()` must stay inside the RE2 subset; everything
+ * else (character classes, alternation, basic quantifiers `*` `+` `?`
+ * `{n,m}`, capturing groups `(...)`, named captures `(?P<name>...)`,
+ * anchors `^` `$` `\b`, Unicode classes) works identically to V8 RegExp.
+ *
+ * **Cost.** `re2js` adds ~868KB to `node_modules` (no native build,
+ * no WASM cold-start — pure JS); first-call compile of any new pattern
+ * is the warm-up. Skill packs typically reuse a small set of patterns,
+ * so amortized per-call cost is dominated by the linear-time DFA match
+ * after the first compile.
+ *
+ * **Breaking-change classification.** Semantically breaking: any pack
+ * authoring an `if:` clause that uses a PCRE-only feature now returns
+ * `false` instead of evaluating the regex. opensquid still bumps PATCH
+ * (0.5.149 → 0.5.150) per the pre-1.0 + agent-only-PATCH SemVer rules
+ * locked in pre-research. None of the shipped `packs/builtin/` clauses
+ * use rejected features (verified by H.3 implementer + post-research
+ * §6 sweep against the RE2 syntax reference).
+ *
+ * **Comparable projects.** Cerbos uses Go's stdlib `regexp` (RE2-derived,
+ * safe for free from the language). Cloudflare Workers ships `re2-wasm`
+ * (also RE2 in a different transport) on their third-party-code surface.
+ * Both made the same trade for the same threat-model reason.
+ */
+const match = (s, pattern) => {
+    if (typeof s !== 'string' || typeof pattern !== 'string')
+        return false;
+    try {
+        return RE2JS.compile(pattern).test(s);
+    }
+    catch (err) {
+        // RE2JSSyntaxException covers PCRE-rejected features + malformed
+        // patterns (e.g. `(`, `[`, trailing `\`). Catching the base class
+        // keeps behavior consistent with the legacy V8-RegExp try/catch:
+        // any compile-time failure → false. We DO swallow other exceptions
+        // defensively, but the only documented thrown type is the syntax one.
+        void err;
+        return false;
+    }
+};
+/**
+ * Frozen allow-list registry. Built on a null-prototype base so author-
+ * supplied call names like `__proto__` / `constructor` / `toString` can't
+ * resolve to inherited Object.prototype methods on lookup. `Object.freeze`
+ * prevents bracket-assignment mutation at runtime; the audit grep on the
+ * registry name (see H.1.5 spec verification commands) enforces no late
+ * mutation at source-review time. Both layers are intentional — runtime
+ * + source-time defense.
+ */
+export const FUNCTIONS = Object.freeze(Object.assign(Object.create(null), {
+    len,
+    contains,
+    startsWith,
+    endsWith,
+    match,
+}));
+//# sourceMappingURL=functions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAK9B,8EAA8E;AAC9E,MAAM,GAAG,GAAc,CAAC,CAAC,EAAE,EAAE;IAC3B,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC,MAAM,CAAC;IAC3C,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC,MAAM,CAAC;IACtC,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACtE,OAAO,CAAC,CAAC;AACX,CAAC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,QAAQ,GAAc,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CACrC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAEtE,4EAA4E;AAC5E,MAAM,UAAU,GAAc,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACrC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAEpE,0EAA0E;AAC1E,MAAM,QAAQ,GAAc,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,KAAK,GAAc,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE;IACtC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACvE,IAAI,CAAC;QACH,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,iEAAiE;QACjE,kEAAkE;QAClE,iEAAiE;QACjE,mEAAmE;QACnE,sEAAsE;QACtE,KAAK,GAAG,CAAC;QACT,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAAwC,MAAM,CAAC,MAAM,CACzE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAA8B,EAAE;IAC9D,GAAG;IACH,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,KAAK;CACN,CAAC,CACH,CAAC"}

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

@@ -0,0 +1,86 @@
+/**
+ * Public `evalCondition` entry — Task H.1.6 (integration cutover).
+ *
+ * Threads the H.1.1–H.1.5 substrate (lexer → parser → AST visitor →
+ * interpreter, with an LRU parse cache) into a single boolean-returning
+ * function that the wider runtime can call as a drop-in replacement for the
+ * old 5-regex `evalCondition` in `evaluator.ts`. All five regex constants
+ * (`EQ_PATTERN`, `BARE_PATTERN`, `NUM_CMP_PATTERN`, `BOOL_CMP_PATTERN`,
+ * `STR_PATH_EQ_PATTERN`) and the `resolveNumericPath` helper are deleted
+ * upstream — the chevrotain grammar covers every form they recognised, plus
+ * the new forms (`||`, `!`, parens, deeper paths, index access, function
+ * calls) that the regex set was unable to express.
+ *
+ * Locked decisions codified here (pre-research §12, this is the cutover
+ * commit that ships them):
+ *
+ *   - §12.2 — empty `if:` returns `true` (was silent `false` + warn). Treat
+ *     a present-but-empty predicate as equivalent to "no `if:` field" so
+ *     pack-author trailing-whitespace YAML doesn't accidentally skip steps.
+ *   - §12.3 — comparison is STRICT equality. `1 == "1"` is `false`. No
+ *     `String()` wrapping. The interpreter's `applyCompare` already enforces
+ *     this; `evalCondition` does not re-coerce.
+ *   - §12.4 — `phases != "complete"` (and any other `!=` form) is now valid
+ *     grammar. The `phase-logged-before-commit` workflow rule that was a
+ *     silent no-op for the entire G-track lifetime starts firing for real.
+ *   - The 5-regex grammar is replaced wholesale; this module is the only
+ *     `if:`-parsing surface in the runtime.
+ *
+ * Error model (3 tiers, all fail-closed → `false` + `console.warn`):
+ *
+ *   1. Lex error — input has a character the lexer doesn't recognise
+ *      (e.g. `'== ='` — `=` alone is not a valid token; only `EqEq`/`NotEq`
+ *      consume `==`/`===`/`!=`/`!==`).
+ *   2. Parse error — token stream doesn't match the grammar (e.g. `'a &&'`,
+ *      `'(a || b'`).
+ *   3. Interpreter error — `InterpreterLimitError` (depth>64 or steps>10k)
+ *      or `InterpreterRuntimeError` (unknown function name).
+ *
+ * The 3-tier model means `console.warn` always names the originating layer,
+ * which makes "why did my `if:` silently skip?" diagnosable in one read.
+ *
+ * Parse cache integration: cache key = trimmed input string; cache value =
+ * the cstToAst result. Cache miss runs lex+parse+ast; cache hit jumps
+ * straight to evaluate. Setting on miss is critical — the spec's code shape
+ * shows `getCached(trimmed) ?? parse(trimmed)` but omits the `setCached`,
+ * which is a one-line bug that would make every call a cache miss.
+ *
+ * `parseExpression()` is the parse-only sibling export, exposed for H.2's
+ * Zod refinement on the `if:` schema field. It throws on any of the 3 error
+ * tiers (caller wraps in try/catch and surfaces via Zod's refinement
+ * message). The empty-string case is also a throw here — load-time
+ * validation has already established that the field is present; an empty
+ * predicate at load-time is a YAML authoring mistake worth surfacing, even
+ * though runtime semantics treat it as `true`.
+ *
+ * Imports from: `./lexer.js`, `./parser.js`, `./ast.js`, `./interpreter.js`,
+ *   `./cache.js`.
+ * Imported by: `src/runtime/evaluator.ts` (the one-line shim that the old
+ *   `evalCondition` collapses to); H.2's `src/packs/schemas/skill.ts`
+ *   refinement will import `parseExpression` from here.
+ */
+import { type ASTNode } from './ast.js';
+/**
+ * Evaluate an `if:` expression against the supplied bindings.
+ *
+ * Returns `true` to mean "run the step", `false` to mean "skip the step".
+ * Errors at every layer fail closed to `false` + `console.warn` so a broken
+ * predicate never silently mis-fires a verdict; the warn surfaces the failure
+ * during pack-author development.
+ */
+export declare function evalCondition(expr: string, bindings: Map<string, unknown>): boolean;
+/**
+ * Parse-only entry for load-time validation (H.2 Zod refinement).
+ *
+ * Throws on any of the 3 error tiers (lex / parse / AST). Callers wrap in
+ * try/catch and surface the message via `z.string().refine()` so pack-load
+ * errors point at the offending `if:` clause via the source-path prefix
+ * already attached by `parseYamlFile`.
+ *
+ * Empty-string here is treated as an authoring mistake (the load-time
+ * surface should reject empties — only the runtime surface is forgiving per
+ * §12.2). Callers that want the runtime-style "empty is true" behavior
+ * should guard at the caller, not here.
+ */
+export declare function parseExpression(expr: string): ASTNode;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/evaluator/expression/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,EAAY,KAAK,OAAO,EAAE,MAAM,UAAU,CAAC;AAMlD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAkDnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQrD"}