@almadar/evaluator 2.41.0 → 2.43.0

package/dist/{index-BIg56YY8.d.ts → index-DY9A18IY.d.ts}

@@ -1,4 +1,4 @@
-import { UserContext, TraitConfig, NavItem, AgentContext, LlmContext, WorkspaceContext, SessionContext, MemoryContext, TraceContext, IntegrationContext, SExpr } from '@almadar/core';
+import { EntityRow, EventPayload, UserContext, RuntimeValue, TraitConfig, NavItem, AgentContext, LlmContext, WorkspaceContext, SessionContext, MemoryContext, TraceContext, IntegrationContext, SExpr } from '@almadar/core';
 
 /**
  * Evaluation Context
@@ -15,9 +15,9 @@ import { UserContext, TraitConfig, NavItem, AgentContext, LlmContext, WorkspaceC
  */
 interface EvaluationContext {
     /** Entity data for @entity bindings */
-    entity: Record<string, unknown>;
+    entity: EntityRow;
     /** Payload data for @payload bindings */
-    payload: Record<string, unknown>;
+    payload: EventPayload;
     /** Current state for @state binding */
     state: string;
     /** Current timestamp for @now binding (defaults to Date.now()) */
@@ -25,9 +25,9 @@ interface EvaluationContext {
     /** User data for @user bindings (role-based UI) */
     user?: UserContext;
     /** Singleton entities for @EntityName bindings */
-    singletons: Map<string, Record<string, unknown>>;
+    singletons: Map<string, EntityRow>;
     /** Local variables from 'let' bindings */
-    locals?: Map<string, unknown>;
+    locals?: Map<string, RuntimeValue>;
     /**
      * Call-site trait config for @config bindings. Populated by
      * `OrbitalServerRuntime.executeEffects` from `RegisteredOrbital.configByTrait`.
@@ -80,40 +80,46 @@ interface EvaluationContext {
     trace?: TraceContext;
     integration?: IntegrationContext;
     /** Mutate entity fields */
-    mutateEntity?: (changes: Record<string, unknown>) => void;
+    mutateEntity?: (changes: Record<string, RuntimeValue>) => void;
     /** Emit an event */
-    emit?: (event: string, payload?: unknown) => void;
+    emit?: (event: string, payload?: RuntimeValue) => void;
     /** Navigate to a route */
-    navigate?: (route: string, params?: Record<string, unknown>) => void;
+    navigate?: (route: string, params?: Record<string, RuntimeValue>) => void;
     /** Persist data (create/update/delete/batch) */
-    persist?: (action: 'create' | 'update' | 'delete' | 'batch', data?: Record<string, unknown>) => Promise<void>;
+    persist?: (action: 'create' | 'update' | 'delete' | 'batch', data?: Record<string, RuntimeValue>) => Promise<void>;
     /** Show a notification */
     notify?: (message: string, type?: 'success' | 'error' | 'warning' | 'info') => void;
     /** Spawn a new entity instance */
-    spawn?: (entityType: string, props?: Record<string, unknown>) => void;
+    spawn?: (entityType: string, props?: Record<string, RuntimeValue>) => void;
     /** Despawn an entity instance */
     despawn?: (entityId?: string) => void;
     /** Call an external service */
-    callService?: (service: string, method: string, params?: Record<string, unknown>) => Promise<unknown>;
+    callService?: (service: string, method: string, params?: Record<string, RuntimeValue>) => Promise<RuntimeValue>;
     /** Render UI to a slot */
-    renderUI?: (slot: string, pattern: unknown, props?: Record<string, unknown>, priority?: number) => void;
+    renderUI?: (slot: string, pattern: RuntimeValue, props?: Record<string, RuntimeValue>, priority?: number) => void;
     /** Register an OS trigger (server-side only) */
-    registerOsTrigger?: (type: string, config: Record<string, unknown>) => void;
+    registerOsTrigger?: (type: string, config: Record<string, RuntimeValue>) => void;
     /** Effect handlers for resource operators (grouped to avoid top-level pollution) */
     effectHandlers?: {
-        ref?: (entityType: string, options?: unknown) => unknown;
-        deref?: (entityType: string, id?: unknown) => unknown;
-        swap?: (entityType: string, id: unknown, transformExpr: unknown, evaluate: unknown, ctx: unknown) => unknown;
-        watch?: (entityType: string, effects: unknown[], evaluate: unknown, ctx: unknown) => void;
-        atomic?: (effects: unknown[], evaluate: unknown, ctx: unknown) => unknown;
-        fetch?: (entityType: string, options?: unknown) => unknown;
+        ref?: (entityType: string, options?: RuntimeValue) => RuntimeValue;
+        deref?: (entityType: string, id?: RuntimeValue) => RuntimeValue;
+        swap?: (entityType: string, id: RuntimeValue, transformExpr: SExpr, evaluate: Evaluator$2, ctx: EvaluationContext) => RuntimeValue;
+        watch?: (entityType: string, effects: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext) => void;
+        atomic?: (effects: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext) => RuntimeValue;
+        fetch?: (entityType: string, options?: RuntimeValue) => RuntimeValue;
     };
 }
+/**
+ * The function operator implementations receive to evaluate child
+ * expressions — the interpreter's `evaluate` or a compiled tree's
+ * child-dispatch; both share this contract.
+ */
+type Evaluator$2 = (expr: SExpr, ctx: EvaluationContext) => RuntimeValue;
 /**
  * Create a minimal evaluation context for testing/guards.
  * Only includes bindings, no effect handlers.
  */
-declare function createMinimalContext(entity?: Record<string, unknown>, payload?: Record<string, unknown>, state?: string): EvaluationContext;
+declare function createMinimalContext(entity?: EntityRow, payload?: EventPayload, state?: string): EvaluationContext;
 /**
  * Create a context with effect handlers.
  * Used for runtime evaluation where effects need to execute.
@@ -123,8 +129,8 @@ declare function createEffectContext(base: EvaluationContext, handlers: Partial<
  * Create a child context with additional local bindings.
  * Used for 'let' expressions.
  */
-declare function createChildContext(parent: EvaluationContext, locals: Map<string, unknown>): EvaluationContext;
-declare function resolveBinding(binding: string, ctx: EvaluationContext): unknown;
+declare function createChildContext(parent: EvaluationContext, locals: Map<string, RuntimeValue>): EvaluationContext;
+declare function resolveBinding(binding: string, ctx: EvaluationContext): RuntimeValue;
 
 /**
  * Arithmetic Operator Implementations
@@ -132,55 +138,55 @@ declare function resolveBinding(binding: string, ctx: EvaluationContext): unknow
  * Implements: +, -, *, /, %, abs, min, max, floor, ceil, round, clamp
  */
 
-type Evaluator$5 = (expr: SExpr, ctx: EvaluationContext) => unknown;
+type Evaluator$1 = (expr: SExpr, ctx: EvaluationContext) => unknown;
 /**
  * Evaluate addition: ["+", a, b, ...]
  */
-declare function evalAdd(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalAdd(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate subtraction: ["-", a] (negate) or ["-", a, b] (subtract)
  */
-declare function evalSubtract(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalSubtract(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate multiplication: ["*", a, b, ...]
  */
-declare function evalMultiply(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalMultiply(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate division: ["/", a, b]
  */
-declare function evalDivide(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalDivide(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate modulo: ["%", a, b]
  */
-declare function evalModulo(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalModulo(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate absolute value: ["abs", a]
  */
-declare function evalAbs(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalAbs(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate minimum: ["min", a, b, ...]
  */
-declare function evalMin(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalMin(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate maximum: ["max", a, b, ...]
  */
-declare function evalMax(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalMax(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate floor: ["floor", a]
  */
-declare function evalFloor(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalFloor(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate ceiling: ["ceil", a]
  */
-declare function evalCeil(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalCeil(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate round: ["round", a]
  */
-declare function evalRound(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalRound(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 /**
  * Evaluate clamp: ["clamp", value, min, max]
  */
-declare function evalClamp(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+declare function evalClamp(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
 
 /**
  * Comparison Operator Implementations
@@ -188,37 +194,37 @@ declare function evalClamp(args: SExpr[], evaluate: Evaluator$5, ctx: Evaluation
  * Implements: =, !=, <, >, <=, >=
  */
 
-type Evaluator$4 = (expr: SExpr, ctx: EvaluationContext) => unknown;
+type Evaluator = (expr: SExpr, ctx: EvaluationContext) => unknown;
 /**
  * Evaluate equality: ["=", a, b]
  * Uses strict equality (===) for type safety.
  */
-declare function evalEqual(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalEqual(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 /**
  * Evaluate not-equal: ["!=", a, b]
  */
-declare function evalNotEqual(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalNotEqual(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 /**
  * Evaluate less-than: ["<", a, b]
  */
-declare function evalLessThan(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalLessThan(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 /**
  * Evaluate greater-than: [">", a, b]
  */
-declare function evalGreaterThan(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalGreaterThan(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 /**
  * Evaluate less-than-or-equal: ["<=", a, b]
  */
-declare function evalLessThanOrEqual(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalLessThanOrEqual(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 /**
  * Evaluate greater-than-or-equal: [">=", a, b]
  */
-declare function evalGreaterThanOrEqual(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalGreaterThanOrEqual(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 /**
  * Evaluate regex match: ["matches", subject, pattern]
  * Returns true if subject matches the regex pattern.
  */
-declare function evalMatches(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+declare function evalMatches(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): boolean;
 
 /**
  * Logic Operator Implementations
@@ -227,7 +233,6 @@ declare function evalMatches(args: SExpr[], evaluate: Evaluator$4, ctx: Evaluati
  * All logic operators support short-circuit evaluation.
  */
 
-type Evaluator$3 = (expr: SExpr, ctx: EvaluationContext) => unknown;
 /**
  * Evaluate logical AND: ["and", a, b, ...]
  * Operand semantics (matches JS `&&` and the compiled TS path — Phase 5,
@@ -237,7 +242,7 @@ type Evaluator$3 = (expr: SExpr, ctx: EvaluationContext) => unknown;
  * shipping behaviors — this is observationally identical to returning a
  * boolean.)
  */
-declare function evalAnd(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationContext): unknown;
+declare function evalAnd(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate logical OR: ["or", a, b, ...]
  * Operand semantics (matches JS `||` and the compiled TS path — Phase 5,
@@ -245,16 +250,16 @@ declare function evalAnd(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationCo
  * last argument's value if all are falsy. Short-circuits — does not evaluate
  * past the first truthy.
  */
-declare function evalOr(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationContext): unknown;
+declare function evalOr(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate logical NOT: ["not", a]
  */
-declare function evalNot(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationContext): boolean;
+declare function evalNot(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): boolean;
 /**
  * Evaluate conditional: ["if", condition, then, else]
  * Only evaluates the branch that matches the condition.
  */
-declare function evalIf(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationContext): unknown;
+declare function evalIf(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 
 /**
  * Control Operator Implementations
@@ -262,7 +267,6 @@ declare function evalIf(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationCon
  * Implements: let, do, when, fn
  */
 
-type Evaluator$2 = (expr: SExpr, ctx: EvaluationContext) => unknown;
 /**
  * Evaluate let binding.
  * Supports two formats:
@@ -280,22 +284,22 @@ type Evaluator$2 = (expr: SExpr, ctx: EvaluationContext) => unknown;
  * reference unresolved (`undefined`), silently corrupting any `let` with
  * dependent bindings.
  */
-declare function evalLet(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): unknown;
+declare function evalLet(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate do block: ["do", expr1, expr2, ...]
  * Executes expressions in sequence, returns last result.
  */
-declare function evalDo(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): unknown;
+declare function evalDo(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate when: ["when", condition, effect]
  * Executes effect only when condition is truthy.
  */
-declare function evalWhen(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
+declare function evalWhen(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate lambda: ["fn", varName, body] or ["fn", [vars], body]
  * Creates a function that can be passed to collection operators.
  */
-declare function evalFn(args: SExpr[], _evaluate: Evaluator$2, _ctx: EvaluationContext): (item: unknown, evaluate: Evaluator$2, ctx: EvaluationContext) => unknown;
+declare function evalFn(args: SExpr[], _evaluate: Evaluator$2, _ctx: EvaluationContext): (item: RuntimeValue, evaluate: Evaluator$2, ctx: EvaluationContext) => RuntimeValue;
 
 /**
  * Collection Operator Implementations
@@ -306,51 +310,50 @@ declare function evalFn(args: SExpr[], _evaluate: Evaluator$2, _ctx: EvaluationC
  * matching the Rust evaluator's approach.
  */
 
-type Evaluator$1 = (expr: SExpr, ctx: EvaluationContext) => unknown;
 /**
  * Evaluate map: ["map", collection, expr_using_@item]
  */
-declare function evalMap(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+declare function evalMap(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue[];
 /**
  * Evaluate filter: ["filter", collection, expr_using_@item]
  */
-declare function evalFilter(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+declare function evalFilter(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue[];
 /**
  * Evaluate find: ["find", collection, expr_using_@item]
  */
-declare function evalFind(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+declare function evalFind(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate count: ["count", collection]
  */
-declare function evalCount(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
+declare function evalCount(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): number;
 /**
  * Evaluate sum: ["sum", collection] or ["sum", collection, mapExpr_using_@item]
  */
-declare function evalSum(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
+declare function evalSum(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): number;
 /**
  * Evaluate first: ["first", collection]
  */
-declare function evalFirst(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+declare function evalFirst(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate last: ["last", collection]
  */
-declare function evalLast(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+declare function evalLast(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate nth: ["nth", collection, index]
  */
-declare function evalNth(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+declare function evalNth(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate concat: ["concat", collection1, collection2, ...]
  */
-declare function evalConcat(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+declare function evalConcat(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue[];
 /**
  * Evaluate includes: ["includes", collection, element]
  */
-declare function evalIncludes(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): boolean;
+declare function evalIncludes(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): boolean;
 /**
  * Evaluate empty: ["empty", collection]
  */
-declare function evalEmpty(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): boolean;
+declare function evalEmpty(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): boolean;
 /**
  * `(list a b c …)` — literal array constructor. Evaluates each argument and
  * returns them as a plain array. Lowering wraps a literal list bound for a
@@ -359,7 +362,7 @@ declare function evalEmpty(args: SExpr[], evaluate: Evaluator$1, ctx: Evaluation
  * operator name (e.g. `[path method …]` would otherwise be read as the `path`
  * operator call and collapse to a string).
  */
-declare function evalList(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+declare function evalList(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue[];
 
 /**
  * Effect Operator Implementations
@@ -369,15 +372,14 @@ declare function evalList(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationC
  * Effect operators have side effects and require effect handlers in the context.
  */
 
-type Evaluator = (expr: SExpr, ctx: EvaluationContext) => unknown;
 /**
  * Evaluate set: ["set", "@entity.field", value] or ["set", "@entity.field", value, operation]
  */
-declare function evalSet(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalSet(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate emit: ["emit", eventKey] or ["emit", eventKey, payload]
  */
-declare function evalEmit(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalEmit(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate persist:
  * - ["persist", action] or ["persist", action, data]
@@ -387,27 +389,27 @@ declare function evalEmit(args: SExpr[], evaluate: Evaluator, ctx: EvaluationCon
  *   Each operation is an S-expression: ["create", "collection", {...data}],
  *   ["update", "collection", "id", {...data}], or ["delete", "collection", "id"].
  */
-declare function evalPersist(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalPersist(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate navigate: ["navigate", route] or ["navigate", route, params]
  */
-declare function evalNavigate(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalNavigate(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate notify: ["notify", message] or ["notify", message, type]
  */
-declare function evalNotify(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalNotify(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate spawn: ["spawn", entityType] or ["spawn", entityType, props]
  */
-declare function evalSpawn(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalSpawn(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate despawn: ["despawn"] or ["despawn", entityId]
  */
-declare function evalDespawn(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalDespawn(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate call-service: ["call-service", service, method] or ["call-service", service, method, params]
  */
-declare function evalCallService(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalCallService(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate render-ui:
  * - ["render-ui", slot, pattern]
@@ -415,45 +417,45 @@ declare function evalCallService(args: SExpr[], evaluate: Evaluator, ctx: Evalua
  * - ["render-ui", slot, pattern, props, priority]
  * - ["render-ui", slot, null] - clears the slot
  */
-declare function evalRenderUI(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalRenderUI(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate set-dynamic: ["set-dynamic", pathExpr, value]
  * Used for dynamic field paths computed at runtime.
  * The pathExpr should evaluate to a dot-separated path string.
  */
-declare function evalSetDynamic(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalSetDynamic(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate increment: ["increment", "@entity.field"] or ["increment", "@entity.field", amount]
  */
-declare function evalIncrement(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalIncrement(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate decrement: ["decrement", "@entity.field"] or ["decrement", "@entity.field", amount]
  */
-declare function evalDecrement(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalDecrement(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate ref: ["ref", "EntityType"] or ["ref", "EntityType", { filter, include }]
  * Server-side: queries entity data. Client-side: subscribes to EntityStore.
  */
-declare function evalRef(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+declare function evalRef(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate deref: ["deref", "EntityType"] or ["deref", "EntityType", idExpr]
  * Pure snapshot read. Returns current entity data from store.
  */
-declare function evalDeref(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+declare function evalDeref(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate swap!: ["swap!", "EntityType", idExpr, transformExpr]
  * Atomic read-modify-write with CAS retry.
  */
-declare function evalSwap(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+declare function evalSwap(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 /**
  * Evaluate watch: ["watch", "EntityType", [effect1, effect2, ...]]
  * Client-only. Registers a callback on the EntityStore.
  */
-declare function evalWatch(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+declare function evalWatch(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
 /**
  * Evaluate atomic: ["atomic", [effect1, effect2, ...]]
  * Groups effects into a transaction. All succeed or all roll back.
  */
-declare function evalAtomic(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+declare function evalAtomic(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): RuntimeValue;
 
 export { evalSetDynamic as $, evalGreaterThanOrEqual as A, evalIf as B, evalIncludes as C, evalIncrement as D, type EvaluationContext as E, evalLast as F, evalLessThan as G, evalLessThanOrEqual as H, evalLet as I, evalList as J, evalMap as K, evalMatches as L, evalMax as M, evalMin as N, evalModulo as O, evalMultiply as P, evalNavigate as Q, evalNot as R, evalNotEqual as S, evalNotify as T, evalNth as U, evalOr as V, evalPersist as W, evalRef as X, evalRenderUI as Y, evalRound as Z, evalSet as _, createEffectContext as a, evalSpawn as a0, evalSubtract as a1, evalSum as a2, evalSwap as a3, evalWatch as a4, evalWhen as a5, resolveBinding as a6, createMinimalContext as b, createChildContext as c, evalAdd as d, evalAbs as e, evalAnd as f, evalAtomic as g, evalCallService as h, evalCeil as i, evalClamp as j, evalConcat as k, evalCount as l, evalDecrement as m, evalDeref as n, evalDespawn as o, evalDivide as p, evalDo as q, evalEmit as r, evalEmpty as s, evalEqual as t, evalFilter as u, evalFind as v, evalFirst as w, evalFloor as x, evalFn as y, evalGreaterThan as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { SExpr, ListenPayloadEvaluator } from '@almadar/core';
+import { SExpr, RuntimeValue, ListenPayloadEvaluator } from '@almadar/core';
 export { CORE_BINDINGS, CoreBinding, Expression, ExpressionSchema, ParsedBinding, SExpr, SExprAtom, SExprSchema, UserContext, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
-import { E as EvaluationContext } from './index-BIg56YY8.js';
-export { c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalAtomic, h as evalCallService, i as evalCeil, j as evalClamp, k as evalConcat, l as evalCount, m as evalDecrement, n as evalDeref, o as evalDespawn, p as evalDivide, q as evalDo, r as evalEmit, s as evalEmpty, t as evalEqual, u as evalFilter, v as evalFind, w as evalFirst, x as evalFloor, y as evalFn, z as evalGreaterThan, A as evalGreaterThanOrEqual, B as evalIf, C as evalIncludes, D as evalIncrement, F as evalLast, G as evalLessThan, H as evalLessThanOrEqual, I as evalLet, J as evalList, K as evalMap, L as evalMatches, M as evalMax, N as evalMin, O as evalModulo, P as evalMultiply, Q as evalNavigate, R as evalNot, S as evalNotEqual, T as evalNotify, U as evalNth, V as evalOr, W as evalPersist, X as evalRef, Y as evalRenderUI, Z as evalRound, _ as evalSet, $ as evalSetDynamic, a0 as evalSpawn, a1 as evalSubtract, a2 as evalSum, a3 as evalSwap, a4 as evalWatch, a5 as evalWhen, a6 as resolveBinding } from './index-BIg56YY8.js';
+import { E as EvaluationContext } from './index-DY9A18IY.js';
+export { c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalAtomic, h as evalCallService, i as evalCeil, j as evalClamp, k as evalConcat, l as evalCount, m as evalDecrement, n as evalDeref, o as evalDespawn, p as evalDivide, q as evalDo, r as evalEmit, s as evalEmpty, t as evalEqual, u as evalFilter, v as evalFind, w as evalFirst, x as evalFloor, y as evalFn, z as evalGreaterThan, A as evalGreaterThanOrEqual, B as evalIf, C as evalIncludes, D as evalIncrement, F as evalLast, G as evalLessThan, H as evalLessThanOrEqual, I as evalLet, J as evalList, K as evalMap, L as evalMatches, M as evalMax, N as evalMin, O as evalModulo, P as evalMultiply, Q as evalNavigate, R as evalNot, S as evalNotEqual, T as evalNotify, U as evalNth, V as evalOr, W as evalPersist, X as evalRef, Y as evalRenderUI, Z as evalRound, _ as evalSet, $ as evalSetDynamic, a0 as evalSpawn, a1 as evalSubtract, a2 as evalSum, a3 as evalSwap, a4 as evalWatch, a5 as evalWhen, a6 as resolveBinding } from './index-DY9A18IY.js';
 
 /**
  * S-Expression Evaluator
@@ -13,19 +13,45 @@ export { c as createChildContext, a as createEffectContext, b as createMinimalCo
  */
 
 /**
- * S-Expression Evaluator class.
- *
- * Provides runtime interpretation of S-expressions for guards, effects, and computed values.
+ * A compiled S-expression node: the operator impl and child closures are
+ * resolved once at compile time, so a firing pays zero dispatch, zero arity
+ * checks, and zero binding-path parsing.
  */
+type CompiledFn = (ctx: EvaluationContext) => RuntimeValue;
 declare class SExpressionEvaluator {
+    /**
+     * Tier-up compilation cache, keyed by node IDENTITY: schema trees are
+     * long-lived parsed objects, so a WeakMap costs no key serialization and
+     * is collected with the schema. First sight of a node interprets it and
+     * marks it seen; the second sight compiles it — one-off dynamically built
+     * expressions never pay compile cost.
+     */
+    private compileCache;
+    /** Single bound interpreter handed to operator impls — was allocated per dispatch. */
+    private readonly boundInterpret;
     /**
      * Evaluate an S-expression in the given context.
+     * Hot trees promote to compiled closures on second use; everything else
+     * runs through the interpreter.
      *
      * @param expr - S-expression to evaluate
      * @param ctx - Evaluation context with bindings and effect handlers
      * @returns Result of evaluation
      */
-    evaluate(expr: SExpr, ctx: EvaluationContext): unknown;
+    evaluate(expr: SExpr, ctx: EvaluationContext): RuntimeValue;
+    /**
+     * The tree-walking interpreter of record — first-use path and the
+     * compiler's fallback for foreign subtrees.
+     */
+    private interpret;
+    /**
+     * Compile one tree into composed closures. Every node of the tree is
+     * registered in `into` so the impls' `evaluate` callback (childDispatch)
+     * resolves in-tree children by identity and falls back to interpretation
+     * only for foreign subtrees. Arity is asserted HERE, once — a tree that
+     * compiles never re-validates.
+     */
+    private compileNode;
     private isPlainObject;
     /**
      * Evaluate an S-expression as a guard (returns boolean).
@@ -51,23 +77,27 @@ declare class SExpressionEvaluator {
     executeEffects(effects: SExpr[], ctx: EvaluationContext): void;
     /**
      * Compile an S-expression to a function for faster repeated evaluation.
-     * Uses a cache to avoid recompilation.
+     * Same machinery as the automatic tier-up in `evaluate`; explicit callers
+     * promote immediately instead of on second use.
      *
      * @param expr - S-expression to compile
      * @returns Function that evaluates the expression given a context
      */
-    compile(expr: SExpr): (ctx: EvaluationContext) => unknown;
+    compile(expr: SExpr): CompiledFn;
     /**
-     * Clear the JIT compilation cache.
+     * Clear the compilation cache.
      */
     clearCache(): void;
+    /**
+     * Dispatch to the appropriate operator implementation.
+     */
     /**
      * Dispatch to the appropriate operator implementation.
      */
     private dispatchOperator;
 }
 declare const evaluator: SExpressionEvaluator;
-declare function evaluate(expr: SExpr, ctx: EvaluationContext): unknown;
+declare function evaluate(expr: SExpr, ctx: EvaluationContext): RuntimeValue;
 declare function evaluateGuard(expr: SExpr, ctx: EvaluationContext): boolean;
 declare function executeEffect(expr: SExpr, ctx: EvaluationContext): void;
 declare function executeEffects(effects: SExpr[], ctx: EvaluationContext): void;