@kanonak-protocol/expression 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -2,36 +2,95 @@
  * `@kanonak-protocol/expression` — the Kanonak expression RUNTIME.
  *
  * A small, deterministic tree-walker that folds a `kanonak.org/transformations`
- * (`tx`) + `kanonak.org/math` expression tree to a single number. Generated SDKs
+ * (`tx`) + `kanonak.org/math` expression tree to a value. Generated SDKs
  * reference it so a typed expression can be *run*, not just *represented*.
  *
  * Three layers, exactly as the six-language proof established:
  *
- *   1. DISPATCH — derived from the ontology. An operator's arity falls out of its
- *      `tx` superclass: UnaryNumericOp -> unary `value`; BinaryArithmetic /
- *      BinaryComparison -> binary; BooleanLogic -> n-ary `operands`; plus the two
- *      structural shapes the hierarchy can't imply (`Not`'s `operand`, `Clip`'s
- *      ternary). The OPERATOR_ARITY table below is that derivation, frozen.
+ *   1. DISPATCH — derived from the ontology. An operator's shape falls out of
+ *      its `tx` superclass: UnaryNumericOp -> unary `value`; BinaryArithmetic /
+ *      BinaryComparison -> binary; BooleanLogic -> n-ary `operands`;
+ *      ListSourcedExpression / ListAggregate -> `source`; IteratingExpression
+ *      -> `source` + `loopVar` + a body; plus the structural shapes the
+ *      hierarchy can't imply (`Not`'s `operand`, `Clip`'s ternary, `Contains`'
+ *      haystack/needle, `Matches`' matchSource/pattern). The tables below are
+ *      that derivation, frozen.
  *
- *   2. PRIMITIVES — the one authored, determinism-bearing artifact. PRIMITIVES
- *      maps each operator URI to its fold. Determinism traps live here and are
- *      matched in every language port (Round half-away-from-zero, floored Modulo,
- *      Sign(0)=0, comparisons as 1/0).
+ *   2. PRIMITIVES — the authored, determinism-bearing artifact. Tables map
+ *      each operator URI to its fold. Determinism traps live here and are
+ *      matched in every language port (Round half-away-from-zero, floored
+ *      Modulo, Sign(0)=0, comparisons as 1/0, RFC 8785-style number
+ *      stringification in Join, the pinned Matches regex subset).
  *
  *   3. THE FOLD — `evaluate`, a fixed shape: operators recurse + apply a
- *      primitive; literals return their numeric value; EVERYTHING ELSE (a typed
- *      VarRef, a domain `Step`/`Time`/`Smooth`, any future leaf) is handed to the
- *      caller's `resolve(node, ctx, evaluate)`. The runtime is a pure operator
- *      engine; binding and domain-leaf semantics are the caller's business. It
- *      never privileges `tx.VarRef` — that is just one leaf a domain may resolve.
+ *      primitive; literals return their value; EVERYTHING ELSE (a typed
+ *      VarRef, a domain `Step`/`Time`/`Smooth`, a host graph read, any future
+ *      leaf) is handed to the caller's `resolve(node, ctx, evaluate)`. The
+ *      runtime is a pure operator engine; binding, graph access, and
+ *      domain-leaf semantics are the caller's business. A property read is
+ *      just a caller leaf that returns a list — the kernel NEVER touches a
+ *      graph.
  *
- * Value domain: uniform numeric. Booleans and comparison results are `1`/`0`, so
- * every language stays on one numeric path. `EXPRESSION_RUNTIME_VERSION` freezes
- * the determinism contract; a change to any primitive, value rule, or dispatch
- * requires a NEW version, never an edit in place.
+ * VALUE DOMAIN (expressionRuntimeVersion "2"): `number | string | ref | list`.
+ *
+ *   - Booleans and comparison results remain `1`/`0` numbers (the v1 rule).
+ *   - A `ref` is a canonical versionless URI identity (`{ ref: string }`),
+ *     compared by URI-key equality — the same identity rule the ordered
+ *     comparisons and `tx.Equals` share.
+ *   - A `list` is an ordered sequence of values.
+ *   - There is NO null/undefined: ABSENCE IS THE EMPTY LIST. A caller leaf
+ *     for a property with no values returns `[]`; `IsSet` distinguishes.
+ *
+ * ERROR CONTRACT (v2 extension of the v1 fail-loud discipline):
+ *
+ *   - COMPUTATIONS FAIL LOUD: an arithmetic/unary-numeric/boolean-logic
+ *     operator whose operand is not a number, an aggregate over a non-numeric
+ *     element, `Min`/`Max`/`Average` on an empty list, a nested list in
+ *     `Join`, a non-string `Matches` source, an out-of-subset `Matches`
+ *     pattern — all raise `ExpressionError`, never coerce.
+ *   - PREDICATES FAIL CLOSED: `Equals` and the ordering comparisons on
+ *     cross-kind or non-numeric operands return `0`, never error (the SHACL
+ *     and reference-engine rule: a non-comparable value is a falsified
+ *     constraint, not a crash).
+ *
+ * v1 COMPATIBILITY: the value domain is a strict superset and no numeric
+ * primitive changed — every v1 parity vector passes unchanged under v2. The
+ * conformance harness runs the v1 vector file through this kernel as the
+ * regression gate.
+ *
+ * LAMBDA BINDING (the one genuinely-new dispatch shape): the iterating
+ * operators (`Filter`, `ListMap`, `ForEach`) bind their `loopVar` per element.
+ * Within an iterating operator's body — and ONLY there — a `tx.VarRef` whose
+ * `varName` names a lexically-enclosing `loopVar` is resolved by the kernel to
+ * the bound element (innermost binder wins). Every other leaf, including a
+ * `VarRef` naming anything else, still goes to the caller's `resolve`. This is
+ * the scoped exception to "the kernel never privileges VarRef": VarRef is the
+ * bound-variable mechanism of the kernel's own binders, nothing more. The
+ * remaining iterating family (WindowedMap, PairwiseMap, Scan, DistinctBy,
+ * PartitionBy) is additive within v2 under this same reserved shape.
+ *
+ * `EXPRESSION_RUNTIME_VERSION` freezes the determinism contract; a change to
+ * any primitive, value rule, or dispatch entry requires a NEW version, never
+ * an edit in place. Adding an operator, or widening the Matches subset (an
+ * error becoming a defined result), is additive WITHIN a version.
  */
 /** The frozen expression-runtime version (determinism contract). Not hashed. */
-export declare const EXPRESSION_RUNTIME_VERSION = "1";
+export declare const EXPRESSION_RUNTIME_VERSION = "2";
+/**
+ * A reference value — a member's canonical versionless URI identity
+ * (`publisher/package/name`). Distinct from a string so `Equals` can hold the
+ * cross-kind-is-false rule: a URI is never equal to the string spelling of it.
+ */
+export interface RefValue {
+    ref: string;
+}
+/**
+ * The v2 value domain. Booleans are `1`/`0` numbers; absence is the empty
+ * list; there is no null.
+ */
+export type Value = number | string | RefValue | Value[];
+/** Discriminate a `RefValue` from the other object shape (arrays). */
+export declare function isRef(v: Value): v is RefValue;
 /** A node in the expression tree. `type` is the operator/literal/leaf canonical
  * URI (versionless: `publisher/package/name`); operand keys are the frozen `tx`
  * operand property local names. Unknown fields are ignored by the kernel and are
@@ -41,17 +100,116 @@ export interface ExprNode {
     [operandOrValue: string]: unknown;
 }
 /** Resolve any node the kernel does not recognise as an operator or literal — a
- * binding (`tx.VarRef`, a domain's typed `refersTo` VarRef) or a domain leaf
- * (`Step`, `Time`, `Smooth`…) — to a number. `ctx` is opaque caller state (the
- * binding env, a sim clock, integration state). `evaluate` is handed back so a
+ * binding (`tx.VarRef`, a domain's typed `refersTo` VarRef), a host graph read
+ * (a property-read leaf returning a list), or a domain leaf (`Step`, `Time`,
+ * `Smooth`…) — to a value. `ctx` is opaque caller state (the binding env, a
+ * graph handle, a sim clock, integration state). `evaluate` is handed back so a
  * domain leaf containing sub-expressions can recurse into the kernel. */
-export type Resolve<C> = (node: ExprNode, ctx: C, evaluate: (n: ExprNode, ctx: C) => number) => number;
+export type Resolve<C> = (node: ExprNode, ctx: C, evaluate: (n: ExprNode, ctx: C) => Value) => Value;
+/**
+ * The transitive closures ordered comparisons consult, keyed by the ordering
+ * property's canonical URI, then by member: `closures[property][from]` is the
+ * set of members `from` reaches. Flat, already-closed data — typically the
+ * SDK reasoner's `prp-trp` saturation emitted at code-generation time. The
+ * kernel does set membership only; it NEVER computes a closure, resolves a
+ * package, or reasons. Supplying the closure is the caller's business, the
+ * same division that keeps variable binding out of the kernel.
+ */
+export type ClosureTable = Record<string, Record<string, readonly string[]>>;
+/** Resolve an identity leaf inside an ordered comparison — any operand node
+ * that is not a `tx.UriLiteral` — to a member's canonical versionless URI
+ * (`publisher/package/name`). The identity-domain mirror of {@link Resolve}:
+ * the kernel owns the constant leaf, the caller owns bindings. */
+export type ResolveRef<C> = (node: ExprNode, ctx: C) => string;
+/** Optional evaluation context for the ordered comparisons (`IsAtLeast`,
+ * `Dominates`). Absent (or missing a needed entry), an ordered comparison
+ * fails loudly — never a silent false from a missing table. */
+export interface EvalOptions<C> {
+    closures?: ClosureTable;
+    resolveRef?: ResolveRef<C>;
+}
 export declare class ExpressionError extends Error {
 }
 /**
- * Evaluate an expression tree to a number. Operators fold via the frozen
- * dispatch + primitive tables; literals yield their numeric value; any other
- * node is delegated to `resolve`.
+ * Validate a `Matches` pattern against the pinned subset — the intersection of
+ * RE2 and the host regex engines, chosen so every port compiles the same
+ * pattern to the same language. RE2 is both the restrictive common denominator
+ * and ReDoS-safe (no catastrophic backtracking), which is a REQUIREMENT for a
+ * predicate that may gate on adversarial input. Out-of-subset constructs are a
+ * LOUD error, the same discipline as Round/Modulo; WIDENING the subset later
+ * (an error becoming a defined result) is additive within v2.
+ *
+ * COUNTING UNIT — pinned: `.` and quantifiers count Unicode CODE POINTS, in
+ * every port. An astral-plane character (a surrogate pair in UTF-16 hosts)
+ * is ONE `.`, and `.{3}` matches exactly three code points — matching RE2's
+ * rune model and Python's, and what SHACL/SPARQL string length means. The
+ * UTF-16 engines must opt in (this port compiles with the `u` flag; Java
+ * and C# ports normalize equivalently) — without the pin, `.{m,n}` counts
+ * different units across exactly these seven targets, and the length
+ * lowering (`(?s)^.{m,}$`) would judge astral input differently per
+ * language. The astral vectors gate this: a port that counts code units
+ * fails conformance, not the tenant.
+ *
+ * Allowed: literals; `.`; anchors `^` `$`; alternation `|`; groups `(...)`,
+ * `(?:...)`; a WHOLE-PATTERN flag prefix over `i`/`m`/`s` (`(?i)` at position
+ * 0 only — each port translates it to its host flag mechanism); quantifiers
+ * `*` `+` `?` `{m}` `{m,}` `{m,n}`; character classes with ranges and
+ * negation; escapes `\d \D \w \W \s \S \b \B \n \r \t \f \v \xHH`, escaped
+ * syntax punctuation (`\.` `\*` `\+` `\?` `\(` `\)` `\[` `\]` `\{` `\}`
+ * `\|` `\^` `\$` `\\` `\/`), and `\-` inside character classes.
+ *
+ * Rejected (divergent or unsafe across engines): lookahead/lookbehind, named
+ * groups, backreferences (`\1`…, `\k`), MID-pattern flag groups (`(?i:…)` —
+ * not portable to the JS and Python engines), `\p{…}`/`\P{…}` unicode
+ * property classes, POSIX classes (`[[:alpha:]]`), class intersection
+ * (`&&`), atomic groups, conditionals, comments, octal/`\u`/`\x{…}` escapes,
+ * escaped space (`\ `), `\-` outside a class, and a bare unescaped `{` that
+ * is not a quantifier (literal braces must be escaped — engines disagree on
+ * the lenient reading, so the subset requires the explicit form).
+ */
+export declare function validateMatchesPattern(pattern: string): void;
+/**
+ * Evaluate an expression tree to a value. Operators fold via the frozen
+ * dispatch + primitive tables; literals yield their value; any other node is
+ * delegated to `resolve`. `options` carries the ordered-comparison context
+ * (closures + identity-leaf resolution) and is only consulted when an
+ * `IsAtLeast` / `Dominates` node is reached.
+ */
+export declare function evaluate<C = unknown>(node: ExprNode, ctx: C, resolve: Resolve<C>, options?: EvalOptions<C>): Value;
+/**
+ * One node of an evaluation trace — the verdict tree {@link explain} returns.
+ *
+ * Mirrors the expression: `type` is the node's type URI, `value` its result
+ * (`1`/`0` for booleans), `children` the operand traces in evaluation order.
+ * A short-circuited operand is simply ABSENT from `children` — the trace is
+ * truthful about what ran. An iterating operator's children are its source
+ * trace followed by one body trace per visited element. Ordered comparisons
+ * carry their resolved operand identities as `leftRef`/`rightRef` instead of
+ * children, since their operands are identities rather than value folds.
+ *
+ * This is a runtime return shape, not an ontology class: nothing authors a
+ * trace, so nothing about it is modelled or serialized as vocabulary. (A host
+ * assembling an AUTHORED report — e.g. a SHACL ValidationReport — builds it
+ * FROM these traces; the vocabulary lives with the host's ontology.)
+ */
+export interface TraceNode {
+    type: string;
+    value: Value;
+    children: TraceNode[];
+    leftRef?: string;
+    rightRef?: string;
+}
+/**
+ * Evaluate an expression tree and return the verdict tree — the regex-debugger
+ * view: every evaluated node, its own result, and (for ordered comparisons)
+ * the identities it compared. The root's `value` is exactly what
+ * {@link evaluate} returns for the same inputs; the conformance suite runs
+ * every vector through both and requires agreement, so the two entry points
+ * cannot drift. Kept separate from `evaluate` so the hot path never pays for
+ * trace allocation.
+ *
+ * Errors propagate exactly as in `evaluate` — a failed evaluation yields an
+ * error, not a partial trace.
  */
-export declare function evaluate<C = unknown>(node: ExprNode, ctx: C, resolve: Resolve<C>): number;
+export declare function explain<C = unknown>(node: ExprNode, ctx: C, resolve: Resolve<C>, options?: EvalOptions<C>): TraceNode;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAK9C;;;+CAG+C;AAC/C,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC;CACnC;AAED;;;;yEAIyE;AACzE,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,KAAK,MAAM,CAAC;AAEvG,qBAAa,eAAgB,SAAQ,KAAK;CAAG;AAgH7C;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CA8CzF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAK9C;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;GAGG;AACH,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,EAAE,CAAC;AAEzD,sEAAsE;AACtE,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,IAAI,QAAQ,CAE7C;AAED;;;+CAG+C;AAC/C,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC;CACnC;AAED;;;;;yEAKyE;AACzE,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,KAAK,CAAC;AAErG;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;AAE7E;;;kEAGkE;AAClE,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC;AAE/D;;+DAE+D;AAC/D,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CAC5B;AAED,qBAAa,eAAgB,SAAQ,KAAK;CAAG;AAmQ7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CA0E5D;AA+JD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GACvB,KAAK,CAEP;AA8KD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EACjC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GACvB,SAAS,CAyKX"}

package/dist/index.js

@@ -2,38 +2,86 @@
  * `@kanonak-protocol/expression` — the Kanonak expression RUNTIME.
  *
  * A small, deterministic tree-walker that folds a `kanonak.org/transformations`
- * (`tx`) + `kanonak.org/math` expression tree to a single number. Generated SDKs
+ * (`tx`) + `kanonak.org/math` expression tree to a value. Generated SDKs
  * reference it so a typed expression can be *run*, not just *represented*.
  *
  * Three layers, exactly as the six-language proof established:
  *
- *   1. DISPATCH — derived from the ontology. An operator's arity falls out of its
- *      `tx` superclass: UnaryNumericOp -> unary `value`; BinaryArithmetic /
- *      BinaryComparison -> binary; BooleanLogic -> n-ary `operands`; plus the two
- *      structural shapes the hierarchy can't imply (`Not`'s `operand`, `Clip`'s
- *      ternary). The OPERATOR_ARITY table below is that derivation, frozen.
+ *   1. DISPATCH — derived from the ontology. An operator's shape falls out of
+ *      its `tx` superclass: UnaryNumericOp -> unary `value`; BinaryArithmetic /
+ *      BinaryComparison -> binary; BooleanLogic -> n-ary `operands`;
+ *      ListSourcedExpression / ListAggregate -> `source`; IteratingExpression
+ *      -> `source` + `loopVar` + a body; plus the structural shapes the
+ *      hierarchy can't imply (`Not`'s `operand`, `Clip`'s ternary, `Contains`'
+ *      haystack/needle, `Matches`' matchSource/pattern). The tables below are
+ *      that derivation, frozen.
  *
- *   2. PRIMITIVES — the one authored, determinism-bearing artifact. PRIMITIVES
- *      maps each operator URI to its fold. Determinism traps live here and are
- *      matched in every language port (Round half-away-from-zero, floored Modulo,
- *      Sign(0)=0, comparisons as 1/0).
+ *   2. PRIMITIVES — the authored, determinism-bearing artifact. Tables map
+ *      each operator URI to its fold. Determinism traps live here and are
+ *      matched in every language port (Round half-away-from-zero, floored
+ *      Modulo, Sign(0)=0, comparisons as 1/0, RFC 8785-style number
+ *      stringification in Join, the pinned Matches regex subset).
  *
  *   3. THE FOLD — `evaluate`, a fixed shape: operators recurse + apply a
- *      primitive; literals return their numeric value; EVERYTHING ELSE (a typed
- *      VarRef, a domain `Step`/`Time`/`Smooth`, any future leaf) is handed to the
- *      caller's `resolve(node, ctx, evaluate)`. The runtime is a pure operator
- *      engine; binding and domain-leaf semantics are the caller's business. It
- *      never privileges `tx.VarRef` — that is just one leaf a domain may resolve.
- *
- * Value domain: uniform numeric. Booleans and comparison results are `1`/`0`, so
- * every language stays on one numeric path. `EXPRESSION_RUNTIME_VERSION` freezes
- * the determinism contract; a change to any primitive, value rule, or dispatch
- * requires a NEW version, never an edit in place.
+ *      primitive; literals return their value; EVERYTHING ELSE (a typed
+ *      VarRef, a domain `Step`/`Time`/`Smooth`, a host graph read, any future
+ *      leaf) is handed to the caller's `resolve(node, ctx, evaluate)`. The
+ *      runtime is a pure operator engine; binding, graph access, and
+ *      domain-leaf semantics are the caller's business. A property read is
+ *      just a caller leaf that returns a list — the kernel NEVER touches a
+ *      graph.
+ *
+ * VALUE DOMAIN (expressionRuntimeVersion "2"): `number | string | ref | list`.
+ *
+ *   - Booleans and comparison results remain `1`/`0` numbers (the v1 rule).
+ *   - A `ref` is a canonical versionless URI identity (`{ ref: string }`),
+ *     compared by URI-key equality — the same identity rule the ordered
+ *     comparisons and `tx.Equals` share.
+ *   - A `list` is an ordered sequence of values.
+ *   - There is NO null/undefined: ABSENCE IS THE EMPTY LIST. A caller leaf
+ *     for a property with no values returns `[]`; `IsSet` distinguishes.
+ *
+ * ERROR CONTRACT (v2 extension of the v1 fail-loud discipline):
+ *
+ *   - COMPUTATIONS FAIL LOUD: an arithmetic/unary-numeric/boolean-logic
+ *     operator whose operand is not a number, an aggregate over a non-numeric
+ *     element, `Min`/`Max`/`Average` on an empty list, a nested list in
+ *     `Join`, a non-string `Matches` source, an out-of-subset `Matches`
+ *     pattern — all raise `ExpressionError`, never coerce.
+ *   - PREDICATES FAIL CLOSED: `Equals` and the ordering comparisons on
+ *     cross-kind or non-numeric operands return `0`, never error (the SHACL
+ *     and reference-engine rule: a non-comparable value is a falsified
+ *     constraint, not a crash).
+ *
+ * v1 COMPATIBILITY: the value domain is a strict superset and no numeric
+ * primitive changed — every v1 parity vector passes unchanged under v2. The
+ * conformance harness runs the v1 vector file through this kernel as the
+ * regression gate.
+ *
+ * LAMBDA BINDING (the one genuinely-new dispatch shape): the iterating
+ * operators (`Filter`, `ListMap`, `ForEach`) bind their `loopVar` per element.
+ * Within an iterating operator's body — and ONLY there — a `tx.VarRef` whose
+ * `varName` names a lexically-enclosing `loopVar` is resolved by the kernel to
+ * the bound element (innermost binder wins). Every other leaf, including a
+ * `VarRef` naming anything else, still goes to the caller's `resolve`. This is
+ * the scoped exception to "the kernel never privileges VarRef": VarRef is the
+ * bound-variable mechanism of the kernel's own binders, nothing more. The
+ * remaining iterating family (WindowedMap, PairwiseMap, Scan, DistinctBy,
+ * PartitionBy) is additive within v2 under this same reserved shape.
+ *
+ * `EXPRESSION_RUNTIME_VERSION` freezes the determinism contract; a change to
+ * any primitive, value rule, or dispatch entry requires a NEW version, never
+ * an edit in place. Adding an operator, or widening the Matches subset (an
+ * error becoming a defined result), is additive WITHIN a version.
  */
 /** The frozen expression-runtime version (determinism contract). Not hashed. */
-export const EXPRESSION_RUNTIME_VERSION = '1';
+export const EXPRESSION_RUNTIME_VERSION = '2';
 const TX = 'kanonak.org/transformations';
 const MATH = 'kanonak.org/math';
+/** Discriminate a `RefValue` from the other object shape (arrays). */
+export function isRef(v) {
+    return typeof v === 'object' && !Array.isArray(v);
+}
 export class ExpressionError extends Error {
 }
 const UN = (operand) => ({ kind: 'unary', operand });
@@ -73,6 +121,23 @@ const OPERATOR_ARITY = {
     // semantics — handled explicitly in `evaluate`, not via the numeric tables.
     [`${MATH}/Clip`]: { kind: 'ternary', a: 'clipValue', b: 'clipLower', c: 'clipUpper' },
 };
+/** IteratingExpression operators: `source` + `loopVar` + the body operand. */
+const ITERATOR_BODY = {
+    [`${TX}/ForEach`]: 'emit',
+    [`${TX}/ListMap`]: 'mapBody',
+    [`${TX}/Filter`]: 'predicate',
+};
+/** KindPredicate operators the kernel can answer over ITS value domain.
+ * `IsBoolean` and `IsEmbedded` name kinds that exist only in a host object
+ * model (booleans are 1/0 numbers here; embedded nodes never enter the
+ * kernel), so they are NOT dispatch entries — they fall through to the
+ * caller's `resolve`, where the host answers with full fidelity. */
+const KIND_PREDICATES = {
+    [`${TX}/IsString`]: (v) => typeof v === 'string',
+    [`${TX}/IsNumber`]: (v) => typeof v === 'number',
+    [`${TX}/IsReference`]: (v) => typeof v === 'object' && !Array.isArray(v),
+    [`${TX}/IsList`]: (v) => Array.isArray(v),
+};
 /** Floored modulo (the host `%` truncates toward zero): Modulo(-7,3) = 2. */
 function flooredMod(a, b) {
     if (b === 0)
@@ -89,7 +154,21 @@ function requireDomain(ok, msg) {
     if (!ok)
         throw new ExpressionError(msg);
 }
-/** Unary/binary/ternary primitives, keyed by operator URI. The authored,
+/** A computation operand must be a number — fail loud, never coerce. */
+function requireNumber(v, op) {
+    if (typeof v !== 'number') {
+        throw new ExpressionError(`${op} requires a numeric operand, got ${kindOf(v)}`);
+    }
+    return v;
+}
+function kindOf(v) {
+    if (typeof v === 'number')
+        return 'number';
+    if (typeof v === 'string')
+        return 'string';
+    return Array.isArray(v) ? 'list' : 'ref';
+}
+/** Unary/binary numeric primitives, keyed by operator URI. The authored,
  * determinism-bearing table — matched per language. */
 const UNARY = {
     [`${TX}/Abs`]: (x) => Math.abs(x),
@@ -103,7 +182,7 @@ const UNARY = {
     [`${MATH}/Round`]: roundHalfAway,
     [`${MATH}/Sign`]: (x) => Math.sign(x),
 };
-const BINARY = {
+const BINARY_ARITH = {
     [`${TX}/Add`]: (a, b) => a + b,
     [`${TX}/Subtract`]: (a, b) => a - b,
     [`${TX}/Multiply`]: (a, b) => a * b,
@@ -112,39 +191,452 @@ const BINARY = {
     [`${MATH}/Modulo`]: flooredMod,
     [`${MATH}/Minimum`]: (a, b) => Math.min(a, b),
     [`${MATH}/Maximum`]: (a, b) => Math.max(a, b),
-    [`${TX}/Equals`]: (a, b) => bool(a === b),
+};
+/**
+ * Ordering comparisons are PREDICATES: on non-numeric operands they fail
+ * CLOSED (`0`), matching the reference engine and the SHACL rule that a
+ * non-comparable value falsifies a constraint. (Contrast the arithmetic
+ * table above, which fails loud.)
+ */
+const BINARY_ORDER = {
     [`${TX}/GreaterThan`]: (a, b) => bool(a > b),
     [`${TX}/LessThan`]: (a, b) => bool(a < b),
     [`${TX}/GreaterThanOrEqual`]: (a, b) => bool(a >= b),
     [`${TX}/LessThanOrEqual`]: (a, b) => bool(a <= b),
 };
-/** Numeric value of a literal node, or `undefined` if it is not a literal. */
+/**
+ * Polymorphic value equality — the full `tx.Equals` ontology contract
+ * (v1 implemented its numeric half):
+ *
+ *   - number/number, string/string: value equality.
+ *   - ref/ref: canonical versionless URI-key equality — identity-by-name,
+ *     the same rule as the ordered comparisons.
+ *   - lists: never equal (a list is a container, not a comparable value).
+ *   - any cross-kind pair: false. Never errors.
+ */
+function valuesEqual(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a === b;
+    if (typeof a === 'string' && typeof b === 'string')
+        return a === b;
+    if (typeof a === 'object' && typeof b === 'object' && !Array.isArray(a) && !Array.isArray(b)) {
+        return a.ref === b.ref;
+    }
+    return false;
+}
+/** Value of a literal node, or `undefined` if it is not a literal. In v2 the
+ * string and URI literals are kernel-known: `StringLiteral` yields its string,
+ * `UriLiteral` yields a ref value (its `refTo` IS its identity, the way an
+ * IntegerLiteral's number is its value). */
 function literalValue(node) {
     switch (node.type) {
         case `${TX}/IntegerLiteral`: return Number(node.integerLiteral);
         case `${TX}/DecimalLiteral`: return Number(node.decimalLiteral);
         case `${TX}/BooleanLiteral`: return bool(node.booleanLiteral === true || node.booleanLiteral === 'true');
+        case `${TX}/StringLiteral`: {
+            const s = node.stringLiteral;
+            if (typeof s !== 'string')
+                throw new ExpressionError('StringLiteral is missing stringLiteral');
+            return s;
+        }
+        case `${TX}/UriLiteral`: {
+            const ref = node.refTo;
+            if (typeof ref !== 'string' || ref.length === 0) {
+                throw new ExpressionError('UriLiteral is missing refTo');
+            }
+            return { ref };
+        }
         default: return undefined;
     }
 }
 /**
- * Evaluate an expression tree to a number. Operators fold via the frozen
- * dispatch + primitive tables; literals yield their numeric value; any other
- * node is delegated to `resolve`.
+ * Stringify one Join element. Numbers follow the ECMAScript number-to-string
+ * rule — the same serialization RFC 8785 (JCS) pins and the canonical layer
+ * already implements in every port, so Join output is deterministic across
+ * languages. Refs stringify to their LOCAL name (the reference-engine rule for
+ * display joins). A nested list is a computation type error — loud.
  */
-export function evaluate(node, ctx, resolve) {
-    const recurse = (n, c) => evaluate(n, c, resolve);
+function joinElement(v) {
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number')
+        return String(v);
+    if (Array.isArray(v))
+        throw new ExpressionError('Join cannot stringify a nested list');
+    return v.ref.slice(v.ref.lastIndexOf('/') + 1);
+}
+/** `IsSet`: absence is the empty list; the empty string is also unset (the
+ * reference-engine rule). Everything else — including `0` — is set. */
+function isSet(v) {
+    if (typeof v === 'string')
+        return v.length > 0;
+    if (Array.isArray(v))
+        return v.length > 0;
+    return true;
+}
+/** The `source`-operand fold table for the non-iterating list family. */
+const LIST_FOLDS = {
+    [`${TX}/Count`]: (list) => list.length,
+    [`${TX}/Sum`]: (list) => {
+        let total = 0;
+        for (const el of list)
+            total += requireNumber(el, 'Sum');
+        return total;
+    },
+    [`${TX}/Min`]: (list) => {
+        if (list.length === 0)
+            throw new ExpressionError('Min on an empty list is undefined; guard with IsSet');
+        let best = requireNumber(list[0], 'Min');
+        for (let i = 1; i < list.length; i++) {
+            const n = requireNumber(list[i], 'Min');
+            if (n < best)
+                best = n;
+        }
+        return best;
+    },
+    [`${TX}/Max`]: (list) => {
+        if (list.length === 0)
+            throw new ExpressionError('Max on an empty list is undefined; guard with IsSet');
+        let best = requireNumber(list[0], 'Max');
+        for (let i = 1; i < list.length; i++) {
+            const n = requireNumber(list[i], 'Max');
+            if (n > best)
+                best = n;
+        }
+        return best;
+    },
+    [`${TX}/Average`]: (list) => {
+        if (list.length === 0)
+            throw new ExpressionError('Average on an empty list is undefined; guard with IsSet');
+        let total = 0;
+        for (const el of list)
+            total += requireNumber(el, 'Average');
+        return total / list.length;
+    },
+    [`${TX}/Join`]: (list, node) => {
+        const sep = typeof node.separator === 'string' ? node.separator : '';
+        return list.map(joinElement).join(sep);
+    },
+    [`${TX}/Reverse`]: (list) => [...list].reverse(),
+};
+// ---------------------------------------------------------------------------
+// Matches — the pinned RE2-compatible XSD-regex subset.
+// ---------------------------------------------------------------------------
+/**
+ * Validate a `Matches` pattern against the pinned subset — the intersection of
+ * RE2 and the host regex engines, chosen so every port compiles the same
+ * pattern to the same language. RE2 is both the restrictive common denominator
+ * and ReDoS-safe (no catastrophic backtracking), which is a REQUIREMENT for a
+ * predicate that may gate on adversarial input. Out-of-subset constructs are a
+ * LOUD error, the same discipline as Round/Modulo; WIDENING the subset later
+ * (an error becoming a defined result) is additive within v2.
+ *
+ * COUNTING UNIT — pinned: `.` and quantifiers count Unicode CODE POINTS, in
+ * every port. An astral-plane character (a surrogate pair in UTF-16 hosts)
+ * is ONE `.`, and `.{3}` matches exactly three code points — matching RE2's
+ * rune model and Python's, and what SHACL/SPARQL string length means. The
+ * UTF-16 engines must opt in (this port compiles with the `u` flag; Java
+ * and C# ports normalize equivalently) — without the pin, `.{m,n}` counts
+ * different units across exactly these seven targets, and the length
+ * lowering (`(?s)^.{m,}$`) would judge astral input differently per
+ * language. The astral vectors gate this: a port that counts code units
+ * fails conformance, not the tenant.
+ *
+ * Allowed: literals; `.`; anchors `^` `$`; alternation `|`; groups `(...)`,
+ * `(?:...)`; a WHOLE-PATTERN flag prefix over `i`/`m`/`s` (`(?i)` at position
+ * 0 only — each port translates it to its host flag mechanism); quantifiers
+ * `*` `+` `?` `{m}` `{m,}` `{m,n}`; character classes with ranges and
+ * negation; escapes `\d \D \w \W \s \S \b \B \n \r \t \f \v \xHH`, escaped
+ * syntax punctuation (`\.` `\*` `\+` `\?` `\(` `\)` `\[` `\]` `\{` `\}`
+ * `\|` `\^` `\$` `\\` `\/`), and `\-` inside character classes.
+ *
+ * Rejected (divergent or unsafe across engines): lookahead/lookbehind, named
+ * groups, backreferences (`\1`…, `\k`), MID-pattern flag groups (`(?i:…)` —
+ * not portable to the JS and Python engines), `\p{…}`/`\P{…}` unicode
+ * property classes, POSIX classes (`[[:alpha:]]`), class intersection
+ * (`&&`), atomic groups, conditionals, comments, octal/`\u`/`\x{…}` escapes,
+ * escaped space (`\ `), `\-` outside a class, and a bare unescaped `{` that
+ * is not a quantifier (literal braces must be escaped — engines disagree on
+ * the lenient reading, so the subset requires the explicit form).
+ */
+export function validateMatchesPattern(pattern) {
+    const fail = (what) => {
+        throw new ExpressionError(`Matches pattern is outside the pinned regex subset (${what}): ${pattern}`);
+    };
+    // The u-legal intersection: character-class escapes, control escapes,
+    // \xHH, and escaped SYNTAX punctuation. `\-` is legal only INSIDE a class;
+    // `\ ` (escaped space) is not legal at all — both are Annex-B leniencies
+    // the code-point mode (and other engines) reject.
+    const ALLOWED_ESCAPES = new Set([
+        'd', 'D', 'w', 'W', 's', 'S', 'b', 'B', 'n', 'r', 't', 'f', 'v',
+        '.', '*', '+', '?', '(', ')', '[', ']', '{', '}', '|', '^', '$', '\\', '/',
+    ]);
+    let inClass = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '\\') {
+            const e = pattern[i + 1];
+            if (e === undefined)
+                fail('trailing backslash');
+            if (e === 'x') {
+                // \xHH only — \x{…} (RE2 long form) is not portable to the JS engine.
+                const hex = pattern.slice(i + 2, i + 4);
+                if (!/^[0-9a-fA-F]{2}$/.test(hex))
+                    fail('\\x escape must be \\xHH');
+                if (pattern[i + 2] === '{')
+                    fail('\\x{…} escape');
+                i += 3;
+                continue;
+            }
+            if (e >= '0' && e <= '9')
+                fail(`backreference or octal escape \\${e}`);
+            if (e === 'p' || e === 'P')
+                fail(`unicode property class \\${e}{…}`);
+            if (e === 'k')
+                fail('named backreference \\k');
+            if (e === 'u')
+                fail('\\u escape');
+            if (e === '-') {
+                if (!inClass)
+                    fail('\\- outside a character class');
+                i++;
+                continue;
+            }
+            if ((e === 'b' || e === 'B') && inClass) {
+                // In-class \b is backspace in JS but an error in RE2-family engines —
+                // reject the divergent reading; word boundaries are outside-class only.
+                fail(`\\${e} inside a character class`);
+            }
+            if ((e === 'D' || e === 'W' || e === 'S') && inClass) {
+                // A negated shorthand inside a class is inexpressible as a textual
+                // fragment under the pinned ASCII expansion — reject rather than
+                // inherit each engine's own reading.
+                fail(`\\${e} inside a character class`);
+            }
+            if (!ALLOWED_ESCAPES.has(e))
+                fail(`escape \\${e}`);
+            i++;
+            continue;
+        }
+        if (inClass) {
+            if (c === ']') {
+                inClass = false;
+                continue;
+            }
+            if (c === '&' && pattern[i + 1] === '&')
+                fail('character-class intersection &&');
+            if (c === '[' && pattern[i + 1] === ':')
+                fail('POSIX class [[:…:]]');
+            continue;
+        }
+        if (c === '[') {
+            inClass = true;
+            continue;
+        }
+        if (c === '(' && pattern[i + 1] === '?') {
+            // Only (?: survives mid-pattern; the flag prefix (?ims) is legal at
+            // position 0 ONLY (validated by splitFlagPrefix before this scanner).
+            if (pattern[i + 2] !== ':')
+                fail(`group construct (?${pattern[i + 2] ?? ''}`);
+            i += 2; // resume after '?:'
+            continue;
+        }
+        if (c === '{') {
+            // A bare `{` must start a valid quantifier — engines disagree on the
+            // lenient literal reading, so the SCANNER enforces the rule uniformly
+            // (a literal brace is written \{), not each host's compile behavior.
+            if (!/^\{\d+(,\d*)?\}/.test(pattern.slice(i))) {
+                fail("bare '{' that is not a quantifier (write \\{)");
+            }
+        }
+    }
+    if (inClass)
+        fail('unterminated character class');
+}
+/** Split the whole-pattern flag prefix — `(?i)`, `(?ims)` at position 0 —
+ * from the body. Each port translates the flags to its host mechanism (`i`
+ * case-fold, `m` multiline anchors, `s` dot-matches-newline). */
+function splitFlagPrefix(pattern) {
+    const m = /^\(\?([ims]+)\)/.exec(pattern);
+    if (!m)
+        return { flags: '', body: pattern };
+    return { flags: m[1], body: pattern.slice(m[0].length) };
+}
+/**
+ * The pinned ASCII expansions of the shorthand classes — the dialect defines
+ * `\d` `\w` `\s` BY these expansions, and every port applies them textually
+ * before compiling, because the native shorthands diverge across exactly our
+ * targets (Rust/Python `\d` matches Arabic-Indic digits; JS `\s` matches
+ * NBSP; `\b` is Unicode in Rust/Python, ASCII in JS/RE2). Outside a class
+ * the shorthand becomes a bracketed class; inside a class it splices as a
+ * fragment. `\b`/`\B` stay as-written — ASCII word boundaries, native in
+ * this engine (Rust: `(?-u:\b)`; Python: `re.ASCII`).
+ */
+const CLASS_EXPANSION_OUT = {
+    d: '[0-9]', D: '[^0-9]',
+    w: '[0-9A-Za-z_]', W: '[^0-9A-Za-z_]',
+    s: '[ \\t\\n\\r\\f\\x0B]', S: '[^ \\t\\n\\r\\f\\x0B]',
+};
+const CLASS_EXPANSION_IN = {
+    d: '0-9',
+    w: '0-9A-Za-z_',
+    s: ' \\t\\n\\r\\f\\x0B',
+};
+/** Apply the pinned ASCII expansions (subset-validated input, so every `\X`
+ * is a known escape and class boundaries are well-formed). Also pins the
+ * non-dotAll `.`: the dialect defines it as "any code point except \n" (the
+ * RE2/Python/Go norm) — THIS engine natively excludes \r/U+2028/U+2029 as
+ * well, so a non-dotAll `.` translates to `[^\n]`. Under `s`, every engine's
+ * dotAll means "everything" and `.` passes through. */
+function expandShorthandClasses(body, dotAll) {
+    let out = '';
+    let inClass = false;
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (c === '\\') {
+            const e = body[i + 1];
+            const table = inClass ? CLASS_EXPANSION_IN : CLASS_EXPANSION_OUT;
+            const expansion = table[e];
+            if (expansion !== undefined) {
+                out += expansion;
+            }
+            else {
+                out += c + e;
+            }
+            i++;
+            continue;
+        }
+        if (!inClass && c === '.' && !dotAll) {
+            out += '[^\\n]';
+            continue;
+        }
+        if (!inClass && c === '[')
+            inClass = true;
+        else if (inClass && c === ']')
+            inClass = false;
+        out += c;
+    }
+    return out;
+}
+/** Compile + test under fn:matches semantics: UNANCHORED (substring) — authors
+ * write `^…$` for a whole-string match. The flag prefix splits off first
+ * (translated to host RegExp flags), then the body is subset-validated, so
+ * the host engine only ever sees portable constructs. Always compiled with
+ * `u` — the pinned CODE-POINT counting unit (an astral character is one `.`;
+ * `.{m,n}` counts code points, matching RE2/Python and SHACL string length).
+ * `u` also rejects a bare literal `{`, turning an engine-divergent lenient
+ * reading into the subset's loud error. */
+function matchesPattern(input, pattern) {
+    const { flags, body } = splitFlagPrefix(pattern);
+    validateMatchesPattern(body);
+    let re;
+    try {
+        re = new RegExp(expandShorthandClasses(body, flags.includes('s')), flags + 'u');
+    }
+    catch {
+        throw new ExpressionError(`Matches pattern does not compile: ${pattern}`);
+    }
+    return re.test(input);
+}
+// ---------------------------------------------------------------------------
+// Ordered comparisons (unchanged from v1).
+// ---------------------------------------------------------------------------
+/**
+ * The identity an ordered comparison compares — a member's canonical
+ * versionless URI. `tx.UriLiteral` is the kernel-known constant leaf (its
+ * `refTo` IS the identity, the way a literal's value is its number); every
+ * other node is the caller's, through `resolveRef` — the same division as the
+ * numeric domain's literals-vs-`resolve`.
+ */
+function identityOf(node, ctx, options) {
+    if (node.type === `${TX}/UriLiteral`) {
+        const ref = node.refTo;
+        if (typeof ref !== 'string' || ref.length === 0) {
+            throw new ExpressionError('UriLiteral is missing refTo');
+        }
+        return ref;
+    }
+    if (!options?.resolveRef) {
+        throw new ExpressionError(`No resolveRef supplied for identity leaf '${node.type}'`);
+    }
+    return options.resolveRef(node, ctx);
+}
+/**
+ * Fold an ordered comparison (`IsAtLeast` / `Dominates`) to `1`/`0`.
+ *
+ * The ordering is the supplied closure for the node's `viaProperty` —
+ * membership in already-closed data, nothing more. Identity is canonical
+ * versionless URI string equality, matching `tx.Equals`' identity rule.
+ * `IsAtLeast` folds reflexivity into the operator (same member → 1) so a
+ * strictly-ordered vocabulary need not declare itself reflexive; `Dominates`
+ * is strict (same member → 0). Two members with no path yield 0 — the
+ * fail-closed direction for a predicate — but a MISSING closure table is a
+ * configuration failure and errors loudly.
+ */
+function foldOrdered(node, ctx, options) {
+    const via = node.viaProperty;
+    if (typeof via !== 'string' || via.length === 0) {
+        throw new ExpressionError(`${node.type} is missing viaProperty`);
+    }
+    const left = identityOf(operand(node, 'compareLeft'), ctx, options);
+    const right = identityOf(operand(node, 'compareRight'), ctx, options);
+    const closure = options?.closures?.[via];
+    if (!closure) {
+        throw new ExpressionError(`No closure supplied for ordering property '${via}'`);
+    }
+    const value = left === right
+        ? bool(node.type === `${TX}/IsAtLeast`)
+        : bool((closure[left] ?? []).includes(right));
+    return { value, left, right };
+}
+/** Innermost-wins lookup of a lambda-bound variable. */
+function boundValue(frames, name) {
+    for (let i = frames.length - 1; i >= 0; i--) {
+        if (frames[i].name === name)
+            return frames[i].value;
+    }
+    return undefined;
+}
+/**
+ * Evaluate an expression tree to a value. Operators fold via the frozen
+ * dispatch + primitive tables; literals yield their value; any other node is
+ * delegated to `resolve`. `options` carries the ordered-comparison context
+ * (closures + identity-leaf resolution) and is only consulted when an
+ * `IsAtLeast` / `Dominates` node is reached.
+ */
+export function evaluate(node, ctx, resolve, options) {
+    return evalNode(node, ctx, resolve, options, []);
+}
+/** `source` operand evaluated as a list: a scalar promotes to a one-element
+ * list (the reference-engine rule); an empty list is absence. */
+function evalSourceList(node, ctx, resolve, options, frames) {
+    const v = evalNode(operand(node, 'source'), ctx, resolve, options, frames);
+    return Array.isArray(v) ? v : [v];
+}
+function evalNode(node, ctx, resolve, options, frames) {
+    const recurse = (n, c) => evalNode(n, c, resolve, options, frames);
+    const recurseNumber = (n, c, op) => requireNumber(recurse(n, c), op);
     const arity = OPERATOR_ARITY[node.type];
     if (arity) {
         switch (arity.kind) {
             case 'unary': {
-                const x = recurse(operand(node, arity.operand), ctx);
+                const x = recurseNumber(operand(node, arity.operand), ctx, node.type);
                 return UNARY[node.type](x);
             }
             case 'binary': {
                 const a = recurse(operand(node, arity.left), ctx);
                 const b = recurse(operand(node, arity.right), ctx);
-                return BINARY[node.type](a, b);
+                if (node.type === `${TX}/Equals`)
+                    return bool(valuesEqual(a, b));
+                const order = BINARY_ORDER[node.type];
+                if (order) {
+                    // Predicate: non-numeric operands fail CLOSED.
+                    if (typeof a !== 'number' || typeof b !== 'number')
+                        return 0;
+                    return order(a, b);
+                }
+                // Arithmetic: computation — fail LOUD on non-numbers.
+                return BINARY_ARITH[node.type](requireNumber(a, node.type), requireNumber(b, node.type));
             }
             case 'nary': {
                 const items = node[arity.operands];
@@ -153,7 +645,7 @@ export function evaluate(node, ctx, resolve) {
                 const isAnd = node.type === `${TX}/And`;
                 // Short-circuit; empty And is vacuously true, empty Or vacuously false.
                 for (const item of items) {
-                    const v = truthy(recurse(item, ctx));
+                    const v = truthy(requireNumber(recurse(item, ctx), node.type));
                     if (isAnd && !v)
                         return 0;
                     if (!isAnd && v)
@@ -163,27 +655,280 @@ export function evaluate(node, ctx, resolve) {
             }
             case 'ternary': {
                 // Only Clip today: clamp clipValue into [clipLower, clipUpper].
-                const v = recurse(operand(node, arity.a), ctx);
-                const lo = recurse(operand(node, arity.b), ctx);
-                const hi = recurse(operand(node, arity.c), ctx);
+                const v = recurseNumber(operand(node, arity.a), ctx, node.type);
+                const lo = recurseNumber(operand(node, arity.b), ctx, node.type);
+                const hi = recurseNumber(operand(node, arity.c), ctx, node.type);
                 return Math.min(Math.max(v, lo), hi);
             }
         }
     }
     if (node.type === `${TX}/Not`) {
-        return bool(!truthy(recurse(operand(node, 'operand'), ctx)));
+        return bool(!truthy(requireNumber(recurse(operand(node, 'operand'), ctx), node.type)));
+    }
+    if (node.type === `${TX}/IsAtLeast` || node.type === `${TX}/Dominates`) {
+        return foldOrdered(node, ctx, options).value;
+    }
+    const listFold = LIST_FOLDS[node.type];
+    if (listFold) {
+        return listFold(evalSourceList(node, ctx, resolve, options, frames), node);
+    }
+    const body = ITERATOR_BODY[node.type];
+    if (body) {
+        const loopVar = node.loopVar;
+        if (typeof loopVar !== 'string' || loopVar.length === 0) {
+            throw new ExpressionError(`${node.type} is missing loopVar`);
+        }
+        const list = evalSourceList(node, ctx, resolve, options, frames);
+        const bodyNode = operand(node, body);
+        const out = [];
+        for (const el of list) {
+            const inner = [...frames, { name: loopVar, value: el }];
+            const v = evalNode(bodyNode, ctx, resolve, options, inner);
+            if (node.type === `${TX}/Filter`) {
+                if (truthy(requireNumber(v, 'Filter predicate')))
+                    out.push(el);
+            }
+            else if (node.type === `${TX}/ForEach`) {
+                // Flatten one level; an empty list contributes nothing — which is
+                // exactly the absence rule doing the reference engine's skip.
+                if (Array.isArray(v))
+                    out.push(...v);
+                else
+                    out.push(v);
+            }
+            else {
+                out.push(v);
+            }
+        }
+        return out;
+    }
+    if (node.type === `${TX}/Contains`) {
+        const haystack = evalNode(operand(node, 'haystack'), ctx, resolve, options, frames);
+        const needle = evalNode(operand(node, 'needle'), ctx, resolve, options, frames);
+        const list = Array.isArray(haystack) ? haystack : [haystack];
+        return bool(list.some((el) => valuesEqual(el, needle)));
+    }
+    if (node.type === `${TX}/IsSet`) {
+        return bool(isSet(evalNode(operand(node, 'checkExpr'), ctx, resolve, options, frames)));
+    }
+    if (node.type === `${TX}/ListItemAt`) {
+        const list = evalSourceList(node, ctx, resolve, options, frames);
+        const idx = evalNode(operand(node, 'itemIndex'), ctx, resolve, options, frames);
+        if (typeof idx !== 'number' || !Number.isInteger(idx) || idx < 0) {
+            throw new ExpressionError('ListItemAt itemIndex must be a non-negative integer');
+        }
+        // Past the end is ABSENCE, not an error — the empty list; guard with IsSet.
+        return idx < list.length ? list[idx] : [];
+    }
+    if (node.type === `${TX}/Matches`) {
+        const src = evalNode(operand(node, 'matchSource'), ctx, resolve, options, frames);
+        if (typeof src !== 'string') {
+            throw new ExpressionError(`Matches requires a string matchSource, got ${kindOf(src)}`);
+        }
+        const pattern = node.pattern;
+        if (typeof pattern !== 'string')
+            throw new ExpressionError('Matches is missing pattern');
+        return bool(matchesPattern(src, pattern));
+    }
+    const kind = KIND_PREDICATES[node.type];
+    if (kind) {
+        return bool(kind(evalNode(operand(node, 'kindCheck'), ctx, resolve, options, frames)));
     }
     const lit = literalValue(node);
     if (lit !== undefined)
         return lit;
-    // Not an operator or literal — a binding or domain leaf. The caller owns it.
-    return resolve(node, ctx, recurse);
+    // A VarRef naming a lexically-enclosing loopVar is the kernel's own bound
+    // variable — the ONLY leaf the kernel answers (see the header). Any other
+    // VarRef, and every other leaf, is the caller's.
+    if (node.type === `${TX}/VarRef` && typeof node.varName === 'string') {
+        const bound = boundValue(frames, node.varName);
+        if (bound !== undefined)
+            return bound;
+    }
+    // Not an operator or literal — a binding, graph read, or domain leaf. The
+    // caller owns it. (Recursion from inside `resolve` re-enters WITHOUT lambda
+    // frames: the caller's subtrees are the caller's scope.)
+    return resolve(node, ctx, (n, c) => evalNode(n, c, resolve, options, []));
 }
 function operand(node, key) {
     const v = node[key];
-    if (v === null || v === undefined || typeof v !== 'object') {
+    if (v === null || v === undefined || typeof v !== 'object' || Array.isArray(v)) {
         throw new ExpressionError(`${node.type} is missing operand '${key}'`);
     }
     return v;
 }
+/**
+ * Evaluate an expression tree and return the verdict tree — the regex-debugger
+ * view: every evaluated node, its own result, and (for ordered comparisons)
+ * the identities it compared. The root's `value` is exactly what
+ * {@link evaluate} returns for the same inputs; the conformance suite runs
+ * every vector through both and requires agreement, so the two entry points
+ * cannot drift. Kept separate from `evaluate` so the hot path never pays for
+ * trace allocation.
+ *
+ * Errors propagate exactly as in `evaluate` — a failed evaluation yields an
+ * error, not a partial trace.
+ */
+export function explain(node, ctx, resolve, options) {
+    // Value recursion for subtrees the caller's `resolve` re-enters: those
+    // folds happen inside the caller and are invisible to the trace, exactly
+    // like the caller's own computation. Only kernel-visited nodes appear.
+    const recurseValue = (n, c) => evalNode(n, c, resolve, options, []);
+    const trace = (n, c, frames) => {
+        const leaf = (value) => ({ type: n.type, value, children: [] });
+        const arity = OPERATOR_ARITY[n.type];
+        if (arity) {
+            switch (arity.kind) {
+                case 'unary': {
+                    const x = trace(operand(n, arity.operand), c, frames);
+                    return { type: n.type, value: UNARY[n.type](requireNumber(x.value, n.type)), children: [x] };
+                }
+                case 'binary': {
+                    const a = trace(operand(n, arity.left), c, frames);
+                    const b = trace(operand(n, arity.right), c, frames);
+                    let value;
+                    if (n.type === `${TX}/Equals`) {
+                        value = bool(valuesEqual(a.value, b.value));
+                    }
+                    else {
+                        const order = BINARY_ORDER[n.type];
+                        if (order) {
+                            value = typeof a.value !== 'number' || typeof b.value !== 'number'
+                                ? 0
+                                : order(a.value, b.value);
+                        }
+                        else {
+                            value = BINARY_ARITH[n.type](requireNumber(a.value, n.type), requireNumber(b.value, n.type));
+                        }
+                    }
+                    return { type: n.type, value, children: [a, b] };
+                }
+                case 'nary': {
+                    const items = n[arity.operands];
+                    if (!Array.isArray(items))
+                        throw new ExpressionError(`${n.type} expects an '${arity.operands}' list`);
+                    const isAnd = n.type === `${TX}/And`;
+                    const children = [];
+                    for (const item of items) {
+                        const child = trace(item, c, frames);
+                        children.push(child);
+                        const v = truthy(requireNumber(child.value, n.type));
+                        // Same short-circuit as `evaluate`: operands after the deciding
+                        // one are never evaluated and never appear in the trace.
+                        if (isAnd && !v)
+                            return { type: n.type, value: 0, children };
+                        if (!isAnd && v)
+                            return { type: n.type, value: 1, children };
+                    }
+                    return { type: n.type, value: bool(isAnd), children };
+                }
+                case 'ternary': {
+                    const v = trace(operand(n, arity.a), c, frames);
+                    const lo = trace(operand(n, arity.b), c, frames);
+                    const hi = trace(operand(n, arity.c), c, frames);
+                    return {
+                        type: n.type,
+                        value: Math.min(Math.max(requireNumber(v.value, n.type), requireNumber(lo.value, n.type)), requireNumber(hi.value, n.type)),
+                        children: [v, lo, hi],
+                    };
+                }
+            }
+        }
+        if (n.type === `${TX}/Not`) {
+            const x = trace(operand(n, 'operand'), c, frames);
+            return { type: n.type, value: bool(!truthy(requireNumber(x.value, n.type))), children: [x] };
+        }
+        if (n.type === `${TX}/IsAtLeast` || n.type === `${TX}/Dominates`) {
+            const r = foldOrdered(n, c, options);
+            return { type: n.type, value: r.value, children: [], leftRef: r.left, rightRef: r.right };
+        }
+        const listFold = LIST_FOLDS[n.type];
+        if (listFold) {
+            const src = trace(operand(n, 'source'), c, frames);
+            const list = Array.isArray(src.value) ? src.value : [src.value];
+            return { type: n.type, value: listFold(list, n), children: [src] };
+        }
+        const body = ITERATOR_BODY[n.type];
+        if (body) {
+            const loopVar = n.loopVar;
+            if (typeof loopVar !== 'string' || loopVar.length === 0) {
+                throw new ExpressionError(`${n.type} is missing loopVar`);
+            }
+            const src = trace(operand(n, 'source'), c, frames);
+            const list = Array.isArray(src.value) ? src.value : [src.value];
+            const bodyNode = operand(n, body);
+            const children = [src];
+            const out = [];
+            for (const el of list) {
+                const inner = [...frames, { name: loopVar, value: el }];
+                const bodyTrace = trace(bodyNode, c, inner);
+                children.push(bodyTrace);
+                const v = bodyTrace.value;
+                if (n.type === `${TX}/Filter`) {
+                    if (truthy(requireNumber(v, 'Filter predicate')))
+                        out.push(el);
+                }
+                else if (n.type === `${TX}/ForEach`) {
+                    if (Array.isArray(v))
+                        out.push(...v);
+                    else
+                        out.push(v);
+                }
+                else {
+                    out.push(v);
+                }
+            }
+            return { type: n.type, value: out, children };
+        }
+        if (n.type === `${TX}/Contains`) {
+            const hay = trace(operand(n, 'haystack'), c, frames);
+            const needle = trace(operand(n, 'needle'), c, frames);
+            const list = Array.isArray(hay.value) ? hay.value : [hay.value];
+            return {
+                type: n.type,
+                value: bool(list.some((el) => valuesEqual(el, needle.value))),
+                children: [hay, needle],
+            };
+        }
+        if (n.type === `${TX}/IsSet`) {
+            const x = trace(operand(n, 'checkExpr'), c, frames);
+            return { type: n.type, value: bool(isSet(x.value)), children: [x] };
+        }
+        if (n.type === `${TX}/ListItemAt`) {
+            const src = trace(operand(n, 'source'), c, frames);
+            const idx = trace(operand(n, 'itemIndex'), c, frames);
+            const list = Array.isArray(src.value) ? src.value : [src.value];
+            if (typeof idx.value !== 'number' || !Number.isInteger(idx.value) || idx.value < 0) {
+                throw new ExpressionError('ListItemAt itemIndex must be a non-negative integer');
+            }
+            const value = idx.value < list.length ? list[idx.value] : [];
+            return { type: n.type, value, children: [src, idx] };
+        }
+        if (n.type === `${TX}/Matches`) {
+            const src = trace(operand(n, 'matchSource'), c, frames);
+            if (typeof src.value !== 'string') {
+                throw new ExpressionError(`Matches requires a string matchSource, got ${kindOf(src.value)}`);
+            }
+            const pattern = n.pattern;
+            if (typeof pattern !== 'string')
+                throw new ExpressionError('Matches is missing pattern');
+            return { type: n.type, value: bool(matchesPattern(src.value, pattern)), children: [src] };
+        }
+        const kind = KIND_PREDICATES[n.type];
+        if (kind) {
+            const x = trace(operand(n, 'kindCheck'), c, frames);
+            return { type: n.type, value: bool(kind(x.value)), children: [x] };
+        }
+        const lit = literalValue(n);
+        if (lit !== undefined)
+            return leaf(lit);
+        if (n.type === `${TX}/VarRef` && typeof n.varName === 'string') {
+            const bound = boundValue(frames, n.varName);
+            if (bound !== undefined)
+                return leaf(bound);
+        }
+        return leaf(resolve(n, c, recurseValue));
+    };
+    return trace(node, ctx, []);
+}
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kanonak-protocol/expression",
-  "version": "0.1.0",
-  "description": "The Kanonak expression runtime (expressionRuntimeVersion \"1\") — a deterministic tree-walker that folds a kanonak.org/transformations + kanonak.org/math expression to a number, verified against the shared parity vectors. The behavior every generated SDK evaluates through.",
+  "version": "0.3.0",
+  "description": "The Kanonak expression runtime (expressionRuntimeVersion \"2\") — a deterministic tree-walker that folds a kanonak.org/transformations + kanonak.org/math expression to a value (number | string | ref | list), verified against the shared parity vectors. The behavior every generated SDK evaluates through.",
   "license": "Apache-2.0",
   "homepage": "https://kanonak.org",
   "author": "Kanonak Maintainers (https://github.com/kanonak-protocol/runtime)",