@seljs/runtime 1.0.0 → 1.0.1

package/package.json

@@ -1,30 +1,36 @@
 {
   "name": "@seljs/runtime",
-  "version": "1.0.0",
+  "version": "1.0.1",
+  "repository": {
+    "url": "https://github.com/abinnovision/seljs"
+  },
   "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"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist",
     "LICENSE.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsdown",
     "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}'",
@@ -34,16 +40,6 @@
     "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"
@@ -52,6 +48,16 @@
       "eslint --fix"
     ]
   },
+  "dependencies": {
+    "@marcbachmann/cel-js": "^7.5.3",
+    "@seljs/checker": "1.0.1",
+    "@seljs/common": "1.0.1",
+    "@seljs/env": "1.0.1",
+    "@seljs/schema": "1.0.1",
+    "@seljs/types": "1.0.1",
+    "debug": "^4.4.3",
+    "viem": "^2.47.2"
+  },
   "devDependencies": {
     "@abinnovision/eslint-config-base": "^3.2.0",
     "@abinnovision/prettier-config": "^2.1.5",
@@ -61,6 +67,7 @@
     "concurrently": "^9.2.1",
     "eslint": "^9.39.4",
     "prettier": "^3.8.1",
+    "tsdown": "^0.21.3",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18",
     "zod": "^4.3.6"

package/dist/analysis/call-collector.d.ts

@@ -1,20 +0,0 @@
-import type { CollectedCall } from "./types.js";
-import type { ASTNode } from "@marcbachmann/cel-js";
-/** Minimal interface required by collectCalls for contract lookup. */
-export interface ContractLookup {
-    get: (name: string) => unknown;
-}
-/**
- * Collects contract calls from a CEL AST by traversing the tree.
- *
- * Walks the AST looking for `rcall` nodes whose receiver matches a registered
- * contract. For each matched call, classifies arguments as literals, variable
- * references, or results of other contract calls (creating dependency edges).
- * Skips `cel.bind()` calls while still collecting any nested contract calls.
- *
- * @param ast The root AST node from a parsed CEL expression
- * @param registry Contract lookup to validate receiver names against
- * @returns Array of collected calls with dependency information
- */
-export declare const collectCalls: (ast: ASTNode, registry: ContractLookup) => CollectedCall[];
-//# sourceMappingURL=call-collector.d.ts.map

package/dist/analysis/call-collector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-collector.d.ts","sourceRoot":"","sources":["../../src/analysis/call-collector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,sEAAsE;AACtE,MAAM,WAAW,cAAc;IAC9B,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAC/B;AAwHD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GACxB,KAAK,OAAO,EACZ,UAAU,cAAc,KACtB,aAAa,EA2Nf,CAAC"}

package/dist/analysis/call-collector.js

@@ -1,272 +0,0 @@
-import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS } from "@seljs/checker";
-import { isAstNode } from "@seljs/common";
-import { createLogger } from "../debug.js";
-const debug = createLogger("analysis:collect");
-/**
- * Generates a deterministic call identifier from contract name, method, and arguments.
- *
- * Format: "contract:method:arg1,arg2,..."
- * Used for deduplication and dependency tracking between calls.
- */
-const generateCallId = (contract, method, args) => {
-    const argKey = args
-        .map((arg) => {
-        if (arg.variableName !== undefined) {
-            return arg.variableName;
-        }
-        if (arg.value !== undefined) {
-            const v = arg.value;
-            return typeof v === "string" ||
-                typeof v === "number" ||
-                typeof v === "boolean" ||
-                typeof v === "bigint"
-                ? String(v)
-                : "?";
-        }
-        if (arg.dependsOnCallId !== undefined) {
-            return arg.dependsOnCallId;
-        }
-        return "?";
-    })
-        .join(",");
-    return `${contract}:${method}:${argKey}`;
-};
-/**
- * Attempts to extract a scalar argument from a Solidity cast/wrapper call
- * (e.g. `uint256(42)`, `solAddress("0x...")`, `int256(tokenId)`).
- *
- * Handles both literal values and variable references.
- * Returns undefined if the node is not a recognized scalar wrapper.
- */
-const collectScalarArgument = (argNode) => {
-    if (!isAstNode(argNode) || argNode.op !== "call") {
-        return undefined;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!Array.isArray(argNode.args) || argNode.args.length !== 2) {
-        return undefined;
-    }
-    const fnName = argNode.args[0];
-    const fnArgs = argNode.args[1];
-    if (typeof fnName !== "string" ||
-        !Array.isArray(fnArgs) ||
-        fnArgs.length !== 1 ||
-        !SCALAR_WRAPPER_FUNCTIONS.has(fnName)) {
-        return undefined;
-    }
-    const inner = fnArgs[0];
-    if (!isAstNode(inner)) {
-        return undefined;
-    }
-    if (inner.op === "value") {
-        return { type: "literal", value: inner.args };
-    }
-    if (inner.op === "id" && typeof inner.args === "string") {
-        return { type: "variable", variableName: inner.args };
-    }
-    return undefined;
-};
-/**
- * Extracts the method name, receiver identifier, and argument nodes from an rcall AST node.
- *
- * An rcall node has the structure: `["methodName", receiverNode, [argNodes...]]`
- */
-const getRCallArgs = (node) => {
-    if (!Array.isArray(node.args) || node.args.length < 3) {
-        return undefined;
-    }
-    const methodNode = node.args[0];
-    const receiverNode = node.args[1];
-    const argNodes = node.args[2];
-    if (typeof methodNode !== "string" || !Array.isArray(argNodes)) {
-        return undefined;
-    }
-    let receiverName;
-    if (isAstNode(receiverNode) &&
-        receiverNode.op === "id" &&
-        typeof receiverNode.args === "string") {
-        receiverName = receiverNode.args;
-    }
-    return { method: methodNode, receiverName, args: argNodes };
-};
-/**
- * Collects contract calls from a CEL AST by traversing the tree.
- *
- * Walks the AST looking for `rcall` nodes whose receiver matches a registered
- * contract. For each matched call, classifies arguments as literals, variable
- * references, or results of other contract calls (creating dependency edges).
- * Skips `cel.bind()` calls while still collecting any nested contract calls.
- *
- * @param ast The root AST node from a parsed CEL expression
- * @param registry Contract lookup to validate receiver names against
- * @returns Array of collected calls with dependency information
- */
-export const collectCalls = (ast, registry) => {
-    const calls = [];
-    /** Variable names that are scoped (comprehension iteration vars, cel.bind vars) — NOT user context */
-    const scopedVars = new Set();
-    /** rcall AST nodes skipped because they have unresolvable args */
-    const deferredNodes = new WeakSet();
-    const traverse = (node) => {
-        if (Array.isArray(node)) {
-            for (const item of node) {
-                traverse(item);
-            }
-            return;
-        }
-        if (!isAstNode(node)) {
-            return;
-        }
-        if (node.op === "rcall") {
-            collectRCall(node);
-            return;
-        }
-        traverse(node.args);
-    };
-    /**
-     * Handles cel.bind() — registers the bind variable name for the body scope,
-     * traverses the initializer and body, then removes the scoped var.
-     */
-    const handleCelBind = (args) => {
-        if (args.length >= 3) {
-            const nameNode = args[0];
-            if (isAstNode(nameNode) &&
-                nameNode.op === "id" &&
-                typeof nameNode.args === "string") {
-                traverse(args[1]);
-                scopedVars.add(nameNode.args);
-                traverse(args[2]);
-                scopedVars.delete(nameNode.args);
-                return;
-            }
-        }
-        for (const argNode of args) {
-            traverse(argNode);
-        }
-    };
-    /**
-     * Handles rcall nodes whose receiver is NOT a registered contract.
-     * Traverses the receiver node and args, registering comprehension
-     * iteration variables for their body scope.
-     */
-    const handleNonContractRCall = (node, method, args) => {
-        // Always traverse the receiver to collect contract calls within it
-        if (Array.isArray(node.args) && node.args.length >= 2) {
-            traverse(node.args[1]);
-        }
-        // Comprehension macros: register iteration variable for body scope
-        if (COMPREHENSION_MACROS.has(method) && args.length >= 2) {
-            const iterVarNode = args[0];
-            if (isAstNode(iterVarNode) &&
-                iterVarNode.op === "id" &&
-                typeof iterVarNode.args === "string") {
-                scopedVars.add(iterVarNode.args);
-                for (let i = 1; i < args.length; i++) {
-                    traverse(args[i]);
-                }
-                scopedVars.delete(iterVarNode.args);
-                return;
-            }
-        }
-        for (const argNode of args) {
-            traverse(argNode);
-        }
-    };
-    /**
-     * Classifies a single argument node, returning the resolved CallArgument
-     * or `undefined` if unresolvable. When `undefined` is returned, the caller
-     * should mark the parent call as deferred.
-     */
-    const classifyArg = (argNode) => {
-        const scalarArg = collectScalarArgument(argNode);
-        if (scalarArg) {
-            return { arg: scalarArg, traversed: false };
-        }
-        if (isAstNode(argNode) && argNode.op === "value") {
-            return {
-                arg: { type: "literal", value: argNode.args },
-                traversed: false,
-            };
-        }
-        if (isAstNode(argNode) &&
-            argNode.op === "id" &&
-            typeof argNode.args === "string") {
-            if (scopedVars.has(argNode.args)) {
-                return { arg: undefined, traversed: false };
-            }
-            return {
-                arg: { type: "variable", variableName: argNode.args },
-                traversed: false,
-            };
-        }
-        if (isAstNode(argNode) && argNode.op === "rcall") {
-            const innerCall = collectRCall(argNode);
-            if (innerCall) {
-                return {
-                    arg: { type: "call_result", dependsOnCallId: innerCall.id },
-                    traversed: true,
-                };
-            }
-            // Inner rcall was not collected — check if it was deferred
-            if (deferredNodes.has(argNode)) {
-                // inner calls already collected by recursive collectRCall
-                return { arg: undefined, traversed: true };
-            }
-        }
-        return { arg: undefined, traversed: false };
-    };
-    /**
-     * Processes an rcall AST node, collecting it as a contract call if the
-     * receiver is a registered contract. Recursively processes nested rcalls
-     * in arguments to build dependency chains.
-     */
-    const collectRCall = (node) => {
-        const callArgs = getRCallArgs(node);
-        if (!callArgs) {
-            traverse(node.args);
-            return undefined;
-        }
-        const { method, receiverName, args } = callArgs;
-        if (receiverName === "cel" && method === "bind") {
-            handleCelBind(args);
-            return undefined;
-        }
-        if (!receiverName || !registry.get(receiverName)) {
-            handleNonContractRCall(node, method, args);
-            return undefined;
-        }
-        const collectedArgs = [];
-        let hasUnresolvableArg = false;
-        for (const argNode of args) {
-            const { arg, traversed } = classifyArg(argNode);
-            if (arg) {
-                collectedArgs.push(arg);
-            }
-            else {
-                hasUnresolvableArg = true;
-                if (!traversed) {
-                    traverse(argNode);
-                }
-            }
-        }
-        if (hasUnresolvableArg) {
-            deferredNodes.add(node);
-            debug("deferred %s.%s (unresolvable args)", receiverName, method);
-            return undefined;
-        }
-        const call = {
-            id: generateCallId(receiverName, method, collectedArgs),
-            contract: receiverName,
-            method,
-            args: collectedArgs,
-            astNode: node,
-        };
-        calls.push(call);
-        debug("found %s.%s (id=%s)", receiverName, method, call.id);
-        return call;
-    };
-    // Start traversal from the root of the AST
-    traverse(ast);
-    debug("collected %d total calls", calls.length);
-    return calls;
-};

package/dist/analysis/dependency-analyzer.d.ts

@@ -1,14 +0,0 @@
-import type { CollectedCall, DependencyGraph } from "./types.js";
-/**
- * Builds a dependency graph from collected contract calls.
- *
- * Creates a directed graph where nodes represent contract calls and edges
- * represent data dependencies (when one call's argument is the result of
- * another call). Validates that no circular dependencies exist.
- *
- * @param calls - Array of collected contract calls from AST traversal
- * @returns A dependency graph with nodes and directed edges
- * @throws {@link CircularDependencyError} If a circular dependency is detected between calls
- */
-export declare const analyzeDependencies: (calls: CollectedCall[]) => DependencyGraph;
-//# sourceMappingURL=dependency-analyzer.d.ts.map

package/dist/analysis/dependency-analyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dependency-analyzer.d.ts","sourceRoot":"","sources":["../../src/analysis/dependency-analyzer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAa,MAAM,YAAY,CAAC;AAiD5E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC/B,OAAO,aAAa,EAAE,KACpB,eAwCF,CAAC"}

package/dist/analysis/dependency-analyzer.js

@@ -1,76 +0,0 @@
-import { createLogger } from "../debug.js";
-import { CircularDependencyError } from "../errors/index.js";
-const debug = createLogger("analysis:dependency");
-/**
- * Detects circular dependencies in the graph using DFS with a recursion stack.
- *
- * @throws {@link CircularDependencyError} If a cycle is found, including the call IDs forming the cycle
- */
-const detectCycles = (nodes, edges) => {
-    const visited = new Set();
-    const inStack = new Set();
-    const dfs = (nodeId, path) => {
-        if (inStack.has(nodeId)) {
-            const cycleStart = path.indexOf(nodeId);
-            const cycle = path.slice(cycleStart);
-            throw new CircularDependencyError(`Circular dependency detected: ${cycle.join(" -> ")} -> ${nodeId}`, { callIds: cycle });
-        }
-        if (visited.has(nodeId)) {
-            return;
-        }
-        visited.add(nodeId);
-        inStack.add(nodeId);
-        path.push(nodeId);
-        for (const depId of edges.get(nodeId) ?? []) {
-            dfs(depId, path);
-        }
-        path.pop();
-        inStack.delete(nodeId);
-    };
-    for (const nodeId of nodes.keys()) {
-        if (!visited.has(nodeId)) {
-            dfs(nodeId, []);
-        }
-    }
-};
-/**
- * Builds a dependency graph from collected contract calls.
- *
- * Creates a directed graph where nodes represent contract calls and edges
- * represent data dependencies (when one call's argument is the result of
- * another call). Validates that no circular dependencies exist.
- *
- * @param calls - Array of collected contract calls from AST traversal
- * @returns A dependency graph with nodes and directed edges
- * @throws {@link CircularDependencyError} If a circular dependency is detected between calls
- */
-export const analyzeDependencies = (calls) => {
-    const nodes = new Map();
-    const edges = new Map();
-    // First pass: create a node and empty edge set for each call
-    for (const call of calls) {
-        nodes.set(call.id, { call, dependsOn: [], dependedOnBy: [] });
-        edges.set(call.id, new Set());
-    }
-    // Second pass: wire up dependency edges from call_result arguments
-    for (const call of calls) {
-        for (const arg of call.args) {
-            if (arg.type === "call_result" && arg.dependsOnCallId) {
-                const depId = arg.dependsOnCallId;
-                edges.get(call.id)?.add(depId);
-                const callNode = nodes.get(call.id);
-                if (callNode && !callNode.dependsOn.includes(depId)) {
-                    callNode.dependsOn.push(depId);
-                }
-                const depNode = nodes.get(depId);
-                if (depNode && !depNode.dependedOnBy.includes(call.id)) {
-                    depNode.dependedOnBy.push(call.id);
-                }
-            }
-        }
-    }
-    // Run cycle detection to ensure there are no circular dependencies in the graph.
-    detectCycles(nodes, edges);
-    debug("graph: %d nodes, %d edges", nodes.size, [...edges.values()].reduce((sum, deps) => sum + deps.size, 0));
-    return { nodes, edges };
-};

package/dist/analysis/index.d.ts

@@ -1,2 +0,0 @@
-export type * from "./types.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/analysis/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAC"}

package/dist/analysis/index.js

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

package/dist/analysis/round-planner.d.ts

@@ -1,32 +0,0 @@
-import type { DependencyGraph, ExecutionPlan } from "./types.js";
-/**
- * Defines limits for the round planner to prevent excessive execution.
- */
-export interface RoundPlannerLimits {
-    /**
-     * Upper limit on the number of execution rounds.
-     *
-     * @default 10
-     */
-    maxRounds?: number;
-    /**
-     * Upper limit on the total number of calls in the graph.
-     *
-     * @default 100
-     */
-    maxCalls?: number;
-}
-/**
- * Plans execution rounds from a dependency graph using topological sorting.
- *
- * Groups independent calls into parallel rounds, ensuring all dependencies
- * of a call are executed in previous rounds. Enforces limits on the number
- * of rounds and total calls to prevent excessive execution.
- *
- * @param graph Dependency graph representing calls and their relationships.
- * @param limits Optional limits for maximum rounds and total calls.
- * @returns Execution plan containing planned rounds, total calls, and maximum depth.
- * @throws ExecutionLimitError If total calls exceed maxCalls or rounds exceed maxRounds.
- */
-export declare const planRounds: (graph: DependencyGraph, limits?: RoundPlannerLimits) => ExecutionPlan;
-//# sourceMappingURL=round-planner.d.ts.map

package/dist/analysis/round-planner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"round-planner.d.ts","sourceRoot":"","sources":["../../src/analysis/round-planner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACX,eAAe,EACf,aAAa,EAEb,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,GACtB,OAAO,eAAe,EACtB,SAAQ,kBAAuB,KAC7B,aA6EF,CAAC"}

package/dist/analysis/round-planner.js

@@ -1,69 +0,0 @@
-import { createLogger } from "../debug.js";
-import { ExecutionLimitError } from "../errors/index.js";
-const debug = createLogger("analysis:plan");
-/**
- * Plans execution rounds from a dependency graph using topological sorting.
- *
- * Groups independent calls into parallel rounds, ensuring all dependencies
- * of a call are executed in previous rounds. Enforces limits on the number
- * of rounds and total calls to prevent excessive execution.
- *
- * @param graph Dependency graph representing calls and their relationships.
- * @param limits Optional limits for maximum rounds and total calls.
- * @returns Execution plan containing planned rounds, total calls, and maximum depth.
- * @throws ExecutionLimitError If total calls exceed maxCalls or rounds exceed maxRounds.
- */
-export const planRounds = (graph, limits = {}) => {
-    const maxRounds = limits.maxRounds ?? 10;
-    const maxCalls = limits.maxCalls ?? 100;
-    const totalCalls = graph.nodes.size;
-    if (totalCalls > maxCalls) {
-        throw new ExecutionLimitError(`Execution limit exceeded: ${String(totalCalls)} calls exceeds maxCalls (${String(maxCalls)})`, { limitType: "maxCalls", limit: maxCalls, actual: totalCalls });
-    }
-    if (totalCalls === 0) {
-        return { rounds: [], totalCalls: 0, maxDepth: 0 };
-    }
-    const inDegree = new Map();
-    for (const nodeId of graph.nodes.keys()) {
-        inDegree.set(nodeId, graph.edges.get(nodeId)?.size ?? 0);
-    }
-    const rounds = [];
-    const processed = new Set();
-    while (processed.size < totalCalls) {
-        const readyNodes = [];
-        for (const [nodeId, degree] of inDegree) {
-            if (degree === 0 && !processed.has(nodeId)) {
-                readyNodes.push(nodeId);
-            }
-        }
-        if (readyNodes.length === 0) {
-            break;
-        }
-        if (rounds.length >= maxRounds) {
-            throw new ExecutionLimitError(`Execution limit exceeded: requires more than maxRounds (${String(maxRounds)}) rounds`, {
-                limitType: "maxRounds",
-                limit: maxRounds,
-                actual: rounds.length + 1,
-            });
-        }
-        const round = {
-            roundNumber: rounds.length,
-            calls: readyNodes
-                .map((id) => graph.nodes.get(id)?.call)
-                .filter((c) => c !== undefined),
-        };
-        rounds.push(round);
-        for (const nodeId of readyNodes) {
-            processed.add(nodeId);
-            const node = graph.nodes.get(nodeId);
-            if (!node) {
-                continue;
-            }
-            for (const dependentId of node.dependedOnBy) {
-                inDegree.set(dependentId, (inDegree.get(dependentId) ?? 0) - 1);
-            }
-        }
-    }
-    debug("planned %d rounds for %d calls (max depth=%d)", rounds.length, totalCalls, rounds.length);
-    return { rounds, totalCalls, maxDepth: rounds.length };
-};