@seljs/runtime 1.0.0

package/dist/execution/multi-round-executor.js

@@ -0,0 +1,47 @@
+import { getBlockNumber } from "viem/actions";
+import { MulticallBatcher } from "./multicall-batcher.js";
+import { ResultCache } from "./result-cache.js";
+import { RoundExecutor } from "./round-executor.js";
+import { createLogger } from "../debug.js";
+const debug = createLogger("execute");
+export class MultiRoundExecutor {
+    client;
+    multicallOptions;
+    contracts;
+    constructor(client, contracts, multicallOptions) {
+        this.client = client;
+        this.multicallOptions = multicallOptions;
+        this.contracts = contracts;
+    }
+    async execute(plan, variables = {}, blockNumber) {
+        const lockedBlockNumber = blockNumber ?? (await getBlockNumber(this.client));
+        debug("start: %d rounds, %d calls, block=%s", plan.rounds.length, plan.totalCalls, String(lockedBlockNumber));
+        const cache = new ResultCache();
+        const batcher = new MulticallBatcher(this.client, this.multicallOptions);
+        const executor = new RoundExecutor(this.contracts, cache, batcher);
+        const context = {
+            client: this.client,
+            blockNumber: lockedBlockNumber,
+            variables,
+        };
+        for (const round of plan.rounds) {
+            debug("round %d: %d calls", round.roundNumber, round.calls.length);
+            await executor.executeRound(round, context);
+        }
+        const results = new Map();
+        for (const round of plan.rounds) {
+            for (const call of round.calls) {
+                results.set(call.id, cache.get(call.id));
+            }
+        }
+        debug("complete: %d results collected", results.size);
+        return {
+            results,
+            meta: {
+                roundsExecuted: plan.rounds.length,
+                totalCalls: plan.totalCalls,
+                blockNumber: lockedBlockNumber,
+            },
+        };
+    }
+}

package/dist/execution/multicall-batcher.d.ts

@@ -0,0 +1,14 @@
+import { type MulticallCall, type MulticallResult } from "./multicall.js";
+import type { Address, PublicClient } from "viem";
+export declare class MulticallBatcher {
+    private readonly client;
+    private readonly address;
+    private readonly batchSize;
+    constructor(client: PublicClient, options?: {
+        address?: Address;
+        batchSize?: number;
+    });
+    executeBatch(calls: MulticallCall[], blockNumber: bigint): Promise<MulticallResult[]>;
+    private executeChunk;
+}
+//# sourceMappingURL=multicall-batcher.d.ts.map

package/dist/execution/multicall-batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multicall-batcher.d.ts","sourceRoot":"","sources":["../../src/execution/multicall-batcher.ts"],"names":[],"mappings":"AAEA,OAAO,EAEN,KAAK,aAAa,EAClB,KAAK,eAAe,EAEpB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,KAAK,EAAE,OAAO,EAAO,YAAY,EAAE,MAAM,MAAM,CAAC;AAIvD,qBAAa,gBAAgB;IAK3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGjB,MAAM,EAAE,YAAY,EACrC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAMvC,YAAY,CACxB,KAAK,EAAE,aAAa,EAAE,EACtB,WAAW,EAAE,MAAM,GACjB,OAAO,CAAC,eAAe,EAAE,CAAC;YA+Bf,YAAY;CAuB1B"}

package/dist/execution/multicall-batcher.js

@@ -0,0 +1,53 @@
+import { readContract } from "viem/actions";
+import { MULTICALL3_ADDRESS, multicall3Abi, } from "./multicall.js";
+import { createLogger } from "../debug.js";
+import { MulticallBatchError } from "../errors/index.js";
+const debug = createLogger("execute:multicall");
+export class MulticallBatcher {
+    client;
+    address;
+    batchSize;
+    constructor(client, options) {
+        this.client = client;
+        this.address = options?.address ?? MULTICALL3_ADDRESS;
+        this.batchSize = options?.batchSize ?? 200;
+    }
+    async executeBatch(calls, blockNumber) {
+        if (calls.length === 0) {
+            return [];
+        }
+        if (calls.length <= this.batchSize) {
+            debug("batch: %d calls (single chunk)", calls.length);
+            return await this.executeChunk(calls, blockNumber);
+        }
+        debug("batch: %d calls (chunked, batchSize=%d)", calls.length, this.batchSize);
+        const results = [];
+        for (let i = 0; i < calls.length; i += this.batchSize) {
+            const chunk = calls.slice(i, i + this.batchSize);
+            debug("chunk %d/%d", i / this.batchSize + 1, Math.ceil(calls.length / this.batchSize));
+            const chunkResults = await this.executeChunk(chunk, blockNumber);
+            results.push(...chunkResults);
+        }
+        return results;
+    }
+    async executeChunk(calls, blockNumber) {
+        try {
+            const result = (await readContract(this.client, {
+                address: this.address,
+                abi: multicall3Abi,
+                functionName: "aggregate3",
+                args: [calls],
+                blockNumber,
+            }));
+            return result.map((r) => ({
+                success: r.success,
+                returnData: r.returnData,
+            }));
+        }
+        catch (error) {
+            throw new MulticallBatchError("Multicall3 aggregate3 call failed", {
+                cause: error,
+            });
+        }
+    }
+}

package/dist/execution/multicall.d.ts

@@ -0,0 +1,42 @@
+import type { Address, Hex } from "viem";
+export declare const MULTICALL3_ADDRESS: Address;
+export declare const multicall3Abi: readonly [{
+    readonly name: "aggregate3";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly name: "allowFailure";
+            readonly type: "bool";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "returnData";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "success";
+            readonly type: "bool";
+        }, {
+            readonly name: "returnData";
+            readonly type: "bytes";
+        }];
+    }];
+}];
+export interface MulticallCall {
+    target: Address;
+    allowFailure: boolean;
+    callData: Hex;
+}
+export interface MulticallResult {
+    success: boolean;
+    returnData: Hex;
+}
+//# sourceMappingURL=multicall.d.ts.map

package/dist/execution/multicall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multicall.d.ts","sourceRoot":"","sources":["../../src/execution/multicall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEzC,eAAO,MAAM,kBAAkB,EAAE,OACY,CAAC;AAE9C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BhB,CAAC;AAEX,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,GAAG,CAAC;CAChB"}

package/dist/execution/multicall.js

@@ -0,0 +1,29 @@
+export const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export const multicall3Abi = [
+    {
+        name: "aggregate3",
+        type: "function",
+        stateMutability: "payable",
+        inputs: [
+            {
+                name: "calls",
+                type: "tuple[]",
+                components: [
+                    { name: "target", type: "address" },
+                    { name: "allowFailure", type: "bool" },
+                    { name: "callData", type: "bytes" },
+                ],
+            },
+        ],
+        outputs: [
+            {
+                name: "returnData",
+                type: "tuple[]",
+                components: [
+                    { name: "success", type: "bool" },
+                    { name: "returnData", type: "bytes" },
+                ],
+            },
+        ],
+    },
+];

package/dist/execution/result-cache.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Cache for storing contract call results during expression evaluation.
+ *
+ * Uses Map-based storage with deterministic call IDs for efficient
+ * lookup and deduplication of repeated contract calls.
+ */
+export declare class ResultCache {
+    private readonly cache;
+    /**
+     * Generate a deterministic call ID from contract details.
+     *
+     * The ID format is `contract:method:serializedArgs` where args are
+     * JSON-stringified with special handling for bigint values.
+     *
+     * @param contract - Contract name (e.g., "token", "vault")
+     * @param method - Method name (e.g., "balanceOf", "totalSupply")
+     * @param args - Method arguments
+     * @returns Deterministic call ID string
+     */
+    generateCallId(contract: string, method: string, args: unknown[]): string;
+    /**
+     * Store a result in the cache.
+     *
+     * @param callId - The call ID (from generateCallId)
+     * @param result - The result to cache
+     */
+    set(callId: string, result: unknown): void;
+    /**
+     * Retrieve a cached result.
+     *
+     * @param callId - The call ID to look up
+     * @returns The cached result, or undefined if not found
+     */
+    get(callId: string): unknown;
+    /**
+     * Check if a result is cached.
+     *
+     * @param callId - The call ID to check
+     * @returns true if cached, false otherwise
+     */
+    has(callId: string): boolean;
+    /**
+     * Clear all cached results.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=result-cache.d.ts.map

package/dist/execution/result-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-cache.d.ts","sourceRoot":"","sources":["../../src/execution/result-cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,WAAW;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IAEpD;;;;;;;;;;OAUG;IACI,cAAc,CACpB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO,EAAE,GACb,MAAM;IAoBT;;;;;OAKG;IACI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAIjD;;;;;OAKG;IACI,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAInC;;;;;OAKG;IACI,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAInC;;OAEG;IACI,KAAK,IAAI,IAAI;CAGpB"}

package/dist/execution/result-cache.js

@@ -0,0 +1,65 @@
+/**
+ * Cache for storing contract call results during expression evaluation.
+ *
+ * Uses Map-based storage with deterministic call IDs for efficient
+ * lookup and deduplication of repeated contract calls.
+ */
+export class ResultCache {
+    cache = new Map();
+    /**
+     * Generate a deterministic call ID from contract details.
+     *
+     * The ID format is `contract:method:serializedArgs` where args are
+     * JSON-stringified with special handling for bigint values.
+     *
+     * @param contract - Contract name (e.g., "token", "vault")
+     * @param method - Method name (e.g., "balanceOf", "totalSupply")
+     * @param args - Method arguments
+     * @returns Deterministic call ID string
+     */
+    generateCallId(contract, method, args) {
+        const argKey = JSON.stringify(args, (_, v) => {
+            if (typeof v === "bigint") {
+                return `${String(v)}n`;
+            }
+            if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+                return Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)));
+            }
+            return v;
+        });
+        return `${contract}:${method}:${argKey}`;
+    }
+    /**
+     * Store a result in the cache.
+     *
+     * @param callId - The call ID (from generateCallId)
+     * @param result - The result to cache
+     */
+    set(callId, result) {
+        this.cache.set(callId, result);
+    }
+    /**
+     * Retrieve a cached result.
+     *
+     * @param callId - The call ID to look up
+     * @returns The cached result, or undefined if not found
+     */
+    get(callId) {
+        return this.cache.get(callId);
+    }
+    /**
+     * Check if a result is cached.
+     *
+     * @param callId - The call ID to check
+     * @returns true if cached, false otherwise
+     */
+    has(callId) {
+        return this.cache.has(callId);
+    }
+    /**
+     * Clear all cached results.
+     */
+    clear() {
+        this.cache.clear();
+    }
+}

package/dist/execution/round-executor.d.ts

@@ -0,0 +1,18 @@
+import { type Abi, type Address } from "viem";
+import type { MulticallBatcher } from "./multicall-batcher.js";
+import type { ResultCache } from "./result-cache.js";
+import type { ExecutionContext } from "./types.js";
+import type { ExecutionRound } from "../analysis/types.js";
+export interface ContractInfo {
+    abi: Abi;
+    address: Address;
+}
+export declare class RoundExecutor {
+    private readonly contracts;
+    private readonly cache;
+    private readonly batcher;
+    constructor(contracts: Map<string, ContractInfo>, cache: ResultCache, batcher: MulticallBatcher);
+    executeRound(round: ExecutionRound, context: ExecutionContext): Promise<void>;
+    private resolveArgs;
+}
+//# sourceMappingURL=round-executor.d.ts.map

package/dist/execution/round-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-executor.d.ts","sourceRoot":"","sources":["../../src/execution/round-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,GAAG,EACR,KAAK,OAAO,EAGZ,MAAM,MAAM,CAAC;AAKd,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAIzE,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,OAAO,CAAC;CACjB;AAED,qBAAa,aAAa;IAExB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACpC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB;IAG9B,YAAY,CACxB,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,gBAAgB,GACvB,OAAO,CAAC,IAAI,CAAC;IA2EhB,OAAO,CAAC,WAAW;CA2BnB"}

package/dist/execution/round-executor.js

@@ -0,0 +1,95 @@
+import { decodeFunctionResult, encodeFunctionData, } from "viem";
+import { createLogger } from "../debug.js";
+import { MulticallBatchError } from "../errors/index.js";
+const debug = createLogger("execute:round");
+export class RoundExecutor {
+    contracts;
+    cache;
+    batcher;
+    constructor(contracts, cache, batcher) {
+        this.contracts = contracts;
+        this.cache = cache;
+        this.batcher = batcher;
+    }
+    async executeRound(round, context) {
+        const encodedCalls = [];
+        let failedCallIndex;
+        let failedCallContract;
+        let failedCallMethod;
+        try {
+            for (const [i, call] of round.calls.entries()) {
+                failedCallIndex = i;
+                failedCallContract = call.contract;
+                failedCallMethod = call.method;
+                const contract = this.contracts.get(call.contract);
+                if (!contract) {
+                    throw new Error(`No ABI registered for contract "${call.contract}"`);
+                }
+                const resolvedArgs = this.resolveArgs(call.args, context);
+                encodedCalls.push({
+                    target: contract.address,
+                    allowFailure: false,
+                    callData: encodeFunctionData({
+                        abi: contract.abi,
+                        functionName: call.method,
+                        args: resolvedArgs,
+                    }),
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof MulticallBatchError) {
+                throw error;
+            }
+            throw new MulticallBatchError("Failed to encode call", {
+                cause: error,
+                failedCallIndex,
+                contractName: failedCallContract,
+                methodName: failedCallMethod,
+            });
+        }
+        debug("encoding %d calls for multicall", encodedCalls.length);
+        const results = await this.batcher.executeBatch(encodedCalls, context.blockNumber);
+        for (const [i, call] of round.calls.entries()) {
+            const contract = this.contracts.get(call.contract);
+            if (!contract) {
+                throw new Error(`No ABI registered for contract "${call.contract}"`);
+            }
+            const result = results[i];
+            if (!result?.success) {
+                throw new MulticallBatchError(`Call failed: ${call.contract}.${call.method}`, {
+                    failedCallIndex: i,
+                    contractName: call.contract,
+                    methodName: call.method,
+                });
+            }
+            const decoded = decodeFunctionResult({
+                abi: contract.abi,
+                functionName: call.method,
+                data: result.returnData,
+            });
+            debug("decoded %s.%s -> %o", call.contract, call.method, decoded);
+            this.cache.set(call.id, decoded);
+        }
+    }
+    resolveArgs(args, context) {
+        return args.map((arg) => {
+            if (arg.type === "literal") {
+                return arg.value;
+            }
+            if (arg.type === "variable") {
+                const name = arg.variableName;
+                if (!name) {
+                    return undefined;
+                }
+                return context.variables[name];
+            }
+            // arg.type === "call_result"
+            const id = arg.dependsOnCallId;
+            if (!id) {
+                return undefined;
+            }
+            return this.cache.get(id);
+        });
+    }
+}

package/dist/execution/types.d.ts

@@ -0,0 +1,55 @@
+import type { PublicClient } from "viem";
+/**
+ * Metadata about the execution.
+ * Contains statistics and block information from the execution run.
+ */
+export interface ExecutionMeta {
+    /** Number of rounds executed (topological depth) */
+    roundsExecuted: number;
+    /** Total number of contract calls executed */
+    totalCalls: number;
+    /** Block number at which calls were executed */
+    blockNumber: bigint;
+}
+/**
+ * Result of executing an SEL expression with contract calls.
+ * Maps call IDs to their decoded results.
+ */
+export interface ExecutionResult {
+    /** Map of callId to decoded result value */
+    results: Map<string, unknown>;
+    /** Execution metadata */
+    meta: ExecutionMeta;
+}
+/**
+ * Context passed to the executor for running contract calls.
+ * Contains the client, block number, and variable bindings.
+ */
+export interface ExecutionContext {
+    /** Viem public client for making contract calls */
+    client: PublicClient;
+    /** Block number for consistent reads across all calls */
+    blockNumber: bigint;
+    /** Variable name to value mapping from evaluate() context */
+    variables: Record<string, unknown>;
+}
+/**
+ * Options for the evaluate() call.
+ */
+export interface EvaluateOptions {
+    /** Override viem client for this evaluation */
+    client?: PublicClient;
+}
+/**
+ * Result of evaluating a SEL expression.
+ *
+ * Always returned by `evaluate()`. The `meta` field is present when
+ * contract calls were executed, absent for pure CEL expressions.
+ */
+export interface EvaluateResult<T = unknown> {
+    /** The evaluated result value */
+    value: T;
+    /** Execution metadata, present when contract calls were executed */
+    meta?: ExecutionMeta;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/execution/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B,oDAAoD;IACpD,cAAc,EAAE,MAAM,CAAC;IAEvB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IAEnB,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,4CAA4C;IAC5C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9B,yBAAyB;IACzB,IAAI,EAAE,aAAa,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,mDAAmD;IACnD,MAAM,EAAE,YAAY,CAAC;IAErB,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;IAEpB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,+CAA+C;IAC/C,MAAM,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IAC1C,iCAAiC;IACjC,KAAK,EAAE,CAAC,CAAC;IAET,oEAAoE;IACpE,IAAI,CAAC,EAAE,aAAa,CAAC;CACrB"}

package/dist/execution/types.js

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

package/dist/factory.d.ts

@@ -0,0 +1,3 @@
+import { SELRuntime, type SELRuntimeConfig } from "./environment/index.js";
+export declare const createSEL: (config: SELRuntimeConfig) => SELRuntime;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,eAAO,MAAM,SAAS,GAAI,QAAQ,gBAAgB,KAAG,UAC9B,CAAC"}

package/dist/factory.js

@@ -0,0 +1,2 @@
+import { SELRuntime } from "./environment/index.js";
+export const createSEL = (config) => new SELRuntime(config);

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SEL (Solidity Expression Language) - CEL-based queries for EVM contracts.
+ * @module @seljs/runtime
+ */
+export * from "./environment/index.js";
+export * from "./errors/index.js";
+export * from "./factory.js";
+export type * from "./analysis/index.js";
+export type * from "./execution/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAG7B,mBAAmB,qBAAqB,CAAC;AACzC,mBAAmB,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+/**
+ * SEL (Solidity Expression Language) - CEL-based queries for EVM contracts.
+ * @module @seljs/runtime
+ */
+export * from "./environment/index.js";
+export * from "./errors/index.js";
+export * from "./factory.js";

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@seljs/runtime",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "abi group GmbH",
+    "email": "info@abigroup.io",
+    "url": "https://abigroup.io/"
+  },
+  "repository": {
+    "url": "https://github.com/abinnovision/seljs"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "format:check": "prettier --check '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
+    "format:fix": "prettier --write '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
+    "lint:check": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}'",
+    "lint:fix": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}' --fix",
+    "test-integration": "vitest run --config test/integration/vitest.config.ts",
+    "test-unit": "vitest run",
+    "test-unit:watch": "vitest watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@marcbachmann/cel-js": "^7.5.2",
+    "@seljs/checker": "1.0.0",
+    "@seljs/common": "1.0.0",
+    "@seljs/env": "1.0.0",
+    "@seljs/schema": "1.0.0",
+    "@seljs/types": "1.0.0",
+    "debug": "^4.4.3",
+    "viem": "^2.47.2"
+  },
+  "lint-staged": {
+    "{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}": [
+      "prettier --write"
+    ],
+    "{{src,test}/**/*,*}.{t,j}s{,x}": [
+      "eslint --fix"
+    ]
+  },
+  "devDependencies": {
+    "@abinnovision/eslint-config-base": "^3.2.0",
+    "@abinnovision/prettier-config": "^2.1.5",
+    "@seljs-internal/fixtures": "0.0.0",
+    "@seljs-internal/tsconfig": "^0.0.0",
+    "@types/debug": "^4.1.12",
+    "concurrently": "^9.2.1",
+    "eslint": "^9.39.4",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "typescript": "^5",
+    "zod": "^4.0.0"
+  },
+  "publishConfig": {
+    "npm": true,
+    "npmAccess": "public"
+  }
+}