@seljs/runtime 1.0.0 → 1.0.1

package/dist/analysis/types.d.ts

@@ -1,113 +0,0 @@
-/**
- * Represents a contract call found in AST traversal.
- * Contains all information needed to execute the call and track dependencies.
- */
-export interface CollectedCall {
-    /**
-     * Unique identifier: "contract:method:serializedArgs"
-     */
-    id: string;
-    /**
-     * Contract name: e.g., "erc20_usdc"
-     */
-    contract: string;
-    /**
-     * Method name: e.g., "balanceOf"
-     */
-    method: string;
-    /**
-     * Arguments with type and dependency information
-     */
-    args: CallArgument[];
-    /**
-     * Reference to original AST node for error reporting
-     */
-    astNode: unknown;
-}
-/**
- * Argument to a contract call with type information.
- * Tracks whether the argument is a literal, variable, or result of another call.
- */
-export interface CallArgument {
-    /**
-     * Type of argument: literal value, variable reference, or call result
-     */
-    type: "literal" | "variable" | "call_result";
-    /**
-     * Literal value (when type is "literal")
-     */
-    value?: unknown;
-    /**
-     * Variable name (when type is "variable")
-     */
-    variableName?: string;
-    /**
-     * Call ID this depends on (when type is "call_result")
-     */
-    dependsOnCallId?: string;
-}
-/**
- * Dependency graph for all collected calls.
- * Maps call IDs to their nodes and dependency relationships.
- */
-export interface DependencyGraph {
-    /**
-     * Call ID to graph node mapping
-     */
-    nodes: Map<string, GraphNode>;
-    /**
-     * Call ID to set of call IDs it depends on
-     */
-    edges: Map<string, Set<string>>;
-}
-/**
- * Single node in the dependency graph.
- * Tracks both incoming and outgoing dependencies.
- */
-export interface GraphNode {
-    /**
-     * The original collected call
-     */
-    call: CollectedCall;
-    /**
-     * Call IDs this call depends on (must complete first)
-     */
-    dependsOn: string[];
-    /**
-     * Call IDs that depend on this call (will execute after)
-     */
-    dependedOnBy: string[];
-}
-/**
- * Execution plan with rounds of parallel calls.
- * Result of topological sorting the dependency graph.
- */
-export interface ExecutionPlan {
-    /**
-     * Rounds of calls to execute in sequence
-     */
-    rounds: ExecutionRound[];
-    /**
-     * Total number of calls across all rounds
-     */
-    totalCalls: number;
-    /**
-     * Number of rounds (maximum dependency depth)
-     */
-    maxDepth: number;
-}
-/**
- * Single round of calls that can execute in parallel.
- * All calls in a round have no dependencies on each other.
- */
-export interface ExecutionRound {
-    /**
-     * Round number (0-indexed)
-     */
-    roundNumber: number;
-    /**
-     * Calls that can execute in parallel this round
-     */
-    calls: CollectedCall[];
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/analysis/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/analysis/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,IAAI,EAAE,YAAY,EAAE,CAAC;IAErB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B;;OAEG;IACH,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC;IAE7C;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B;;OAEG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAE9B;;OAEG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB;;OAEG;IACH,IAAI,EAAE,aAAa,CAAC;IAEpB;;OAEG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,KAAK,EAAE,aAAa,EAAE,CAAC;CACvB"}

package/dist/analysis/types.js

@@ -1 +0,0 @@
-export {};

package/dist/debug.d.ts

@@ -1,13 +0,0 @@
-import createDebug from "debug";
-/**
- * Creates a namespaced debug logger for a SEL module.
- *
- * Enable via the `DEBUG` environment variable:
- * - `DEBUG=sel:*`           — all SEL logging
- * - `DEBUG=sel:evaluate`    — only evaluate flow
- * - `DEBUG=sel:execute:*`   — all execution sub-loggers
- *
- * @param namespace - Module namespace (e.g. "evaluate", "execute:round")
- */
-export declare const createLogger: (namespace: string) => createDebug.Debugger;
-//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,OAAO,CAAC;AAEhC;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,MAAM,KAAG,WAAW,CAAC,QAC7B,CAAC"}

package/dist/debug.js

@@ -1,12 +0,0 @@
-import createDebug from "debug";
-/**
- * Creates a namespaced debug logger for a SEL module.
- *
- * Enable via the `DEBUG` environment variable:
- * - `DEBUG=sel:*`           — all SEL logging
- * - `DEBUG=sel:evaluate`    — only evaluate flow
- * - `DEBUG=sel:execute:*`   — all execution sub-loggers
- *
- * @param namespace - Module namespace (e.g. "evaluate", "execute:round")
- */
-export const createLogger = (namespace) => createDebug(`sel:${namespace}`);

package/dist/environment/context.d.ts

@@ -1,3 +0,0 @@
-import type { CelCodecRegistry } from "@seljs/checker";
-export declare const normalizeContextForEvaluation: (context: Record<string, unknown>, variableTypes: Map<string, string>, codecRegistry: CelCodecRegistry) => Record<string, unknown>;
-//# sourceMappingURL=context.d.ts.map

package/dist/environment/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/environment/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,eAAO,MAAM,6BAA6B,GACzC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,eAAe,gBAAgB,KAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CASxB,CAAC"}

package/dist/environment/context.js

@@ -1,8 +0,0 @@
-export const normalizeContextForEvaluation = (context, variableTypes, codecRegistry) => {
-    const normalized = {};
-    for (const [key, value] of Object.entries(context)) {
-        const type = variableTypes.get(key);
-        normalized[key] = codecRegistry.resolve(type ?? "dyn").parse(value);
-    }
-    return normalized;
-};

package/dist/environment/contract-caller.d.ts

@@ -1,25 +0,0 @@
-import type { CelCodecRegistry } from "@seljs/checker";
-import type { ContractSchema, MethodSchema } from "@seljs/schema";
-import type { Abi, Address, PublicClient } from "viem";
-/**
- * Tracks total RPC calls (pre-executed + live) across a single evaluation.
- * Create one per `evaluate()` call and pass it through the handler closure.
- */
-export declare class CallCounter {
-    private readonly maxCalls;
-    private count;
-    constructor(maxCalls: number, initialCount?: number);
-    increment(contractName: string, methodName: string): void;
-}
-export declare const executeContractCall: (contract: ContractSchema, method: MethodSchema, args: unknown[], options: {
-    executionCache?: Map<string, unknown>;
-    client?: PublicClient;
-    codecRegistry?: CelCodecRegistry;
-    callCounter?: CallCounter;
-}) => Promise<unknown>;
-export declare const resolveExecutionBlockNumber: (client: PublicClient) => Promise<bigint | undefined>;
-export declare const buildContractInfoMap: (contracts: ContractSchema[]) => Map<string, {
-    abi: Abi;
-    address: Address;
-}>;
-//# sourceMappingURL=contract-caller.d.ts.map

package/dist/environment/contract-caller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-caller.d.ts","sourceRoot":"","sources":["../../src/environment/contract-caller.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAIvD;;;GAGG;AACH,qBAAa,WAAW;IAGtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF1B,OAAO,CAAC,KAAK,CAAK;gBAEA,QAAQ,EAAE,MAAM,EACjC,YAAY,GAAE,MAAU;IAKlB,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;CAqBhE;AAED,eAAO,MAAM,mBAAmB,GAC/B,UAAU,cAAc,EACxB,QAAQ,YAAY,EACpB,MAAM,OAAO,EAAE,EACf,SAAS;IACR,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC1B,KAEC,OAAO,CAAC,OAAO,CAwDjB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACvC,QAAQ,YAAY,KAClB,OAAO,CAAC,MAAM,GAAG,SAAS,CAe5B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAChC,WAAW,cAAc,EAAE,KACzB,GAAG,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAQ5C,CAAC"}

package/dist/environment/contract-caller.js

@@ -1,85 +0,0 @@
-import { readContract } from "viem/actions";
-import { createReplayCallId } from "./replay-cache.js";
-import { createLogger } from "../debug.js";
-import { ExecutionLimitError, SELContractError } from "../errors/index.js";
-const debug = createLogger("contract-caller");
-/**
- * Tracks total RPC calls (pre-executed + live) across a single evaluation.
- * Create one per `evaluate()` call and pass it through the handler closure.
- */
-export class CallCounter {
-    maxCalls;
-    count = 0;
-    constructor(maxCalls, initialCount = 0) {
-        this.maxCalls = maxCalls;
-        this.count = initialCount;
-    }
-    increment(contractName, methodName) {
-        this.count++;
-        if (this.count > this.maxCalls) {
-            throw new ExecutionLimitError(`Execution limit exceeded: ${String(this.count)} calls exceeds maxCalls (${String(this.maxCalls)})`, {
-                limitType: "maxCalls",
-                limit: this.maxCalls,
-                actual: this.count,
-            });
-        }
-        debug("call count: %d/%d (%s.%s)", this.count, this.maxCalls, contractName, methodName);
-    }
-}
-export const executeContractCall = async (contract, method, args, options) => {
-    const normalizedArgs = options.codecRegistry
-        ? args.map((arg, i) => options.codecRegistry.encode(method.params[i]?.type ?? "dyn", arg))
-        : args;
-    if (options.executionCache) {
-        const callId = createReplayCallId(contract.name, method.name, normalizedArgs);
-        if (options.executionCache.has(callId)) {
-            debug("cache hit: %s.%s", contract.name, method.name);
-            return options.executionCache.get(callId);
-        }
-        debug("cache miss: %s.%s — executing live", contract.name, method.name);
-    }
-    if (!options.client) {
-        throw new SELContractError("No client provided for contract call. Provide a client in SELRuntime config or evaluate() context.", {
-            contractName: contract.name,
-            methodName: method.name,
-        });
-    }
-    // Count live RPC calls against the limit
-    options.callCounter?.increment(contract.name, method.name);
-    try {
-        return await readContract(options.client, {
-            address: contract.address,
-            abi: [method.abi],
-            functionName: method.name,
-            args: normalizedArgs,
-        });
-    }
-    catch (error) {
-        if (error instanceof SELContractError) {
-            throw error;
-        }
-        throw new SELContractError(`Contract call failed: ${contract.name}.${method.name}`, {
-            cause: error,
-            contractName: contract.name,
-            methodName: method.name,
-        });
-    }
-};
-export const resolveExecutionBlockNumber = async (client) => {
-    const clientWithGetBlockNumber = client;
-    if (typeof clientWithGetBlockNumber.getBlockNumber === "function") {
-        return await clientWithGetBlockNumber.getBlockNumber();
-    }
-    if (typeof clientWithGetBlockNumber.request === "function") {
-        return undefined;
-    }
-    return 0n;
-};
-export const buildContractInfoMap = (contracts) => {
-    const map = new Map();
-    for (const contract of contracts) {
-        const abi = contract.methods.map((m) => m.abi);
-        map.set(contract.name, { abi, address: contract.address });
-    }
-    return map;
-};

package/dist/environment/environment.d.ts

@@ -1,81 +0,0 @@
-import type { SELRuntimeConfig } from "./types.js";
-import type { EvaluateOptions, EvaluateResult } from "../execution/types.js";
-import type { TypeCheckResult } from "@marcbachmann/cel-js";
-export declare class SELRuntime {
-    private readonly env;
-    private readonly client?;
-    private readonly schema;
-    private readonly variableTypes;
-    private readonly maxRounds;
-    private readonly maxCalls;
-    private readonly multicallOptions?;
-    private readonly contractBindings;
-    private readonly codecRegistry;
-    /**
-     * Per-evaluation mutable state.
-     *
-     * These fields are set before CEL evaluation and cleared in `finally`.
-     * They exist because the contract call handler closure (created in the
-     * constructor) needs access to per-evaluation context, but CEL's
-     * `Environment.parse()` returns a function that doesn't accept extra
-     * parameters beyond the variable bindings.
-     *
-     * Thread safety: The `mutex` field serializes concurrent `evaluate()`
-     * calls, ensuring these fields are never accessed concurrently.
-     *
-     * TODO: Consider refactoring to pass an EvaluationContext object through
-     * the handler closure instead of mutating instance state. This would
-     * eliminate the need for the mutex and make the code more testable.
-     * See .omc/drafts/context-object-spike.md for preliminary analysis.
-     */
-    private currentCache?;
-    private currentClient?;
-    private currentCallCounter?;
-    /** Mutex to serialize concurrent evaluate() calls (protects current* fields) */
-    private mutex;
-    /**
-     * Creates a new immutable SEL runtime with Solidity types pre-registered.
-     *
-     * Initializes the underlying CEL runtime, registers all Solidity primitive types,
-     * and processes any contracts and variables from the schema. After construction,
-     * the environment is fully configured and immutable.
-     *
-     * @param config - Configuration containing the SEL schema, optional viem client,
-     *   multicall settings, and CEL/execution limits (maxRounds defaults to 10, maxCalls to 100)
-     */
-    constructor(config: SELRuntimeConfig);
-    /**
-     * Type-checks an expression against registered variables and contract methods.
-     *
-     * @param expression - A CEL expression string to type-check
-     * @returns The type-check result containing validity, inferred type, and any errors
-     * @throws {@link SELTypeError} If the expression contains unrecoverable type errors
-     */
-    check(expression: string): TypeCheckResult;
-    /**
-     * Evaluates a SEL expression, executing any embedded contract calls on-chain.
-     *
-     * When contract calls are present, the full pipeline runs:
-     * 1. Parse the expression and collect contract calls from the AST
-     * 2. Type-check against registered variables and contract methods
-     * 3. Build a dependency graph and plan execution rounds
-     * 4. Execute contract calls via multicall3 batching at a pinned block number
-     * 5. Evaluate the CEL expression with resolved contract results and context values
-     * 6. Unwrap Solidity wrapper types back to native JS values (BigInt, string, etc.)
-     *
-     * @param expression A CEL expression string
-     * @param context Variable bindings for evaluation
-     * @param options Optional client override
-     * @returns An {@link EvaluateResult} containing the value and optional execution metadata
-     * @throws {@link SELParseError} If the expression has invalid syntax
-     * @throws {@link SELTypeError} If type-checking fails
-     * @throws {@link SELContractError} If a contract call fails or no client is available
-     * @throws {@link SELEvaluationError} If CEL evaluation fails
-     */
-    evaluate<T = unknown>(expression: string, context?: Record<string, unknown>, options?: EvaluateOptions): Promise<EvaluateResult<T>>;
-    private planExecution;
-    private executeContractCalls;
-    private doEvaluate;
-    private findContract;
-}
-//# sourceMappingURL=environment.d.ts.map

package/dist/environment/environment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/environment/environment.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErE,OAAO,KAAK,EACX,eAAe,EACf,cAAc,EAEd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAezE,qBAAa,UAAU;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA0B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IAEjD;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,YAAY,CAAC,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAAC,CAAe;IACrC,OAAO,CAAC,kBAAkB,CAAC,CAAc;IAEzC,gFAAgF;IAChF,OAAO,CAAC,KAAK,CAAqB;IAElC;;;;;;;;;OASG;gBACgB,MAAM,EAAE,gBAAgB;IAgE3C;;;;;;OAMG;IACI,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe;IAQjD;;;;;;;;;;;;;;;;;;;OAmBG;IACU,QAAQ,CAAC,CAAC,GAAG,OAAO,EAChC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAiB7B,OAAO,CAAC,aAAa;YA+CP,oBAAoB;YA0FpB,UAAU;IAyExB,OAAO,CAAC,YAAY;CAGpB"}

package/dist/environment/environment.js

@@ -1,279 +0,0 @@
-import { createRuntimeEnvironment } from "@seljs/checker";
-import { normalizeContextForEvaluation } from "./context.js";
-import { CallCounter, buildContractInfoMap, executeContractCall, resolveExecutionBlockNumber, } from "./contract-caller.js";
-import { wrapError } from "./error-wrapper.js";
-import { buildExecutionReplayCache } from "./replay-cache.js";
-import { collectCalls } from "../analysis/call-collector.js";
-import { analyzeDependencies } from "../analysis/dependency-analyzer.js";
-import { planRounds } from "../analysis/round-planner.js";
-import { createLogger } from "../debug.js";
-import { MulticallBatchError, SELContractError, SELTypeError, } from "../errors/index.js";
-import { MultiRoundExecutor } from "../execution/multi-round-executor.js";
-/**
- * Core SEL runtime that bridges CEL expression evaluation with EVM contract reads.
- *
- * Manages a CEL runtime extended with Solidity primitive types (uint256, address, bool, etc.),
- * registered smart contracts whose view functions become callable in expressions, and typed
- * variables that are supplied at evaluation time. Contract calls are automatically batched
- * via multicall3 and executed in dependency-ordered rounds.
- */
-const debug = createLogger("environment");
-export class SELRuntime {
-    env;
-    client;
-    schema;
-    variableTypes = new Map();
-    maxRounds;
-    maxCalls;
-    multicallOptions;
-    contractBindings;
-    codecRegistry;
-    /**
-     * Per-evaluation mutable state.
-     *
-     * These fields are set before CEL evaluation and cleared in `finally`.
-     * They exist because the contract call handler closure (created in the
-     * constructor) needs access to per-evaluation context, but CEL's
-     * `Environment.parse()` returns a function that doesn't accept extra
-     * parameters beyond the variable bindings.
-     *
-     * Thread safety: The `mutex` field serializes concurrent `evaluate()`
-     * calls, ensuring these fields are never accessed concurrently.
-     *
-     * TODO: Consider refactoring to pass an EvaluationContext object through
-     * the handler closure instead of mutating instance state. This would
-     * eliminate the need for the mutex and make the code more testable.
-     * See .omc/drafts/context-object-spike.md for preliminary analysis.
-     */
-    currentCache;
-    currentClient;
-    currentCallCounter;
-    /** Mutex to serialize concurrent evaluate() calls (protects current* fields) */
-    mutex = Promise.resolve();
-    /**
-     * Creates a new immutable SEL runtime with Solidity types pre-registered.
-     *
-     * Initializes the underlying CEL runtime, registers all Solidity primitive types,
-     * and processes any contracts and variables from the schema. After construction,
-     * the environment is fully configured and immutable.
-     *
-     * @param config - Configuration containing the SEL schema, optional viem client,
-     *   multicall settings, and CEL/execution limits (maxRounds defaults to 10, maxCalls to 100)
-     */
-    constructor(config) {
-        const limits = config.limits;
-        const celLimits = limits
-            ? {
-                maxAstNodes: limits.maxAstNodes,
-                maxDepth: limits.maxDepth,
-                maxListElements: limits.maxListElements,
-                maxMapEntries: limits.maxMapEntries,
-                maxCallArguments: limits.maxCallArguments,
-            }
-            : undefined;
-        this.maxRounds = limits?.maxRounds ?? 10;
-        this.maxCalls = limits?.maxCalls ?? 100;
-        this.multicallOptions = config.multicall;
-        this.client = config.client;
-        this.schema = config.schema;
-        // Build handler closure that captures `this` for contract execution
-        const handler = (contractName, methodName, args) => {
-            const contract = this.findContract(contractName);
-            if (!contract) {
-                throw new SELContractError(`Unknown contract "${contractName}"`, {
-                    contractName,
-                });
-            }
-            const method = contract.methods.find((m) => m.name === methodName);
-            if (!method) {
-                throw new SELContractError(`Unknown method "${contractName}.${methodName}"`, { contractName, methodName });
-            }
-            return executeContractCall(contract, method, args, {
-                executionCache: this.currentCache,
-                client: this.currentClient ?? this.client,
-                codecRegistry: this.codecRegistry,
-                callCounter: this.currentCallCounter,
-            });
-        };
-        // Create environment via unified hydration
-        const { env, contractBindings, codecRegistry } = createRuntimeEnvironment(this.schema, handler, { limits: celLimits, unlistedVariablesAreDyn: true });
-        this.env = env;
-        this.contractBindings = contractBindings;
-        this.codecRegistry = codecRegistry;
-        // Populate variableTypes from schema for normalizeContextForEvaluation
-        for (const v of this.schema.variables) {
-            this.variableTypes.set(v.name, v.type);
-        }
-    }
-    /**
-     * Type-checks an expression against registered variables and contract methods.
-     *
-     * @param expression - A CEL expression string to type-check
-     * @returns The type-check result containing validity, inferred type, and any errors
-     * @throws {@link SELTypeError} If the expression contains unrecoverable type errors
-     */
-    check(expression) {
-        try {
-            return this.env.check(expression);
-        }
-        catch (error) {
-            throw wrapError(error);
-        }
-    }
-    /**
-     * Evaluates a SEL expression, executing any embedded contract calls on-chain.
-     *
-     * When contract calls are present, the full pipeline runs:
-     * 1. Parse the expression and collect contract calls from the AST
-     * 2. Type-check against registered variables and contract methods
-     * 3. Build a dependency graph and plan execution rounds
-     * 4. Execute contract calls via multicall3 batching at a pinned block number
-     * 5. Evaluate the CEL expression with resolved contract results and context values
-     * 6. Unwrap Solidity wrapper types back to native JS values (BigInt, string, etc.)
-     *
-     * @param expression A CEL expression string
-     * @param context Variable bindings for evaluation
-     * @param options Optional client override
-     * @returns An {@link EvaluateResult} containing the value and optional execution metadata
-     * @throws {@link SELParseError} If the expression has invalid syntax
-     * @throws {@link SELTypeError} If type-checking fails
-     * @throws {@link SELContractError} If a contract call fails or no client is available
-     * @throws {@link SELEvaluationError} If CEL evaluation fails
-     */
-    async evaluate(expression, context, options) {
-        let release;
-        const prev = this.mutex;
-        this.mutex = new Promise((resolve) => {
-            release = resolve;
-        });
-        await prev;
-        try {
-            return await this.doEvaluate(expression, context, options);
-        }
-        finally {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            release();
-        }
-    }
-    planExecution(expression, evaluationContext) {
-        const parseResult = this.env.parse(expression);
-        const collectedCalls = collectCalls(parseResult.ast, {
-            get: (name) => this.findContract(name),
-        });
-        debug("evaluate: collected %d calls", collectedCalls.length);
-        const normalizedContext = Object.keys(evaluationContext).length
-            ? normalizeContextForEvaluation(evaluationContext, this.variableTypes, this.codecRegistry)
-            : undefined;
-        const executionVariables = Object.keys(evaluationContext).length
-            ? evaluationContext
-            : {};
-        const typeCheckResult = parseResult.check();
-        if (!typeCheckResult.valid) {
-            throw new SELTypeError(typeCheckResult.error?.message ?? "Type check failed", { cause: typeCheckResult.error });
-        }
-        return {
-            parseResult,
-            collectedCalls,
-            normalizedContext,
-            executionVariables,
-            typeCheckResult,
-        };
-    }
-    async executeContractCalls(collectedCalls, executionVariables, resolvedClient) {
-        debug("evaluate: calls to execute — %o", collectedCalls.map((c) => `${c.contract}.${c.method}`));
-        const graph = analyzeDependencies(collectedCalls);
-        const plan = planRounds(graph, {
-            maxRounds: this.maxRounds,
-            maxCalls: this.maxCalls,
-        });
-        const executor = new MultiRoundExecutor(resolvedClient, buildContractInfoMap(this.schema.contracts), this.multicallOptions);
-        let executionResult;
-        try {
-            executionResult = await executor.execute(plan, executionVariables, await resolveExecutionBlockNumber(resolvedClient));
-        }
-        catch (error) {
-            let failedCall = collectedCalls[0];
-            if (error instanceof MulticallBatchError) {
-                if (error.contractName && error.methodName) {
-                    const contractName = error.contractName;
-                    const methodName = error.methodName;
-                    const base = failedCall ?? {
-                        id: "",
-                        contract: contractName,
-                        method: methodName,
-                        args: [],
-                        astNode: undefined,
-                    };
-                    failedCall = {
-                        ...base,
-                        contract: contractName,
-                        method: methodName,
-                    };
-                }
-                else if (typeof error.failedCallIndex === "number") {
-                    failedCall = collectedCalls[error.failedCallIndex] ?? failedCall;
-                }
-            }
-            if (!failedCall) {
-                throw error;
-            }
-            throw new SELContractError(`Contract call failed: ${failedCall.contract}.${failedCall.method}`, {
-                cause: error,
-                contractName: failedCall.contract,
-                methodName: failedCall.method,
-            });
-        }
-        const executionMeta = executionResult.meta;
-        const executionCache = buildExecutionReplayCache(collectedCalls, executionResult.results, executionVariables, this.codecRegistry, (contract, method) => {
-            const c = this.findContract(contract);
-            const m = c?.methods.find((m) => m.name === method);
-            return m?.params.map((p) => p.type) ?? [];
-        });
-        return { executionMeta, executionCache };
-    }
-    async doEvaluate(expression, context, options) {
-        debug("evaluate: %s", expression);
-        const resolvedClient = options?.client ?? this.client;
-        try {
-            const { parseResult, collectedCalls, normalizedContext, executionVariables, typeCheckResult, } = this.planExecution(expression, context ?? {});
-            let executionMeta;
-            let executionCache;
-            if (collectedCalls.length > 0) {
-                if (!resolvedClient) {
-                    throw new SELContractError("No client provided for contract call. Provide a client in SELRuntime config or evaluate() options.", {
-                        contractName: collectedCalls[0]?.contract,
-                        methodName: collectedCalls[0]?.method,
-                    });
-                }
-                ({ executionMeta, executionCache } = await this.executeContractCalls(collectedCalls, executionVariables, resolvedClient));
-            }
-            // Set per-evaluation state for the handler closure
-            this.currentCache = executionCache;
-            this.currentClient = resolvedClient;
-            this.currentCallCounter = new CallCounter(this.maxCalls, executionMeta?.totalCalls ?? 0);
-            let result;
-            try {
-                result = await parseResult({
-                    ...normalizedContext,
-                    ...this.contractBindings,
-                });
-            }
-            finally {
-                this.currentCache = undefined;
-                this.currentClient = undefined;
-                this.currentCallCounter = undefined;
-            }
-            const value = (typeCheckResult.type
-                ? this.codecRegistry.encode(typeCheckResult.type, result)
-                : result);
-            debug("evaluate: result type=%s", typeof value);
-            return executionMeta ? { value, meta: executionMeta } : { value };
-        }
-        catch (error) {
-            throw wrapError(error);
-        }
-    }
-    findContract(name) {
-        return this.schema.contracts.find((c) => c.name === name);
-    }
-}

package/dist/environment/error-wrapper.d.ts

@@ -1,11 +0,0 @@
-/**
- * Wraps an unknown error into a known SEL error type.
- * - If the error is already a SEL error, it is returned as is.
- * - If the error is a CEL error, it is wrapped into the corresponding SEL error type.
- * - If the error is an unknown type, it is wrapped into a generic Error.
- *
- * @param error The error to wrap.
- * @returns The wrapped error.
- */
-export declare const wrapError: (error: unknown) => Error;
-//# sourceMappingURL=error-wrapper.d.ts.map

package/dist/environment/error-wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-wrapper.d.ts","sourceRoot":"","sources":["../../src/environment/error-wrapper.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KA2B1C,CAAC"}