@callcium/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3216 @@
+import { keccak_256 } from "@noble/hashes/sha3";
+//#region src/errors.ts
+/**
+* Thrown when a policy or descriptor blob is structurally malformed.
+* The optional `offset` indicates the byte position in the source blob where the error was detected.
+*/
+var CallciumError = class CallciumError extends Error {
+	code;
+	/** Byte position in the source blob where the error was detected, if applicable. */
+	offset;
+	constructor(code, message, offset) {
+		const prefix = offset !== void 0 ? `[offset ${offset}] ` : "";
+		super(`${prefix}${message}`);
+		this.name = "CallciumError";
+		this.code = code;
+		Object.setPrototypeOf(this, CallciumError.prototype);
+	}
+};
+/**
+* Thrown by `PolicyEnforcer.enforce` when calldata fails policy enforcement.
+* Distinct from `CallciumError("VALIDATION_ERROR")`, which signals static
+* issues in the policy itself.
+* Carries the full list of violations (one per failed group).
+*/
+var PolicyViolationError = class PolicyViolationError extends Error {
+	violations;
+	constructor(violations) {
+		const first = violations[0];
+		const msg = first ? `Policy violation: ${first.message}` : "Policy violation";
+		super(msg);
+		this.name = "PolicyViolationError";
+		this.violations = violations;
+		Object.setPrototypeOf(this, PolicyViolationError.prototype);
+	}
+};
+//#endregion
+//#region src/bytes.ts
+/** Regex that matches a valid hex body (even number of hex chars). */
+const HEX_BODY_RE = /^[0-9a-fA-F]*$/;
+/** Convert a hex string to a byte array, stripping the 0x prefix if present. */
+function hexToBytes(hex) {
+	const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (clean.length % 2 !== 0) throw new CallciumError("INVALID_HEX", "Odd-length hex string");
+	if (!HEX_BODY_RE.test(clean)) throw new CallciumError("INVALID_HEX", "Invalid hex characters");
+	const bytes = new Uint8Array(clean.length / 2);
+	for (let i = 0; i < clean.length; i += 2) bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
+	return bytes;
+}
+const HEX_LUT = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+/** Convert a byte array to a 0x-prefixed lowercase hex string. */
+function bytesToHex(bytes) {
+	let body = "";
+	for (let i = 0; i < bytes.length; i++) body += HEX_LUT[bytes[i]];
+	return `0x${body}`;
+}
+/** Extract a subarray and return it as a 0x-prefixed hex string. */
+function toHex(data, start, end) {
+	return bytesToHex(data.subarray(start, end));
+}
+/** Read a big-endian uint16 from a byte array at the given offset. */
+function readU16(data, offset) {
+	return data[offset] << 8 | data[offset + 1];
+}
+/** Read a big-endian uint24 from a byte array at the given offset. */
+function readU24(data, offset) {
+	return data[offset] << 16 | data[offset + 1] << 8 | data[offset + 2];
+}
+/** Read a big-endian uint32 from a byte array at the given offset. */
+function readU32(data, offset) {
+	return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+/** Write a 16-bit big-endian value into a Uint8Array at offset. */
+function writeBE16(buffer, offset, value) {
+	buffer[offset] = value >>> 8 & 255;
+	buffer[offset + 1] = value & 255;
+}
+/** Write a 24-bit big-endian value into a Uint8Array at offset. */
+function writeBE24(buffer, offset, value) {
+	buffer[offset] = value >>> 16 & 255;
+	buffer[offset + 1] = value >>> 8 & 255;
+	buffer[offset + 2] = value & 255;
+}
+/** Format a bigint as a zero-padded 32-byte hex string. */
+function bigintToHex(value) {
+	return `0x${value.toString(16).padStart(64, "0")}`;
+}
+/** Validate and brand a hex string as an address. Throws if the runtime length is not exactly 20 bytes. */
+function toAddress(hex) {
+	const body = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (body.length !== 40) throw new CallciumError("INVALID_HEX", `Invalid address length: expected 40 hex chars, got ${body.length}`);
+	if (!HEX_BODY_RE.test(body)) throw new CallciumError("INVALID_HEX", "Invalid hex characters in address");
+	return `0x${body}`;
+}
+//#endregion
+//#region src/constants.ts
+/** Binary layout constants for the Callcium descriptor format. */
+const DescriptorFormat = {
+	VERSION: 1,
+	HEADER_SIZE: 2,
+	TYPECODE_SIZE: 1,
+	COMPOSITE_META_SIZE: 3,
+	TUPLE_HEADER_SIZE: 6,
+	ARRAY_HEADER_SIZE: 4,
+	ARRAY_LENGTH_SIZE: 2,
+	TUPLE_FIELDCOUNT_SIZE: 2,
+	META_STATIC_WORDS_SHIFT: 12,
+	META_NODE_LENGTH_MASK: 4095,
+	MAX_NODE_LENGTH: 4095,
+	MAX_STATIC_ARRAY_LENGTH: 4095,
+	MAX_TUPLE_FIELDS: 4089,
+	MAX_PARAMS: 255
+};
+/** Binary layout constants for the Callcium policy format. */
+const PolicyFormat = {
+	VERSION: 1,
+	VERSION_MASK: 15,
+	FLAG_NO_SELECTOR: 16,
+	RESERVED_MASK: 224,
+	HEADER_SIZE: 1,
+	SELECTOR_OFFSET: 1,
+	SELECTOR_SIZE: 4,
+	DESC_LENGTH_OFFSET: 5,
+	DESC_LENGTH_SIZE: 2,
+	DESC_OFFSET: 7,
+	GROUP_COUNT_SIZE: 1,
+	GROUP_RULECOUNT_SIZE: 2,
+	GROUP_SIZE_SIZE: 4,
+	GROUP_HEADER_SIZE: 6,
+	RULE_SIZE_SIZE: 2,
+	RULE_SCOPE_OFFSET: 2,
+	RULE_DEPTH_OFFSET: 3,
+	RULE_PATH_OFFSET: 4,
+	PATH_STEP_SIZE: 2,
+	RULE_OPCODE_SIZE: 1,
+	RULE_DATALENGTH_SIZE: 2,
+	RULE_FIXED_OVERHEAD: 7,
+	RULE_MIN_SIZE: 9
+};
+/** Build a plain `{ KEY: code }` object from a table at runtime. */
+function buildCodeMap(table) {
+	return Object.fromEntries(table.map((e) => [e.key, e.code]));
+}
+const SCOPE_TABLE = [{
+	key: "CONTEXT",
+	code: 0,
+	label: "context"
+}, {
+	key: "CALLDATA",
+	code: 1,
+	label: "calldata"
+}];
+/** Rule scope discriminant: context (EVM environment) vs. calldata (ABI payload). */
+const Scope = buildCodeMap(SCOPE_TABLE);
+const scopeByCode = new Map(SCOPE_TABLE.map((e) => [e.code, { label: e.label }]));
+/**
+* Map a scope code to its display label.
+* @param code - Scope byte value.
+* @returns Display metadata for the scope.
+* @throws {CallciumError} If the code is not a recognised scope.
+*/
+function lookupScope(code) {
+	const info = scopeByCode.get(code);
+	if (!info) throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${code}`);
+	return info;
+}
+const CTX_PROP_TABLE = [
+	{
+		key: "MSG_SENDER",
+		code: 0,
+		label: "msg.sender",
+		typeCode: 64
+	},
+	{
+		key: "MSG_VALUE",
+		code: 1,
+		label: "msg.value",
+		typeCode: 31
+	},
+	{
+		key: "BLOCK_TIMESTAMP",
+		code: 2,
+		label: "block.timestamp",
+		typeCode: 31
+	},
+	{
+		key: "BLOCK_NUMBER",
+		code: 3,
+		label: "block.number",
+		typeCode: 31
+	},
+	{
+		key: "CHAIN_ID",
+		code: 4,
+		label: "block.chainid",
+		typeCode: 31
+	},
+	{
+		key: "TX_ORIGIN",
+		code: 5,
+		label: "tx.origin",
+		typeCode: 64
+	}
+];
+/** Well-known context property IDs for context-scope rules. */
+const ContextProperty = buildCodeMap(CTX_PROP_TABLE);
+/** Maximum valid context property ID. */
+const MAX_CONTEXT_PROPERTY_ID = Math.max(...CTX_PROP_TABLE.map((e) => e.code));
+/** Maps each context property table key to its camelCase Context key. */
+const CTX_KEY_MAP = {
+	MSG_SENDER: "msgSender",
+	MSG_VALUE: "msgValue",
+	BLOCK_TIMESTAMP: "blockTimestamp",
+	BLOCK_NUMBER: "blockNumber",
+	CHAIN_ID: "chainId",
+	TX_ORIGIN: "txOrigin"
+};
+const ctxPropByCode = new Map(CTX_PROP_TABLE.map((e) => [e.code, {
+	label: e.label,
+	contextKey: CTX_KEY_MAP[e.key],
+	typeCode: e.typeCode
+}]));
+/**
+* Map a context property code to its display label and ABI type code.
+* @param code - Context property ID.
+* @returns Display metadata including the Solidity type code for the property value.
+* @throws {CallciumError} If the code is not a recognised context property.
+*/
+function lookupContextProperty(code) {
+	const info = ctxPropByCode.get(code);
+	if (!info) throw new CallciumError("INVALID_CONTEXT_PROPERTY", `Unknown context property ${code}`);
+	return info;
+}
+/** Protocol-imposed safety limits for path depth and quantifier array size. */
+const Limits = {
+	MAX_PATH_DEPTH: 32,
+	MAX_QUANTIFIED_ARRAY_LENGTH: 256
+};
+/** @internal */
+const OP_TABLE = [
+	{
+		key: "EQ",
+		code: 1,
+		label: "==",
+		operands: "single"
+	},
+	{
+		key: "GT",
+		code: 2,
+		label: ">",
+		operands: "single"
+	},
+	{
+		key: "LT",
+		code: 3,
+		label: "<",
+		operands: "single"
+	},
+	{
+		key: "GTE",
+		code: 4,
+		label: ">=",
+		operands: "single"
+	},
+	{
+		key: "LTE",
+		code: 5,
+		label: "<=",
+		operands: "single"
+	},
+	{
+		key: "BETWEEN",
+		code: 6,
+		label: "between",
+		operands: "range"
+	},
+	{
+		key: "IN",
+		code: 7,
+		label: "in",
+		operands: "variadic"
+	},
+	{
+		key: "BITMASK_ALL",
+		code: 16,
+		label: "bitmask all",
+		operands: "single"
+	},
+	{
+		key: "BITMASK_ANY",
+		code: 17,
+		label: "bitmask any",
+		operands: "single"
+	},
+	{
+		key: "BITMASK_NONE",
+		code: 18,
+		label: "bitmask none",
+		operands: "single"
+	},
+	{
+		key: "LENGTH_EQ",
+		code: 32,
+		label: "length ==",
+		operands: "single"
+	},
+	{
+		key: "LENGTH_GT",
+		code: 33,
+		label: "length >",
+		operands: "single"
+	},
+	{
+		key: "LENGTH_LT",
+		code: 34,
+		label: "length <",
+		operands: "single"
+	},
+	{
+		key: "LENGTH_GTE",
+		code: 35,
+		label: "length >=",
+		operands: "single"
+	},
+	{
+		key: "LENGTH_LTE",
+		code: 36,
+		label: "length <=",
+		operands: "single"
+	},
+	{
+		key: "LENGTH_BETWEEN",
+		code: 37,
+		label: "length between",
+		operands: "range"
+	}
+];
+/** Callcium policy operator codes. */
+const Op = {
+	...buildCodeMap(OP_TABLE),
+	NOT: 128
+};
+const opByCode = new Map(OP_TABLE.map((e) => [e.code, {
+	label: e.label,
+	operands: e.operands
+}]));
+/**
+* Map an operator code to its display label. Strips the NOT flag automatically.
+* @param code - Operator byte value (may include the NOT flag).
+* @returns Display metadata for the base operator.
+* @throws {CallciumError} If the base code is not a recognised operator.
+*/
+function lookupOp(code) {
+	const base = code & ~Op.NOT;
+	const info = opByCode.get(base);
+	if (!info) throw new CallciumError("INVALID_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}`);
+	return info;
+}
+/**
+* Check whether an operator's data payload has the correct length.
+* @param opBase - Base operator code with the NOT flag stripped.
+* @param dataLength - Byte length of the operator's data payload.
+* @returns True if the data length is valid for the given operator.
+*/
+function isValidOperatorData(opBase, dataLength) {
+	const operands = opByCode.get(opBase)?.operands;
+	if (operands === "single") return dataLength === 32;
+	if (operands === "range") return dataLength === 64;
+	if (operands === "variadic") return dataLength > 0 && dataLength % 32 === 0;
+	return false;
+}
+const QUANTIFIER_TABLE = [
+	{
+		key: "ALL_OR_EMPTY",
+		code: 65535,
+		label: "all or empty"
+	},
+	{
+		key: "ALL",
+		code: 65534,
+		label: "all"
+	},
+	{
+		key: "ANY",
+		code: 65533,
+		label: "any"
+	}
+];
+/** Reserved path step values that trigger quantified evaluation over array elements. */
+const Quantifier = buildCodeMap(QUANTIFIER_TABLE);
+const quantifierByCode = new Map(QUANTIFIER_TABLE.map((e) => [e.code, { label: e.label }]));
+/** Check whether a path step is a quantifier (ALL_OR_EMPTY, ALL, or ANY). */
+function isQuantifier(step) {
+	return step >= Quantifier.ANY;
+}
+/**
+* Map a quantifier path step to its display label.
+* @param code - Quantifier step value.
+* @returns Display metadata for the quantifier.
+* @throws {CallciumError} If the code is not a recognised quantifier.
+*/
+function lookupQuantifier(code) {
+	const info = quantifierByCode.get(code);
+	if (!info) throw new CallciumError("INVALID_QUANTIFIER", `Unknown quantifier step 0x${code.toString(16)}`);
+	return info;
+}
+/** ABI type code ranges and sentinel values for the descriptor format. */
+const TypeCode = {
+	UINT_MIN: 0,
+	UINT_MAX: 31,
+	INT_MIN: 32,
+	INT_MAX: 63,
+	ADDRESS: 64,
+	BOOL: 65,
+	FUNCTION: 66,
+	FIXED_BYTES_MIN: 80,
+	FIXED_BYTES_MAX: 111,
+	BYTES: 112,
+	STRING: 113,
+	STATIC_ARRAY: 128,
+	DYNAMIC_ARRAY: 129,
+	TUPLE: 144
+};
+/** Throw an UNKNOWN_TYPE_CODE error. */
+function unknownTypeCode(code) {
+	throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code 0x${code.toString(16).padStart(2, "0")}`);
+}
+const ELEMENTARY = {
+	typeClass: "elementary",
+	isDynamic: false
+};
+const ELEMENTARY_DYN = {
+	typeClass: "elementary",
+	isDynamic: true
+};
+const STATIC_ARR = {
+	typeClass: "staticArray",
+	isDynamic: false
+};
+const DYNAMIC_ARR = {
+	typeClass: "dynamicArray",
+	isDynamic: true
+};
+const TUPLE = {
+	typeClass: "tuple",
+	isDynamic: false
+};
+/**
+* Classify a type code into its structural category and dynamism.
+* Lightweight variant of `lookupTypeCode` that skips label computation.
+* @param code - A single-byte descriptor type code.
+* @returns Type class and whether the type is ABI-dynamic.
+* @throws {CallciumError} If the code is not a recognised type code.
+*/
+function classifyTypeCode(code) {
+	if (code >= TypeCode.UINT_MIN && code <= TypeCode.UINT_MAX) return ELEMENTARY;
+	if (code >= TypeCode.INT_MIN && code <= TypeCode.INT_MAX) return ELEMENTARY;
+	if (code === TypeCode.ADDRESS || code === TypeCode.BOOL || code === TypeCode.FUNCTION) return ELEMENTARY;
+	if (code >= 67 && code <= 79) unknownTypeCode(code);
+	if (code >= TypeCode.FIXED_BYTES_MIN && code <= TypeCode.FIXED_BYTES_MAX) return ELEMENTARY;
+	if (code === TypeCode.BYTES || code === TypeCode.STRING) return ELEMENTARY_DYN;
+	if (code >= 114 && code <= 127) unknownTypeCode(code);
+	if (code === TypeCode.STATIC_ARRAY) return STATIC_ARR;
+	if (code === TypeCode.DYNAMIC_ARRAY) return DYNAMIC_ARR;
+	if (code >= 130 && code <= 143) unknownTypeCode(code);
+	if (code === TypeCode.TUPLE) return TUPLE;
+	unknownTypeCode(code);
+}
+/** Compute the Solidity type label for a type code. */
+function typeCodeLabel(code) {
+	if (code >= TypeCode.UINT_MIN && code <= TypeCode.UINT_MAX) return `uint${(code - TypeCode.UINT_MIN + 1) * 8}`;
+	if (code >= TypeCode.INT_MIN && code <= TypeCode.INT_MAX) return `int${(code - TypeCode.INT_MIN + 1) * 8}`;
+	if (code === TypeCode.ADDRESS) return "address";
+	if (code === TypeCode.BOOL) return "bool";
+	if (code === TypeCode.FUNCTION) return "function";
+	if (code >= TypeCode.FIXED_BYTES_MIN && code <= TypeCode.FIXED_BYTES_MAX) return `bytes${code - TypeCode.FIXED_BYTES_MIN + 1}`;
+	if (code === TypeCode.BYTES) return "bytes";
+	if (code === TypeCode.STRING) return "string";
+	if (code === TypeCode.STATIC_ARRAY) return "T[k]";
+	if (code === TypeCode.DYNAMIC_ARRAY) return "T[]";
+	if (code === TypeCode.TUPLE) return "tuple";
+	return `0x${code.toString(16).padStart(2, "0")}`;
+}
+/**
+* Map a raw type code byte to its Solidity label, structural category, and dynamism.
+* @param code - A single-byte descriptor type code.
+* @returns Label, type class, and whether the type is ABI-dynamic.
+* @throws {CallciumError} If the code is not a recognised type code.
+*/
+function lookupTypeCode(code) {
+	return {
+		label: typeCodeLabel(code),
+		...classifyTypeCode(code)
+	};
+}
+//#endregion
+//#region src/descriptor.ts
+/**
+* Return the byte length of the node at `offset`.
+* Elementary nodes occupy exactly one byte; composite nodes encode their
+* length in the lower 12 bits of the 24-bit meta field.
+*/
+function nodeLength(desc, offset) {
+	if (desc[offset] < TypeCode.STATIC_ARRAY) return DescriptorFormat.TYPECODE_SIZE;
+	return readU24(desc, offset + 1) & DescriptorFormat.META_NODE_LENGTH_MASK;
+}
+/**
+* Return the byte offset of the `fieldIndex`-th field inside a tuple node.
+* Starts at the first field and skips `fieldIndex` nodes using `nodeLength`.
+*/
+function tupleFieldOffset(desc, tupleOffset, fieldIndex) {
+	let cursor = tupleOffset + DescriptorFormat.TUPLE_HEADER_SIZE;
+	for (let i = 0; i < fieldIndex; i++) cursor += nodeLength(desc, cursor);
+	return cursor;
+}
+/** Return paramCount from header byte 1. */
+function paramCount(desc) {
+	return desc[1];
+}
+/** Return byte offset of the N-th top-level param (0-indexed). */
+function paramOffset(desc, index) {
+	const count = desc[1];
+	if (index >= count) throw new CallciumError("INVALID_PATH", `Param index ${index} out of range (paramCount=${count}).`);
+	let cursor = DescriptorFormat.HEADER_SIZE;
+	for (let i = 0; i < index; i++) cursor += nodeLength(desc, cursor);
+	return cursor;
+}
+/**
+* Inspect the type node at a given byte offset.
+* @param desc - Raw descriptor bytes.
+* @param offset - Byte position of the node.
+* @returns typeCode, isDynamic, and staticSize in bytes.
+*/
+function inspect$1(desc, offset) {
+	const typeCode = desc[offset];
+	let staticWords;
+	if (typeCode < TypeCode.STATIC_ARRAY) staticWords = typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING ? 0 : 1;
+	else staticWords = readU24(desc, offset + 1) >> DescriptorFormat.META_STATIC_WORDS_SHIFT;
+	return {
+		typeCode,
+		isDynamic: staticWords === 0,
+		staticSize: staticWords * 32
+	};
+}
+/**
+* Resolve the type at a calldata path (array of step indices).
+*
+* The first step selects a top-level param. Each subsequent step descends
+* into the current node: for tuples it selects a field, for arrays it
+* advances to the element descriptor.
+*
+* @param desc - Raw descriptor bytes.
+* @param steps - Path steps, length >= 1.
+* @returns TypeInfo for the node at the resolved path.
+* @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
+*/
+function typeAt(desc, steps) {
+	if (steps.length === 0) throw new CallciumError("INVALID_PATH", "Path must have at least one step.");
+	const paramIndex = steps[0];
+	const count = desc[1];
+	if (paramIndex >= count) throw new CallciumError("INVALID_PATH", `Param index ${paramIndex} out of range (paramCount=${count}).`);
+	let cursor = paramOffset(desc, paramIndex);
+	for (let stepIndex = 1; stepIndex < steps.length; stepIndex++) {
+		const typeCode = desc[cursor];
+		const step = steps[stepIndex];
+		if (typeCode === TypeCode.TUPLE) {
+			const fields = tupleFieldCount(desc, cursor);
+			if (step >= fields) throw new CallciumError("INVALID_PATH", `Tuple field index ${step} out of range (tuple has ${fields} fields).`);
+			cursor = tupleFieldOffset(desc, cursor, step);
+		} else if (typeCode === TypeCode.STATIC_ARRAY || typeCode === TypeCode.DYNAMIC_ARRAY) cursor = arrayElementOffset(cursor);
+		else throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type at offset ${cursor}.`);
+	}
+	return inspect$1(desc, cursor);
+}
+/**
+* Return tuple field count at a tuple node offset.
+* @param desc - Raw descriptor bytes.
+* @param offset - Byte position of the tuple node.
+*/
+function tupleFieldCount(desc, offset) {
+	return readU16(desc, offset + 4);
+}
+/**
+* Return static array length at a static array node offset.
+* @param desc - Raw descriptor bytes.
+* @param offset - Byte position of the static array node.
+*/
+function staticArrayLength(desc, offset) {
+	const elemOffset = arrayElementOffset(offset);
+	return readU16(desc, elemOffset + nodeLength(desc, elemOffset));
+}
+/**
+* Return the byte offset of the array element descriptor.
+* @param offset - Byte position of the array node (static or dynamic).
+*/
+function arrayElementOffset(offset) {
+	return offset + DescriptorFormat.ARRAY_HEADER_SIZE;
+}
+/** Inspect and navigate raw descriptor bytes. */
+const Descriptor = {
+	paramCount,
+	paramOffset,
+	inspect: inspect$1,
+	typeAt,
+	tupleFieldOffset,
+	tupleFieldCount,
+	staticArrayLength,
+	nodeLength,
+	arrayElementOffset
+};
+//#endregion
+//#region src/type-desc.ts
+/**
+* Extract the staticWords count from a descriptor node.
+*
+* For elementary types (typeCode < STATIC_ARRAY), returns 1 unless the type is
+* BYTES or STRING, which are ABI-dynamic and return 0. For composite types,
+* reads the 24-bit meta field at offset 1 and shifts right by
+* META_STATIC_WORDS_SHIFT.
+*/
+function extractStaticWords(desc) {
+	const typeCode = desc[0];
+	if (typeCode < TypeCode.STATIC_ARRAY) return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING ? 0 : 1;
+	return readU24(desc, 1) >> DescriptorFormat.META_STATIC_WORDS_SHIFT;
+}
+/** Build a descriptor node for `address`. */
+function address() {
+	return new Uint8Array([TypeCode.ADDRESS]);
+}
+/** Build a descriptor node for `bool`. */
+function bool() {
+	return new Uint8Array([TypeCode.BOOL]);
+}
+/** Build a descriptor node for `function`. */
+function function_() {
+	return new Uint8Array([TypeCode.FUNCTION]);
+}
+/** Build a descriptor node for `uint256`. */
+function uint256() {
+	return new Uint8Array([TypeCode.UINT_MAX]);
+}
+/**
+* Build a descriptor node for `uintN`.
+* @param bits - Bit width, 8–256 in steps of 8.
+* @throws {CallciumError} If bits is out of range or not a multiple of 8.
+*/
+function uintN(bits) {
+	if (bits < 8 || bits > 256 || bits % 8 !== 0) throw new CallciumError("INVALID_TYPE_STRING", `Invalid uintN bits: ${bits}. Must be 8–256 in steps of 8.`);
+	return new Uint8Array([TypeCode.UINT_MIN + (bits / 8 - 1)]);
+}
+/**
+* Build a descriptor node for `intN`.
+* @param bits - Bit width, 8–256 in steps of 8.
+* @throws {CallciumError} If bits is out of range or not a multiple of 8.
+*/
+function intN(bits) {
+	if (bits < 8 || bits > 256 || bits % 8 !== 0) throw new CallciumError("INVALID_TYPE_STRING", `Invalid intN bits: ${bits}. Must be 8–256 in steps of 8.`);
+	return new Uint8Array([TypeCode.INT_MIN + (bits / 8 - 1)]);
+}
+/** Build a descriptor node for `bytes` (dynamic). */
+function bytes() {
+	return new Uint8Array([TypeCode.BYTES]);
+}
+/** Build a descriptor node for `string`. */
+function string_() {
+	return new Uint8Array([TypeCode.STRING]);
+}
+/**
+* Build a descriptor node for `bytesN`.
+* @param n - Byte width, 1–32.
+* @throws {CallciumError} If n is out of range.
+*/
+function bytesN(n) {
+	if (n < 1 || n > 32) throw new CallciumError("INVALID_TYPE_STRING", `Invalid bytesN size: ${n}. Must be 1–32.`);
+	return new Uint8Array([TypeCode.FIXED_BYTES_MIN + (n - 1)]);
+}
+/**
+* Build a descriptor node for a dynamic array `T[]` or static array `T[length]`.
+*
+* Dynamic form: `[0x81][meta:3][elemDesc]`
+* Static form:  `[0x80][meta:3][elemDesc][length:be16]`
+*
+* @param elemDesc - Descriptor bytes for the element type.
+* @param length - Fixed array length. When omitted, produces a dynamic array.
+* @throws {CallciumError} If length is 0 or exceeds MAX_STATIC_ARRAY_LENGTH.
+*/
+function array(elemDesc, length) {
+	if (length === void 0) {
+		const nodeLength = DescriptorFormat.ARRAY_HEADER_SIZE + elemDesc.length;
+		if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("DESCRIPTOR_TOO_LARGE", `Dynamic array node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}.`);
+		const meta24 = 0 << DescriptorFormat.META_STATIC_WORDS_SHIFT | nodeLength;
+		const buf = new Uint8Array(1 + DescriptorFormat.COMPOSITE_META_SIZE + elemDesc.length);
+		buf[0] = TypeCode.DYNAMIC_ARRAY;
+		writeBE24(buf, 1, meta24);
+		buf.set(elemDesc, 4);
+		return buf;
+	}
+	if (length <= 0 || length > DescriptorFormat.MAX_STATIC_ARRAY_LENGTH) throw new CallciumError("INVALID_ARRAY_LENGTH", `Static array length ${length} out of range. Must be 1–${DescriptorFormat.MAX_STATIC_ARRAY_LENGTH}.`);
+	const nodeLength = DescriptorFormat.ARRAY_HEADER_SIZE + elemDesc.length + DescriptorFormat.ARRAY_LENGTH_SIZE;
+	if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("DESCRIPTOR_TOO_LARGE", `Static array node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}.`);
+	const elemStaticWords = extractStaticWords(elemDesc);
+	const staticWords = elemStaticWords === 0 ? 0 : length * elemStaticWords;
+	if (staticWords > DescriptorFormat.META_NODE_LENGTH_MASK) throw new CallciumError("DESCRIPTOR_TOO_LARGE", `Static array static words ${staticWords} exceeds 12-bit maximum ${DescriptorFormat.META_NODE_LENGTH_MASK}.`);
+	const meta24 = staticWords << DescriptorFormat.META_STATIC_WORDS_SHIFT | nodeLength;
+	const buf = new Uint8Array(1 + DescriptorFormat.COMPOSITE_META_SIZE + elemDesc.length + DescriptorFormat.ARRAY_LENGTH_SIZE);
+	buf[0] = TypeCode.STATIC_ARRAY;
+	writeBE24(buf, 1, meta24);
+	buf.set(elemDesc, 4);
+	writeBE16(buf, 4 + elemDesc.length, length);
+	return buf;
+}
+/**
+* Build a descriptor node for a tuple.
+*
+* Format: `[0x90][meta:3][fieldCount:be16][field0][field1]...`
+*
+* @param fieldDescs - Descriptor bytes for each field, in order.
+* @throws {CallciumError} If fieldDescs is empty, exceeds MAX_TUPLE_FIELDS, or nodeLength overflows MAX_NODE_LENGTH.
+*/
+function tuple(fieldDescs) {
+	if (fieldDescs.length === 0 || fieldDescs.length > DescriptorFormat.MAX_TUPLE_FIELDS) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", `Tuple field count ${fieldDescs.length} out of range. Must be 1–${DescriptorFormat.MAX_TUPLE_FIELDS}.`);
+	const totalFieldBytes = fieldDescs.reduce((sum, f) => sum + f.length, 0);
+	const nodeLength = DescriptorFormat.TUPLE_HEADER_SIZE + totalFieldBytes;
+	if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", `Tuple node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}.`);
+	let anyDynamic = false;
+	let staticWordsSum = 0;
+	for (const field of fieldDescs) {
+		const staticWords = extractStaticWords(field);
+		if (staticWords === 0) anyDynamic = true;
+		staticWordsSum += staticWords;
+	}
+	const staticWords = anyDynamic ? 0 : staticWordsSum;
+	if (staticWords > DescriptorFormat.META_NODE_LENGTH_MASK) throw new CallciumError("DESCRIPTOR_TOO_LARGE", `Tuple static words ${staticWords} exceeds 12-bit maximum ${DescriptorFormat.META_NODE_LENGTH_MASK}.`);
+	const meta24 = staticWords << DescriptorFormat.META_STATIC_WORDS_SHIFT | nodeLength;
+	const buf = new Uint8Array(1 + DescriptorFormat.COMPOSITE_META_SIZE + DescriptorFormat.TUPLE_FIELDCOUNT_SIZE + totalFieldBytes);
+	buf[0] = TypeCode.TUPLE;
+	writeBE24(buf, 1, meta24);
+	writeBE16(buf, 4, fieldDescs.length);
+	let offset = 6;
+	for (const field of fieldDescs) {
+		buf.set(field, offset);
+		offset += field.length;
+	}
+	return buf;
+}
+//#endregion
+//#region src/descriptor-coder.ts
+/**
+* Collect the positions of depth-0 commas in input[start..end).
+* Commas inside `()` or `[]` are skipped.
+*/
+function commaPositions(input, start, end) {
+	const positions = [];
+	let depth = 0;
+	for (let i = start; i < end; i++) {
+		const char = input[i];
+		if (char === "(" || char === "[") depth++;
+		else if (char === ")" || char === "]") depth--;
+		else if (char === "," && depth === 0) positions.push(i);
+	}
+	return positions;
+}
+/**
+* Parse a decimal integer from input[start..end).
+* Returns -1 if the substring is empty or contains non-digit characters.
+*/
+function parseUint(input, start, end) {
+	if (start >= end) return -1;
+	let value = 0;
+	for (let i = start; i < end; i++) {
+		const code = input.charCodeAt(i);
+		if (code < 48 || code > 57) return -1;
+		value = value * 10 + (code - 48);
+	}
+	return value;
+}
+/**
+* Parse a tuple literal `(field0,field1,...)` where the opening `(` is at
+* `start` and the substring to parse ends before `end`.
+*/
+function parseTuple(input, start, end) {
+	if (input[start] !== "(") throw new CallciumError("INVALID_TYPE_STRING", `Expected '(' at position ${start}`);
+	let depth = 0;
+	let closePos = -1;
+	for (let i = start; i < end; i++) if (input[i] === "(") depth++;
+	else if (input[i] === ")") {
+		depth--;
+		if (depth === 0) {
+			closePos = i;
+			break;
+		}
+	}
+	if (closePos === -1) throw new CallciumError("INVALID_TYPE_STRING", `Unmatched '(' at position ${start}`);
+	const innerStart = start + 1;
+	const innerEnd = closePos;
+	const commas = commaPositions(input, innerStart, innerEnd);
+	const segments = [];
+	let segStart = innerStart;
+	for (const comma of commas) {
+		segments.push([segStart, comma]);
+		segStart = comma + 1;
+	}
+	segments.push([segStart, innerEnd]);
+	if (segments.length === 1 && segments[0][0] === segments[0][1]) throw new CallciumError("INVALID_TYPE_STRING", "Empty tuple is not allowed");
+	return tuple(segments.map(([fieldStart, fieldEnd]) => parseType(input, fieldStart, fieldEnd)));
+}
+/** Parse the base type (no array suffixes) from input[start..end). */
+function parseBaseType(input, start, end) {
+	const segment = input.slice(start, end);
+	if (segment === "address") return address();
+	if (segment === "bool") return bool();
+	if (segment === "function") return function_();
+	if (segment === "bytes") return bytes();
+	if (segment === "string") return string_();
+	if (segment === "uint256") return uint256();
+	if (segment === "int256") return intN(256);
+	if (segment.startsWith("(")) return parseTuple(input, start, end);
+	if (segment.startsWith("uint")) {
+		const bits = parseUint(input, start + 4, end);
+		if (bits === -1) throw new CallciumError("UNKNOWN_TYPE", `Unrecognised type '${segment}'`);
+		return uintN(bits);
+	}
+	if (segment.startsWith("int")) {
+		const bits = parseUint(input, start + 3, end);
+		if (bits === -1) throw new CallciumError("UNKNOWN_TYPE", `Unrecognised type '${segment}'`);
+		return intN(bits);
+	}
+	if (segment.startsWith("bytes")) {
+		const n = parseUint(input, start + 5, end);
+		if (n === -1) throw new CallciumError("UNKNOWN_TYPE", `Unrecognised type '${segment}'`);
+		return bytesN(n);
+	}
+	throw new CallciumError("UNKNOWN_TYPE", `Unrecognised type '${segment}'`);
+}
+/**
+* Parse a type segment from input[start..end).
+*
+* Scans backward from end to collect all `[...]` suffixes, identifies the
+* base type extent, parses the base, then applies suffixes left-to-right.
+*/
+function parseType(input, start, end) {
+	if (start >= end) throw new CallciumError("INVALID_TYPE_STRING", "Empty type segment");
+	const suffixes = [];
+	let baseEnd = end;
+	while (baseEnd > start && input[baseEnd - 1] === "]") {
+		const closePos = baseEnd - 1;
+		let openPos = closePos - 1;
+		while (openPos > start && input[openPos] !== "[") openPos--;
+		if (input[openPos] !== "[") throw new CallciumError("INVALID_TYPE_STRING", `Unmatched ']' at position ${closePos}`);
+		const innerStart = openPos + 1;
+		const innerEnd = closePos;
+		if (innerStart === innerEnd) suffixes.unshift(void 0);
+		else {
+			const length = parseUint(input, innerStart, innerEnd);
+			if (length === -1) throw new CallciumError("INVALID_TYPE_STRING", `Invalid array length at position ${innerStart}`);
+			suffixes.unshift(length);
+		}
+		baseEnd = openPos;
+	}
+	let desc = parseBaseType(input, start, baseEnd);
+	for (const length of suffixes) desc = array(desc, length);
+	return desc;
+}
+/**
+* Encode a comma-separated list of ABI type strings into a binary descriptor.
+*
+* @param typesCsv - Comma-separated ABI type strings, e.g. `"address,uint256,(bool,bytes32)[],string"`.
+* @returns Binary descriptor bytes starting with the version+paramCount header.
+* @throws {CallciumError} With code `INVALID_TYPE_STRING` for malformed input.
+* @throws {CallciumError} With code `UNKNOWN_TYPE` for unrecognised type names.
+*/
+function fromTypes(typesCsv) {
+	if (typesCsv === "") return new Uint8Array([DescriptorFormat.VERSION, 0]);
+	const commas = commaPositions(typesCsv, 0, typesCsv.length);
+	const segments = [];
+	let segStart = 0;
+	for (const comma of commas) {
+		segments.push([segStart, comma]);
+		segStart = comma + 1;
+	}
+	segments.push([segStart, typesCsv.length]);
+	const paramDescs = segments.map(([start, end]) => parseType(typesCsv, start, end));
+	if (paramDescs.length > DescriptorFormat.MAX_PARAMS) throw new CallciumError("DESCRIPTOR_TOO_LARGE", `Parameter count ${paramDescs.length} exceeds maximum ${DescriptorFormat.MAX_PARAMS}.`);
+	const totalBytes = paramDescs.reduce((sum, d) => sum + d.length, 0);
+	const result = new Uint8Array(DescriptorFormat.HEADER_SIZE + totalBytes);
+	result[0] = DescriptorFormat.VERSION;
+	result[1] = paramDescs.length;
+	let offset = DescriptorFormat.HEADER_SIZE;
+	for (const desc of paramDescs) {
+		result.set(desc, offset);
+		offset += desc.length;
+	}
+	return result;
+}
+/** Reconstruct a Solidity type string from a descriptor node at the given offset. */
+function nodeToTypeString(desc, offset) {
+	const typeCode = desc[offset];
+	if (typeCode === TypeCode.TUPLE) {
+		const fieldCount = Descriptor.tupleFieldCount(desc, offset);
+		const fieldTypes = [];
+		let fieldOffset = offset + DescriptorFormat.TUPLE_HEADER_SIZE;
+		for (let i = 0; i < fieldCount; i++) {
+			fieldTypes.push(nodeToTypeString(desc, fieldOffset));
+			fieldOffset += Descriptor.nodeLength(desc, fieldOffset);
+		}
+		return `(${fieldTypes.join(",")})`;
+	}
+	if (typeCode === TypeCode.STATIC_ARRAY) {
+		const length = Descriptor.staticArrayLength(desc, offset);
+		return `${nodeToTypeString(desc, Descriptor.arrayElementOffset(offset))}[${length}]`;
+	}
+	if (typeCode === TypeCode.DYNAMIC_ARRAY) return `${nodeToTypeString(desc, Descriptor.arrayElementOffset(offset))}[]`;
+	return lookupTypeCode(typeCode).label;
+}
+/**
+* Reconstruct a comma-separated list of ABI type strings from a binary descriptor.
+*
+* Inverse of `fromTypes`: `toTypes(fromTypes(s))` returns `s` for any valid input.
+*
+* @param desc - Binary descriptor bytes (with version+paramCount header).
+* @returns Comma-separated ABI type strings, e.g. `"address,uint256,(bool,bytes32)[]"`.
+* @throws {CallciumError} If the descriptor is malformed.
+*/
+function toTypes(desc) {
+	const count = Descriptor.paramCount(desc);
+	const types = [];
+	let offset = DescriptorFormat.HEADER_SIZE;
+	for (let i = 0; i < count; i++) {
+		types.push(nodeToTypeString(desc, offset));
+		offset += Descriptor.nodeLength(desc, offset);
+	}
+	return types.join(",");
+}
+/** Recursively parse a single descriptor node starting at offset. */
+function parseNode(data, offset) {
+	if (offset >= data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end of descriptor", offset);
+	const code = data[offset];
+	const info = classifyTypeCode(code);
+	const metaOffset = offset + DescriptorFormat.TYPECODE_SIZE;
+	if (info.typeClass === "elementary") return {
+		node: {
+			type: "elementary",
+			typeCode: code,
+			isDynamic: info.isDynamic,
+			staticSize: info.isDynamic ? 0 : 32,
+			span: {
+				start: offset,
+				end: metaOffset
+			}
+		},
+		next: metaOffset
+	};
+	const metaEnd = metaOffset + DescriptorFormat.COMPOSITE_META_SIZE;
+	if (metaEnd > data.length) throw new CallciumError("UNEXPECTED_END", "Incomplete composite metadata", offset);
+	const meta = readU24(data, metaOffset);
+	const staticWords = meta >> DescriptorFormat.META_STATIC_WORDS_SHIFT;
+	const nodeLength = meta & DescriptorFormat.META_NODE_LENGTH_MASK;
+	const minHeader = info.typeClass === "tuple" ? DescriptorFormat.TUPLE_HEADER_SIZE : DescriptorFormat.ARRAY_HEADER_SIZE;
+	if (nodeLength < minHeader) throw new CallciumError("MALFORMED_HEADER", `Composite node length ${nodeLength} is smaller than minimum header ${minHeader}`, offset);
+	if (offset + nodeLength > data.length) throw new CallciumError("NODE_OVERFLOW", "Composite node extends beyond descriptor", offset);
+	const isDynamic = staticWords === 0;
+	const staticSize = isDynamic ? 0 : staticWords * 32;
+	const nodeEnd = offset + nodeLength;
+	if (info.typeClass === "tuple") {
+		const fieldCountOffset = metaEnd;
+		if (fieldCountOffset + 2 > data.length) throw new CallciumError("UNEXPECTED_END", "Incomplete tuple header", offset);
+		const fieldCount = readU16(data, fieldCountOffset);
+		if (fieldCount === 0) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", "Tuple must have at least one field", offset);
+		if (fieldCount > DescriptorFormat.MAX_TUPLE_FIELDS) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", `Tuple field count ${fieldCount} exceeds maximum ${DescriptorFormat.MAX_TUPLE_FIELDS}`, offset);
+		const fields = [];
+		let cursor = offset + DescriptorFormat.TUPLE_HEADER_SIZE;
+		for (let i = 0; i < fieldCount; i++) {
+			const result = parseNode(data, cursor);
+			fields.push(result.node);
+			cursor = result.next;
+		}
+		return {
+			node: {
+				type: "tuple",
+				typeCode: code,
+				isDynamic,
+				staticSize,
+				fields,
+				span: {
+					start: offset,
+					end: nodeEnd
+				}
+			},
+			next: nodeEnd
+		};
+	}
+	if (info.typeClass === "staticArray") {
+		const elemResult = parseNode(data, Descriptor.arrayElementOffset(offset));
+		const lengthOffset = elemResult.next;
+		if (lengthOffset + DescriptorFormat.ARRAY_LENGTH_SIZE > data.length) throw new CallciumError("UNEXPECTED_END", "Missing static array length suffix", offset);
+		const length = readU16(data, lengthOffset);
+		if (length === 0) throw new CallciumError("INVALID_ARRAY_LENGTH", "Static array length must be greater than zero", offset);
+		if (length > DescriptorFormat.MAX_STATIC_ARRAY_LENGTH) throw new CallciumError("INVALID_ARRAY_LENGTH", `Static array length ${length} exceeds maximum ${DescriptorFormat.MAX_STATIC_ARRAY_LENGTH}`, offset);
+		return {
+			node: {
+				type: "staticArray",
+				typeCode: code,
+				isDynamic,
+				staticSize,
+				element: elemResult.node,
+				length,
+				span: {
+					start: offset,
+					end: nodeEnd
+				}
+			},
+			next: nodeEnd
+		};
+	}
+	return {
+		node: {
+			type: "dynamicArray",
+			typeCode: code,
+			isDynamic: true,
+			staticSize: 0,
+			element: parseNode(data, Descriptor.arrayElementOffset(offset)).node,
+			span: {
+				start: offset,
+				end: nodeEnd
+			}
+		},
+		next: nodeEnd
+	};
+}
+/** Convert a zero-based param index to a BE16 hex path step. */
+function indexToPath(index) {
+	return `0x${index.toString(16).padStart(4, "0")}`;
+}
+/** Decode a binary descriptor blob, returning the structural representation and AST. */
+function decodeDescriptor(data) {
+	if (data.length < 1) throw new CallciumError("MALFORMED_HEADER", "Descriptor is empty");
+	const version = data[0];
+	if (version !== DescriptorFormat.VERSION) throw new CallciumError("UNSUPPORTED_VERSION", `Version ${version} is not supported (expected ${DescriptorFormat.VERSION})`);
+	if (data.length < DescriptorFormat.HEADER_SIZE) throw new CallciumError("MALFORMED_HEADER", "Descriptor too short for header");
+	const declaredCount = data[1];
+	const params = [];
+	const tree = [];
+	let cursor = DescriptorFormat.HEADER_SIZE;
+	while (cursor < data.length) {
+		if (params.length >= DescriptorFormat.MAX_PARAMS) throw new CallciumError("PARAM_COUNT_MISMATCH", `Descriptor exceeds the maximum of ${DescriptorFormat.MAX_PARAMS} top-level params`);
+		const { node, next } = parseNode(data, cursor);
+		tree.push(node);
+		params.push({
+			index: params.length,
+			typeCode: node.typeCode,
+			isDynamic: node.isDynamic,
+			staticSize: node.staticSize,
+			path: indexToPath(params.length),
+			span: {
+				start: cursor,
+				end: next
+			}
+		});
+		cursor = next;
+	}
+	if (params.length !== declaredCount) throw new CallciumError("PARAM_COUNT_MISMATCH", `Header declares ${declaredCount} params but ${params.length} were parsed`);
+	return {
+		descriptor: {
+			version,
+			params
+		},
+		tree
+	};
+}
+/** Encode and decode descriptors. */
+const DescriptorCoder = {
+	fromTypes,
+	toTypes
+};
+//#endregion
+//#region src/policy-coder.ts
+/**
+* Parse a BE16-encoded hex path into an array of step values.
+* @param path - 0x-prefixed hex string containing BE16-encoded path steps.
+* @returns Array of numeric step values.
+*/
+function parsePathSteps(path) {
+	const body = path.slice(2);
+	const steps = [];
+	for (let i = 0; i < body.length; i += 4) steps.push(parseInt(body.slice(i, i + 4), 16));
+	return steps;
+}
+/** Wrap a value with its byte span for positional tracking. */
+function field(value, start, end) {
+	return {
+		value,
+		span: {
+			start,
+			end
+		}
+	};
+}
+/** Decode a policy blob, returning the structural representation and descriptor AST. */
+function decodePolicy(blob) {
+	const data = hexToBytes(blob);
+	if (data.length < PolicyFormat.DESC_OFFSET + 1) throw new CallciumError("MALFORMED_HEADER", "Policy blob is too short");
+	const headerByte = data[0];
+	const version = headerByte & PolicyFormat.VERSION_MASK;
+	if (version !== PolicyFormat.VERSION) throw new CallciumError("UNSUPPORTED_VERSION", `Version ${version} is not supported (expected ${PolicyFormat.VERSION})`);
+	if ((headerByte & PolicyFormat.RESERVED_MASK) !== 0) throw new CallciumError("MALFORMED_HEADER", "Reserved header bits must be zero");
+	const isSelectorless = (headerByte & PolicyFormat.FLAG_NO_SELECTOR) !== 0;
+	const selectorStart = PolicyFormat.SELECTOR_OFFSET;
+	const selectorEnd = selectorStart + PolicyFormat.SELECTOR_SIZE;
+	const selectorHex = toHex(data, selectorStart, selectorEnd);
+	if (isSelectorless && selectorHex !== "0x00000000") throw new CallciumError("MALFORMED_HEADER", "Selectorless policy must have a zeroed selector slot");
+	const descLengthStart = PolicyFormat.DESC_LENGTH_OFFSET;
+	const descLengthValue = readU16(data, descLengthStart);
+	if (descLengthValue < 2) throw new CallciumError("MALFORMED_HEADER", "Descriptor length must be at least 2");
+	const descStart = PolicyFormat.DESC_OFFSET;
+	const descEnd = descStart + descLengthValue;
+	const groupCountOffset = descEnd;
+	if (data.length < groupCountOffset + PolicyFormat.GROUP_COUNT_SIZE) throw new CallciumError("MALFORMED_HEADER", "Policy blob is too short for descriptor and group count");
+	const { descriptor: desc, tree } = decodeDescriptor(data.subarray(descStart, descEnd));
+	const params = desc.params.map((param) => ({
+		...param,
+		span: {
+			start: descStart + param.span.start,
+			end: descStart + param.span.end
+		}
+	}));
+	const descriptorRaw = toHex(data, descStart, descEnd);
+	const groupCountStart = groupCountOffset;
+	const groupCountEnd = groupCountStart + PolicyFormat.GROUP_COUNT_SIZE;
+	const groupCountValue = data[groupCountOffset];
+	if (groupCountValue === 0) throw new CallciumError("EMPTY_POLICY", "Policy must contain at least one group");
+	let offset = groupCountEnd;
+	const groups = [];
+	for (let groupIndex = 0; groupIndex < groupCountValue; groupIndex++) {
+		if (offset + PolicyFormat.GROUP_HEADER_SIZE > data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end while reading group header", offset);
+		const ruleCountStart = offset;
+		const ruleCountValue = readU16(data, ruleCountStart);
+		const groupSizeStart = offset + PolicyFormat.GROUP_RULECOUNT_SIZE;
+		const groupSizeValue = readU32(data, groupSizeStart);
+		const groupBodyStart = offset + PolicyFormat.GROUP_HEADER_SIZE;
+		const groupEnd = groupBodyStart + groupSizeValue;
+		if (ruleCountValue === 0) throw new CallciumError("EMPTY_GROUP", "Group must contain at least one rule", offset);
+		if (groupSizeValue < ruleCountValue * PolicyFormat.RULE_MIN_SIZE) throw new CallciumError("GROUP_SIZE_MISMATCH", "Declared group size is too small for its rule count", offset);
+		if (groupEnd > data.length) throw new CallciumError("GROUP_OVERFLOW", "Group extends beyond policy blob", offset);
+		const rules = [];
+		let ruleOffset = groupBodyStart;
+		for (let ruleIndex = 0; ruleIndex < ruleCountValue; ruleIndex++) {
+			if (ruleOffset + PolicyFormat.RULE_SIZE_SIZE > data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end while reading rule size", ruleOffset);
+			const ruleSizeValue = readU16(data, ruleOffset);
+			if (ruleSizeValue < PolicyFormat.RULE_MIN_SIZE) throw new CallciumError("RULE_SIZE_MISMATCH", `Rule size ${ruleSizeValue} is below minimum ${PolicyFormat.RULE_MIN_SIZE}`, ruleOffset);
+			if (ruleOffset + ruleSizeValue > groupEnd) throw new CallciumError("RULE_OVERFLOW", "Rule extends beyond group boundary", ruleOffset);
+			const scopeOffset = ruleOffset + PolicyFormat.RULE_SCOPE_OFFSET;
+			const scopeValue = data[scopeOffset];
+			if (scopeValue !== Scope.CONTEXT && scopeValue !== Scope.CALLDATA) throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${scopeValue}`, ruleOffset);
+			const depthOffset = ruleOffset + PolicyFormat.RULE_DEPTH_OFFSET;
+			const depthValue = data[depthOffset];
+			if (depthValue === 0) throw new CallciumError("EMPTY_PATH", "Rule path must have at least one step", ruleOffset);
+			if (scopeValue === Scope.CONTEXT && depthValue !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope rules must have exactly one path step", ruleOffset);
+			const pathStart = ruleOffset + PolicyFormat.RULE_PATH_OFFSET;
+			const pathLength = depthValue * PolicyFormat.PATH_STEP_SIZE;
+			const pathHex = toHex(data, pathStart, pathStart + pathLength);
+			const opCodeOffset = pathStart + pathLength;
+			const opCodeValue = data[opCodeOffset];
+			const dataLengthOffset = opCodeOffset + PolicyFormat.RULE_OPCODE_SIZE;
+			const dataLengthValue = readU16(data, dataLengthOffset);
+			const dataStart = dataLengthOffset + PolicyFormat.RULE_DATALENGTH_SIZE;
+			const expectedRuleSize = PolicyFormat.RULE_FIXED_OVERHEAD + pathLength + dataLengthValue;
+			if (ruleSizeValue !== expectedRuleSize) throw new CallciumError("RULE_SIZE_MISMATCH", `Declared rule size ${ruleSizeValue} does not match computed size ${expectedRuleSize}`, ruleOffset);
+			const opBase = opCodeValue & ~Op.NOT;
+			if (opBase === 0 || !isValidOperatorData(opBase, dataLengthValue)) throw new CallciumError("INVALID_OPERATOR", "Unrecognized or malformed operator", ruleOffset);
+			rules.push({
+				ruleSize: field(ruleSizeValue, ruleOffset, ruleOffset + PolicyFormat.RULE_SIZE_SIZE),
+				scope: field(scopeValue, scopeOffset, scopeOffset + 1),
+				pathDepth: field(depthValue, depthOffset, depthOffset + 1),
+				path: field(pathHex, pathStart, pathStart + pathLength),
+				opCode: field(opCodeValue, opCodeOffset, opCodeOffset + PolicyFormat.RULE_OPCODE_SIZE),
+				dataLength: field(dataLengthValue, dataLengthOffset, dataLengthOffset + PolicyFormat.RULE_DATALENGTH_SIZE),
+				data: field(toHex(data, dataStart, dataStart + dataLengthValue), dataStart, dataStart + dataLengthValue),
+				span: {
+					start: ruleOffset,
+					end: ruleOffset + ruleSizeValue
+				}
+			});
+			ruleOffset += ruleSizeValue;
+		}
+		if (ruleOffset !== groupEnd) throw new CallciumError("GROUP_SIZE_MISMATCH", "Rules do not exactly fill the declared group size", offset);
+		groups.push({
+			ruleCount: field(ruleCountValue, ruleCountStart, ruleCountStart + PolicyFormat.GROUP_RULECOUNT_SIZE),
+			groupSize: field(groupSizeValue, groupSizeStart, groupSizeStart + PolicyFormat.GROUP_SIZE_SIZE),
+			rules,
+			span: {
+				start: offset,
+				end: groupEnd
+			}
+		});
+		offset = groupEnd;
+	}
+	if (offset !== data.length) throw new CallciumError("TRAILING_BYTES", "Trailing bytes after last group", offset);
+	return {
+		policy: {
+			header: field(headerByte, 0, PolicyFormat.HEADER_SIZE),
+			selector: field(selectorHex, selectorStart, selectorEnd),
+			descLength: field(descLengthValue, descLengthStart, descLengthStart + PolicyFormat.DESC_LENGTH_SIZE),
+			descriptor: {
+				raw: descriptorRaw,
+				header: field({
+					version: desc.version,
+					paramCount: desc.params.length
+				}, descStart, descStart + DescriptorFormat.HEADER_SIZE),
+				params,
+				span: {
+					start: descStart,
+					end: descEnd
+				}
+			},
+			groupCount: field(groupCountValue, groupCountStart, groupCountEnd),
+			groups,
+			span: {
+				start: 0,
+				end: data.length
+			},
+			version,
+			isSelectorless
+		},
+		tree
+	};
+}
+/** Flatten a Constraint into one Rule per operator. */
+function flattenConstraint(constraint) {
+	const path = hexToBytes(constraint.path);
+	return constraint.operators.map((op) => ({
+		scope: constraint.scope,
+		path,
+		operator: hexToBytes(op)
+	}));
+}
+/** Compare two byte arrays lexicographically. */
+function compareBytes(a, b) {
+	const length = Math.min(a.length, b.length);
+	for (let i = 0; i < length; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+/** Sort rules by (scope, pathDepth, pathBytes, operatorBytes). */
+function sortRules(rules) {
+	rules.sort((a, b) => {
+		if (a.scope !== b.scope) return a.scope - b.scope;
+		const depthA = a.path.length / 2;
+		const depthB = b.path.length / 2;
+		if (depthA !== depthB) return depthA - depthB;
+		const pathCmp = compareBytes(a.path, b.path);
+		if (pathCmp !== 0) return pathCmp;
+		return compareBytes(a.operator, b.operator);
+	});
+}
+/** Serialize a single rule to its wire format bytes. */
+function encodeRule(rule) {
+	if (rule.path.length === 0) throw new CallciumError("EMPTY_PATH", "Rule path must have at least one step.");
+	if ((rule.path.length & 1) !== 0) throw new CallciumError("INVALID_PATH", "Path byte length must be even.");
+	if (rule.operator.length < 1) throw new CallciumError("INVALID_OPERATOR", "Operator must have at least one byte (opcode).");
+	const depth = rule.path.length / 2;
+	if (depth > Limits.MAX_PATH_DEPTH) throw new CallciumError("INVALID_PATH", `Path depth ${depth} exceeds maximum ${Limits.MAX_PATH_DEPTH}.`);
+	if (rule.scope === Scope.CONTEXT && depth !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope rules must have exactly one path step.");
+	const opCode = rule.operator[0];
+	const data = rule.operator.subarray(1);
+	const ruleSize = PolicyFormat.RULE_FIXED_OVERHEAD + rule.path.length + data.length;
+	if (ruleSize > 65535) throw new CallciumError("RULE_SIZE_OVERFLOW", `Rule size ${ruleSize} exceeds maximum 65535`);
+	const buf = new Uint8Array(ruleSize);
+	writeBE16(buf, 0, ruleSize);
+	buf[2] = rule.scope;
+	buf[3] = depth;
+	buf.set(rule.path, 4);
+	const opOffset = 4 + rule.path.length;
+	buf[opOffset] = opCode;
+	writeBE16(buf, opOffset + 1, data.length);
+	buf.set(data, opOffset + 3);
+	return buf;
+}
+/** Serialize all rules in a group to a single byte array. */
+function encodeGroupRules(rules) {
+	const parts = rules.map(encodeRule);
+	const totalSize = parts.reduce((sum, p) => sum + p.length, 0);
+	const buf = new Uint8Array(totalSize);
+	let offset = 0;
+	for (const part of parts) {
+		buf.set(part, offset);
+		offset += part.length;
+	}
+	return buf;
+}
+/** Build a single operator hex string from a decoded rule's opCode and data. */
+function buildOperatorHex(rule) {
+	return `0x${rule.opCode.value.toString(16).padStart(2, "0")}${rule.data.value.slice(2)}`;
+}
+/**
+* Encode a PolicyData structure into the canonical binary format.
+* @param data - The policy data to encode.
+* @returns The encoded policy as a 0x-prefixed hex string.
+*/
+function encode(data) {
+	const sortedGroups = data.groups.map((group) => {
+		const rules = group.flatMap(flattenConstraint);
+		sortRules(rules);
+		return rules;
+	});
+	if (sortedGroups.length === 0) throw new CallciumError("EMPTY_POLICY", "Policy must contain at least one group");
+	if (sortedGroups.length > 255) throw new CallciumError("GROUP_COUNT_OVERFLOW", `Group count ${sortedGroups.length} exceeds maximum 255`);
+	const groupsWithHash = sortedGroups.map((rules, groupIndex) => {
+		if (rules.length === 0) throw new CallciumError("EMPTY_GROUP", `Group ${groupIndex} is empty`);
+		if (rules.length > 65535) throw new CallciumError("RULE_COUNT_OVERFLOW", `Group ${groupIndex} rule count ${rules.length} exceeds maximum 65535`);
+		const wireBytes = encodeGroupRules(rules);
+		return {
+			wireBytes,
+			hash: keccak_256(wireBytes),
+			ruleCount: rules.length
+		};
+	});
+	groupsWithHash.sort((a, b) => compareBytes(a.hash, b.hash));
+	const descBytes = hexToBytes(data.descriptor);
+	if (descBytes.length > 65535) throw new CallciumError("DESC_LENGTH_OVERFLOW", `Descriptor length ${descBytes.length} exceeds maximum 65535`);
+	const selectorBytes = data.isSelectorless ? new Uint8Array(4) : hexToBytes(data.selector);
+	const headerByte = PolicyFormat.VERSION | (data.isSelectorless ? PolicyFormat.FLAG_NO_SELECTOR : 0);
+	let totalSize = PolicyFormat.HEADER_SIZE + PolicyFormat.SELECTOR_SIZE + PolicyFormat.DESC_LENGTH_SIZE + descBytes.length + PolicyFormat.GROUP_COUNT_SIZE;
+	for (const g of groupsWithHash) totalSize += PolicyFormat.GROUP_HEADER_SIZE + g.wireBytes.length;
+	const out = new Uint8Array(totalSize);
+	let offset = 0;
+	out[offset++] = headerByte;
+	out.set(selectorBytes, offset);
+	offset += PolicyFormat.SELECTOR_SIZE;
+	writeBE16(out, offset, descBytes.length);
+	offset += PolicyFormat.DESC_LENGTH_SIZE;
+	out.set(descBytes, offset);
+	offset += descBytes.length;
+	out[offset++] = groupsWithHash.length;
+	for (const g of groupsWithHash) {
+		writeBE16(out, offset, g.ruleCount);
+		offset += PolicyFormat.GROUP_RULECOUNT_SIZE;
+		out[offset++] = g.wireBytes.length >>> 24 & 255;
+		out[offset++] = g.wireBytes.length >>> 16 & 255;
+		out[offset++] = g.wireBytes.length >>> 8 & 255;
+		out[offset++] = g.wireBytes.length & 255;
+		out.set(g.wireBytes, offset);
+		offset += g.wireBytes.length;
+	}
+	return bytesToHex(out);
+}
+/**
+* Decode a binary policy blob into a PolicyData structure.
+* @param blob - Binary policy as 0x-prefixed hex string.
+* @returns The decoded policy data with constraints grouped by scope and path.
+* @throws {CallciumError} If the blob is structurally malformed.
+*/
+function decode(blob) {
+	const { policy } = decodePolicy(blob);
+	const groups = policy.groups.map((group) => {
+		const constraintMap = /* @__PURE__ */ new Map();
+		const constraintOrder = [];
+		for (const rule of group.rules) {
+			const key = `${rule.scope.value}:${rule.path.value}`;
+			const opHex = buildOperatorHex(rule);
+			const existing = constraintMap.get(key);
+			if (existing !== void 0) existing.operators.push(opHex);
+			else {
+				const constraint = {
+					scope: rule.scope.value,
+					path: rule.path.value,
+					operators: [opHex],
+					span: rule.span
+				};
+				constraintMap.set(key, constraint);
+				constraintOrder.push(key);
+			}
+		}
+		return constraintOrder.map((k) => constraintMap.get(k));
+	});
+	return {
+		isSelectorless: policy.isSelectorless,
+		selector: policy.selector.value,
+		descriptor: policy.descriptor.raw,
+		groups,
+		span: policy.span
+	};
+}
+/**
+* Inspect a binary policy blob, returning the structural representation with full byte-level spans.
+* @param blob - Binary policy as 0x-prefixed hex string.
+* @returns The inspected policy with per-field spans for every structural element.
+* @throws {CallciumError} If the blob is structurally malformed.
+*/
+function inspect(blob) {
+	return decodePolicy(blob).policy;
+}
+/** Encode, decode, and inspect policies in the canonical binary format. */
+const PolicyCoder = {
+	encode,
+	decode,
+	inspect
+};
+//#endregion
+//#region src/operators.ts
+/** Read a big-endian 256-bit unsigned integer from a 32-byte window. */
+function toBigInt(bytes, offset = 0) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset + offset, 32);
+	return view.getBigUint64(0, false) << 192n | view.getBigUint64(8, false) << 128n | view.getBigUint64(16, false) << 64n | view.getBigUint64(24, false);
+}
+/** Return true when the type code represents a signed integer (int8 through int256). */
+function isSigned(typeCode) {
+	return typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
+}
+/** Return true when the operator code (with or without NOT flag) is a LENGTH_* variant. */
+function isLengthOp(opCode) {
+	const base = opCode & ~Op.NOT;
+	return base >= Op.LENGTH_EQ && base <= Op.LENGTH_BETWEEN;
+}
+/** Return true when LENGTH_* operators are valid for the given type code (bytes, string, or dynamic array). */
+function isLengthValidType(typeCode) {
+	return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING || typeCode === TypeCode.DYNAMIC_ARRAY;
+}
+/** Compare two 256-bit values, using two's complement interpretation for signed type codes. */
+function compareTyped(a, b, typeCode) {
+	if (isSigned(typeCode)) {
+		const sa = BigInt.asIntN(256, a);
+		const sb = BigInt.asIntN(256, b);
+		return sa < sb ? -1 : sa > sb ? 1 : 0;
+	}
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+/** Binary search over a sorted array of 32-byte words. Comparison is always unsigned. */
+function isIn(value, data) {
+	const count = data.length / 32;
+	let lo = 0;
+	let hi = count - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >>> 1;
+		const elem = toBigInt(data, mid * 32);
+		if (value === elem) return true;
+		if (value < elem) hi = mid - 1;
+		else lo = mid + 1;
+	}
+	return false;
+}
+/**
+* Apply a single operator against a value and operand data.
+* Handles the NOT flag internally by inverting the base operator result.
+* @param opCode - Operator code, potentially OR'd with the NOT flag.
+* @param value - The 256-bit value to test (ignored for LENGTH_* operators).
+* @param valueLength - Runtime byte or element count, only meaningful for LENGTH_* operators.
+* @param operandData - Raw operand bytes (32 per operand, 64 for range operators).
+* @param typeCode - ABI type code, used to select signed vs. unsigned comparison.
+* @returns Whether the value satisfies the operator.
+*/
+function applyOperator(opCode, value, valueLength, operandData, typeCode) {
+	const negate = (opCode & Op.NOT) !== 0;
+	const base = opCode & ~Op.NOT;
+	let result;
+	switch (base) {
+		case Op.EQ:
+			result = value === toBigInt(operandData, 0);
+			break;
+		case Op.GT:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) > 0;
+			break;
+		case Op.LT:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) < 0;
+			break;
+		case Op.GTE:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) >= 0;
+			break;
+		case Op.LTE:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) <= 0;
+			break;
+		case Op.BETWEEN: {
+			const min = toBigInt(operandData, 0);
+			const max = toBigInt(operandData, 32);
+			result = compareTyped(value, min, typeCode) >= 0 && compareTyped(value, max, typeCode) <= 0;
+			break;
+		}
+		case Op.IN:
+			result = isIn(value, operandData);
+			break;
+		case Op.BITMASK_ALL: {
+			const mask = toBigInt(operandData, 0);
+			result = (value & mask) === mask;
+			break;
+		}
+		case Op.BITMASK_ANY:
+			result = (value & toBigInt(operandData, 0)) !== 0n;
+			break;
+		case Op.BITMASK_NONE:
+			result = (value & toBigInt(operandData, 0)) === 0n;
+			break;
+		case Op.LENGTH_EQ:
+			result = BigInt(valueLength) === toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_GT:
+			result = BigInt(valueLength) > toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_LT:
+			result = BigInt(valueLength) < toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_GTE:
+			result = BigInt(valueLength) >= toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_LTE:
+			result = BigInt(valueLength) <= toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_BETWEEN: {
+			const length = BigInt(valueLength);
+			const min = toBigInt(operandData, 0);
+			const max = toBigInt(operandData, 32);
+			result = length >= min && length <= max;
+			break;
+		}
+		default: throw new CallciumError("INVALID_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}.`);
+	}
+	return negate ? !result : result;
+}
+//#endregion
+//#region src/validation-issue.ts
+const ZERO = `0x${"0".repeat(64)}`;
+/** Construct a fully populated Issue. */
+function makeIssue(severity, category, groupIndex, constraintIndex, code, value1, value2, message) {
+	return {
+		severity,
+		category,
+		groupIndex,
+		constraintIndex,
+		code,
+		value1,
+		value2,
+		message
+	};
+}
+/** Create an issue from operator compatibility results. */
+function fromOpRule(code, message, groupIndex, constraintIndex, opCode) {
+	return makeIssue("error", "typeMismatch", groupIndex, constraintIndex, code, opCode, ZERO, message);
+}
+/** eq(v) and neq(v) on same path. */
+function eqNeqContradiction(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "EQ_NEQ_CONTRADICTION", value, ZERO, "eq(v) and neq(v) on same path");
+}
+/** Multiple eq() operators with different values. */
+function conflictingEquality(groupIndex, constraintIndex, existing, newValue) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "CONFLICTING_EQUALITY", existing, newValue, "Multiple eq() operators with different values");
+}
+/** Value is outside the physical range of the type. */
+function outOfPhysicalBounds(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "OUT_OF_PHYSICAL_BOUNDS", value, ZERO, "Value is outside the physical range of the type");
+}
+/** gt() on type maximum is impossible. */
+function impossibleGt(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "IMPOSSIBLE_GT", value, ZERO, "gt() on type maximum is impossible");
+}
+/** lt() on type minimum is impossible. */
+function impossibleLt(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "IMPOSSIBLE_LT", value, ZERO, "lt() on type minimum is impossible");
+}
+/** eq() value is excluded by bound. */
+function boundsExcludeEquality(groupIndex, constraintIndex, eq, bound) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "BOUNDS_EXCLUDE_EQUALITY", eq, bound, "eq() value is excluded by bound");
+}
+/** Lower bound exceeds upper bound. */
+function impossibleRange(groupIndex, constraintIndex, lower, upper) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "IMPOSSIBLE_RANGE", lower, upper, "Lower bound exceeds upper bound");
+}
+/** Set operation excludes existing eq() value. */
+function setExcludesEquality(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "SET_EXCLUDES_EQUALITY", value, ZERO, "Set operation excludes existing eq() value");
+}
+/** Multiple isIn() sets have no intersection. */
+function emptySetIntersection(groupIndex, constraintIndex) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "EMPTY_SET_INTERSECTION", ZERO, ZERO, "Multiple isIn() sets have no intersection");
+}
+/** All values in isIn() set are excluded by neq/notIn. */
+function setFullyExcluded(groupIndex, constraintIndex) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "SET_FULLY_EXCLUDED", ZERO, ZERO, "All values in isIn() set are excluded by neq/notIn");
+}
+/** lengthEq(v) and lengthNeq(v) on same path. */
+function lengthEqNeqContradiction(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "LENGTH_EQ_NEQ_CONTRADICTION", value, ZERO, "lengthEq(v) and lengthNeq(v) on same path");
+}
+/** Multiple lengthEq() operators with different values. */
+function conflictingLength(groupIndex, constraintIndex, existing, newValue) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "CONFLICTING_LENGTH", existing, newValue, "Multiple lengthEq() operators with different values");
+}
+/** lengthEq() value is excluded by bound. */
+function boundsExcludeLength(groupIndex, constraintIndex, eq, bound) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "BOUNDS_EXCLUDE_LENGTH", eq, bound, "lengthEq() value is excluded by bound");
+}
+/** Lower length bound exceeds upper bound. */
+function impossibleLengthRange(groupIndex, constraintIndex, lower, upper) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "IMPOSSIBLE_LENGTH_RANGE", lower, upper, "Lower length bound exceeds upper bound");
+}
+/** Length value is outside the physical range. */
+function outOfPhysicalLengthBounds(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "OUT_OF_PHYSICAL_LENGTH_BOUNDS", value, ZERO, "Length value is outside the physical range");
+}
+/** lengthGt() on maximum length is impossible. */
+function impossibleLengthGt(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "IMPOSSIBLE_LENGTH_GT", value, ZERO, "lengthGt() on maximum length is impossible");
+}
+/** lengthLt() on minimum length is impossible. */
+function impossibleLengthLt(groupIndex, constraintIndex, value) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "IMPOSSIBLE_LENGTH_LT", value, ZERO, "lengthLt() on minimum length is impossible");
+}
+/** Bitmask operators conflict. */
+function bitmaskContradiction(groupIndex, constraintIndex, mask, conflicting) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "BITMASK_CONTRADICTION", mask, conflicting, "Bitmask operators conflict");
+}
+/** bitmaskAny is impossible because all bits are forbidden. */
+function bitmaskAnyImpossible(groupIndex, constraintIndex, mask, mustBeZero) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "BITMASK_ANY_IMPOSSIBLE", mask, mustBeZero, "bitmaskAny is impossible because all bits are forbidden");
+}
+/** isIn/notIn set is not strictly sorted and deduplicated. */
+function unsortedInSet(groupIndex, constraintIndex) {
+	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "UNSORTED_IN_SET", ZERO, ZERO, "isIn/notIn set is not strictly sorted and deduplicated.");
+}
+/** Group contains zero constraints. */
+function emptyGroup(groupIndex) {
+	return makeIssue("error", "vacuity", groupIndex, 0, "EMPTY_GROUP", ZERO, ZERO, "Group contains zero constraints.");
+}
+/** Numeric bound is dominated by a stricter bound. */
+function dominatedBound(groupIndex, constraintIndex, value) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "DOMINATED_BOUND", value, ZERO, "Numeric bound is dominated by a stricter bound");
+}
+/** Bound is redundant because eq() is set. */
+function redundantBound(groupIndex, constraintIndex, bound, eq) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "REDUNDANT_BOUND", bound, eq, "Bound is redundant because eq() is set");
+}
+/** notIn() value was present in isIn() set. */
+function setReduction(groupIndex, constraintIndex, value) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "SET_REDUCTION", value, ZERO, "notIn() value was present in isIn() set");
+}
+/** isIn() sets partially overlap. */
+function setRedundancy(groupIndex, constraintIndex, intersectionCount) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "SET_REDUNDANCY", intersectionCount, ZERO, "isIn() sets partially overlap");
+}
+/** Some values in isIn() set are excluded by neq/notIn. */
+function setPartiallyExcluded(groupIndex, constraintIndex, excludedCount) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "SET_PARTIALLY_EXCLUDED", excludedCount, ZERO, "Some values in isIn() set are excluded by neq/notIn");
+}
+/** Length bound is dominated by a stricter bound. */
+function dominatedLengthBound(groupIndex, constraintIndex, value) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "DOMINATED_LENGTH_BOUND", value, ZERO, "Length bound is dominated by a stricter bound");
+}
+/** Length bound is redundant because lengthEq() is set. */
+function redundantLengthBound(groupIndex, constraintIndex, bound, eq) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "REDUNDANT_LENGTH_BOUND", bound, eq, "Length bound is redundant because lengthEq() is set");
+}
+/** Bitmask operation is redundant. */
+function redundantBitmask(groupIndex, constraintIndex, mask, existing) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "REDUNDANT_BITMASK", mask, existing, "Bitmask operation is redundant");
+}
+/** Duplicate operator in constraint. */
+function duplicateConstraint(groupIndex, constraintIndex) {
+	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "DUPLICATE_CONSTRAINT", ZERO, ZERO, "Duplicate operator in constraint");
+}
+/** gte() bound equals type minimum (always true). */
+function vacuousGte(groupIndex, constraintIndex, value) {
+	return makeIssue("info", "vacuity", groupIndex, constraintIndex, "VACUOUS_GTE", value, ZERO, "gte() bound equals type minimum (always true)");
+}
+/** lte() bound equals type maximum (always true). */
+function vacuousLte(groupIndex, constraintIndex, value) {
+	return makeIssue("info", "vacuity", groupIndex, constraintIndex, "VACUOUS_LTE", value, ZERO, "lte() bound equals type maximum (always true)");
+}
+/** lengthGte(0) is always true. */
+function vacuousLengthGte(groupIndex, constraintIndex, value) {
+	return makeIssue("info", "vacuity", groupIndex, constraintIndex, "VACUOUS_LENGTH_GTE", value, ZERO, "lengthGte(0) is always true");
+}
+/** lengthLte() bound equals maximum (always true). */
+function vacuousLengthLte(groupIndex, constraintIndex, value) {
+	return makeIssue("info", "vacuity", groupIndex, constraintIndex, "VACUOUS_LENGTH_LTE", value, ZERO, "lengthLte() bound equals maximum (always true)");
+}
+/** Pre-select value or length issue factories for a bound domain. */
+function boundIssues(isLength) {
+	return {
+		eqNeqContradiction: isLength ? lengthEqNeqContradiction : eqNeqContradiction,
+		conflicting: isLength ? conflictingLength : conflictingEquality,
+		outOfPhysicalBounds: isLength ? outOfPhysicalLengthBounds : outOfPhysicalBounds,
+		impossibleGt: isLength ? impossibleLengthGt : impossibleGt,
+		impossibleLt: isLength ? impossibleLengthLt : impossibleLt,
+		boundsExcludeEquality: isLength ? boundsExcludeLength : boundsExcludeEquality,
+		impossibleRange: isLength ? impossibleLengthRange : impossibleRange,
+		dominated: isLength ? dominatedLengthBound : dominatedBound,
+		redundant: isLength ? redundantLengthBound : redundantBound,
+		vacuousGte: isLength ? vacuousLengthGte : vacuousGte,
+		vacuousLte: isLength ? vacuousLengthLte : vacuousLte
+	};
+}
+//#endregion
+//#region src/policy-validator.ts
+/**
+* Maximum number of tracked "holes" (neq exclusions) and notIn values per
+* domain. A hole is a single value excluded via a negated equality (neq).
+* During cross-operator analysis, holes punch values out of isIn sets — if
+* every member of an isIn set is excluded by holes or notIn, the constraint
+* is unsatisfiable (SET_FULLY_EXCLUDED). When only some are excluded, the
+* validator emits SET_PARTIALLY_EXCLUDED.
+*
+* Both caps are protocol-defined limits. Beyond these limits,
+* additional exclusions are silently ignored — the validator becomes
+* best-effort for set-reduction diagnostics but never produces false
+* positives, only potential false negatives (missed redundancy warnings).
+*/
+const MAX_HOLES = 8;
+const MAX_NOT_IN = 8;
+const LENGTH_MAX = 4294967295n;
+const UINT256_MAX = (1n << 256n) - 1n;
+const INT256_SIGN_BIT = 1n << 255n;
+/** Reinterpret a uint256 bigint as a signed int256. */
+function toSigned(v) {
+	return v >= INT256_SIGN_BIT ? v - (1n << 256n) : v;
+}
+/** a > b. */
+function isGt(a, b, signed) {
+	return signed ? toSigned(a) > toSigned(b) : a > b;
+}
+/** a >= b. */
+function isGte(a, b, signed) {
+	return signed ? toSigned(a) >= toSigned(b) : a >= b;
+}
+/** a < b. */
+function isLt(a, b, signed) {
+	return signed ? toSigned(a) < toSigned(b) : a < b;
+}
+/** a <= b. */
+function isLte(a, b, signed) {
+	return signed ? toSigned(a) <= toSigned(b) : a <= b;
+}
+/** True for uint and int type codes. */
+function isNumericType(typeCode) {
+	return typeCode <= TypeCode.UINT_MAX || typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
+}
+/** True for uint and bytes32 type codes. */
+function isBitmaskCompatible(typeCode) {
+	return typeCode <= TypeCode.UINT_MAX || typeCode === TypeCode.FIXED_BYTES_MIN + 31;
+}
+/** Physical domain limits for a type code (returned as raw uint256 bigints). */
+function getDomainLimits(typeCode) {
+	if (typeCode <= TypeCode.UINT_MAX) {
+		const bits = BigInt(typeCode - TypeCode.UINT_MIN + 1) * 8n;
+		return {
+			min: 0n,
+			max: bits === 256n ? UINT256_MAX : (1n << bits) - 1n
+		};
+	}
+	if (typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX) {
+		const bits = BigInt(typeCode - TypeCode.INT_MIN + 1) * 8n;
+		if (bits === 256n) return {
+			min: INT256_SIGN_BIT,
+			max: INT256_SIGN_BIT - 1n
+		};
+		const half = 1n << bits - 1n;
+		const max = half - 1n;
+		return {
+			min: UINT256_MAX - half + 1n & UINT256_MAX,
+			max
+		};
+	}
+	if (typeCode === TypeCode.BOOL) return {
+		min: 0n,
+		max: 1n
+	};
+	if (typeCode === TypeCode.ADDRESS) return {
+		min: 0n,
+		max: (1n << 160n) - 1n
+	};
+	return {
+		min: 0n,
+		max: UINT256_MAX
+	};
+}
+/** True for EQ, GT, LT, GTE, LTE, BETWEEN, IN, BITMASK_*. */
+function isValueOp(opBase) {
+	return opBase <= Op.BITMASK_NONE;
+}
+/** True for GT, LT, GTE, LTE, BETWEEN. */
+function isComparisonOp(opBase) {
+	return opBase >= Op.GT && opBase <= Op.BETWEEN;
+}
+/** True for BITMASK_ALL, BITMASK_ANY, BITMASK_NONE. */
+function isBitmaskOp(opBase) {
+	return opBase >= Op.BITMASK_ALL && opBase <= Op.BITMASK_NONE;
+}
+/** Return the incompatibility reason, or null if the operator is allowed. */
+function getIncompat(opBase, typeInfo) {
+	const { typeCode, isDynamic, staticSize } = typeInfo;
+	if (isValueOp(opBase)) {
+		if (isDynamic || staticSize !== 32) return {
+			code: "VALUE_OP_ON_DYNAMIC",
+			message: "Value operator used on dynamic type"
+		};
+		if (isComparisonOp(opBase) && !isNumericType(typeCode)) return {
+			code: "NUMERIC_OP_ON_NON_NUMERIC",
+			message: "Comparison operator used on non-numeric type"
+		};
+		if (isBitmaskOp(opBase) && !isBitmaskCompatible(typeCode)) return {
+			code: "BITMASK_ON_INVALID",
+			message: "Bitmask operator used on incompatible type"
+		};
+		return null;
+	}
+	if (isLengthOp(opBase)) {
+		if (!isLengthValidType(typeCode)) return {
+			code: "LENGTH_ON_STATIC",
+			message: "Length operator used on non-dynamic type"
+		};
+		return null;
+	}
+	return {
+		code: "UNKNOWN_OPERATOR",
+		message: "Unknown operator code"
+	};
+}
+/** Check operator–type compatibility and return an issue descriptor on mismatch. */
+function checkCompatibility(opBase, typeCode, isDynamic, staticSize) {
+	const incompat = getIncompat(opBase, {
+		typeCode,
+		isDynamic,
+		staticSize
+	});
+	return incompat ? {
+		compatible: false,
+		...incompat
+	} : {
+		compatible: true,
+		code: "",
+		message: ""
+	};
+}
+/**
+* True if operator `opCode` is allowed on a target with the given type info.
+* Tolerates the NOT flag on `opCode`.
+*/
+function isOpAllowed(opCode, typeInfo) {
+	return getIncompat(opCode & ~Op.NOT, typeInfo) === null;
+}
+/** Read a single uint256 from operator hex (bytes after the opcode byte). */
+function readValue(opHex) {
+	return BigInt(`0x${opHex.slice(4)}`);
+}
+/** Read a pair of uint256 values from a BETWEEN operator. */
+function readPair(opHex) {
+	const body = opHex.slice(4);
+	return {
+		low: BigInt(`0x${body.slice(0, 64)}`),
+		high: BigInt(`0x${body.slice(64, 128)}`)
+	};
+}
+/** Unpack an IN operator's payload into an array of bigint values. */
+function unpackSet(opHex) {
+	const body = opHex.slice(4);
+	const count = body.length / 64;
+	const values = [];
+	for (let i = 0; i < count; i++) values.push(BigInt(`0x${body.slice(i * 64, (i + 1) * 64)}`));
+	return values;
+}
+/** True if every element is strictly greater than the previous. */
+function isStrictlyAscending(values) {
+	for (let i = 1; i < values.length; i++) if (values[i] <= values[i - 1]) return false;
+	return true;
+}
+/** Convert LENGTH_* opcode to its core comparison equivalent. */
+function normalizeLengthOp(base) {
+	if (base === Op.LENGTH_EQ) return Op.EQ;
+	if (base === Op.LENGTH_GT) return Op.GT;
+	if (base === Op.LENGTH_LT) return Op.LT;
+	if (base === Op.LENGTH_GTE) return Op.GTE;
+	if (base === Op.LENGTH_LTE) return Op.LTE;
+	return base;
+}
+/** Convert a negated bound opcode to its positive equivalent. */
+function negateBoundOp(base) {
+	if (base === Op.GT) return Op.LTE;
+	if (base === Op.GTE) return Op.LT;
+	if (base === Op.LT) return Op.GTE;
+	if (base === Op.LTE) return Op.GT;
+	return base;
+}
+/** Create a fresh constraint context with domain limits from the type. */
+function initContext(scope, path, typeInfo) {
+	const { min, max } = getDomainLimits(typeInfo.typeCode);
+	return {
+		scope,
+		path,
+		typeInfo,
+		numeric: {
+			isSigned: isSigned(typeInfo.typeCode),
+			min,
+			max,
+			hasEq: false,
+			eq: 0n,
+			hasLower: false,
+			lower: 0n,
+			lowerInclusive: false,
+			hasUpper: false,
+			upper: 0n,
+			upperInclusive: false,
+			holes: []
+		},
+		bitmask: {
+			mustBeOne: 0n,
+			mustBeZero: 0n
+		},
+		length: {
+			isSigned: false,
+			min: 0n,
+			max: LENGTH_MAX,
+			hasEq: false,
+			eq: 0n,
+			hasLower: false,
+			lower: 0n,
+			lowerInclusive: false,
+			hasUpper: false,
+			upper: 0n,
+			upperInclusive: false,
+			holes: []
+		},
+		set: {
+			hasIn: false,
+			inValues: [],
+			notInValues: []
+		}
+	};
+}
+/** Narrow the numeric bound domain with an operator and emit issues on contradiction or redundancy. */
+function updateBound(domain, base, isNegated, value, emit, groupIndex, constraintIndex, issues) {
+	let changedEq = false;
+	let changedLower = false;
+	let changedUpper = false;
+	if (isNegated) {
+		if (base === Op.EQ) {
+			if (domain.hasEq && domain.eq === value) issues.push(emit.eqNeqContradiction(groupIndex, constraintIndex, bigintToHex(value)));
+			let alreadyHole = false;
+			for (let j = 0; j < domain.holes.length; j++) if (domain.holes[j] === value) {
+				alreadyHole = true;
+				break;
+			}
+			if (!alreadyHole && domain.holes.length < MAX_HOLES) domain.holes.push(value);
+		} else updateBound(domain, negateBoundOp(base), false, value, emit, groupIndex, constraintIndex, issues);
+		return;
+	}
+	if (base === Op.GTE && value === domain.min) issues.push(emit.vacuousGte(groupIndex, constraintIndex, bigintToHex(value)));
+	else if (base === Op.LTE && value === domain.max) issues.push(emit.vacuousLte(groupIndex, constraintIndex, bigintToHex(value)));
+	if (isLt(value, domain.min, domain.isSigned) || isGt(value, domain.max, domain.isSigned)) issues.push(emit.outOfPhysicalBounds(groupIndex, constraintIndex, bigintToHex(value)));
+	else if (base === Op.GT && value === domain.max) issues.push(emit.impossibleGt(groupIndex, constraintIndex, bigintToHex(value)));
+	else if (base === Op.LT && value === domain.min) issues.push(emit.impossibleLt(groupIndex, constraintIndex, bigintToHex(value)));
+	if (base === Op.EQ) {
+		if (!domain.hasEq || domain.eq !== value) changedEq = true;
+		if (domain.hasEq) {
+			if (domain.eq !== value) issues.push(emit.conflicting(groupIndex, constraintIndex, bigintToHex(domain.eq), bigintToHex(value)));
+		}
+		for (let j = 0; j < domain.holes.length; j++) if (domain.holes[j] === value) issues.push(emit.eqNeqContradiction(groupIndex, constraintIndex, bigintToHex(value)));
+		domain.hasEq = true;
+		domain.eq = value;
+	} else if (base === Op.GT || base === Op.GTE) {
+		const inclusive = base === Op.GTE;
+		if (domain.hasLower) {
+			let redundant = false;
+			let strictlyBetter = false;
+			if (isLt(value, domain.lower, domain.isSigned)) redundant = true;
+			else if (value === domain.lower) {
+				if (domain.lowerInclusive) if (!inclusive) strictlyBetter = true;
+				else redundant = true;
+				else if (!inclusive) redundant = true;
+			} else strictlyBetter = true;
+			if (redundant) issues.push(emit.dominated(groupIndex, constraintIndex, bigintToHex(value)));
+			if (strictlyBetter) {
+				issues.push(emit.dominated(groupIndex, constraintIndex, bigintToHex(domain.lower)));
+				domain.lower = value;
+				domain.lowerInclusive = inclusive;
+				changedLower = true;
+			}
+		} else {
+			domain.hasLower = true;
+			domain.lower = value;
+			domain.lowerInclusive = inclusive;
+			changedLower = true;
+		}
+	} else if (base === Op.LT || base === Op.LTE) {
+		const inclusive = base === Op.LTE;
+		if (domain.hasUpper) {
+			let redundant = false;
+			let strictlyBetter = false;
+			if (isGt(value, domain.upper, domain.isSigned)) redundant = true;
+			else if (value === domain.upper) {
+				if (domain.upperInclusive) if (!inclusive) strictlyBetter = true;
+				else redundant = true;
+				else if (!inclusive) redundant = true;
+			} else strictlyBetter = true;
+			if (redundant) issues.push(emit.dominated(groupIndex, constraintIndex, bigintToHex(value)));
+			if (strictlyBetter) {
+				issues.push(emit.dominated(groupIndex, constraintIndex, bigintToHex(domain.upper)));
+				domain.upper = value;
+				domain.upperInclusive = inclusive;
+				changedUpper = true;
+			}
+		} else {
+			domain.hasUpper = true;
+			domain.upper = value;
+			domain.upperInclusive = inclusive;
+			changedUpper = true;
+		}
+	}
+	if (changedEq || changedLower) {
+		if (domain.hasEq && domain.hasLower) if (domain.lowerInclusive ? isLt(domain.eq, domain.lower, domain.isSigned) : isLte(domain.eq, domain.lower, domain.isSigned)) issues.push(emit.boundsExcludeEquality(groupIndex, constraintIndex, bigintToHex(domain.eq), bigintToHex(domain.lower)));
+		else issues.push(emit.redundant(groupIndex, constraintIndex, bigintToHex(domain.lower), bigintToHex(domain.eq)));
+	}
+	if (changedEq || changedUpper) {
+		if (domain.hasEq && domain.hasUpper) if (domain.upperInclusive ? isGt(domain.eq, domain.upper, domain.isSigned) : isGte(domain.eq, domain.upper, domain.isSigned)) issues.push(emit.boundsExcludeEquality(groupIndex, constraintIndex, bigintToHex(domain.eq), bigintToHex(domain.upper)));
+		else issues.push(emit.redundant(groupIndex, constraintIndex, bigintToHex(domain.upper), bigintToHex(domain.eq)));
+	}
+	if (changedLower || changedUpper) {
+		if (domain.hasLower && domain.hasUpper) {
+			if (isGt(domain.lower, domain.upper, domain.isSigned) || domain.lower === domain.upper && (!domain.lowerInclusive || !domain.upperInclusive)) issues.push(emit.impossibleRange(groupIndex, constraintIndex, bigintToHex(domain.lower), bigintToHex(domain.upper)));
+		}
+	}
+}
+/** Update the bitmask domain and emit issues on contradiction or redundancy. */
+function updateBitmask(ctx, base, isNegated, mask, groupIndex, constraintIndex, issues) {
+	if (isNegated) return;
+	if (base === Op.BITMASK_ALL) {
+		if ((ctx.bitmask.mustBeZero & mask) !== 0n) issues.push(bitmaskContradiction(groupIndex, constraintIndex, bigintToHex(mask), bigintToHex(ctx.bitmask.mustBeZero)));
+		if ((ctx.bitmask.mustBeOne & mask) === mask) issues.push(redundantBitmask(groupIndex, constraintIndex, bigintToHex(mask), bigintToHex(ctx.bitmask.mustBeOne)));
+		ctx.bitmask.mustBeOne |= mask;
+	} else if (base === Op.BITMASK_NONE) {
+		if ((ctx.bitmask.mustBeOne & mask) !== 0n) issues.push(bitmaskContradiction(groupIndex, constraintIndex, bigintToHex(mask), bigintToHex(ctx.bitmask.mustBeOne)));
+		if ((ctx.bitmask.mustBeZero & mask) === mask) issues.push(redundantBitmask(groupIndex, constraintIndex, bigintToHex(mask), bigintToHex(ctx.bitmask.mustBeZero)));
+		ctx.bitmask.mustBeZero |= mask;
+	} else if (base === Op.BITMASK_ANY) {
+		if (mask !== 0n && (ctx.bitmask.mustBeZero & mask) === mask) issues.push(bitmaskAnyImpossible(groupIndex, constraintIndex, bigintToHex(mask), bigintToHex(ctx.bitmask.mustBeZero)));
+		if ((ctx.bitmask.mustBeOne & mask) !== 0n) issues.push(redundantBitmask(groupIndex, constraintIndex, bigintToHex(mask), bigintToHex(ctx.bitmask.mustBeOne)));
+	}
+}
+/** Emit an issue if the IN set has been fully excluded by NOT_IN or NEQ holes. */
+function checkSetEmpty(ctx, groupIndex, constraintIndex, issues) {
+	if (!ctx.set.hasIn) return;
+	let possibleCount = 0;
+	const inCount = ctx.set.inValues.length;
+	for (let i = 0; i < inCount; i++) {
+		const value = ctx.set.inValues[i];
+		let forbidden = false;
+		for (let k = 0; k < ctx.numeric.holes.length; k++) if (ctx.numeric.holes[k] === value) {
+			forbidden = true;
+			break;
+		}
+		if (!forbidden) {
+			for (let k = 0; k < ctx.set.notInValues.length; k++) if (ctx.set.notInValues[k] === value) {
+				forbidden = true;
+				break;
+			}
+		}
+		if (!forbidden) possibleCount++;
+	}
+	if (possibleCount === 0) issues.push(setFullyExcluded(groupIndex, constraintIndex));
+	else if (possibleCount < inCount) issues.push(setPartiallyExcluded(groupIndex, constraintIndex, bigintToHex(BigInt(inCount - possibleCount))));
+}
+/** Update the set domain with IN or NOT_IN values and emit issues on contradiction or redundancy. */
+function updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues) {
+	if (isNegated) {
+		for (const value of values) {
+			if (ctx.numeric.hasEq && ctx.numeric.eq === value) issues.push(setExcludesEquality(groupIndex, constraintIndex, bigintToHex(value)));
+			if (ctx.set.hasIn) {
+				let inSet = false;
+				for (const existing of ctx.set.inValues) if (existing === value) {
+					inSet = true;
+					break;
+				}
+				if (inSet) issues.push(setReduction(groupIndex, constraintIndex, bigintToHex(value)));
+			}
+			if (ctx.set.notInValues.length < MAX_NOT_IN) ctx.set.notInValues.push(value);
+		}
+		checkSetEmpty(ctx, groupIndex, constraintIndex, issues);
+	} else {
+		if (ctx.numeric.hasEq) {
+			let found = false;
+			for (const candidate of values) if (candidate === ctx.numeric.eq) {
+				found = true;
+				break;
+			}
+			if (!found) issues.push(setExcludesEquality(groupIndex, constraintIndex, bigintToHex(ctx.numeric.eq)));
+		}
+		if (ctx.set.hasIn) {
+			const intersection = [];
+			for (const existing of ctx.set.inValues) for (const candidate of values) if (existing === candidate) {
+				intersection.push(existing);
+				break;
+			}
+			if (intersection.length === 0) issues.push(emptySetIntersection(groupIndex, constraintIndex));
+			else if (intersection.length < values.length || intersection.length < ctx.set.inValues.length) issues.push(setRedundancy(groupIndex, constraintIndex, bigintToHex(BigInt(intersection.length))));
+			ctx.set.inValues = intersection;
+		} else {
+			ctx.set.hasIn = true;
+			ctx.set.inValues = values;
+		}
+		checkSetEmpty(ctx, groupIndex, constraintIndex, issues);
+	}
+}
+/** Emit a warning if the constraint contains any identical operators. */
+function checkDuplicates(issues, operators, groupIndex, constraintIndex) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const op of operators) {
+		const key = op.toLowerCase();
+		if (seen.has(key)) {
+			issues.push(duplicateConstraint(groupIndex, constraintIndex));
+			return;
+		}
+		seen.add(key);
+	}
+}
+/** Validate all operators on a single constraint against its domain context. */
+function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues) {
+	const operators = constraint.operators;
+	for (const opHex of operators) {
+		const opCode = parseInt(opHex.slice(2, 4), 16);
+		const base = opCode & ~Op.NOT;
+		const isNegated = (opCode & Op.NOT) !== 0;
+		const compat = checkCompatibility(base, ctx.typeInfo.typeCode, ctx.typeInfo.isDynamic, ctx.typeInfo.staticSize);
+		if (!compat.compatible) {
+			issues.push(fromOpRule(compat.code, compat.message, groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
+			continue;
+		}
+		if (isValueOp(base)) {
+			if (base >= Op.EQ && base <= Op.BETWEEN) if (base === Op.BETWEEN) {
+				const { low, high } = readPair(opHex);
+				updateBound(ctx.numeric, Op.GTE, isNegated, low, boundIssues(false), groupIndex, constraintIndex, issues);
+				updateBound(ctx.numeric, Op.LTE, isNegated, high, boundIssues(false), groupIndex, constraintIndex, issues);
+			} else {
+				const value = readValue(opHex);
+				const holesBefore = ctx.numeric.holes.length;
+				updateBound(ctx.numeric, base, isNegated, value, boundIssues(false), groupIndex, constraintIndex, issues);
+				if (ctx.numeric.holes.length > holesBefore) checkSetEmpty(ctx, groupIndex, constraintIndex, issues);
+			}
+			else if (isBitmaskOp(base)) updateBitmask(ctx, base, isNegated, readValue(opHex), groupIndex, constraintIndex, issues);
+			else if (base === Op.IN) {
+				const values = unpackSet(opHex);
+				if (!isStrictlyAscending(values)) issues.push(unsortedInSet(groupIndex, constraintIndex));
+				else updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues);
+			}
+		} else if (isLengthOp(base)) if (base === Op.LENGTH_BETWEEN) {
+			const { low, high } = readPair(opHex);
+			updateBound(ctx.length, Op.GTE, isNegated, low, boundIssues(true), groupIndex, constraintIndex, issues);
+			updateBound(ctx.length, Op.LTE, isNegated, high, boundIssues(true), groupIndex, constraintIndex, issues);
+		} else {
+			const value = readValue(opHex);
+			updateBound(ctx.length, normalizeLengthOp(base), isNegated, value, boundIssues(true), groupIndex, constraintIndex, issues);
+		}
+	}
+	checkDuplicates(issues, operators, groupIndex, constraintIndex);
+}
+/** Validate all constraints in a group, building per-path contexts for cross-constraint analysis. */
+function validateGroup(data, descBytes, groupIndex, issues) {
+	const constraints = data.groups[groupIndex];
+	const contexts = [];
+	for (let constraintIndex = 0; constraintIndex < constraints.length; constraintIndex++) {
+		const constraint = constraints[constraintIndex];
+		const normalizedPath = `0x${constraint.path.slice(2).toLowerCase()}`;
+		let ctx;
+		for (const existing of contexts) if (existing.scope === constraint.scope && existing.path === normalizedPath) {
+			ctx = existing;
+			break;
+		}
+		if (!ctx) {
+			let typeInfo;
+			if (constraint.scope === Scope.CALLDATA) {
+				const steps = parsePathSteps(constraint.path);
+				typeInfo = Descriptor.typeAt(descBytes, steps);
+			} else {
+				const ctxId = parsePathSteps(constraint.path)[0];
+				typeInfo = {
+					typeCode: lookupContextProperty(ctxId).typeCode,
+					isDynamic: false,
+					staticSize: 32
+				};
+			}
+			ctx = initContext(constraint.scope, normalizedPath, typeInfo);
+			contexts.push(ctx);
+		}
+		validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues);
+	}
+}
+/**
+* Validate a policy for type mismatches, contradictions, redundancies, and vacuities.
+* @param data - The canonical policy data to validate.
+* @returns All validation issues found, ordered by group and constraint index.
+*/
+function validate(data) {
+	const issues = [];
+	const descBytes = hexToBytes(data.descriptor);
+	for (let groupIndex = 0; groupIndex < data.groups.length; groupIndex++) {
+		if (data.groups[groupIndex].length === 0) {
+			issues.push(emptyGroup(groupIndex));
+			continue;
+		}
+		validateGroup(data, descBytes, groupIndex, issues);
+	}
+	return issues;
+}
+/** Semantic validation for policies. */
+const PolicyValidator = { validate };
+//#endregion
+//#region src/signature.ts
+/** Return true if the char code is an ASCII letter. */
+function isAlpha(c) {
+	return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+}
+/** Return true if the char code is an ASCII alphanumeric character. */
+function isAlphanum(c) {
+	return isAlpha(c) || c >= 48 && c <= 57;
+}
+/**
+* Parse an ABI function signature into its selector and types.
+*
+* Strict mode: no whitespace, name must match `[A-Za-z_][A-Za-z0-9_]*`,
+* structure must be `name(types)` with the final `)` as the last character.
+*
+* @param signature - A function signature string, e.g. `"transfer(address,uint256)"`.
+* @returns The 4-byte selector and the comma-separated types string.
+* @throws {CallciumError} with code `"INVALID_SIGNATURE"` if the signature is malformed.
+*/
+function parse(signature) {
+	if (signature.length < 3) throw new CallciumError("INVALID_SIGNATURE", `Invalid signature: too short, got "${signature}"`);
+	let openParen = -1;
+	for (let i = 0; i < signature.length; i++) {
+		const c = signature.charCodeAt(i);
+		if (c === 32 || c === 9 || c === 10 || c === 13) throw new CallciumError("INVALID_SIGNATURE", "Signature must not contain whitespace");
+		if (c > 126) throw new CallciumError("INVALID_SIGNATURE", "Signature must contain only ASCII characters");
+		if (openParen === -1 && c === 40) openParen = i;
+	}
+	if (openParen < 1) throw new CallciumError("INVALID_SIGNATURE", `Invalid signature: must have a function name followed by parentheses, got "${signature}"`);
+	if (!signature.endsWith(")")) throw new CallciumError("INVALID_SIGNATURE", `Invalid signature: must end with ")", got "${signature}"`);
+	const firstChar = signature.charCodeAt(0);
+	if (!isAlpha(firstChar) && firstChar !== 95) throw new CallciumError("INVALID_SIGNATURE", "Function name must start with a letter or underscore");
+	for (let i = 1; i < openParen; i++) {
+		const c = signature.charCodeAt(i);
+		if (!isAlphanum(c) && c !== 95) throw new CallciumError("INVALID_SIGNATURE", "Function name must contain only alphanumeric characters or underscores");
+	}
+	const types = signature.slice(openParen + 1, signature.length - 1);
+	const encoded = new Uint8Array(signature.length);
+	for (let i = 0; i < signature.length; i++) encoded[i] = signature.charCodeAt(i);
+	return {
+		selector: bytesToHex(keccak_256(encoded).subarray(0, 4)),
+		types
+	};
+}
+/** ABI function signature parser. */
+const SignatureParser = { parse };
+//#endregion
+//#region src/policy-builder.ts
+/** Validate a context-scope path. */
+function validateContextPath(pathBytes) {
+	if (pathBytes.length !== 2) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope path must be exactly one step (2 bytes).");
+	const step = readU16(pathBytes, 0);
+	if (step > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("INVALID_CONTEXT_PROPERTY", `Unknown context property ID 0x${step.toString(16).padStart(4, "0")}.`);
+}
+/** Validate a calldata-scope path against the descriptor. */
+function validateCalldataPath(path, desc) {
+	const steps = parsePathSteps(path);
+	if (steps.length === 0) throw new CallciumError("INVALID_PATH", "Calldata path must have at least one step.");
+	const argIndex = steps[0];
+	const paramCount = Descriptor.paramCount(desc);
+	if (argIndex >= paramCount) throw new CallciumError("INVALID_PATH", `Argument index ${argIndex} out of range (descriptor has ${paramCount} params).`);
+	let offset = Descriptor.paramOffset(desc, argIndex);
+	let hasQuantifier = false;
+	for (let i = 1; i < steps.length; i++) {
+		const step = steps[i];
+		const info = Descriptor.inspect(desc, offset);
+		if (info.typeCode === TypeCode.TUPLE) {
+			if (isQuantifier(step)) throw new CallciumError("INVALID_PATH", "Quantifier step is not valid on a tuple node.");
+			const fieldCount = Descriptor.tupleFieldCount(desc, offset);
+			if (step >= fieldCount) throw new CallciumError("INVALID_PATH", `Tuple field index ${step} out of range (tuple has ${fieldCount} fields).`);
+			offset = Descriptor.tupleFieldOffset(desc, offset, step);
+		} else if (info.typeCode === TypeCode.STATIC_ARRAY || info.typeCode === TypeCode.DYNAMIC_ARRAY) {
+			if (isQuantifier(step)) {
+				if (hasQuantifier) throw new CallciumError("INVALID_PATH", "Nested quantifiers are not allowed.");
+				hasQuantifier = true;
+			} else if (info.typeCode === TypeCode.STATIC_ARRAY) {
+				const arrayLength = Descriptor.staticArrayLength(desc, offset);
+				if (step >= arrayLength) throw new CallciumError("INVALID_PATH", `Array index ${step} out of range (static array has ${arrayLength} elements).`);
+			}
+			offset = Descriptor.arrayElementOffset(offset);
+		} else throw new CallciumError("INVALID_PATH", "Cannot descend into an elementary type.");
+	}
+}
+/** Fluent builder for constructing Callcium policies. */
+var PolicyBuilder = class PolicyBuilder {
+	draft;
+	constructor(draft) {
+		this.draft = draft;
+	}
+	/**
+	* Create a builder from a function signature.
+	* @param signature - ABI function signature, e.g. `"transfer(address,uint256)"`.
+	*/
+	static create(signature) {
+		const parsed = SignatureParser.parse(signature);
+		const descriptor = DescriptorCoder.fromTypes(parsed.types);
+		return new PolicyBuilder({
+			isSelectorless: false,
+			selector: parsed.selector,
+			descriptor,
+			groups: [[]],
+			pathHashes: [/* @__PURE__ */ new Set()]
+		});
+	}
+	/**
+	* Create a selectorless builder from a raw type string.
+	* @param typesCsv - Comma-separated ABI type strings, e.g. `"address,uint256"`.
+	*/
+	static createRaw(typesCsv) {
+		return new PolicyBuilder({
+			isSelectorless: true,
+			selector: "0x00000000",
+			descriptor: DescriptorCoder.fromTypes(typesCsv),
+			groups: [[]],
+			pathHashes: [/* @__PURE__ */ new Set()]
+		});
+	}
+	/**
+	* Add a constraint to the current group.
+	* @param constraint - A `Constraint` object or a `ConstraintBuilder` instance.
+	*/
+	add(constraint) {
+		const c = {
+			scope: constraint.scope,
+			path: constraint.path,
+			operators: [...constraint.operators]
+		};
+		if (c.operators.length === 0) throw new CallciumError("INVALID_CONSTRAINT", "Constraint must have at least one operator.");
+		if (c.scope === Scope.CONTEXT) validateContextPath(hexToBytes(c.path));
+		else if (c.scope === Scope.CALLDATA) validateCalldataPath(c.path, this.draft.descriptor);
+		else throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${c.scope}.`);
+		const key = `${c.scope}:${c.path.toLowerCase()}`;
+		const currentHashes = this.draft.pathHashes[this.draft.pathHashes.length - 1];
+		if (currentHashes.has(key)) throw new CallciumError("DUPLICATE_PATH", `Duplicate path ${c.path} in the same group.`);
+		currentHashes.add(key);
+		this.draft.groups[this.draft.groups.length - 1].push(c);
+		return this;
+	}
+	/** Start a new constraint group (OR branch). */
+	or() {
+		if (this.draft.groups[this.draft.groups.length - 1].length === 0) throw new CallciumError("EMPTY_GROUP", "Cannot start a new group when the current group is empty.");
+		this.draft.groups.push([]);
+		this.draft.pathHashes.push(/* @__PURE__ */ new Set());
+		return this;
+	}
+	/**
+	* Build the policy into an encoded binary blob.
+	* @returns The policy as a 0x-prefixed hex string.
+	* @throws {CallciumError} If any group is empty or validation finds errors.
+	*/
+	build() {
+		this.checkGroups();
+		const policyData = this.toPolicyData();
+		const firstError = PolicyValidator.validate(policyData).find((issue) => issue.severity === "error");
+		if (firstError) throw new CallciumError("VALIDATION_ERROR", firstError.message);
+		return PolicyCoder.encode(policyData);
+	}
+	/**
+	* Validate the policy without encoding.
+	* @returns All validation issues found.
+	*/
+	validate() {
+		this.checkGroups();
+		const policyData = this.toPolicyData();
+		return PolicyValidator.validate(policyData);
+	}
+	/** Throw if any group is empty. */
+	checkGroups() {
+		for (let i = 0; i < this.draft.groups.length; i++) if (this.draft.groups[i].length === 0) throw new CallciumError("EMPTY_GROUP", `Group ${i} is empty.`);
+	}
+	/** Convert the draft to a PolicyData structure. */
+	toPolicyData() {
+		return {
+			isSelectorless: this.draft.isSelectorless,
+			selector: this.draft.selector,
+			descriptor: bytesToHex(this.draft.descriptor),
+			groups: this.draft.groups
+		};
+	}
+};
+//#endregion
+//#region src/constraint.ts
+/** Convert a scalar value to a 32-byte big-endian word. */
+function encodeWord(value) {
+	const word = new Uint8Array(32);
+	if (typeof value === "boolean") {
+		word[31] = value ? 1 : 0;
+		return word;
+	}
+	if (typeof value === "string") {
+		const body = value.startsWith("0x") ? value.slice(2) : value;
+		if (body.length !== 40) throw new CallciumError("INVALID_CONSTRAINT", `Invalid address length: expected 40 hex chars, got ${body.length}`);
+		for (let i = 0; i < 20; i++) {
+			const byte = parseInt(body.substring(i * 2, i * 2 + 2), 16);
+			if (Number.isNaN(byte)) throw new CallciumError("INVALID_CONSTRAINT", `Invalid hex character in address at position ${i * 2}`);
+			word[12 + i] = byte;
+		}
+		return word;
+	}
+	let bigValue = typeof value === "number" ? BigInt(value) : value;
+	for (let i = 31; i >= 0; i--) {
+		word[i] = Number(bigValue & 255n);
+		bigValue >>= 8n;
+	}
+	return word;
+}
+/** Pack a scalar value as a hex operator payload (opCode byte + 32-byte word). */
+function singleOp(opCode, value) {
+	const buffer = new Uint8Array(33);
+	buffer[0] = opCode;
+	buffer.set(encodeWord(value), 1);
+	return bytesToHex(buffer);
+}
+/** Pack a range operator (opCode byte + min word + max word). */
+function rangeOp(opCode, min, max) {
+	if (min > max) throw new CallciumError("INVALID_RANGE", `Range min (${min}) must not exceed max (${max})`);
+	const buffer = new Uint8Array(65);
+	buffer[0] = opCode;
+	buffer.set(encodeWord(min), 1);
+	buffer.set(encodeWord(max), 33);
+	return bytesToHex(buffer);
+}
+/** Convert values to bigint, sort ascending (unsigned), deduplicate, and pack as set payload. */
+function setOp(opCode, values) {
+	const bigs = values.map((v) => {
+		if (typeof v === "bigint") return v;
+		if (typeof v === "number") return BigInt(v);
+		if (typeof v === "boolean") return v ? 1n : 0n;
+		const body = v.startsWith("0x") ? v.slice(2) : v;
+		return BigInt("0x" + (body || "0"));
+	});
+	bigs.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	const deduped = [];
+	for (const value of bigs) if (deduped.length === 0 || deduped[deduped.length - 1] !== value) deduped.push(value);
+	if (deduped.length === 0) throw new CallciumError("EMPTY_SET", "Set must contain at least one value");
+	const buffer = new Uint8Array(1 + deduped.length * 32);
+	buffer[0] = opCode;
+	for (let i = 0; i < deduped.length; i++) buffer.set(encodeWord(deduped[i]), 1 + i * 32);
+	return bytesToHex(buffer);
+}
+/** Encode a sequence of uint16 path steps as a big-endian hex string. */
+function encodePath(steps) {
+	const buffer = new Uint8Array(steps.length * 2);
+	for (let i = 0; i < steps.length; i++) writeBE16(buffer, i * 2, steps[i]);
+	return bytesToHex(buffer);
+}
+/**
+* Mutable builder that accumulates operators targeting a single path.
+* Implements the `Constraint` interface so it can be passed directly to policy builders.
+*/
+var ConstraintBuilder = class {
+	scope;
+	path;
+	operators;
+	/** @internal */
+	constructor(scope, path) {
+		this.scope = scope;
+		this.path = path;
+		this.operators = [];
+	}
+	/** Push a pre-encoded operator hex string and return this for chaining. */
+	push(opHex) {
+		this.operators.push(opHex);
+		return this;
+	}
+	/** Assert the value equals `value`. */
+	eq(value) {
+		return this.push(singleOp(Op.EQ, value));
+	}
+	/** Assert the value does not equal `value`. */
+	neq(value) {
+		return this.push(singleOp(Op.EQ | Op.NOT, value));
+	}
+	/** Assert the value is greater than `bound`. */
+	gt(bound) {
+		return this.push(singleOp(Op.GT, bound));
+	}
+	/** Assert the value is less than `bound`. */
+	lt(bound) {
+		return this.push(singleOp(Op.LT, bound));
+	}
+	/** Assert the value is greater than or equal to `bound`. */
+	gte(bound) {
+		return this.push(singleOp(Op.GTE, bound));
+	}
+	/** Assert the value is less than or equal to `bound`. */
+	lte(bound) {
+		return this.push(singleOp(Op.LTE, bound));
+	}
+	/**
+	* Assert the value is within [min, max] inclusive.
+	* @throws {CallciumError} If min > max.
+	*/
+	between(min, max) {
+		return this.push(rangeOp(Op.BETWEEN, BigInt(min), BigInt(max)));
+	}
+	/**
+	* Assert the value is a member of the set.
+	* Values are sorted and deduplicated before encoding.
+	* @throws {CallciumError} If the set is empty after deduplication.
+	*/
+	isIn(values) {
+		return this.push(setOp(Op.IN, values));
+	}
+	/**
+	* Assert the value is not a member of the set.
+	* @throws {CallciumError} If the set is empty after deduplication.
+	*/
+	notIn(values) {
+		return this.push(setOp(Op.IN | Op.NOT, values));
+	}
+	/** Assert all bits in `mask` are set. */
+	bitmaskAll(mask) {
+		return this.push(singleOp(Op.BITMASK_ALL, mask));
+	}
+	/** Assert at least one bit in `mask` is set. */
+	bitmaskAny(mask) {
+		return this.push(singleOp(Op.BITMASK_ANY, mask));
+	}
+	/** Assert no bit in `mask` is set. */
+	bitmaskNone(mask) {
+		return this.push(singleOp(Op.BITMASK_NONE, mask));
+	}
+	/** Assert the runtime length equals `n`. */
+	lengthEq(n) {
+		return this.push(singleOp(Op.LENGTH_EQ, n));
+	}
+	/** Assert the runtime length is greater than `n`. */
+	lengthGt(n) {
+		return this.push(singleOp(Op.LENGTH_GT, n));
+	}
+	/** Assert the runtime length is less than `n`. */
+	lengthLt(n) {
+		return this.push(singleOp(Op.LENGTH_LT, n));
+	}
+	/** Assert the runtime length is greater than or equal to `n`. */
+	lengthGte(n) {
+		return this.push(singleOp(Op.LENGTH_GTE, n));
+	}
+	/** Assert the runtime length is less than or equal to `n`. */
+	lengthLte(n) {
+		return this.push(singleOp(Op.LENGTH_LTE, n));
+	}
+	/**
+	* Assert the runtime length is within [min, max] inclusive.
+	* @throws {CallciumError} If min > max.
+	*/
+	lengthBetween(min, max) {
+		return this.push(rangeOp(Op.LENGTH_BETWEEN, BigInt(min), BigInt(max)));
+	}
+};
+function arg(...steps) {
+	return new ConstraintBuilder(Scope.CALLDATA, encodePath(steps));
+}
+/** Target the `msg.sender` context property. */
+function msgSender() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.MSG_SENDER]));
+}
+/** Target the `msg.value` context property. */
+function msgValue() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.MSG_VALUE]));
+}
+/** Target the `block.timestamp` context property. */
+function blockTimestamp() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BLOCK_TIMESTAMP]));
+}
+/** Target the `block.number` context property. */
+function blockNumber() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BLOCK_NUMBER]));
+}
+/** Target the `block.chainid` context property. */
+function chainId() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.CHAIN_ID]));
+}
+/** Target the `tx.origin` context property. */
+function txOrigin() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.TX_ORIGIN]));
+}
+//#endregion
+//#region src/reader.ts
+/** Read 32 bytes at offset, bounds-checked. */
+function load32(callData, offset) {
+	if (offset < 0 || offset + 32 > callData.length) return { code: "CALLDATA_OUT_OF_BOUNDS" };
+	return callData.subarray(offset, offset + 32);
+}
+/**
+* Read ABI pointer (offset or length) from a 32-byte slot.
+* Validates high 28 bytes are zero (rejects values > 32-bit).
+*/
+function readPointer(callData, head) {
+	const word = load32(callData, head);
+	if (word instanceof Uint8Array) {
+		for (let i = 0; i < 28; i++) if (word[i] !== 0) return { code: "CALLDATA_OUT_OF_BOUNDS" };
+		return (word[28] << 24 | word[29] << 16 | word[30] << 8 | word[31]) >>> 0;
+	}
+	return word;
+}
+/** Return the number of bytes this node occupies in the head region. */
+function headContribution(node) {
+	return node.isDynamic ? 32 : node.staticSize;
+}
+/** Read a single BE16 path step at the given step index. */
+function readStep(pathBytes, stepIndex) {
+	return readU16(pathBytes, stepIndex * 2);
+}
+/** Navigate one path step through a node (tuple field, array element, or quantifier). */
+function descend(node, callData, head, base, childIndex) {
+	if (node.type === "tuple") return descendTuple(node, callData, head, base, childIndex);
+	if (node.type === "dynamicArray") return descendDynamicArray(node, callData, head, base, childIndex);
+	if (node.type === "staticArray") return descendStaticArray(node, callData, head, base, childIndex);
+	throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type (${node.type}).`);
+}
+/** Descend into a tuple field by index. */
+function descendTuple(node, callData, head, base, childIndex) {
+	if (childIndex >= node.fields.length) throw new CallciumError("INVALID_PATH", `Tuple field index ${childIndex} out of range (${node.fields.length} fields).`);
+	let tupleBase;
+	let cursor;
+	if (node.isDynamic) {
+		const ptrResult = readPointer(callData, head);
+		if (typeof ptrResult !== "number") return {
+			type: "violation",
+			code: ptrResult.code
+		};
+		tupleBase = base + ptrResult;
+		cursor = tupleBase;
+	} else {
+		tupleBase = base;
+		cursor = head;
+	}
+	for (let i = 0; i < childIndex; i++) cursor += headContribution(node.fields[i]);
+	return {
+		type: "ok",
+		head: cursor,
+		base: tupleBase,
+		node: node.fields[childIndex]
+	};
+}
+/** Descend into a dynamic array element by index. */
+function descendDynamicArray(node, callData, head, base, childIndex) {
+	const arrayBaseResult = readPointer(callData, head);
+	if (typeof arrayBaseResult !== "number") return {
+		type: "violation",
+		code: arrayBaseResult.code
+	};
+	const arrayBase = base + arrayBaseResult;
+	const lengthResult = readPointer(callData, arrayBase);
+	if (typeof lengthResult !== "number") return {
+		type: "violation",
+		code: lengthResult.code
+	};
+	if (childIndex >= lengthResult) return {
+		type: "violation",
+		code: "ARRAY_INDEX_OUT_OF_BOUNDS"
+	};
+	const headsBase = arrayBase + 32;
+	const elem = node.element;
+	if (elem.isDynamic) return {
+		type: "ok",
+		head: headsBase + childIndex * 32,
+		base: headsBase,
+		node: elem
+	};
+	return {
+		type: "ok",
+		head: headsBase + childIndex * elem.staticSize,
+		base: arrayBase,
+		node: elem
+	};
+}
+/** Descend into a static array element by index. */
+function descendStaticArray(node, callData, head, base, childIndex) {
+	if (childIndex >= node.length) throw new CallciumError("INVALID_PATH", `Static array index ${childIndex} out of range (length ${node.length}).`);
+	const elem = node.element;
+	if (elem.isDynamic) {
+		const ptrResult = readPointer(callData, head);
+		if (typeof ptrResult !== "number") return {
+			type: "violation",
+			code: ptrResult.code
+		};
+		const arrayBase = base + ptrResult;
+		return {
+			type: "ok",
+			head: arrayBase + childIndex * 32,
+			base: arrayBase,
+			node: elem
+		};
+	}
+	return {
+		type: "ok",
+		head: head + childIndex * elem.staticSize,
+		base,
+		node: elem
+	};
+}
+/**
+* Resolve a path to a calldata location, stopping at a leaf or quantifier.
+*
+* The path is a sequence of BE16 steps. The first step selects the top-level
+* parameter; subsequent steps descend into tuples and arrays. If a quantifier
+* step is encountered, returns a QuantifierResult with the array location and
+* remaining path suffix.
+*/
+function locate(tree, callData, pathBytes, baseOffset) {
+	const stepCount = pathBytes.length / 2;
+	if (stepCount === 0) throw new CallciumError("INVALID_PATH", "Path is empty.");
+	const paramIndex = readStep(pathBytes, 0);
+	if (paramIndex >= tree.length) throw new CallciumError("INVALID_PATH", `Param index ${paramIndex} out of range (${tree.length} params).`);
+	let head = baseOffset;
+	for (let i = 0; i < paramIndex; i++) head += headContribution(tree[i]);
+	let base = baseOffset;
+	let node = tree[paramIndex];
+	for (let s = 1; s < stepCount; s++) {
+		const step = readStep(pathBytes, s);
+		if (isQuantifier(step)) {
+			const remaining = pathBytes.subarray((s + 1) * 2);
+			for (let r = 0; r < remaining.length / 2; r++) if (isQuantifier(readStep(remaining, r))) throw new CallciumError("INVALID_QUANTIFIER", "Nested quantifiers are not supported.");
+			return {
+				ok: true,
+				type: "quantifier",
+				quantifier: {
+					quantifier: step,
+					location: {
+						head,
+						base,
+						node
+					},
+					remainingPath: remaining
+				}
+			};
+		}
+		const result = descend(node, callData, head, base, step);
+		if (result.type === "violation") return {
+			ok: false,
+			code: result.code
+		};
+		head = result.head;
+		base = result.base;
+		node = result.node;
+	}
+	return {
+		ok: true,
+		type: "leaf",
+		location: {
+			head,
+			base,
+			node
+		}
+	};
+}
+/** Extract array shape from a location pointing to an array node. */
+function arrayShape(callData, location) {
+	const { head, base, node } = location;
+	if (node.type === "dynamicArray") {
+		const arrayBaseResult = readPointer(callData, head);
+		if (typeof arrayBaseResult !== "number") return {
+			ok: false,
+			code: arrayBaseResult.code
+		};
+		const arrayBase = base + arrayBaseResult;
+		const lengthResult = readPointer(callData, arrayBase);
+		if (typeof lengthResult !== "number") return {
+			ok: false,
+			code: lengthResult.code
+		};
+		const elem = node.element;
+		const headsBase = arrayBase + 32;
+		if (elem.isDynamic) return {
+			ok: true,
+			shape: {
+				length: lengthResult,
+				elementNode: elem,
+				elementIsDynamic: true,
+				elementStaticSize: 0,
+				headsBase,
+				dataOffset: 0,
+				compositeBase: headsBase
+			}
+		};
+		return {
+			ok: true,
+			shape: {
+				length: lengthResult,
+				elementNode: elem,
+				elementIsDynamic: false,
+				elementStaticSize: elem.staticSize,
+				headsBase: 0,
+				dataOffset: headsBase,
+				compositeBase: arrayBase
+			}
+		};
+	}
+	if (node.type === "staticArray") {
+		const elem = node.element;
+		if (elem.isDynamic) {
+			const arrayBaseResult = readPointer(callData, head);
+			if (typeof arrayBaseResult !== "number") return {
+				ok: false,
+				code: arrayBaseResult.code
+			};
+			const arrayBase = base + arrayBaseResult;
+			return {
+				ok: true,
+				shape: {
+					length: node.length,
+					elementNode: elem,
+					elementIsDynamic: true,
+					elementStaticSize: 0,
+					headsBase: arrayBase,
+					dataOffset: 0,
+					compositeBase: arrayBase
+				}
+			};
+		}
+		return {
+			ok: true,
+			shape: {
+				length: node.length,
+				elementNode: elem,
+				elementIsDynamic: false,
+				elementStaticSize: elem.staticSize,
+				headsBase: 0,
+				dataOffset: head,
+				compositeBase: base
+			}
+		};
+	}
+	throw new CallciumError("INVALID_PATH", `Cannot compute array shape for non-array node (${node.type}).`);
+}
+/** Compute the location for element N within a precomputed array shape. */
+function arrayElementAt(shape, index, callData) {
+	if (index >= shape.length) return {
+		ok: false,
+		code: "ARRAY_INDEX_OUT_OF_BOUNDS"
+	};
+	let head;
+	let base;
+	if (!shape.elementIsDynamic) {
+		head = shape.dataOffset + index * shape.elementStaticSize;
+		base = shape.compositeBase;
+	} else {
+		head = shape.headsBase + index * 32;
+		base = shape.headsBase;
+	}
+	if (head + 32 > callData.length) return {
+		ok: false,
+		code: "CALLDATA_OUT_OF_BOUNDS"
+	};
+	return {
+		ok: true,
+		location: {
+			head,
+			base,
+			node: shape.elementNode
+		}
+	};
+}
+/** Load a 32-byte scalar value from a resolved location. */
+function loadScalar(callData, location) {
+	const result = load32(callData, location.head);
+	if (result instanceof Uint8Array) return {
+		ok: true,
+		value: result
+	};
+	return {
+		ok: false,
+		code: result.code
+	};
+}
+/** Load the data offset and logical length for a dynamic type (bytes, string, or dynamic array). */
+function loadSlice(callData, location) {
+	const ptrResult = readPointer(callData, location.head);
+	if (typeof ptrResult !== "number") return {
+		ok: false,
+		code: ptrResult.code
+	};
+	const dataStart = location.base + ptrResult;
+	const lengthResult = readPointer(callData, dataStart);
+	if (typeof lengthResult !== "number") return {
+		ok: false,
+		code: lengthResult.code
+	};
+	return {
+		ok: true,
+		dataOffset: dataStart + 32,
+		length: lengthResult
+	};
+}
+/** Continue navigating through additional path steps from a resolved location. */
+function descendPath(callData, location, pathBytes) {
+	const stepCount = pathBytes.length / 2;
+	let { head, base, node } = location;
+	for (let s = 0; s < stepCount; s++) {
+		const step = readStep(pathBytes, s);
+		const result = descend(node, callData, head, base, step);
+		if (result.type === "violation") return {
+			ok: false,
+			code: result.code
+		};
+		head = result.head;
+		base = result.base;
+		node = result.node;
+	}
+	return {
+		ok: true,
+		location: {
+			head,
+			base,
+			node
+		}
+	};
+}
+//#endregion
+//#region src/policy-enforcer.ts
+/** Convert a hex address to a 256-bit bigint (zero-padded to 32 bytes). */
+function addressToBigInt(hex) {
+	const bytes = hexToBytes(hex);
+	const padded = new Uint8Array(32);
+	padded.set(bytes, 32 - bytes.length);
+	return toBigInt(padded, 0);
+}
+/** Format a bigint as a compact hex string without leading-zero padding. */
+function compactHex(value) {
+	if (value === 0n) return "0x0";
+	return `0x${value.toString(16)}`;
+}
+/** Truncate a hex string to at most maxChars characters, adding ellipsis if needed. */
+function truncateHexForMessage(hex, maxChars = 66) {
+	if (hex.length <= maxChars) return hex;
+	return `${hex.slice(0, maxChars - 1)}…`;
+}
+/** Format a decoded operand as decimal for length ops, otherwise compact hex. */
+function formatOperandValue(value, opCode) {
+	return isLengthOp(opCode) ? value.toString(10) : compactHex(value);
+}
+/** Format the constraint (operator + operands) from a single lookupOp call. */
+function formatConstraint(opCode, operandData) {
+	const negated = (opCode & Op.NOT) !== 0;
+	const { label, operands } = lookupOp(opCode);
+	const op = negated ? `not ${label}` : label;
+	let formattedOperands;
+	if (operands === "variadic") formattedOperands = `(${operandData.length / 32} values)`;
+	else if (operands === "range") {
+		const min = toBigInt(operandData, 0);
+		const max = toBigInt(operandData, 32);
+		formattedOperands = `[${formatOperandValue(min, opCode)}, ${formatOperandValue(max, opCode)}]`;
+	} else formattedOperands = formatOperandValue(toBigInt(operandData, 0), opCode);
+	return `${op} ${formattedOperands}`;
+}
+/** Build a self-contained VALUE_MISMATCH message for a scalar or length comparison. */
+function mismatchMessage(opCode, actual, operandData) {
+	const display = typeof actual === "number" ? String(actual) : truncateHexForMessage(compactHex(actual));
+	return `constraint ${formatConstraint(opCode, operandData)} violated by ${display}`;
+}
+/**
+* Check a policy against ABI-encoded call data without throwing on violations.
+* @param policy - Binary policy blob as 0x-prefixed hex string.
+* @param callData - ABI-encoded call data as 0x-prefixed hex string.
+* @param context - Optional execution context for context-scoped rules.
+* @returns Pass with matched group index, or fail with one violation per failed group.
+* @throws {CallciumError} If the policy blob is structurally malformed.
+*/
+function check(policy, callData, context) {
+	const { policy: decoded, tree } = decodePolicy(policy);
+	const callDataBytes = hexToBytes(callData);
+	if (!decoded.isSelectorless) {
+		if (callDataBytes.length < 4) return {
+			ok: false,
+			violations: [{
+				code: "MISSING_SELECTOR",
+				message: "Calldata too short to contain a selector"
+			}]
+		};
+		const expectedSelector = decoded.selector.value;
+		const actualSelector = bytesToHex(callDataBytes.subarray(0, 4));
+		if (actualSelector !== expectedSelector) return {
+			ok: false,
+			violations: [{
+				code: "SELECTOR_MISMATCH",
+				message: `Expected selector ${expectedSelector}, got ${actualSelector}`,
+				resolvedValue: actualSelector
+			}]
+		};
+	}
+	const baseOffset = decoded.isSelectorless ? 0 : PolicyFormat.SELECTOR_SIZE;
+	const allViolations = [];
+	for (let groupIndex = 0; groupIndex < decoded.groups.length; groupIndex++) {
+		const group = decoded.groups[groupIndex];
+		let groupFailed = false;
+		for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex++) {
+			const rule = group.rules[ruleIndex];
+			const violation = evaluateRule(rule, tree, callDataBytes, baseOffset, groupIndex, ruleIndex, context);
+			if (violation !== null) {
+				allViolations.push(violation);
+				groupFailed = true;
+				break;
+			}
+		}
+		if (!groupFailed) return {
+			ok: true,
+			matchedGroup: groupIndex
+		};
+	}
+	return {
+		ok: false,
+		violations: allViolations
+	};
+}
+/**
+* Enforce a policy against ABI-encoded call data, throwing on violation.
+* @param policy - Binary policy blob as 0x-prefixed hex string.
+* @param callData - ABI-encoded call data as 0x-prefixed hex string.
+* @param context - Optional execution context for context-scoped rules.
+* @throws {PolicyViolationError} If the policy rejects the call data.
+* @throws {CallciumError} If the policy blob is structurally malformed.
+*/
+function enforce(policy, callData, context) {
+	const result = check(policy, callData, context);
+	if (!result.ok) throw new PolicyViolationError(result.violations);
+}
+/** Evaluate a single rule against calldata or context, returning a violation or null on pass. */
+function evaluateRule(rule, tree, callDataBytes, baseOffset, groupIndex, ruleIndex, context) {
+	const scope = rule.scope.value;
+	const pathBytes = hexToBytes(rule.path.value);
+	const opCode = rule.opCode.value;
+	const operandData = hexToBytes(rule.data.value);
+	if (pathBytes.length / 2 > Limits.MAX_PATH_DEPTH) throw new CallciumError("INVALID_PATH", `Path depth ${pathBytes.length / 2} exceeds maximum ${Limits.MAX_PATH_DEPTH}.`);
+	if (scope === Scope.CONTEXT) return evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleIndex, rule.path.value, context);
+	const locResult = locate(tree, callDataBytes, pathBytes, baseOffset);
+	if (!locResult.ok) return {
+		group: groupIndex,
+		rule: ruleIndex,
+		code: locResult.code,
+		message: `Navigation failed: ${locResult.code}`,
+		path: rule.path.value
+	};
+	if (locResult.type === "quantifier") return evaluateQuantifier(locResult.quantifier, callDataBytes, opCode, operandData, groupIndex, ruleIndex, rule.path.value);
+	return evaluateLeaf(locResult.location, callDataBytes, opCode, operandData, groupIndex, ruleIndex, rule.path.value);
+}
+/** Evaluate a context-scoped rule by resolving the property from the execution context. */
+function evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleIndex, pathHex, context) {
+	const propertyId = readU16(pathBytes, 0);
+	if (propertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("INVALID_CONTEXT_PATH", `Unknown context property ID 0x${propertyId.toString(16).padStart(4, "0")}`);
+	const propInfo = lookupContextProperty(propertyId);
+	const contextValue = context?.[propInfo.contextKey];
+	if (contextValue === void 0) return {
+		group: groupIndex,
+		rule: ruleIndex,
+		code: "MISSING_CONTEXT",
+		message: `Context property ${propInfo.label} not provided`,
+		path: pathHex
+	};
+	let value;
+	if (typeof contextValue === "string") value = addressToBigInt(contextValue);
+	else value = contextValue;
+	if (!applyOperator(opCode, value, 32, operandData, TypeCode.UINT_MAX)) return {
+		group: groupIndex,
+		rule: ruleIndex,
+		code: "VALUE_MISMATCH",
+		message: mismatchMessage(opCode, value, operandData),
+		path: pathHex,
+		resolvedValue: bigintToHex(value)
+	};
+	return null;
+}
+/** Load a value from calldata at the given location and apply the operator. */
+function applyLeafOperator(callDataBytes, location, opCode, operandData) {
+	const { node } = location;
+	if (isLengthOp(opCode)) {
+		let valueLength;
+		if (node.isDynamic) {
+			const lengthResult = loadSlice(callDataBytes, location);
+			if (!lengthResult.ok) return { error: lengthResult.code };
+			valueLength = lengthResult.length;
+		} else valueLength = node.staticSize;
+		return {
+			passed: applyOperator(opCode, 0n, valueLength, operandData, node.typeCode),
+			length: valueLength
+		};
+	}
+	const result = loadScalar(callDataBytes, location);
+	if (!result.ok) return { error: result.code };
+	const value = toBigInt(result.value, 0);
+	return {
+		passed: applyOperator(opCode, value, 32, operandData, node.typeCode),
+		value
+	};
+}
+/** Evaluate a leaf rule, producing a violation on failure or null on pass. */
+function evaluateLeaf(location, callDataBytes, opCode, operandData, groupIndex, ruleIndex, pathHex) {
+	const result = applyLeafOperator(callDataBytes, location, opCode, operandData);
+	if ("error" in result) {
+		const message = isLengthOp(opCode) ? `Failed to read length: ${result.error}` : `Failed to load value: ${result.error}`;
+		return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: result.error,
+			message,
+			path: pathHex
+		};
+	}
+	if (!result.passed) {
+		const actual = result.value !== void 0 ? result.value : result.length ?? 0;
+		return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: "VALUE_MISMATCH",
+			message: mismatchMessage(opCode, actual, operandData),
+			path: pathHex,
+			resolvedValue: bigintToHex(typeof actual === "number" ? BigInt(actual) : actual)
+		};
+	}
+	return null;
+}
+/** Evaluate a quantified rule by iterating over array elements with ALL/ANY semantics. */
+function evaluateQuantifier(qResult, callDataBytes, opCode, operandData, groupIndex, ruleIndex, pathHex) {
+	const { quantifier, location: arrayLocation, remainingPath } = qResult;
+	const shapeResult = arrayShape(callDataBytes, arrayLocation);
+	if (!shapeResult.ok) return {
+		group: groupIndex,
+		rule: ruleIndex,
+		code: shapeResult.code,
+		message: `Failed to read array shape: ${shapeResult.code}`,
+		path: pathHex
+	};
+	const shape = shapeResult.shape;
+	if (shape.length > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) return {
+		group: groupIndex,
+		rule: ruleIndex,
+		code: "QUANTIFIER_LIMIT_EXCEEDED",
+		message: `Array length ${shape.length} exceeds maximum ${Limits.MAX_QUANTIFIED_ARRAY_LENGTH}`,
+		path: pathHex
+	};
+	if (shape.length === 0) {
+		if (quantifier === Quantifier.ALL_OR_EMPTY) return null;
+		return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: "QUANTIFIER_EMPTY_ARRAY",
+			message: "Quantifier applied to empty array",
+			path: pathHex
+		};
+	}
+	const isUniversal = quantifier === Quantifier.ALL_OR_EMPTY || quantifier === Quantifier.ALL;
+	const hasSuffix = remainingPath.length > 0;
+	for (let elemIndex = 0; elemIndex < shape.length; elemIndex++) {
+		const elemResult = arrayElementAt(shape, elemIndex, callDataBytes);
+		if (!elemResult.ok) {
+			if (isUniversal) return {
+				group: groupIndex,
+				rule: ruleIndex,
+				code: elemResult.code,
+				message: `Quantifier element ${elemIndex}: ${elemResult.code}`,
+				path: pathHex
+			};
+			continue;
+		}
+		const elemLocation = elemResult.location;
+		let elemPassed;
+		if (hasSuffix) {
+			const leafResult = descendPath(callDataBytes, elemLocation, remainingPath);
+			if (!leafResult.ok) {
+				if (isUniversal) return {
+					group: groupIndex,
+					rule: ruleIndex,
+					code: leafResult.code,
+					message: `Quantifier element ${elemIndex} navigation failed: ${leafResult.code}`,
+					path: pathHex
+				};
+				continue;
+			}
+			elemPassed = evaluateLeafValue(leafResult.location, callDataBytes, opCode, operandData);
+		} else {
+			const leafResult = applyLeafOperator(callDataBytes, elemLocation, opCode, operandData);
+			if ("error" in leafResult) {
+				if (isUniversal) return {
+					group: groupIndex,
+					rule: ruleIndex,
+					code: leafResult.error,
+					message: `Quantifier element ${elemIndex}: ${leafResult.error}`,
+					path: pathHex
+				};
+				continue;
+			}
+			elemPassed = leafResult.passed;
+		}
+		if (isUniversal && !elemPassed) return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: "VALUE_MISMATCH",
+			message: `constraint ${formatConstraint(opCode, operandData)} violated at element ${elemIndex}`,
+			path: pathHex
+		};
+		if (!isUniversal && elemPassed) return null;
+	}
+	if (isUniversal) return null;
+	return {
+		group: groupIndex,
+		rule: ruleIndex,
+		code: "VALUE_MISMATCH",
+		message: `constraint ${formatConstraint(opCode, operandData)} violated by all elements`,
+		path: pathHex
+	};
+}
+/** Apply a leaf operator and return a boolean. Returns false on calldata read failure. */
+function evaluateLeafValue(location, callDataBytes, opCode, operandData) {
+	const result = applyLeafOperator(callDataBytes, location, opCode, operandData);
+	if ("error" in result) return false;
+	return result.passed;
+}
+/** Check and enforce policies against ABI-encoded call data. */
+const PolicyEnforcer = {
+	check,
+	enforce
+};
+//#endregion
+export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Limits, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, arg, blockNumber, blockTimestamp, bytesToHex, chainId, hexToBytes, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+
+//# sourceMappingURL=index.js.map