@seljs/runtime 1.0.0 → 1.0.1

package/dist/execution/multicall-batcher.cjs

@@ -0,0 +1,51 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_debug = require("../debug.cjs");
+const require_errors = require("../errors/errors.cjs");
+require("../errors/index.cjs");
+const require_multicall = require("./multicall.cjs");
+let viem_actions = require("viem/actions");
+//#region src/execution/multicall-batcher.ts
+const debug = require_debug.createLogger("execute:multicall");
+var MulticallBatcher = class {
+	address;
+	batchSize;
+	constructor(client, options) {
+		this.client = client;
+		this.address = options?.address ?? "0xcA11bde05977b3631167028862bE2a173976CA11";
+		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 {
+			return (await (0, viem_actions.readContract)(this.client, {
+				address: this.address,
+				abi: require_multicall.multicall3Abi,
+				functionName: "aggregate3",
+				args: [calls],
+				blockNumber
+			})).map((r) => ({
+				success: r.success,
+				returnData: r.returnData
+			}));
+		} catch (error) {
+			throw new require_errors.MulticallBatchError("Multicall3 aggregate3 call failed", { cause: error });
+		}
+	}
+};
+//#endregion
+exports.MulticallBatcher = MulticallBatcher;

package/dist/execution/multicall-batcher.mjs

@@ -0,0 +1,50 @@
+import { createLogger } from "../debug.mjs";
+import { MulticallBatchError } from "../errors/errors.mjs";
+import "../errors/index.mjs";
+import { multicall3Abi } from "./multicall.mjs";
+import { readContract } from "viem/actions";
+//#region src/execution/multicall-batcher.ts
+const debug = createLogger("execute:multicall");
+var MulticallBatcher = class {
+	address;
+	batchSize;
+	constructor(client, options) {
+		this.client = client;
+		this.address = options?.address ?? "0xcA11bde05977b3631167028862bE2a173976CA11";
+		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 {
+			return (await readContract(this.client, {
+				address: this.address,
+				abi: multicall3Abi,
+				functionName: "aggregate3",
+				args: [calls],
+				blockNumber
+			})).map((r) => ({
+				success: r.success,
+				returnData: r.returnData
+			}));
+		} catch (error) {
+			throw new MulticallBatchError("Multicall3 aggregate3 call failed", { cause: error });
+		}
+	}
+};
+//#endregion
+export { MulticallBatcher };

package/dist/execution/multicall.cjs

@@ -0,0 +1,39 @@
+//#region src/execution/multicall.ts
+const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+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"
+		}]
+	}]
+}];
+//#endregion
+exports.MULTICALL3_ADDRESS = MULTICALL3_ADDRESS;
+exports.multicall3Abi = multicall3Abi;

package/dist/execution/multicall.mjs

@@ -0,0 +1,38 @@
+//#region src/execution/multicall.ts
+const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+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"
+		}]
+	}]
+}];
+//#endregion
+export { MULTICALL3_ADDRESS, multicall3Abi };

package/dist/execution/result-cache.cjs

@@ -0,0 +1,63 @@
+//#region src/execution/result-cache.ts
+/**
+* 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.
+*/
+var ResultCache = class {
+	cache = /* @__PURE__ */ 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) {
+		return `${contract}:${method}:${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;
+		})}`;
+	}
+	/**
+	* 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();
+	}
+};
+//#endregion
+exports.ResultCache = ResultCache;

package/dist/execution/result-cache.mjs

@@ -0,0 +1,63 @@
+//#region src/execution/result-cache.ts
+/**
+* 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.
+*/
+var ResultCache = class {
+	cache = /* @__PURE__ */ 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) {
+		return `${contract}:${method}:${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;
+		})}`;
+	}
+	/**
+	* 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();
+	}
+};
+//#endregion
+export { ResultCache };

package/dist/execution/round-executor.cjs

@@ -0,0 +1,81 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_debug = require("../debug.cjs");
+const require_errors = require("../errors/errors.cjs");
+require("../errors/index.cjs");
+let viem = require("viem");
+//#region src/execution/round-executor.ts
+const debug = require_debug.createLogger("execute:round");
+var RoundExecutor = class {
+	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: (0, viem.encodeFunctionData)({
+						abi: contract.abi,
+						functionName: call.method,
+						args: resolvedArgs
+					})
+				});
+			}
+		} catch (error) {
+			if (error instanceof require_errors.MulticallBatchError) throw error;
+			throw new require_errors.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 require_errors.MulticallBatchError(`Call failed: ${call.contract}.${call.method}`, {
+				failedCallIndex: i,
+				contractName: call.contract,
+				methodName: call.method
+			});
+			const decoded = (0, viem.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;
+				return context.variables[name];
+			}
+			const id = arg.dependsOnCallId;
+			if (!id) return;
+			return this.cache.get(id);
+		});
+	}
+};
+//#endregion
+exports.RoundExecutor = RoundExecutor;

package/dist/execution/round-executor.mjs

@@ -0,0 +1,80 @@
+import { createLogger } from "../debug.mjs";
+import { MulticallBatchError } from "../errors/errors.mjs";
+import "../errors/index.mjs";
+import { decodeFunctionResult, encodeFunctionData } from "viem";
+//#region src/execution/round-executor.ts
+const debug = createLogger("execute:round");
+var RoundExecutor = class {
+	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;
+				return context.variables[name];
+			}
+			const id = arg.dependsOnCallId;
+			if (!id) return;
+			return this.cache.get(id);
+		});
+	}
+};
+//#endregion
+export { RoundExecutor };

package/dist/execution/types.d.cts

@@ -0,0 +1,58 @@
+import { PublicClient } from "viem";
+
+//#region src/execution/types.d.ts
+/**
+ * Metadata about the execution.
+ * Contains statistics and block information from the execution run.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+interface EvaluateResult<T = unknown> {
+  /** The evaluated result value */
+  value: T;
+  /** Execution metadata, present when contract calls were executed */
+  meta?: ExecutionMeta;
+}
+//#endregion
+export { EvaluateOptions, EvaluateResult, ExecutionContext, ExecutionMeta, ExecutionResult };

package/dist/execution/types.d.mts

@@ -0,0 +1,58 @@
+import { PublicClient } from "viem";
+
+//#region src/execution/types.d.ts
+/**
+ * Metadata about the execution.
+ * Contains statistics and block information from the execution run.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+interface EvaluateResult<T = unknown> {
+  /** The evaluated result value */
+  value: T;
+  /** Execution metadata, present when contract calls were executed */
+  meta?: ExecutionMeta;
+}
+//#endregion
+export { EvaluateOptions, EvaluateResult, ExecutionContext, ExecutionMeta, ExecutionResult };

package/dist/factory.cjs

@@ -0,0 +1,6 @@
+const require_environment = require("./environment/environment.cjs");
+require("./environment/index.cjs");
+//#region src/factory.ts
+const createSEL = (config) => new require_environment.SELRuntime(config);
+//#endregion
+exports.createSEL = createSEL;

package/dist/factory.d.cts

@@ -0,0 +1,7 @@
+import { SELRuntimeConfig } from "./environment/types.cjs";
+import { SELRuntime } from "./environment/environment.cjs";
+
+//#region src/factory.d.ts
+declare const createSEL: (config: SELRuntimeConfig) => SELRuntime;
+//#endregion
+export { createSEL };

package/dist/factory.d.mts

@@ -0,0 +1,6 @@
+import { SELRuntimeConfig } from "./environment/types.mjs";
+import { SELRuntime } from "./environment/environment.mjs";
+//#region src/factory.d.ts
+declare const createSEL: (config: SELRuntimeConfig) => SELRuntime;
+//#endregion
+export { createSEL };

package/dist/factory.mjs

@@ -0,0 +1,6 @@
+import { SELRuntime } from "./environment/environment.mjs";
+import "./environment/index.mjs";
+//#region src/factory.ts
+const createSEL = (config) => new SELRuntime(config);
+//#endregion
+export { createSEL };

package/dist/index.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./_virtual/_rolldown/runtime.cjs");
+const require_errors = require("./errors/errors.cjs");
+require("./errors/index.cjs");
+const require_environment = require("./environment/environment.cjs");
+require("./environment/index.cjs");
+const require_factory = require("./factory.cjs");
+let _seljs_common = require("@seljs/common");
+exports.CircularDependencyError = require_errors.CircularDependencyError;
+exports.ExecutionLimitError = require_errors.ExecutionLimitError;
+exports.MulticallBatchError = require_errors.MulticallBatchError;
+exports.SELContractError = require_errors.SELContractError;
+exports.SELError = _seljs_common.SELError;
+exports.SELEvaluationError = require_errors.SELEvaluationError;
+exports.SELParseError = _seljs_common.SELParseError;
+exports.SELRuntime = require_environment.SELRuntime;
+exports.SELTypeError = _seljs_common.SELTypeError;
+exports.createSEL = require_factory.createSEL;

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+import { MulticallOptions, SELLimits, SELRuntimeConfig } from "./environment/types.cjs";
+import { EvaluateOptions, EvaluateResult, ExecutionContext, ExecutionMeta, ExecutionResult } from "./execution/types.cjs";
+import { SELRuntime } from "./environment/environment.cjs";
+import { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError } from "./errors/errors.cjs";
+import { createSEL } from "./factory.cjs";
+import { CallArgument, CollectedCall, DependencyGraph, ExecutionPlan, ExecutionRound, GraphNode } from "./analysis/types.cjs";
+export { CallArgument, CircularDependencyError, CollectedCall, DependencyGraph, EvaluateOptions, EvaluateResult, ExecutionContext, ExecutionLimitError, ExecutionMeta, ExecutionPlan, ExecutionResult, ExecutionRound, GraphNode, MulticallBatchError, MulticallOptions, SELContractError, SELError, SELEvaluationError, SELLimits, SELParseError, SELRuntime, SELRuntimeConfig, SELTypeError, createSEL };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { MulticallOptions, SELLimits, SELRuntimeConfig } from "./environment/types.mjs";
+import { EvaluateOptions, EvaluateResult, ExecutionContext, ExecutionMeta, ExecutionResult } from "./execution/types.mjs";
+import { SELRuntime } from "./environment/environment.mjs";
+import { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError } from "./errors/errors.mjs";
+import { createSEL } from "./factory.mjs";
+import { CallArgument, CollectedCall, DependencyGraph, ExecutionPlan, ExecutionRound, GraphNode } from "./analysis/types.mjs";
+export { CallArgument, CircularDependencyError, CollectedCall, DependencyGraph, EvaluateOptions, EvaluateResult, ExecutionContext, ExecutionLimitError, ExecutionMeta, ExecutionPlan, ExecutionResult, ExecutionRound, GraphNode, MulticallBatchError, MulticallOptions, SELContractError, SELError, SELEvaluationError, SELLimits, SELParseError, SELRuntime, SELRuntimeConfig, SELTypeError, createSEL };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError } from "./errors/errors.mjs";
+import "./errors/index.mjs";
+import { SELRuntime } from "./environment/environment.mjs";
+import "./environment/index.mjs";
+import { createSEL } from "./factory.mjs";
+export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELRuntime, SELTypeError, createSEL };