@almadar/evaluator 1.0.0

package/LICENSE

@@ -0,0 +1,72 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             Almadar FZE
+Licensed Work:        KFlow Builder / Almadar
+                      The Licensed Work is (c) 2025-2026 Almadar FZE.
+Additional Use Grant: You may make production use of the Licensed Work for
+                      non-commercial purposes and for internal evaluation.
+                      Production use for commercial purposes requires a
+                      commercial license from the Licensor.
+Change Date:          2030-02-01
+Change License:       Apache License, Version 2.0
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+---
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+ADDITIONAL TERMS:
+
+Documentation (builder/packages/website/docs/) is licensed under CC BY 4.0.
+
+TRADEMARKS:
+
+"Orbital", "KFlow", "Almadar", and the Almadar logo are trademarks of
+Almadar FZE. You may not use these trademarks without prior written
+permission from Almadar FZE.
+
+For licensing inquiries: licensing@almadar.io

package/dist/index-BBb9Y3Sp.d.ts

@@ -0,0 +1,498 @@
+import { z } from 'zod';
+
+/**
+ * S-Expression Types
+ *
+ * Defines the S-Expression type system for guards, effects, and computed values.
+ * S-expressions are JSON arrays where the first element is an operator string.
+ *
+ * @example
+ * // Guard: health > 0
+ * [">", "@entity.health", 0]
+ *
+ * // Effect: set x to x + vx
+ * ["set", "@entity.x", ["+", "@entity.x", "@entity.vx"]]
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * S-Expression type - recursive structure representing expressions.
+ *
+ * An S-expression is either:
+ * - A literal value (string, number, boolean, null)
+ * - An object literal (for payload data, props, etc.)
+ * - A binding reference (string starting with @)
+ * - A call expression (array with operator as first element)
+ */
+type SExprAtom = string | number | boolean | null | Record<string, unknown>;
+type SExpr = SExprAtom | SExpr[];
+/**
+ * Expression type - S-expressions only.
+ * Used for guards, computed values, and effect expressions.
+ *
+ * NOTE: Legacy string format is no longer supported.
+ * All expressions must be S-expression arrays.
+ */
+type Expression = SExpr;
+/**
+ * Recursive schema for S-expressions.
+ * Validates that arrays have at least one element and first element is a string (operator).
+ */
+declare const SExprSchema: z.ZodType<SExpr>;
+/**
+ * Schema for Expression type - S-expressions only.
+ * S-expressions are arrays with operator as first element.
+ *
+ * NOTE: Legacy string format is no longer supported.
+ */
+declare const ExpressionSchema: z.ZodType<Expression>;
+/**
+ * Type guard for S-expression detection.
+ * 100% reliable - structural check, no regex or keyword matching.
+ *
+ * @param value - Value to check
+ * @returns true if value is an S-expression (array with string operator)
+ */
+declare function isSExpr(value: unknown): value is SExpr[];
+/**
+ * Type guard for S-expression atoms (non-array values).
+ * Includes objects (for payload data, props, etc.)
+ */
+declare function isSExprAtom(value: unknown): value is SExprAtom;
+/**
+ * Check if a value is a binding reference.
+ * Bindings start with @ (e.g., @entity.health, @payload.amount, @now)
+ */
+declare function isBinding(value: unknown): value is string;
+/**
+ * Check if a value is a valid S-expression call (array with operator).
+ * Use this to distinguish between S-expression calls and atom values.
+ */
+declare function isSExprCall(value: unknown): value is SExpr[];
+/**
+ * Parsed binding reference
+ */
+interface ParsedBinding {
+    /** Type of binding: core (@entity, @payload, @state, @now) or entity (@EntityName) */
+    type: 'core' | 'entity';
+    /** The root binding name (entity, payload, state, now, or EntityName) */
+    root: string;
+    /** Path segments after the root (e.g., ['health'] for @entity.health) */
+    path: string[];
+    /** Full original binding string */
+    original: string;
+}
+/**
+ * Core bindings that are always available.
+ * Phase 4.5 adds: config, computed, trait (for behavior support)
+ */
+declare const CORE_BINDINGS: readonly ["entity", "payload", "state", "now", "config", "computed", "trait"];
+type CoreBinding = (typeof CORE_BINDINGS)[number];
+/**
+ * Parse a binding reference into its components.
+ * Does NOT use regex - uses structured string operations.
+ *
+ * @param binding - Binding string starting with @
+ * @returns Parsed binding object or null if invalid
+ */
+declare function parseBinding(binding: string): ParsedBinding | null;
+/**
+ * Validate a binding reference format.
+ *
+ * @param binding - Binding string to validate
+ * @returns true if valid binding format
+ */
+declare function isValidBinding(binding: string): boolean;
+/**
+ * Get the operator from an S-expression call.
+ *
+ * @param expr - S-expression array
+ * @returns The operator string or null if not a valid call
+ */
+declare function getOperator(expr: SExpr): string | null;
+/**
+ * Get the arguments from an S-expression call.
+ *
+ * @param expr - S-expression array
+ * @returns Array of arguments (empty if not a valid call)
+ */
+declare function getArgs(expr: SExpr): SExpr[];
+/**
+ * Create an S-expression call.
+ *
+ * @param operator - The operator string
+ * @param args - Arguments to the operator
+ * @returns S-expression array
+ */
+declare function sexpr(operator: string, ...args: SExpr[]): SExpr[];
+/**
+ * Walk an S-expression tree and apply a visitor function to each node.
+ *
+ * @param expr - S-expression to walk
+ * @param visitor - Function to call on each node
+ */
+declare function walkSExpr(expr: SExpr, visitor: (node: SExpr, parent: SExpr[] | null, index: number) => void, parent?: SExpr[] | null, index?: number): void;
+/**
+ * Collect all bindings referenced in an S-expression.
+ *
+ * @param expr - S-expression to analyze
+ * @returns Array of binding strings found
+ */
+declare function collectBindings(expr: SExpr): string[];
+
+/**
+ * Evaluation Context
+ *
+ * Defines the context for evaluating S-expressions at runtime.
+ * This context provides access to entity data, payload, state, and effect handlers.
+ *
+ * @packageDocumentation
+ */
+/**
+ * User context for @user bindings (role-based UI).
+ */
+interface UserContext {
+    /** User's unique ID */
+    id: string;
+    /** User's email */
+    email?: string;
+    /** User's display name */
+    name?: string;
+    /** User's role (for RBAC) */
+    role?: string;
+    /** User's permissions */
+    permissions?: string[];
+    /** Additional custom profile fields */
+    [key: string]: unknown;
+}
+/**
+ * Evaluation context for S-expression evaluation.
+ * Provides all bindings and effect handlers needed at runtime.
+ */
+interface EvaluationContext {
+    /** Entity data for @entity bindings */
+    entity: Record<string, unknown>;
+    /** Payload data for @payload bindings */
+    payload: Record<string, unknown>;
+    /** Current state for @state binding */
+    state: string;
+    /** Current timestamp for @now binding (defaults to Date.now()) */
+    now: number;
+    /** User data for @user bindings (role-based UI) */
+    user?: UserContext;
+    /** Singleton entities for @EntityName bindings */
+    singletons: Map<string, Record<string, unknown>>;
+    /** Local variables from 'let' bindings */
+    locals?: Map<string, unknown>;
+    /** Mutate entity fields */
+    mutateEntity?: (changes: Record<string, unknown>) => void;
+    /** Emit an event */
+    emit?: (event: string, payload?: unknown) => void;
+    /** Navigate to a route */
+    navigate?: (route: string, params?: Record<string, unknown>) => void;
+    /** Persist data (create/update/delete) */
+    persist?: (action: 'create' | 'update' | 'delete', data?: Record<string, unknown>) => 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;
+    /** Despawn an entity instance */
+    despawn?: (entityId?: string) => void;
+    /** Call an external service */
+    callService?: (service: string, method: string, params?: Record<string, unknown>) => Promise<unknown>;
+    /** Render UI to a slot */
+    renderUI?: (slot: string, pattern: unknown, props?: Record<string, unknown>, priority?: number) => void;
+}
+/**
+ * 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;
+/**
+ * Create a context with effect handlers.
+ * Used for runtime evaluation where effects need to execute.
+ */
+declare function createEffectContext(base: EvaluationContext, handlers: Partial<Pick<EvaluationContext, 'mutateEntity' | 'emit' | 'navigate' | 'persist' | 'notify' | 'spawn' | 'despawn' | 'callService' | 'renderUI'>>): EvaluationContext;
+/**
+ * Create a child context with additional local bindings.
+ * Used for 'let' expressions.
+ */
+declare function createChildContext(parent: EvaluationContext, locals: Map<string, unknown>): EvaluationContext;
+/**
+ * Resolve a binding in the context.
+ *
+ * @param binding - Binding string (e.g., "@entity.health", "@payload.amount")
+ * @param ctx - Evaluation context
+ * @returns Resolved value or undefined
+ */
+declare function resolveBinding(binding: string, ctx: EvaluationContext): unknown;
+
+/**
+ * Arithmetic Operator Implementations
+ *
+ * Implements: +, -, *, /, %, abs, min, max, floor, ceil, round, clamp
+ */
+
+type Evaluator$5 = (expr: SExpr, ctx: EvaluationContext) => unknown;
+/**
+ * Evaluate addition: ["+", a, b, ...]
+ */
+declare function evalAdd(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate subtraction: ["-", a] (negate) or ["-", a, b] (subtract)
+ */
+declare function evalSubtract(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate multiplication: ["*", a, b, ...]
+ */
+declare function evalMultiply(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate division: ["/", a, b]
+ */
+declare function evalDivide(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate modulo: ["%", a, b]
+ */
+declare function evalModulo(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate absolute value: ["abs", a]
+ */
+declare function evalAbs(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate minimum: ["min", a, b, ...]
+ */
+declare function evalMin(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate maximum: ["max", a, b, ...]
+ */
+declare function evalMax(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate floor: ["floor", a]
+ */
+declare function evalFloor(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate ceiling: ["ceil", a]
+ */
+declare function evalCeil(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate round: ["round", a]
+ */
+declare function evalRound(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+/**
+ * Evaluate clamp: ["clamp", value, min, max]
+ */
+declare function evalClamp(args: SExpr[], evaluate: Evaluator$5, ctx: EvaluationContext): number;
+
+/**
+ * Comparison Operator Implementations
+ *
+ * Implements: =, !=, <, >, <=, >=
+ */
+
+type Evaluator$4 = (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;
+/**
+ * Evaluate not-equal: ["!=", a, b]
+ */
+declare function evalNotEqual(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate less-than: ["<", a, b]
+ */
+declare function evalLessThan(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate greater-than: [">", a, b]
+ */
+declare function evalGreaterThan(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate less-than-or-equal: ["<=", a, b]
+ */
+declare function evalLessThanOrEqual(args: SExpr[], evaluate: Evaluator$4, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate greater-than-or-equal: [">=", a, b]
+ */
+declare function evalGreaterThanOrEqual(args: SExpr[], evaluate: Evaluator$4, 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;
+
+/**
+ * Logic Operator Implementations
+ *
+ * Implements: and, or, not, if
+ * All logic operators support short-circuit evaluation.
+ */
+
+type Evaluator$3 = (expr: SExpr, ctx: EvaluationContext) => unknown;
+/**
+ * Evaluate logical AND: ["and", a, b, ...]
+ * Short-circuits: returns false as soon as any argument is falsy.
+ */
+declare function evalAnd(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate logical OR: ["or", a, b, ...]
+ * Short-circuits: returns true as soon as any argument is truthy.
+ */
+declare function evalOr(args: SExpr[], evaluate: Evaluator$3, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate logical NOT: ["not", a]
+ */
+declare function evalNot(args: SExpr[], evaluate: Evaluator$3, 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;
+
+/**
+ * Control Operator Implementations
+ *
+ * Implements: let, do, when, fn
+ */
+
+type Evaluator$2 = (expr: SExpr, ctx: EvaluationContext) => unknown;
+/**
+ * Evaluate let binding: ["let", [[name, value], ...], body]
+ * Creates local bindings for use in body.
+ */
+declare function evalLet(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate do block: ["do", expr1, expr2, ...]
+ * Executes expressions in sequence, returns last result.
+ */
+declare function evalDo(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate when: ["when", condition, effect]
+ * Executes effect only when condition is truthy.
+ */
+declare function evalWhen(args: SExpr[], evaluate: Evaluator$2, ctx: EvaluationContext): void;
+/**
+ * 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;
+
+/**
+ * Collection Operator Implementations
+ *
+ * Implements: map, filter, find, count, sum, first, last, nth, concat, includes, empty
+ */
+
+type Evaluator$1 = (expr: SExpr, ctx: EvaluationContext) => unknown;
+/**
+ * Evaluate map: ["map", collection, ["fn", varName, body]]
+ */
+declare function evalMap(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+/**
+ * Evaluate filter: ["filter", collection, ["fn", varName, predicate]]
+ */
+declare function evalFilter(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+/**
+ * Evaluate find: ["find", collection, ["fn", varName, predicate]]
+ */
+declare function evalFind(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate count: ["count", collection]
+ */
+declare function evalCount(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
+/**
+ * Evaluate sum: ["sum", collection] or ["sum", collection, ["fn", varName, mapper]]
+ */
+declare function evalSum(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): number;
+/**
+ * Evaluate first: ["first", collection]
+ */
+declare function evalFirst(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate last: ["last", collection]
+ */
+declare function evalLast(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate nth: ["nth", collection, index]
+ */
+declare function evalNth(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate concat: ["concat", collection1, collection2, ...]
+ */
+declare function evalConcat(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
+/**
+ * Evaluate includes: ["includes", collection, element]
+ */
+declare function evalIncludes(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): boolean;
+/**
+ * Evaluate empty: ["empty", collection]
+ */
+declare function evalEmpty(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): boolean;
+
+/**
+ * Effect Operator Implementations
+ *
+ * Implements: set, emit, persist, navigate, notify, spawn, despawn, call-service, render-ui
+ *
+ * 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;
+/**
+ * Evaluate emit: ["emit", eventKey] or ["emit", eventKey, payload]
+ */
+declare function evalEmit(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate persist: ["persist", action] or ["persist", action, data]
+ * Actions: "create", "update", "delete"
+ */
+declare function evalPersist(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate navigate: ["navigate", route] or ["navigate", route, params]
+ */
+declare function evalNavigate(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate notify: ["notify", message] or ["notify", message, type]
+ */
+declare function evalNotify(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate spawn: ["spawn", entityType] or ["spawn", entityType, props]
+ */
+declare function evalSpawn(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate despawn: ["despawn"] or ["despawn", entityId]
+ */
+declare function evalDespawn(args: SExpr[], evaluate: Evaluator, 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;
+/**
+ * Evaluate render-ui:
+ * - ["render-ui", slot, pattern]
+ * - ["render-ui", slot, pattern, props]
+ * - ["render-ui", slot, pattern, props, priority]
+ * - ["render-ui", slot, null] - clears the slot
+ */
+declare function evalRenderUI(args: SExpr[], evaluate: Evaluator, 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;
+/**
+ * Evaluate increment: ["increment", "@entity.field"] or ["increment", "@entity.field", amount]
+ */
+declare function evalIncrement(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate decrement: ["decrement", "@entity.field"] or ["decrement", "@entity.field", amount]
+ */
+declare function evalDecrement(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+
+export { evalOr as $, evalFirst as A, evalFloor as B, CORE_BINDINGS as C, evalFn as D, type EvaluationContext as E, evalGreaterThan as F, evalGreaterThanOrEqual as G, evalIf as H, evalIncludes as I, evalIncrement as J, evalLast as K, evalLessThan as L, evalLessThanOrEqual as M, evalLet as N, evalMap as O, type ParsedBinding as P, evalMatches as Q, evalMax as R, type SExpr as S, evalMin as T, evalModulo as U, evalMultiply as V, evalNavigate as W, evalNot as X, evalNotEqual as Y, evalNotify as Z, evalNth as _, type CoreBinding as a, evalPersist as a0, evalRenderUI as a1, evalRound as a2, evalSet as a3, evalSetDynamic as a4, evalSpawn as a5, evalSubtract as a6, evalSum as a7, evalWhen as a8, getArgs as a9, getOperator as aa, isBinding as ab, isSExpr as ac, isSExprAtom as ad, isSExprCall as ae, isValidBinding as af, parseBinding as ag, resolveBinding as ah, sexpr as ai, walkSExpr as aj, type Expression as b, ExpressionSchema as c, type SExprAtom as d, SExprSchema as e, collectBindings as f, createChildContext as g, createEffectContext as h, createMinimalContext as i, evalAbs as j, evalAdd as k, evalAnd as l, evalCallService as m, evalCeil as n, evalClamp as o, evalConcat as p, evalCount as q, evalDecrement as r, evalDespawn as s, evalDivide as t, evalDo as u, evalEmit as v, evalEmpty as w, evalEqual as x, evalFilter as y, evalFind as z };

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import { S as SExpr, E as EvaluationContext } from './index-BBb9Y3Sp.js';
+export { C as CORE_BINDINGS, a as CoreBinding, b as Expression, c as ExpressionSchema, P as ParsedBinding, d as SExprAtom, e as SExprSchema, f as collectBindings, g as createChildContext, h as createEffectContext, i as createMinimalContext, j as evalAbs, k as evalAdd, l as evalAnd, m as evalCallService, n as evalCeil, o as evalClamp, p as evalConcat, q as evalCount, r as evalDecrement, s as evalDespawn, t as evalDivide, u as evalDo, v as evalEmit, w as evalEmpty, x as evalEqual, y as evalFilter, z as evalFind, A as evalFirst, B as evalFloor, D as evalFn, F as evalGreaterThan, G as evalGreaterThanOrEqual, H as evalIf, I as evalIncludes, J as evalIncrement, K as evalLast, L as evalLessThan, M as evalLessThanOrEqual, N as evalLet, O as evalMap, Q as evalMatches, R as evalMax, T as evalMin, U as evalModulo, V as evalMultiply, W as evalNavigate, X as evalNot, Y as evalNotEqual, Z as evalNotify, _ as evalNth, $ as evalOr, a0 as evalPersist, a1 as evalRenderUI, a2 as evalRound, a3 as evalSet, a4 as evalSetDynamic, a5 as evalSpawn, a6 as evalSubtract, a7 as evalSum, a8 as evalWhen, a9 as getArgs, aa as getOperator, ab as isBinding, ac as isSExpr, ad as isSExprAtom, ae as isSExprCall, af as isValidBinding, ag as parseBinding, ah as resolveBinding, ai as sexpr, aj as walkSExpr } from './index-BBb9Y3Sp.js';
+import 'zod';
+
+/**
+ * S-Expression Evaluator
+ *
+ * Runtime interpreter for S-expressions.
+ * Used for evaluating guards and executing effects in the preview system.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * S-Expression Evaluator class.
+ *
+ * Provides runtime interpretation of S-expressions for guards, effects, and computed values.
+ */
+declare class SExpressionEvaluator {
+    /**
+     * Evaluate an S-expression in the given context.
+     *
+     * @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 an S-expression as a guard (returns boolean).
+     *
+     * @param expr - S-expression guard
+     * @param ctx - Evaluation context
+     * @returns true if guard passes, false otherwise
+     */
+    evaluateGuard(expr: SExpr, ctx: EvaluationContext): boolean;
+    /**
+     * Execute an effect S-expression.
+     *
+     * @param expr - Effect S-expression (e.g., ["set", "@entity.x", 10])
+     * @param ctx - Evaluation context with effect handlers
+     */
+    executeEffect(expr: SExpr, ctx: EvaluationContext): void;
+    /**
+     * Execute multiple effects in sequence.
+     *
+     * @param effects - Array of effect S-expressions
+     * @param ctx - Evaluation context with effect handlers
+     */
+    executeEffects(effects: SExpr[], ctx: EvaluationContext): void;
+    /**
+     * Compile an S-expression to a function for faster repeated evaluation.
+     * Uses a cache to avoid recompilation.
+     *
+     * @param expr - S-expression to compile
+     * @returns Function that evaluates the expression given a context
+     */
+    compile(expr: SExpr): (ctx: EvaluationContext) => unknown;
+    /**
+     * Clear the JIT compilation cache.
+     */
+    clearCache(): void;
+    /**
+     * Dispatch to the appropriate operator implementation.
+     */
+    private dispatchOperator;
+}
+declare const evaluator: SExpressionEvaluator;
+declare function evaluate(expr: SExpr, ctx: EvaluationContext): unknown;
+declare function evaluateGuard(expr: SExpr, ctx: EvaluationContext): boolean;
+declare function executeEffect(expr: SExpr, ctx: EvaluationContext): void;
+declare function executeEffects(effects: SExpr[], ctx: EvaluationContext): void;
+
+export { EvaluationContext, SExpr, SExpressionEvaluator, evaluate, evaluateGuard, evaluator, executeEffect, executeEffects };