@seljs/checker 1.0.0 → 1.0.1-beta.9

package/dist/checker/diagnostics.cjs

@@ -0,0 +1,66 @@
+//#region src/checker/diagnostics.ts
+/**
+* Extract position information from a cel-js error message.
+*
+* cel-js error messages embed a caret (`^`) on a separate line indicating
+* the error column. The format is:
+* ```
+* Error description
+*
+* >    1 | expression text
+*              ^
+* ```
+*
+* We parse the caret offset relative to the code line prefix (`>    N | `)
+* to derive the zero-based character offset within the expression.
+*/
+const extractPositionFromMessage = (message) => {
+	const lines = message.split("\n");
+	const caretLine = lines.find((line) => /^\s*\^+\s*$/.test(line));
+	if (!caretLine) return;
+	const codeLine = lines.find((line) => line.startsWith(">"));
+	if (!codeLine) return;
+	const pipeIndex = codeLine.indexOf("|");
+	if (pipeIndex === -1) return;
+	const prefixLength = pipeIndex + 2;
+	const caretStart = caretLine.indexOf("^");
+	const caretEnd = caretLine.lastIndexOf("^");
+	const from = caretStart - prefixLength;
+	const to = caretEnd - prefixLength + 1;
+	if (from < 0) return;
+	return {
+		from,
+		to
+	};
+};
+/**
+* Extract the plain error message without the caret/code-line decoration.
+*/
+const extractPlainMessage = (message) => {
+	return message.split("\n").filter((line) => !line.startsWith(">") && !/^\s*\^+\s*$/.test(line) && line.trim().length > 0).join(" ").trim() || message;
+};
+/**
+* Convert a cel-js error into position-aware SEL diagnostics.
+*
+* The error's `name` property distinguishes parse errors (`"ParseError"`)
+* from type errors (`"TypeError"`).  Position information is extracted from
+* the caret annotation embedded in the error message; when absent the
+* diagnostic spans the entire expression.
+*/
+const extractDiagnostics = (expression, error) => {
+	if (!(error instanceof Error)) return [{
+		message: String(error),
+		severity: "error",
+		from: 0,
+		to: expression.length
+	}];
+	const position = extractPositionFromMessage(error.message);
+	return [{
+		message: extractPlainMessage(error.message),
+		severity: "error",
+		from: position?.from ?? 0,
+		to: position?.to ?? expression.length
+	}];
+};
+//#endregion
+exports.extractDiagnostics = extractDiagnostics;

package/dist/checker/diagnostics.mjs

@@ -0,0 +1,66 @@
+//#region src/checker/diagnostics.ts
+/**
+* Extract position information from a cel-js error message.
+*
+* cel-js error messages embed a caret (`^`) on a separate line indicating
+* the error column. The format is:
+* ```
+* Error description
+*
+* >    1 | expression text
+*              ^
+* ```
+*
+* We parse the caret offset relative to the code line prefix (`>    N | `)
+* to derive the zero-based character offset within the expression.
+*/
+const extractPositionFromMessage = (message) => {
+	const lines = message.split("\n");
+	const caretLine = lines.find((line) => /^\s*\^+\s*$/.test(line));
+	if (!caretLine) return;
+	const codeLine = lines.find((line) => line.startsWith(">"));
+	if (!codeLine) return;
+	const pipeIndex = codeLine.indexOf("|");
+	if (pipeIndex === -1) return;
+	const prefixLength = pipeIndex + 2;
+	const caretStart = caretLine.indexOf("^");
+	const caretEnd = caretLine.lastIndexOf("^");
+	const from = caretStart - prefixLength;
+	const to = caretEnd - prefixLength + 1;
+	if (from < 0) return;
+	return {
+		from,
+		to
+	};
+};
+/**
+* Extract the plain error message without the caret/code-line decoration.
+*/
+const extractPlainMessage = (message) => {
+	return message.split("\n").filter((line) => !line.startsWith(">") && !/^\s*\^+\s*$/.test(line) && line.trim().length > 0).join(" ").trim() || message;
+};
+/**
+* Convert a cel-js error into position-aware SEL diagnostics.
+*
+* The error's `name` property distinguishes parse errors (`"ParseError"`)
+* from type errors (`"TypeError"`).  Position information is extracted from
+* the caret annotation embedded in the error message; when absent the
+* diagnostic spans the entire expression.
+*/
+const extractDiagnostics = (expression, error) => {
+	if (!(error instanceof Error)) return [{
+		message: String(error),
+		severity: "error",
+		from: 0,
+		to: expression.length
+	}];
+	const position = extractPositionFromMessage(error.message);
+	return [{
+		message: extractPlainMessage(error.message),
+		severity: "error",
+		from: position?.from ?? 0,
+		to: position?.to ?? expression.length
+	}];
+};
+//#endregion
+export { extractDiagnostics };

package/dist/checker/index.cjs

@@ -0,0 +1,2 @@
+require("./type-compatibility.cjs");
+require("./checker.cjs");

package/dist/checker/index.d.mts

@@ -0,0 +1,2 @@
+import { CompletionItem, SELChecker, SELCheckerOptions, SELDiagnostic } from "./checker.mjs";
+import { isTypeCompatible } from "./type-compatibility.mjs";

package/dist/checker/index.mjs

@@ -0,0 +1,3 @@
+import "./type-compatibility.mjs";
+import "./checker.mjs";
+export {};

package/dist/checker/type-compatibility.cjs

@@ -0,0 +1,70 @@
+//#region src/checker/type-compatibility.ts
+const LOGICAL_OPERATORS = new Set(["&&", "||"]);
+const ARITHMETIC_OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%"
+]);
+const COMPARISON_OPERATORS = new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const EQUALITY_OPERATORS = new Set(["==", "!="]);
+/** Types that support arithmetic operators (same-type only). */
+const ARITHMETIC_TYPES = new Set([
+	"int",
+	"uint",
+	"double",
+	"sol_int"
+]);
+/** Types that support the + operator for concatenation. */
+const CONCATENATION_TYPES = new Set([
+	"string",
+	"list",
+	"bytes"
+]);
+/** Types that support comparison operators (same-type only). */
+const COMPARISON_TYPES = new Set([
+	"int",
+	"uint",
+	"double",
+	"string",
+	"bytes",
+	"sol_address",
+	"sol_int"
+]);
+/**
+* Given the type of the left operand and the operator,
+* returns the expected type for the right operand.
+*
+* Based on the registered operators in register-types.ts.
+* Type compatibility is strictly same-type (no implicit coercion).
+*
+* Returns undefined when the type/operator combination is unknown,
+* signaling that no narrowing should occur.
+*/
+const expectedTypeForOperator = (leftType, operator) => {
+	if (LOGICAL_OPERATORS.has(operator)) return "bool";
+	if (ARITHMETIC_OPERATORS.has(operator)) {
+		if (ARITHMETIC_TYPES.has(leftType)) return leftType;
+		if (operator === "+" && CONCATENATION_TYPES.has(leftType)) return leftType;
+		return;
+	}
+	if (COMPARISON_OPERATORS.has(operator)) return COMPARISON_TYPES.has(leftType) ? leftType : void 0;
+	if (EQUALITY_OPERATORS.has(operator)) return leftType;
+};
+/**
+* Check if a candidate type is compatible with an expected type.
+* "dyn" is a wildcard — compatible with anything in either direction.
+*/
+const isTypeCompatible = (candidateType, expectedType) => {
+	if (expectedType === "dyn" || candidateType === "dyn") return true;
+	return candidateType === expectedType;
+};
+//#endregion
+exports.expectedTypeForOperator = expectedTypeForOperator;
+exports.isTypeCompatible = isTypeCompatible;

package/dist/checker/type-compatibility.d.cts

@@ -0,0 +1,8 @@
+//#region src/checker/type-compatibility.d.ts
+/**
+ * Check if a candidate type is compatible with an expected type.
+ * "dyn" is a wildcard — compatible with anything in either direction.
+ */
+declare const isTypeCompatible: (candidateType: string, expectedType: string) => boolean;
+//#endregion
+export { isTypeCompatible };

package/dist/checker/type-compatibility.d.mts

@@ -0,0 +1,8 @@
+//#region src/checker/type-compatibility.d.ts
+/**
+ * Check if a candidate type is compatible with an expected type.
+ * "dyn" is a wildcard — compatible with anything in either direction.
+ */
+declare const isTypeCompatible: (candidateType: string, expectedType: string) => boolean;
+//#endregion
+export { isTypeCompatible };

package/dist/checker/type-compatibility.mjs

@@ -0,0 +1,69 @@
+//#region src/checker/type-compatibility.ts
+const LOGICAL_OPERATORS = new Set(["&&", "||"]);
+const ARITHMETIC_OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%"
+]);
+const COMPARISON_OPERATORS = new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const EQUALITY_OPERATORS = new Set(["==", "!="]);
+/** Types that support arithmetic operators (same-type only). */
+const ARITHMETIC_TYPES = new Set([
+	"int",
+	"uint",
+	"double",
+	"sol_int"
+]);
+/** Types that support the + operator for concatenation. */
+const CONCATENATION_TYPES = new Set([
+	"string",
+	"list",
+	"bytes"
+]);
+/** Types that support comparison operators (same-type only). */
+const COMPARISON_TYPES = new Set([
+	"int",
+	"uint",
+	"double",
+	"string",
+	"bytes",
+	"sol_address",
+	"sol_int"
+]);
+/**
+* Given the type of the left operand and the operator,
+* returns the expected type for the right operand.
+*
+* Based on the registered operators in register-types.ts.
+* Type compatibility is strictly same-type (no implicit coercion).
+*
+* Returns undefined when the type/operator combination is unknown,
+* signaling that no narrowing should occur.
+*/
+const expectedTypeForOperator = (leftType, operator) => {
+	if (LOGICAL_OPERATORS.has(operator)) return "bool";
+	if (ARITHMETIC_OPERATORS.has(operator)) {
+		if (ARITHMETIC_TYPES.has(leftType)) return leftType;
+		if (operator === "+" && CONCATENATION_TYPES.has(leftType)) return leftType;
+		return;
+	}
+	if (COMPARISON_OPERATORS.has(operator)) return COMPARISON_TYPES.has(leftType) ? leftType : void 0;
+	if (EQUALITY_OPERATORS.has(operator)) return leftType;
+};
+/**
+* Check if a candidate type is compatible with an expected type.
+* "dyn" is a wildcard — compatible with anything in either direction.
+*/
+const isTypeCompatible = (candidateType, expectedType) => {
+	if (expectedType === "dyn" || candidateType === "dyn") return true;
+	return candidateType === expectedType;
+};
+//#endregion
+export { expectedTypeForOperator, isTypeCompatible };

package/dist/constants.cjs

@@ -0,0 +1,14 @@
+//#region src/constants.ts
+/** Comprehension macro names that introduce scoped iteration variables. */
+const COMPREHENSION_MACROS = new Set([
+	"map",
+	"filter",
+	"exists",
+	"all",
+	"exists_one"
+]);
+/** Solidity scalar wrapper functions (pass-through for arg classification). */
+const SCALAR_WRAPPER_FUNCTIONS = new Set(["solInt", "solAddress"]);
+//#endregion
+exports.COMPREHENSION_MACROS = COMPREHENSION_MACROS;
+exports.SCALAR_WRAPPER_FUNCTIONS = SCALAR_WRAPPER_FUNCTIONS;

package/dist/constants.d.cts

@@ -0,0 +1,7 @@
+//#region src/constants.d.ts
+/** Comprehension macro names that introduce scoped iteration variables. */
+declare const COMPREHENSION_MACROS: Set<string>;
+/** Solidity scalar wrapper functions (pass-through for arg classification). */
+declare const SCALAR_WRAPPER_FUNCTIONS: Set<string>;
+//#endregion
+export { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS };

package/dist/constants.d.mts

@@ -0,0 +1,7 @@
+//#region src/constants.d.ts
+/** Comprehension macro names that introduce scoped iteration variables. */
+declare const COMPREHENSION_MACROS: Set<string>;
+/** Solidity scalar wrapper functions (pass-through for arg classification). */
+declare const SCALAR_WRAPPER_FUNCTIONS: Set<string>;
+//#endregion
+export { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS };

package/dist/constants.mjs

@@ -0,0 +1,13 @@
+//#region src/constants.ts
+/** Comprehension macro names that introduce scoped iteration variables. */
+const COMPREHENSION_MACROS = new Set([
+	"map",
+	"filter",
+	"exists",
+	"all",
+	"exists_one"
+]);
+/** Solidity scalar wrapper functions (pass-through for arg classification). */
+const SCALAR_WRAPPER_FUNCTIONS = new Set(["solInt", "solAddress"]);
+//#endregion
+export { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS };

package/dist/debug.cjs

@@ -0,0 +1,7 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let debug = require("debug");
+debug = require_runtime.__toESM(debug);
+//#region src/debug.ts
+const createLogger = (namespace) => (0, debug.default)(`sel:checker:${namespace}`);
+//#endregion
+exports.createLogger = createLogger;

package/dist/debug.mjs

@@ -0,0 +1,5 @@
+import createDebug from "debug";
+//#region src/debug.ts
+const createLogger = (namespace) => createDebug(`sel:checker:${namespace}`);
+//#endregion
+export { createLogger };

package/dist/environment/codec-registry.cjs

@@ -0,0 +1,109 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let _seljs_types = require("@seljs/types");
+let zod = require("zod");
+//#region src/environment/codec-registry.ts
+const solidityAddressCodec = zod.z.codec(zod.z.string(), zod.z.instanceof(_seljs_types.SolidityAddressTypeWrapper), {
+	decode: (s) => new _seljs_types.SolidityAddressTypeWrapper(s),
+	encode: (w) => w.value
+});
+const solidityIntCodec = zod.z.codec(zod.z.union([zod.z.bigint(), zod.z.number().transform((n) => BigInt(n))]), zod.z.instanceof(_seljs_types.SolidityIntTypeWrapper), {
+	decode: (n) => new _seljs_types.SolidityIntTypeWrapper(n),
+	encode: (w) => w.value
+});
+/**
+* Registry that maps CEL type strings to bidirectional Zod 4 codecs.
+* Immutable after construction — all codecs resolved eagerly.
+*/
+var CelCodecRegistry = class {
+	codecs;
+	structMetas;
+	constructor(options) {
+		this.codecs = /* @__PURE__ */ new Map();
+		this.structMetas = /* @__PURE__ */ new Map();
+		this.codecs.set("sol_address", solidityAddressCodec);
+		this.codecs.set("sol_int", solidityIntCodec);
+		this.codecs.set("bool", zod.z.boolean());
+		this.codecs.set("string", zod.z.string());
+		this.codecs.set("int", zod.z.bigint());
+		this.codecs.set("bytes", zod.z.union([zod.z.instanceof(Uint8Array), zod.z.string().transform((s) => {
+			const hex = s.startsWith("0x") ? s.slice(2) : s;
+			const bytes = new Uint8Array(hex.length / 2);
+			for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+			return bytes;
+		})]));
+		this.codecs.set("dyn", zod.z.unknown().transform((v) => typeof v === "bigint" ? new _seljs_types.SolidityIntTypeWrapper(v) : v));
+		for (const desc of options?.structs ?? []) {
+			this.codecs.set(desc.name, this.buildStructCodec(desc));
+			this.structMetas.set(desc.name, {
+				fieldNames: desc.fieldNames,
+				fieldTypes: desc.fieldTypes
+			});
+		}
+	}
+	/**
+	* Resolve a codec for the given CEL type string.
+	* Handles `list<T>` container types by composing element codecs.
+	* Unknown types fall back to z.unknown().
+	*/
+	resolve(celType) {
+		const listMatch = /^list<(.+)>$/.exec(celType);
+		if (listMatch) {
+			const elementCodec = this.resolve(listMatch[1]);
+			return zod.z.array(elementCodec);
+		}
+		return this.codecs.get(celType) ?? zod.z.unknown();
+	}
+	/**
+	* Encode a CEL value back to its raw form using the codec for the given type.
+	* For bidirectional codecs (SolidityAddress, SolidityInt) this calls .encode().
+	* For structs, it recursively encodes each field.
+	* For passthrough types (bool, string, int), returns the value as-is.
+	*/
+	encode(celType, value) {
+		if (celType === "bytes") {
+			if (value instanceof Uint8Array) return "0x" + Array.from(value).map((b) => b.toString(16).padStart(2, "0")).join("");
+			return value;
+		}
+		if (celType === "dyn") {
+			if (value instanceof _seljs_types.SolidityIntTypeWrapper) return value.value;
+			if (value instanceof _seljs_types.SolidityAddressTypeWrapper) return value.value;
+			return value;
+		}
+		const listMatch = /^list<(.+)>$/.exec(celType);
+		if (listMatch && Array.isArray(value)) {
+			const elementType = listMatch[1];
+			return value.map((item) => this.encode(elementType, item));
+		}
+		const structMeta = this.structMetas.get(celType);
+		if (structMeta) {
+			const raw = value;
+			const result = {};
+			for (const name of structMeta.fieldNames) result[name] = this.encode(structMeta.fieldTypes[name] ?? "dyn", raw[name]);
+			return result;
+		}
+		const codec = this.codecs.get(celType);
+		if (!codec) return value;
+		try {
+			return codec.encode(value);
+		} catch {
+			return value;
+		}
+	}
+	buildStructCodec(desc) {
+		const { ctor, fieldNames, fieldTypes } = desc;
+		return zod.z.unknown().transform((input) => {
+			let data;
+			if (Array.isArray(input)) data = Object.fromEntries(fieldNames.map((name, i) => [name, this.decodeField(fieldTypes[name] ?? "dyn", input[i])]));
+			else {
+				const raw = input;
+				data = Object.fromEntries(fieldNames.map((name) => [name, this.decodeField(fieldTypes[name] ?? "dyn", raw[name])]));
+			}
+			return Object.assign(new ctor(), data);
+		});
+	}
+	decodeField(celType, value) {
+		return this.resolve(celType).parse(value);
+	}
+};
+//#endregion
+exports.CelCodecRegistry = CelCodecRegistry;

package/dist/environment/codec-registry.d.cts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+//#region src/environment/codec-registry.d.ts
+type AnyCodec = z.ZodType;
+/**
+ * Struct descriptor provided to CelCodecRegistry.
+ */
+interface StructCodecDescriptor {
+  name: string;
+  ctor: new () => object;
+  fieldNames: string[];
+  fieldTypes: Record<string, string>;
+}
+/**
+ * Options for constructing a CelCodecRegistry.
+ */
+interface CelCodecRegistryOptions {
+  structs?: StructCodecDescriptor[];
+}
+/**
+ * Registry that maps CEL type strings to bidirectional Zod 4 codecs.
+ * Immutable after construction — all codecs resolved eagerly.
+ */
+declare class CelCodecRegistry {
+  private readonly codecs;
+  private readonly structMetas;
+  constructor(options?: CelCodecRegistryOptions);
+  /**
+   * Resolve a codec for the given CEL type string.
+   * Handles `list<T>` container types by composing element codecs.
+   * Unknown types fall back to z.unknown().
+   */
+  resolve(celType: string): AnyCodec;
+  /**
+   * Encode a CEL value back to its raw form using the codec for the given type.
+   * For bidirectional codecs (SolidityAddress, SolidityInt) this calls .encode().
+   * For structs, it recursively encodes each field.
+   * For passthrough types (bool, string, int), returns the value as-is.
+   */
+  encode(celType: string, value: unknown): unknown;
+  private buildStructCodec;
+  private decodeField;
+}
+//#endregion
+export { CelCodecRegistry, CelCodecRegistryOptions, StructCodecDescriptor };

package/dist/environment/codec-registry.d.mts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+//#region src/environment/codec-registry.d.ts
+type AnyCodec = z.ZodType;
+/**
+ * Struct descriptor provided to CelCodecRegistry.
+ */
+interface StructCodecDescriptor {
+  name: string;
+  ctor: new () => object;
+  fieldNames: string[];
+  fieldTypes: Record<string, string>;
+}
+/**
+ * Options for constructing a CelCodecRegistry.
+ */
+interface CelCodecRegistryOptions {
+  structs?: StructCodecDescriptor[];
+}
+/**
+ * Registry that maps CEL type strings to bidirectional Zod 4 codecs.
+ * Immutable after construction — all codecs resolved eagerly.
+ */
+declare class CelCodecRegistry {
+  private readonly codecs;
+  private readonly structMetas;
+  constructor(options?: CelCodecRegistryOptions);
+  /**
+   * Resolve a codec for the given CEL type string.
+   * Handles `list<T>` container types by composing element codecs.
+   * Unknown types fall back to z.unknown().
+   */
+  resolve(celType: string): AnyCodec;
+  /**
+   * Encode a CEL value back to its raw form using the codec for the given type.
+   * For bidirectional codecs (SolidityAddress, SolidityInt) this calls .encode().
+   * For structs, it recursively encodes each field.
+   * For passthrough types (bool, string, int), returns the value as-is.
+   */
+  encode(celType: string, value: unknown): unknown;
+  private buildStructCodec;
+  private decodeField;
+}
+//#endregion
+export { CelCodecRegistry, CelCodecRegistryOptions, StructCodecDescriptor };

package/dist/environment/codec-registry.mjs

@@ -0,0 +1,108 @@
+import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper } from "@seljs/types";
+import { z } from "zod";
+//#region src/environment/codec-registry.ts
+const solidityAddressCodec = z.codec(z.string(), z.instanceof(SolidityAddressTypeWrapper), {
+	decode: (s) => new SolidityAddressTypeWrapper(s),
+	encode: (w) => w.value
+});
+const solidityIntCodec = z.codec(z.union([z.bigint(), z.number().transform((n) => BigInt(n))]), z.instanceof(SolidityIntTypeWrapper), {
+	decode: (n) => new SolidityIntTypeWrapper(n),
+	encode: (w) => w.value
+});
+/**
+* Registry that maps CEL type strings to bidirectional Zod 4 codecs.
+* Immutable after construction — all codecs resolved eagerly.
+*/
+var CelCodecRegistry = class {
+	codecs;
+	structMetas;
+	constructor(options) {
+		this.codecs = /* @__PURE__ */ new Map();
+		this.structMetas = /* @__PURE__ */ new Map();
+		this.codecs.set("sol_address", solidityAddressCodec);
+		this.codecs.set("sol_int", solidityIntCodec);
+		this.codecs.set("bool", z.boolean());
+		this.codecs.set("string", z.string());
+		this.codecs.set("int", z.bigint());
+		this.codecs.set("bytes", z.union([z.instanceof(Uint8Array), z.string().transform((s) => {
+			const hex = s.startsWith("0x") ? s.slice(2) : s;
+			const bytes = new Uint8Array(hex.length / 2);
+			for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+			return bytes;
+		})]));
+		this.codecs.set("dyn", z.unknown().transform((v) => typeof v === "bigint" ? new SolidityIntTypeWrapper(v) : v));
+		for (const desc of options?.structs ?? []) {
+			this.codecs.set(desc.name, this.buildStructCodec(desc));
+			this.structMetas.set(desc.name, {
+				fieldNames: desc.fieldNames,
+				fieldTypes: desc.fieldTypes
+			});
+		}
+	}
+	/**
+	* Resolve a codec for the given CEL type string.
+	* Handles `list<T>` container types by composing element codecs.
+	* Unknown types fall back to z.unknown().
+	*/
+	resolve(celType) {
+		const listMatch = /^list<(.+)>$/.exec(celType);
+		if (listMatch) {
+			const elementCodec = this.resolve(listMatch[1]);
+			return z.array(elementCodec);
+		}
+		return this.codecs.get(celType) ?? z.unknown();
+	}
+	/**
+	* Encode a CEL value back to its raw form using the codec for the given type.
+	* For bidirectional codecs (SolidityAddress, SolidityInt) this calls .encode().
+	* For structs, it recursively encodes each field.
+	* For passthrough types (bool, string, int), returns the value as-is.
+	*/
+	encode(celType, value) {
+		if (celType === "bytes") {
+			if (value instanceof Uint8Array) return "0x" + Array.from(value).map((b) => b.toString(16).padStart(2, "0")).join("");
+			return value;
+		}
+		if (celType === "dyn") {
+			if (value instanceof SolidityIntTypeWrapper) return value.value;
+			if (value instanceof SolidityAddressTypeWrapper) return value.value;
+			return value;
+		}
+		const listMatch = /^list<(.+)>$/.exec(celType);
+		if (listMatch && Array.isArray(value)) {
+			const elementType = listMatch[1];
+			return value.map((item) => this.encode(elementType, item));
+		}
+		const structMeta = this.structMetas.get(celType);
+		if (structMeta) {
+			const raw = value;
+			const result = {};
+			for (const name of structMeta.fieldNames) result[name] = this.encode(structMeta.fieldTypes[name] ?? "dyn", raw[name]);
+			return result;
+		}
+		const codec = this.codecs.get(celType);
+		if (!codec) return value;
+		try {
+			return codec.encode(value);
+		} catch {
+			return value;
+		}
+	}
+	buildStructCodec(desc) {
+		const { ctor, fieldNames, fieldTypes } = desc;
+		return z.unknown().transform((input) => {
+			let data;
+			if (Array.isArray(input)) data = Object.fromEntries(fieldNames.map((name, i) => [name, this.decodeField(fieldTypes[name] ?? "dyn", input[i])]));
+			else {
+				const raw = input;
+				data = Object.fromEntries(fieldNames.map((name) => [name, this.decodeField(fieldTypes[name] ?? "dyn", raw[name])]));
+			}
+			return Object.assign(new ctor(), data);
+		});
+	}
+	decodeField(celType, value) {
+		return this.resolve(celType).parse(value);
+	}
+};
+//#endregion
+export { CelCodecRegistry };