@callcium/sdk 0.4.0 → 0.6.0

package/dist/index.js

@@ -172,54 +172,71 @@ function lookupScope(code) {
 	if (!info) throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${code}`);
 	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
+};
 const CTX_PROP_TABLE = [
 	{
 		key: "MSG_SENDER",
 		code: 0,
 		label: "msg.sender",
-		typeCode: 64
+		typeCode: TypeCode.ADDRESS
 	},
 	{
 		key: "MSG_VALUE",
 		code: 1,
 		label: "msg.value",
-		typeCode: 31
+		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "BLOCK_TIMESTAMP",
 		code: 2,
 		label: "block.timestamp",
-		typeCode: 31
+		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "BLOCK_NUMBER",
 		code: 3,
 		label: "block.number",
-		typeCode: 31
+		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "CHAIN_ID",
 		code: 4,
 		label: "block.chainid",
-		typeCode: 31
+		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "TX_ORIGIN",
 		code: 5,
 		label: "tx.origin",
-		typeCode: 64
+		typeCode: TypeCode.ADDRESS
 	},
 	{
 		key: "BASE_FEE",
 		code: 6,
 		label: "block.basefee",
-		typeCode: 31
+		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "GAS_PRICE",
 		code: 7,
 		label: "tx.gasprice",
-		typeCode: 31
+		typeCode: TypeCode.UINT_MAX
 	}
 ];
 /** Well-known context property IDs for context-scope rules. */
@@ -426,23 +443,6 @@ function lookupQuantifier(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")}`);
@@ -574,7 +574,7 @@ function inspect$1(desc, offset) {
 * @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.
+* @throws {CallciumError} On empty steps, out-of-bounds param or array index, or descent into elementary type.
 */
 function typeAt(desc, steps) {
 	return walkPath(desc, steps).typeInfo;
@@ -586,7 +586,7 @@ function typeAt(desc, steps) {
 * @param desc - Raw descriptor bytes.
 * @param steps - Path steps, length >= 1.
 * @returns TypeInfo at the resolved path and the quantified static array length.
-* @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
+* @throws {CallciumError} On empty steps, out-of-bounds param or array index, or descent into elementary type.
 */
 function walkPath(desc, steps) {
 	if (steps.length === 0) throw new CallciumError("INVALID_PATH", "Path must have at least one step.");
@@ -603,7 +603,11 @@ function walkPath(desc, steps) {
 			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) {
-			if (typeCode === TypeCode.STATIC_ARRAY && isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			if (typeCode === TypeCode.STATIC_ARRAY) if (isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			else {
+				const length = staticArrayLength(desc, cursor);
+				if (step >= length) throw new CallciumError("INVALID_PATH", `Array index ${step} out of range (length=${length}).`);
+			}
 			cursor = arrayElementOffset(cursor);
 		} else throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type at offset ${cursor}.`);
 	}
@@ -807,6 +811,7 @@ function commaPositions(input, start, end) {
 */
 function parseUint(input, start, end) {
 	if (start >= end) return -1;
+	if (end - start > 1 && input.charCodeAt(start) === 48) return -1;
 	let value = 0;
 	for (let i = start; i < end; i++) {
 		const code = input.charCodeAt(i);
@@ -1457,6 +1462,13 @@ function isSigned(typeCode) {
 	return typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
 }
 /**
+* Return true when the type code represents a left-aligned type (fixed bytes or function),
+* whose value occupies the high bytes of the word with zero padding below.
+*/
+function isLeftAligned(typeCode) {
+	return typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX || typeCode === TypeCode.FUNCTION;
+}
+/**
 * Canonicalize a raw 256-bit calldata word to its ABI value for the declared type (Policy Spec §7.8).
 * A scalar loaded from untrusted calldata may carry bits outside the declared width; masking
 * unsigned/address/bool/function/bytesN to width and sign-extending signed integers makes the
@@ -1490,6 +1502,15 @@ function isLengthOp(opCode) {
 	const base = opCode & ~Op.NOT;
 	return base >= Op.LENGTH_EQ && base <= Op.LENGTH_BETWEEN;
 }
+/** Map a LENGTH_* opcode base to its core value-comparison twin. */
+function lengthToValueOp(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 Op.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;
@@ -1529,7 +1550,12 @@ function isIn(value, data) {
 */
 function applyOperator(opCode, value, valueLength, operandData, typeCode) {
 	const negate = (opCode & Op.NOT) !== 0;
-	const base = opCode & ~Op.NOT;
+	let base = opCode & ~Op.NOT;
+	if (isLengthOp(base)) {
+		value = BigInt(valueLength);
+		typeCode = TypeCode.UINT_MAX;
+		base = lengthToValueOp(base);
+	}
 	let result;
 	switch (base) {
 		case Op.EQ:
@@ -1561,32 +1587,14 @@ function applyOperator(opCode, value, valueLength, operandData, typeCode) {
 			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);
+		case Op.BITMASK_ANY: {
+			const mask = toBigInt(operandData, 0);
+			result = (value & mask) !== 0n;
 			break;
-		case Op.LENGTH_BETWEEN: {
-			const length = BigInt(valueLength);
-			const min = toBigInt(operandData, 0);
-			const max = toBigInt(operandData, 32);
-			result = length >= min && length <= max;
+		}
+		case Op.BITMASK_NONE: {
+			const mask = toBigInt(operandData, 0);
+			result = (value & mask) === 0n;
 			break;
 		}
 		default: throw new CallciumError("INVALID_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}.`);
@@ -1596,230 +1604,435 @@ function applyOperator(opCode, value, valueLength, operandData, typeCode) {
 //#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) {
+/** Create an issue from operator compatibility results. */
+function fromOpRule(code, message, groupIndex, constraintIndex, opCode) {
 	return {
-		severity,
-		category,
+		severity: "error",
+		category: "typeMismatch",
 		groupIndex,
 		constraintIndex,
 		code,
-		value1,
-		value2,
+		value1: opCode,
+		value2: ZERO,
 		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);
+/** Issue for a calldata path that does not navigate the descriptor. */
+function unnavigablePath(groupIndex, constraintIndex) {
+	return {
+		severity: "error",
+		category: "typeMismatch",
+		groupIndex,
+		constraintIndex,
+		code: "UNNAVIGABLE_PATH",
+		value1: ZERO,
+		value2: ZERO,
+		message: "Path does not navigate the descriptor"
+	};
 }
-/** 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");
+/** Issue for an operand that is not canonically encoded for the declared type. */
+function nonCanonicalOperand(groupIndex, constraintIndex, operand, canonical) {
+	return {
+		severity: "error",
+		category: "typeMismatch",
+		groupIndex,
+		constraintIndex,
+		code: "NON_CANONICAL_OPERAND",
+		value1: operand,
+		value2: canonical,
+		message: "Operand is not the canonical encoding for the declared type"
+	};
 }
-/** 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");
+/** eq(v)/neq(v) or lengthEq(v)/lengthNeq(v) on the same path. */
+function eqNeqContradiction(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "LENGTH_EQ_NEQ_CONTRADICTION" : "EQ_NEQ_CONTRADICTION",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "lengthEq(v) and lengthNeq(v) on same path" : "eq(v) and neq(v) on same path"
+	};
+}
+/** Multiple eq()/lengthEq() operators with different values. */
+function conflictingEquality(isLength, groupIndex, constraintIndex, existing, newValue) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "CONFLICTING_LENGTH" : "CONFLICTING_EQUALITY",
+		value1: existing,
+		value2: newValue,
+		message: isLength ? "Multiple lengthEq() operators with different values" : "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");
+/** Value/length is outside the physical range of its type. */
+function outOfPhysicalBounds(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "OUT_OF_PHYSICAL_LENGTH_BOUNDS" : "OUT_OF_PHYSICAL_BOUNDS",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "Length value is outside the physical range" : "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");
+/** gt()/lengthGt() on the maximum is impossible. */
+function impossibleGt(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "IMPOSSIBLE_LENGTH_GT" : "IMPOSSIBLE_GT",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "lengthGt() on maximum length is impossible" : "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");
+/** lt()/lengthLt() on the minimum is impossible. */
+function impossibleLt(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "IMPOSSIBLE_LENGTH_LT" : "IMPOSSIBLE_LT",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "lengthLt() on minimum length is impossible" : "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");
+/** eq()/lengthEq() value is excluded by a bound. */
+function boundsExcludeEquality(isLength, groupIndex, constraintIndex, eq, bound) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "BOUNDS_EXCLUDE_LENGTH" : "BOUNDS_EXCLUDE_EQUALITY",
+		value1: eq,
+		value2: bound,
+		message: isLength ? "lengthEq() value is excluded by 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");
+/** Lower bound/length exceeds the upper bound. */
+function impossibleRange(isLength, groupIndex, constraintIndex, lower, upper) {
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "IMPOSSIBLE_LENGTH_RANGE" : "IMPOSSIBLE_RANGE",
+		value1: lower,
+		value2: upper,
+		message: isLength ? "Lower length bound exceeds upper bound" : "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");
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: "SET_EXCLUDES_EQUALITY",
+		value1: value,
+		value2: ZERO,
+		message: "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");
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: "EMPTY_SET_INTERSECTION",
+		value1: ZERO,
+		value2: ZERO,
+		message: "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");
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: "SET_FULLY_EXCLUDED",
+		value1: ZERO,
+		value2: ZERO,
+		message: "All values in isIn() set are excluded by neq/notIn"
+	};
 }
 /** Bitmask operators conflict. */
 function bitmaskContradiction(groupIndex, constraintIndex, mask, conflicting) {
-	return makeIssue("error", "contradiction", groupIndex, constraintIndex, "BITMASK_CONTRADICTION", mask, conflicting, "Bitmask operators conflict");
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: "BITMASK_CONTRADICTION",
+		value1: mask,
+		value2: conflicting,
+		message: "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");
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: "BITMASK_ANY_IMPOSSIBLE",
+		value1: mask,
+		value2: mustBeZero,
+		message: "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.");
+	return {
+		severity: "error",
+		category: "contradiction",
+		groupIndex,
+		constraintIndex,
+		code: "UNSORTED_IN_SET",
+		value1: ZERO,
+		value2: ZERO,
+		message: "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.");
+	return {
+		severity: "error",
+		category: "vacuity",
+		groupIndex,
+		constraintIndex: 0,
+		code: "EMPTY_GROUP",
+		value1: ZERO,
+		value2: ZERO,
+		message: "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");
+/** Numeric/length bound dominated by a stricter bound. */
+function dominatedBound(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "DOMINATED_LENGTH_BOUND" : "DOMINATED_BOUND",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "Length bound is dominated by a stricter bound" : "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");
+/** Bound redundant because eq()/lengthEq() is set. */
+function redundantBound(isLength, groupIndex, constraintIndex, bound, eq) {
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "REDUNDANT_LENGTH_BOUND" : "REDUNDANT_BOUND",
+		value1: bound,
+		value2: eq,
+		message: isLength ? "Length bound is redundant because lengthEq() is set" : "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");
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: "SET_REDUCTION",
+		value1: value,
+		value2: ZERO,
+		message: "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");
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: "SET_REDUNDANCY",
+		value1: intersectionCount,
+		value2: ZERO,
+		message: "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");
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: "SET_PARTIALLY_EXCLUDED",
+		value1: excludedCount,
+		value2: ZERO,
+		message: "Some values in isIn() set are excluded by neq/notIn"
+	};
 }
 /** Bitmask operation is redundant. */
 function redundantBitmask(groupIndex, constraintIndex, mask, existing) {
-	return makeIssue("warning", "redundancy", groupIndex, constraintIndex, "REDUNDANT_BITMASK", mask, existing, "Bitmask operation is redundant");
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: "REDUNDANT_BITMASK",
+		value1: mask,
+		value2: existing,
+		message: "Bitmask operation is redundant"
+	};
+}
+/** gte/lte pair fusible into a single range operator. */
+function fusibleRange(isLength, groupIndex, constraintIndex, low, high) {
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "FUSIBLE_LENGTH_RANGE" : "FUSIBLE_RANGE",
+		value1: low,
+		value2: high,
+		message: isLength ? "lengthGte() and lengthLte() fuse into a single lengthBetween()" : "gte() and lte() fuse into a single between()"
+	};
 }
 /** 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)");
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: "DUPLICATE_CONSTRAINT",
+		value1: ZERO,
+		value2: ZERO,
+		message: "Duplicate operator in constraint"
+	};
 }
-/** 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)");
+/** gte(min)/lengthGte(0) is always true. */
+function vacuousGte(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "info",
+		category: "vacuity",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "VACUOUS_LENGTH_GTE" : "VACUOUS_GTE",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "lengthGte(0) is always true" : "gte() bound equals type minimum (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");
+/** lte(max)/lengthLte(max) is always true. */
+function vacuousLte(isLength, groupIndex, constraintIndex, value) {
+	return {
+		severity: "info",
+		category: "vacuity",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "VACUOUS_LENGTH_LTE" : "VACUOUS_LTE",
+		value1: value,
+		value2: ZERO,
+		message: isLength ? "lengthLte() bound equals maximum (always true)" : "lte() bound equals type maximum (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)");
+/** Negated range with inverted bounds excludes nothing (always true). */
+function vacuousNegatedRange(isLength, groupIndex, constraintIndex, low, high) {
+	return {
+		severity: "info",
+		category: "vacuity",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "VACUOUS_NEGATED_LENGTH_RANGE" : "VACUOUS_NEGATED_RANGE",
+		value1: low,
+		value2: high,
+		message: isLength ? "Negated lengthBetween() with low > high excludes nothing (always true)" : "Negated between() with low > high excludes nothing (always true)"
+	};
 }
 /** Path deeper than the reference enforcer's cap. */
 function pathDepthExceeded(groupIndex, constraintIndex, depth, maxDepth) {
-	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "PATH_DEPTH_EXCEEDED", depth, maxDepth, "Path depth exceeds the reference enforcer cap");
+	return {
+		severity: "warning",
+		category: "compatibility",
+		groupIndex,
+		constraintIndex,
+		code: "PATH_DEPTH_EXCEEDED",
+		value1: depth,
+		value2: maxDepth,
+		message: "Path depth exceeds the reference enforcer cap"
+	};
 }
 /** Quantifier over a static array beyond the reference enforcer's iteration cap. */
 function quantifierOverStaticLimit(groupIndex, constraintIndex, arrayLength, maxLength) {
-	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "QUANTIFIER_OVER_STATIC_LIMIT", arrayLength, maxLength, "Quantifier over static array exceeds the reference enforcer cap");
+	return {
+		severity: "warning",
+		category: "compatibility",
+		groupIndex,
+		constraintIndex,
+		code: "QUANTIFIER_OVER_STATIC_LIMIT",
+		value1: arrayLength,
+		value2: maxLength,
+		message: "Quantifier over static array exceeds the reference enforcer cap"
+	};
 }
 /** Context property ID outside the assigned set. */
 function unknownContextProperty(groupIndex, constraintIndex, contextId, maxContextId) {
-	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "UNKNOWN_CONTEXT_PROPERTY", contextId, maxContextId, "Unknown context property ID");
+	return {
+		severity: "warning",
+		category: "compatibility",
+		groupIndex,
+		constraintIndex,
+		code: "UNKNOWN_CONTEXT_PROPERTY",
+		value1: contextId,
+		value2: maxContextId,
+		message: "Unknown context property ID"
+	};
 }
 /** Negated operator under the existential quantifier. */
 function negationUnderAny(groupIndex, constraintIndex, opCode) {
-	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "NEGATION_UNDER_ANY", opCode, ZERO, "Negated operator under any() passes when a decoy element differs");
-}
-/** 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
+		severity: "warning",
+		category: "compatibility",
+		groupIndex,
+		constraintIndex,
+		code: "NEGATION_UNDER_ANY",
+		value1: opCode,
+		value2: ZERO,
+		message: "Negated operator under any() passes when a decoy element differs"
 	};
 }
 //#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).
+* Maximum length value for dynamic types.
 */
-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;
+/** Signed-aware difference of two raw uint256 values: negative if a<b, zero if equal, positive if a>b. */
+function signedCompare(a, b, signed) {
+	if (!signed) return a - b;
+	const toS = (v) => v >= INT256_SIGN_BIT ? v - (1n << 256n) : v;
+	return toS(a) - toS(b);
 }
 /** True for uint and int type codes. */
 function isNumericType(typeCode) {
@@ -1914,22 +2127,6 @@ function getIncompat(opBase, typeInfo) {
 		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`.
@@ -1941,6 +2138,19 @@ function isOpAllowed(opCode, typeInfo) {
 function readValue(opHex) {
 	return BigInt(`0x${opHex.slice(4)}`);
 }
+/** First payload word deviating from the canonical encoding for the type, with its canonical form, or null. */
+function findNonCanonicalWord(opHex, typeCode) {
+	const body = opHex.slice(4);
+	for (let i = 0; i + 64 <= body.length; i += 64) {
+		const word = BigInt(`0x${body.slice(i, i + 64)}`);
+		const canonical = canonicalize(word, typeCode);
+		if (canonical !== word) return {
+			word,
+			canonical
+		};
+	}
+	return null;
+}
 /** Read a pair of uint256 values from a BETWEEN operator. */
 function readPair(opHex) {
 	const body = opHex.slice(4);
@@ -1979,6 +2189,23 @@ function negateBoundOp(base) {
 	if (base === Op.LTE) return Op.GT;
 	return base;
 }
+/** Fresh bound domain with no constraints recorded yet. */
+function emptyBoundDomain(boundIsSigned, min, max) {
+	return {
+		isSigned: boundIsSigned,
+		min,
+		max,
+		hasEq: false,
+		eq: 0n,
+		hasLower: false,
+		lower: 0n,
+		lowerInclusive: false,
+		hasUpper: false,
+		upper: 0n,
+		upperInclusive: false,
+		holes: []
+	};
+}
 /** Create a fresh constraint context with domain limits from the type. */
 function initContext(scope, path, typeInfo) {
 	const { min, max } = getDomainLimits(typeInfo.typeCode);
@@ -1986,38 +2213,12 @@ function initContext(scope, path, typeInfo) {
 		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: []
-		},
+		numeric: emptyBoundDomain(isSigned(typeInfo.typeCode), min, max),
 		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: []
-		},
+		length: emptyBoundDomain(false, 0n, LENGTH_MAX),
 		set: {
 			hasIn: false,
 			inValues: [],
@@ -2026,33 +2227,33 @@ function initContext(scope, path, typeInfo) {
 	};
 }
 /** 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) {
+function updateBound(domain, base, isNegated, value, isLength, 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)));
+			if (domain.hasEq && domain.eq === value) issues.push(eqNeqContradiction(isLength, 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);
+			if (!alreadyHole) domain.holes.push(value);
+		} else updateBound(domain, negateBoundOp(base), false, value, isLength, 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.GTE && value === domain.min) issues.push(vacuousGte(isLength, groupIndex, constraintIndex, bigintToHex(value)));
+	else if (base === Op.LTE && value === domain.max) issues.push(vacuousLte(isLength, groupIndex, constraintIndex, bigintToHex(value)));
+	if (signedCompare(value, domain.min, domain.isSigned) < 0n || signedCompare(value, domain.max, domain.isSigned) > 0n) issues.push(outOfPhysicalBounds(isLength, groupIndex, constraintIndex, bigintToHex(value)));
+	else if (base === Op.GT && value === domain.max) issues.push(impossibleGt(isLength, groupIndex, constraintIndex, bigintToHex(value)));
+	else if (base === Op.LT && value === domain.min) issues.push(impossibleLt(isLength, 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)));
+			if (domain.eq !== value) issues.push(conflictingEquality(isLength, 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)));
+		for (let j = 0; j < domain.holes.length; j++) if (domain.holes[j] === value) issues.push(eqNeqContradiction(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 		domain.hasEq = true;
 		domain.eq = value;
 	} else if (base === Op.GT || base === Op.GTE) {
@@ -2060,15 +2261,15 @@ function updateBound(domain, base, isNegated, value, emit, groupIndex, constrain
 		if (domain.hasLower) {
 			let redundant = false;
 			let strictlyBetter = false;
-			if (isLt(value, domain.lower, domain.isSigned)) redundant = true;
+			if (signedCompare(value, domain.lower, domain.isSigned) < 0n) 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 (redundant) issues.push(dominatedBound(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 			if (strictlyBetter) {
-				issues.push(emit.dominated(groupIndex, constraintIndex, bigintToHex(domain.lower)));
+				issues.push(dominatedBound(isLength, groupIndex, constraintIndex, bigintToHex(domain.lower)));
 				domain.lower = value;
 				domain.lowerInclusive = inclusive;
 				changedLower = true;
@@ -2084,15 +2285,15 @@ function updateBound(domain, base, isNegated, value, emit, groupIndex, constrain
 		if (domain.hasUpper) {
 			let redundant = false;
 			let strictlyBetter = false;
-			if (isGt(value, domain.upper, domain.isSigned)) redundant = true;
+			if (signedCompare(value, domain.upper, domain.isSigned) > 0n) 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 (redundant) issues.push(dominatedBound(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 			if (strictlyBetter) {
-				issues.push(emit.dominated(groupIndex, constraintIndex, bigintToHex(domain.upper)));
+				issues.push(dominatedBound(isLength, groupIndex, constraintIndex, bigintToHex(domain.upper)));
 				domain.upper = value;
 				domain.upperInclusive = inclusive;
 				changedUpper = true;
@@ -2105,16 +2306,16 @@ function updateBound(domain, base, isNegated, value, emit, groupIndex, constrain
 		}
 	}
 	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 (domain.hasEq && domain.hasLower) if (domain.lowerInclusive ? signedCompare(domain.eq, domain.lower, domain.isSigned) < 0n : signedCompare(domain.eq, domain.lower, domain.isSigned) <= 0n) issues.push(boundsExcludeEquality(isLength, groupIndex, constraintIndex, bigintToHex(domain.eq), bigintToHex(domain.lower)));
+		else issues.push(redundantBound(isLength, 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 (domain.hasEq && domain.hasUpper) if (domain.upperInclusive ? signedCompare(domain.eq, domain.upper, domain.isSigned) > 0n : signedCompare(domain.eq, domain.upper, domain.isSigned) >= 0n) issues.push(boundsExcludeEquality(isLength, groupIndex, constraintIndex, bigintToHex(domain.eq), bigintToHex(domain.upper)));
+		else issues.push(redundantBound(isLength, 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)));
+			if (signedCompare(domain.lower, domain.upper, domain.isSigned) > 0n || domain.lower === domain.upper && (!domain.lowerInclusive || !domain.upperInclusive)) issues.push(impossibleRange(isLength, groupIndex, constraintIndex, bigintToHex(domain.lower), bigintToHex(domain.upper)));
 		}
 	}
 }
@@ -2170,10 +2371,11 @@ function updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues)
 				}
 				if (inSet) issues.push(setReduction(groupIndex, constraintIndex, bigintToHex(value)));
 			}
-			if (ctx.set.notInValues.length < MAX_NOT_IN) ctx.set.notInValues.push(value);
+			ctx.set.notInValues.push(value);
 		}
 		checkSetEmpty(ctx, groupIndex, constraintIndex, issues);
 	} else {
+		for (const value of values) if (signedCompare(value, ctx.numeric.min, ctx.numeric.isSigned) < 0n || signedCompare(value, ctx.numeric.max, ctx.numeric.isSigned) > 0n) issues.push(outOfPhysicalBounds(false, groupIndex, constraintIndex, bigintToHex(value)));
 		if (ctx.numeric.hasEq) {
 			let found = false;
 			for (const candidate of values) if (candidate === ctx.numeric.eq) {
@@ -2210,6 +2412,40 @@ function checkDuplicates(issues, operators, groupIndex, constraintIndex) {
 		seen.add(key);
 	}
 }
+/**
+* Report a lone unnegated gte/lte pair (value or length domain) as fusible into the
+* corresponding single range operator. Fires only for a satisfiable pair on a compatible
+* type; contradictions and dominated bounds are already reported by the domain checks.
+*/
+function checkFusibleRange(ctx, operators, groupIndex, constraintIndex, issues) {
+	const numericPair = findLonePair(operators, Op.GTE, Op.LTE);
+	if (numericPair && getIncompat(Op.GTE, ctx.typeInfo) === null && signedCompare(numericPair.low, numericPair.high, ctx.numeric.isSigned) <= 0n) issues.push(fusibleRange(false, groupIndex, constraintIndex, bigintToHex(numericPair.low), bigintToHex(numericPair.high)));
+	const lengthPair = findLonePair(operators, Op.LENGTH_GTE, Op.LENGTH_LTE);
+	if (lengthPair && getIncompat(Op.LENGTH_GTE, ctx.typeInfo) === null && lengthPair.low <= lengthPair.high) issues.push(fusibleRange(true, groupIndex, constraintIndex, bigintToHex(lengthPair.low), bigintToHex(lengthPair.high)));
+}
+/** Return the operand pair when the operators contain exactly one of each unnegated bound opcode. */
+function findLonePair(operators, lowerOp, upperOp) {
+	let lowerCount = 0;
+	let upperCount = 0;
+	let low = 0n;
+	let high = 0n;
+	for (const opHex of operators) {
+		const opCode = parseInt(opHex.slice(2, 4), 16);
+		const dataLength = (opHex.length - 4) / 2;
+		if (dataLength > 65535 || !isValidOperatorData(opCode & ~Op.NOT, dataLength)) continue;
+		if (opCode === lowerOp) {
+			lowerCount++;
+			low = readValue(opHex);
+		} else if (opCode === upperOp) {
+			upperCount++;
+			high = readValue(opHex);
+		}
+	}
+	return lowerCount === 1 && upperCount === 1 ? {
+		low,
+		high
+	} : null;
+}
 /** Validate all operators on a single constraint against its domain context. */
 function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues) {
 	const operators = constraint.operators;
@@ -2218,21 +2454,36 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 		const opCode = parseInt(opHex.slice(2, 4), 16);
 		const base = opCode & ~Op.NOT;
 		const isNegated = (opCode & Op.NOT) !== 0;
+		const dataLength = (opHex.length - 4) / 2;
+		if (dataLength > 65535 || !isValidOperatorData(base, dataLength)) {
+			issues.push(fromOpRule("UNKNOWN_OPERATOR", "Unknown operator code", groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
+			continue;
+		}
 		if (underAny && isNegated) issues.push(negationUnderAny(groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
-		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))));
+		const incompat = getIncompat(base, ctx.typeInfo);
+		if (incompat) {
+			issues.push(fromOpRule(incompat.code, incompat.message, groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
 			continue;
 		}
 		if (isValueOp(base)) {
+			const typeCode = ctx.typeInfo.typeCode;
+			if (isLeftAligned(typeCode)) {
+				const nonCanonical = findNonCanonicalWord(opHex, typeCode);
+				if (nonCanonical !== null) {
+					issues.push(nonCanonicalOperand(groupIndex, constraintIndex, bigintToHex(nonCanonical.word), bigintToHex(nonCanonical.canonical)));
+					continue;
+				}
+			}
 			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);
+				if (!isNegated) {
+					updateBound(ctx.numeric, Op.GTE, false, low, false, groupIndex, constraintIndex, issues);
+					updateBound(ctx.numeric, Op.LTE, false, high, false, groupIndex, constraintIndex, issues);
+				} else if (signedCompare(low, high, ctx.numeric.isSigned) > 0n) issues.push(vacuousNegatedRange(false, groupIndex, constraintIndex, bigintToHex(low), bigintToHex(high)));
 			} else {
 				const value = readValue(opHex);
 				const holesBefore = ctx.numeric.holes.length;
-				updateBound(ctx.numeric, base, isNegated, value, boundIssues(false), groupIndex, constraintIndex, issues);
+				updateBound(ctx.numeric, base, isNegated, value, 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);
@@ -2243,11 +2494,13 @@ function validateConstraint(ctx, constraint, 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);
+			if (!isNegated) {
+				updateBound(ctx.length, Op.GTE, false, low, true, groupIndex, constraintIndex, issues);
+				updateBound(ctx.length, Op.LTE, false, high, true, groupIndex, constraintIndex, issues);
+			} else if (low > high) issues.push(vacuousNegatedRange(true, groupIndex, constraintIndex, bigintToHex(low), bigintToHex(high)));
 		} else {
 			const value = readValue(opHex);
-			updateBound(ctx.length, normalizeLengthOp(base), isNegated, value, boundIssues(true), groupIndex, constraintIndex, issues);
+			updateBound(ctx.length, normalizeLengthOp(base), isNegated, value, true, groupIndex, constraintIndex, issues);
 		}
 	}
 	checkDuplicates(issues, operators, groupIndex, constraintIndex);
@@ -2269,7 +2522,16 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			if (constraint.scope === Scope.CALLDATA) {
 				const steps = parsePathSteps(constraint.path);
 				if (steps.length > Limits.MAX_PATH_DEPTH) issues.push(pathDepthExceeded(groupIndex, constraintIndex, bigintToHex(BigInt(steps.length)), bigintToHex(BigInt(Limits.MAX_PATH_DEPTH))));
-				const walk = Descriptor.walkPath(descBytes, steps);
+				let walk;
+				try {
+					walk = Descriptor.walkPath(descBytes, steps);
+				} catch (error) {
+					if (error instanceof CallciumError && error.code === "INVALID_PATH") {
+						issues.push(unnavigablePath(groupIndex, constraintIndex));
+						continue;
+					}
+					throw error;
+				}
 				if (walk.quantifiedStaticLength > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) issues.push(quantifierOverStaticLimit(groupIndex, constraintIndex, bigintToHex(BigInt(walk.quantifiedStaticLength)), bigintToHex(BigInt(Limits.MAX_QUANTIFIED_ARRAY_LENGTH))));
 				typeInfo = walk.typeInfo;
 			} else {
@@ -2291,16 +2553,20 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			contexts.push(ctx);
 		}
 		validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues);
+		checkFusibleRange(ctx, constraint.operators, 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.
+* @throws {CallciumError} If the descriptor is not well-formed; semantic validation is
+* defined only over a well-formed descriptor.
 */
 function validate(data) {
 	const issues = [];
 	const descBytes = hexToBytes(data.descriptor);
+	decodeDescriptor(descBytes);
 	for (let groupIndex = 0; groupIndex < data.groups.length; groupIndex++) {
 		if (data.groups[groupIndex].length === 0) {
 			issues.push(emptyGroup(groupIndex));
@@ -2508,6 +2774,12 @@ var PolicyBuilder = class PolicyBuilder {
 };
 //#endregion
 //#region src/constraint.ts
+/** Strip an optional 0x prefix and validate a 40-hex-char (20-byte) address body. */
+function addressBody(value) {
+	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}`);
+	return body;
+}
 /** Convert a scalar value to a 32-byte big-endian word. */
 function encodeWord(value) {
 	const word = new Uint8Array(32);
@@ -2516,8 +2788,7 @@ function encodeWord(value) {
 		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}`);
+		const body = addressBody(value);
 		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}`);
@@ -2554,8 +2825,7 @@ function setOp(opCode, values) {
 		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"));
+		return BigInt("0x" + addressBody(v));
 	});
 	bigs.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 	const deduped = [];
@@ -2754,7 +3024,7 @@ function descendTuple(node, callData, head, base, childIndex) {
 	if (node.isDynamic) {
 		const ptrResult = readPointer(callData, head);
 		if (typeof ptrResult !== "number") return {
-			type: "violation",
+			ok: false,
 			code: ptrResult.code
 		};
 		tupleBase = base + ptrResult;
@@ -2765,42 +3035,48 @@ function descendTuple(node, callData, head, base, childIndex) {
 	}
 	for (let i = 0; i < childIndex; i++) cursor += headContribution(node.fields[i]);
 	return {
-		type: "ok",
-		head: cursor,
-		base: tupleBase,
-		node: node.fields[childIndex]
+		ok: true,
+		location: {
+			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",
+		ok: false,
 		code: arrayBaseResult.code
 	};
 	const arrayBase = base + arrayBaseResult;
 	const lengthResult = readPointer(callData, arrayBase);
 	if (typeof lengthResult !== "number") return {
-		type: "violation",
+		ok: false,
 		code: lengthResult.code
 	};
 	if (childIndex >= lengthResult) return {
-		type: "violation",
+		ok: false,
 		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
+		ok: true,
+		location: {
+			head: headsBase + childIndex * 32,
+			base: headsBase,
+			node: elem
+		}
 	};
 	return {
-		type: "ok",
-		head: headsBase + childIndex * elem.staticSize,
-		base: arrayBase,
-		node: elem
+		ok: true,
+		location: {
+			head: headsBase + childIndex * elem.staticSize,
+			base: arrayBase,
+			node: elem
+		}
 	};
 }
 /** Descend into a static array element by index. */
@@ -2810,22 +3086,26 @@ function descendStaticArray(node, callData, head, base, childIndex) {
 	if (elem.isDynamic) {
 		const ptrResult = readPointer(callData, head);
 		if (typeof ptrResult !== "number") return {
-			type: "violation",
+			ok: false,
 			code: ptrResult.code
 		};
 		const arrayBase = base + ptrResult;
 		return {
-			type: "ok",
-			head: arrayBase + childIndex * 32,
-			base: arrayBase,
-			node: elem
+			ok: true,
+			location: {
+				head: arrayBase + childIndex * 32,
+				base: arrayBase,
+				node: elem
+			}
 		};
 	}
 	return {
-		type: "ok",
-		head: head + childIndex * elem.staticSize,
-		base,
-		node: elem
+		ok: true,
+		location: {
+			head: head + childIndex * elem.staticSize,
+			base,
+			node: elem
+		}
 	};
 }
 /**
@@ -2865,13 +3145,13 @@ function locate(tree, callData, pathBytes, baseOffset) {
 			};
 		}
 		const result = descend(node, callData, head, base, step);
-		if (result.type === "violation") return {
+		if (!result.ok) return {
 			ok: false,
 			code: result.code
 		};
-		head = result.head;
-		base = result.base;
-		node = result.node;
+		head = result.location.head;
+		base = result.location.base;
+		node = result.location.node;
 	}
 	return {
 		ok: true,
@@ -2883,6 +3163,29 @@ function locate(tree, callData, pathBytes, baseOffset) {
 		}
 	};
 }
+/**
+* Build the element-shape fields shared by dynamic- and static-array nodes, branching only on
+* whether the element itself is dynamic.
+*/
+function makeArrayShape(length, elem, dynamicHeadsBase, staticDataOffset, staticCompositeBase) {
+	return elem.isDynamic ? {
+		length,
+		elementNode: elem,
+		elementIsDynamic: true,
+		elementStaticSize: 0,
+		headsBase: dynamicHeadsBase,
+		dataOffset: 0,
+		compositeBase: dynamicHeadsBase
+	} : {
+		length,
+		elementNode: elem,
+		elementIsDynamic: false,
+		elementStaticSize: elem.staticSize,
+		headsBase: 0,
+		dataOffset: staticDataOffset,
+		compositeBase: staticCompositeBase
+	};
+}
 /** Extract array shape from a location pointing to an array node. */
 function arrayShape(callData, location) {
 	const { head, base, node } = location;
@@ -2898,66 +3201,26 @@ function arrayShape(callData, location) {
 			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
-			}
+			shape: makeArrayShape(lengthResult, node.element, headsBase, headsBase, arrayBase)
 		};
 	}
 	if (node.type === "staticArray") {
 		const elem = node.element;
+		let dynamicHeadsBase = 0;
 		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
-				}
-			};
+			dynamicHeadsBase = base + arrayBaseResult;
 		}
 		return {
 			ok: true,
-			shape: {
-				length: node.length,
-				elementNode: elem,
-				elementIsDynamic: false,
-				elementStaticSize: elem.staticSize,
-				headsBase: 0,
-				dataOffset: head,
-				compositeBase: base
-			}
+			shape: makeArrayShape(node.length, elem, dynamicHeadsBase, head, base)
 		};
 	}
 	throw new CallciumError("INVALID_PATH", `Cannot compute array shape for non-array node (${node.type}).`);
@@ -3035,13 +3298,13 @@ function descendPath(callData, location, pathBytes) {
 	for (let stepIndex = 0; stepIndex < stepCount; stepIndex++) {
 		const step = readStep(pathBytes, stepIndex);
 		const result = descend(node, callData, head, base, step);
-		if (result.type === "violation") return {
+		if (!result.ok) return {
 			ok: false,
 			code: result.code
 		};
-		head = result.head;
-		base = result.base;
-		node = result.node;
+		head = result.location.head;
+		base = result.location.base;
+		node = result.location.node;
 	}
 	return {
 		ok: true,
@@ -3054,10 +3317,11 @@ function descendPath(callData, location, pathBytes) {
 }
 //#endregion
 //#region src/policy-enforcer.ts
-/** Violations that abort evaluation instead of failing only their group (spec §10.3). */
+/** Violations that abort evaluation instead of failing only their group (spec §9.3). */
 const ABORT_VIOLATION_CODES = new Set([
 	"CALLDATA_OUT_OF_BOUNDS",
 	"ARRAY_INDEX_OUT_OF_BOUNDS",
+	"NON_CANONICAL_VALUE",
 	"QUANTIFIER_LIMIT_EXCEEDED"
 ]);
 /** Convert a hex address to a 256-bit bigint (zero-padded to 32 bytes). */
@@ -3227,9 +3491,14 @@ function applyLeafOperator(callDataBytes, location, opCode, operandData) {
 			resolvedValue: bigintToHex(BigInt(valueLength))
 		};
 	}
+	if (node.isDynamic || node.type !== "elementary") throw new CallciumError("NOT_SCALAR", "Value operator on a target without a scalar word.");
 	const result = loadScalar(callDataBytes, location);
 	if (!result.ok) return { error: result.code };
-	const value = canonicalize(toBigInt(result.value, 0), node.typeCode);
+	const value = toBigInt(result.value, 0);
+	if (canonicalize(value, node.typeCode) !== value) return {
+		error: "NON_CANONICAL_VALUE",
+		resolvedValue: bigintToHex(value)
+	};
 	return {
 		passed: applyOperator(opCode, value, 32, operandData, node.typeCode),
 		resolvedValue: bigintToHex(value)
@@ -3239,16 +3508,29 @@ function applyLeafOperator(callDataBytes, location, opCode, operandData) {
 function evaluateLeaf(location, callDataBytes, opCode, operandData, groupIndex, ruleIndex, pathHex) {
 	const result = applyLeafOperator(callDataBytes, location, opCode, operandData);
 	const typeCode = location.node.typeCode;
-	if ("error" in result) return {
-		group: groupIndex,
-		rule: ruleIndex,
-		code: result.error,
-		scope: Scope.CALLDATA,
-		path: pathHex,
-		opCode,
-		operandData: bytesToHex(operandData),
-		typeCode
-	};
+	if ("error" in result) {
+		if (result.error === "NON_CANONICAL_VALUE") return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: result.error,
+			scope: Scope.CALLDATA,
+			path: pathHex,
+			opCode,
+			operandData: bytesToHex(operandData),
+			typeCode,
+			resolvedValue: result.resolvedValue
+		};
+		return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: result.error,
+			scope: Scope.CALLDATA,
+			path: pathHex,
+			opCode,
+			operandData: bytesToHex(operandData),
+			typeCode
+		};
+	}
 	if (!result.passed) return {
 		group: groupIndex,
 		rule: ruleIndex,
@@ -3338,6 +3620,18 @@ function evaluateQuantifier(qResult, callDataBytes, opCode, operandData, groupIn
 		} else leafLocation = elemLocation;
 		const applied = applyLeafOperator(callDataBytes, leafLocation, opCode, operandData);
 		if ("error" in applied) {
+			if (applied.error === "NON_CANONICAL_VALUE") return {
+				group: groupIndex,
+				rule: ruleIndex,
+				code: applied.error,
+				scope: Scope.CALLDATA,
+				path: pathHex,
+				opCode,
+				operandData: operandHex,
+				typeCode: leafTypeCode,
+				elementIndex: elemIndex,
+				resolvedValue: applied.resolvedValue
+			};
 			if (isUniversal) return {
 				group: groupIndex,
 				rule: ruleIndex,