@seljs/runtime 1.0.0 → 1.0.1-beta.9

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/analysis/call-collector.cjs

@@ -0,0 +1,233 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_debug = require("../debug.cjs");
+let _seljs_checker = require("@seljs/checker");
+let _seljs_common = require("@seljs/common");
+//#region src/analysis/call-collector.ts
+const debug = require_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) => {
+	return `${contract}:${method}:${args.map((arg) => {
+		if (arg.variableName !== void 0) return arg.variableName;
+		if (arg.value !== void 0) {
+			const v = arg.value;
+			return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "bigint" ? String(v) : "?";
+		}
+		if (arg.dependsOnCallId !== void 0) return arg.dependsOnCallId;
+		return "?";
+	}).join(",")}`;
+};
+/**
+* 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 (!(0, _seljs_common.isAstNode)(argNode) || argNode.op !== "call") return;
+	if (!Array.isArray(argNode.args) || argNode.args.length !== 2) return;
+	const fnName = argNode.args[0];
+	const fnArgs = argNode.args[1];
+	if (typeof fnName !== "string" || !Array.isArray(fnArgs) || fnArgs.length !== 1 || !_seljs_checker.SCALAR_WRAPPER_FUNCTIONS.has(fnName)) return;
+	const inner = fnArgs[0];
+	if (!(0, _seljs_common.isAstNode)(inner)) return;
+	if (inner.op === "value") return {
+		type: "literal",
+		value: inner.args
+	};
+	if (inner.op === "id" && typeof inner.args === "string") return {
+		type: "variable",
+		variableName: inner.args
+	};
+};
+/**
+* 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;
+	const methodNode = node.args[0];
+	const receiverNode = node.args[1];
+	const argNodes = node.args[2];
+	if (typeof methodNode !== "string" || !Array.isArray(argNodes)) return;
+	let receiverName;
+	if ((0, _seljs_common.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
+*/
+const collectCalls = (ast, registry) => {
+	const calls = [];
+	/** Variable names that are scoped (comprehension iteration vars, cel.bind vars) — NOT user context */
+	const scopedVars = /* @__PURE__ */ new Set();
+	/** rcall AST nodes skipped because they have unresolvable args */
+	const deferredNodes = /* @__PURE__ */ new WeakSet();
+	const traverse = (node) => {
+		if (Array.isArray(node)) {
+			for (const item of node) traverse(item);
+			return;
+		}
+		if (!(0, _seljs_common.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 ((0, _seljs_common.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) => {
+		if (Array.isArray(node.args) && node.args.length >= 2) traverse(node.args[1]);
+		if (_seljs_checker.COMPREHENSION_MACROS.has(method) && args.length >= 2) {
+			const iterVarNode = args[0];
+			if ((0, _seljs_common.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 ((0, _seljs_common.isAstNode)(argNode) && argNode.op === "value") return {
+			arg: {
+				type: "literal",
+				value: argNode.args
+			},
+			traversed: false
+		};
+		if ((0, _seljs_common.isAstNode)(argNode) && argNode.op === "id" && typeof argNode.args === "string") {
+			if (scopedVars.has(argNode.args)) return {
+				arg: void 0,
+				traversed: false
+			};
+			return {
+				arg: {
+					type: "variable",
+					variableName: argNode.args
+				},
+				traversed: false
+			};
+		}
+		if ((0, _seljs_common.isAstNode)(argNode) && argNode.op === "rcall") {
+			const innerCall = collectRCall(argNode);
+			if (innerCall) return {
+				arg: {
+					type: "call_result",
+					dependsOnCallId: innerCall.id
+				},
+				traversed: true
+			};
+			if (deferredNodes.has(argNode)) return {
+				arg: void 0,
+				traversed: true
+			};
+		}
+		return {
+			arg: void 0,
+			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;
+		}
+		const { method, receiverName, args } = callArgs;
+		if (receiverName === "cel" && method === "bind") {
+			handleCelBind(args);
+			return;
+		}
+		if (!receiverName || !registry.get(receiverName)) {
+			handleNonContractRCall(node, method, args);
+			return;
+		}
+		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;
+		}
+		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;
+	};
+	traverse(ast);
+	debug("collected %d total calls", calls.length);
+	return calls;
+};
+//#endregion
+exports.collectCalls = collectCalls;

package/dist/analysis/call-collector.mjs

@@ -0,0 +1,232 @@
+import { createLogger } from "../debug.mjs";
+import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS } from "@seljs/checker";
+import { isAstNode } from "@seljs/common";
+//#region src/analysis/call-collector.ts
+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) => {
+	return `${contract}:${method}:${args.map((arg) => {
+		if (arg.variableName !== void 0) return arg.variableName;
+		if (arg.value !== void 0) {
+			const v = arg.value;
+			return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "bigint" ? String(v) : "?";
+		}
+		if (arg.dependsOnCallId !== void 0) return arg.dependsOnCallId;
+		return "?";
+	}).join(",")}`;
+};
+/**
+* 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;
+	if (!Array.isArray(argNode.args) || argNode.args.length !== 2) return;
+	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;
+	const inner = fnArgs[0];
+	if (!isAstNode(inner)) return;
+	if (inner.op === "value") return {
+		type: "literal",
+		value: inner.args
+	};
+	if (inner.op === "id" && typeof inner.args === "string") return {
+		type: "variable",
+		variableName: inner.args
+	};
+};
+/**
+* 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;
+	const methodNode = node.args[0];
+	const receiverNode = node.args[1];
+	const argNodes = node.args[2];
+	if (typeof methodNode !== "string" || !Array.isArray(argNodes)) return;
+	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
+*/
+const collectCalls = (ast, registry) => {
+	const calls = [];
+	/** Variable names that are scoped (comprehension iteration vars, cel.bind vars) — NOT user context */
+	const scopedVars = /* @__PURE__ */ new Set();
+	/** rcall AST nodes skipped because they have unresolvable args */
+	const deferredNodes = /* @__PURE__ */ 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) => {
+		if (Array.isArray(node.args) && node.args.length >= 2) traverse(node.args[1]);
+		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: void 0,
+				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
+			};
+			if (deferredNodes.has(argNode)) return {
+				arg: void 0,
+				traversed: true
+			};
+		}
+		return {
+			arg: void 0,
+			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;
+		}
+		const { method, receiverName, args } = callArgs;
+		if (receiverName === "cel" && method === "bind") {
+			handleCelBind(args);
+			return;
+		}
+		if (!receiverName || !registry.get(receiverName)) {
+			handleNonContractRCall(node, method, args);
+			return;
+		}
+		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;
+		}
+		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;
+	};
+	traverse(ast);
+	debug("collected %d total calls", calls.length);
+	return calls;
+};
+//#endregion
+export { collectCalls };

package/dist/analysis/dependency-analyzer.cjs

@@ -0,0 +1,68 @@
+const require_debug = require("../debug.cjs");
+const require_errors = require("../errors/errors.cjs");
+require("../errors/index.cjs");
+//#region src/analysis/dependency-analyzer.ts
+const debug = require_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 = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ new Set();
+	const dfs = (nodeId, path) => {
+		if (inStack.has(nodeId)) {
+			const cycleStart = path.indexOf(nodeId);
+			const cycle = path.slice(cycleStart);
+			throw new require_errors.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
+*/
+const analyzeDependencies = (calls) => {
+	const nodes = /* @__PURE__ */ new Map();
+	const edges = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		nodes.set(call.id, {
+			call,
+			dependsOn: [],
+			dependedOnBy: []
+		});
+		edges.set(call.id, /* @__PURE__ */ new Set());
+	}
+	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);
+	}
+	detectCycles(nodes, edges);
+	debug("graph: %d nodes, %d edges", nodes.size, [...edges.values()].reduce((sum, deps) => sum + deps.size, 0));
+	return {
+		nodes,
+		edges
+	};
+};
+//#endregion
+exports.analyzeDependencies = analyzeDependencies;

package/dist/analysis/dependency-analyzer.mjs

@@ -0,0 +1,68 @@
+import { createLogger } from "../debug.mjs";
+import { CircularDependencyError } from "../errors/errors.mjs";
+import "../errors/index.mjs";
+//#region src/analysis/dependency-analyzer.ts
+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 = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ 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
+*/
+const analyzeDependencies = (calls) => {
+	const nodes = /* @__PURE__ */ new Map();
+	const edges = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		nodes.set(call.id, {
+			call,
+			dependsOn: [],
+			dependedOnBy: []
+		});
+		edges.set(call.id, /* @__PURE__ */ new Set());
+	}
+	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);
+	}
+	detectCycles(nodes, edges);
+	debug("graph: %d nodes, %d edges", nodes.size, [...edges.values()].reduce((sum, deps) => sum + deps.size, 0));
+	return {
+		nodes,
+		edges
+	};
+};
+//#endregion
+export { analyzeDependencies };

package/dist/analysis/round-planner.cjs

@@ -0,0 +1,65 @@
+const require_debug = require("../debug.cjs");
+const require_errors = require("../errors/errors.cjs");
+require("../errors/index.cjs");
+//#region src/analysis/round-planner.ts
+const debug = require_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.
+*/
+const planRounds = (graph, limits = {}) => {
+	const maxRounds = limits.maxRounds ?? 10;
+	const maxCalls = limits.maxCalls ?? 100;
+	const totalCalls = graph.nodes.size;
+	if (totalCalls > maxCalls) throw new require_errors.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 = /* @__PURE__ */ new Map();
+	for (const nodeId of graph.nodes.keys()) inDegree.set(nodeId, graph.edges.get(nodeId)?.size ?? 0);
+	const rounds = [];
+	const processed = /* @__PURE__ */ 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 require_errors.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 !== void 0)
+		};
+		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
+	};
+};
+//#endregion
+exports.planRounds = planRounds;