@callcium/sdk 0.3.0 → 0.5.0

package/dist/index.js

@@ -116,7 +116,8 @@ const DescriptorFormat = {
 	MAX_NODE_LENGTH: 4095,
 	MAX_STATIC_ARRAY_LENGTH: 4095,
 	MAX_TUPLE_FIELDS: 4089,
-	MAX_PARAMS: 255
+	MAX_PARAMS: 255,
+	MAX_NESTING_DEPTH: 64
 };
 /** Binary layout constants for the Callcium policy format. */
 const PolicyFormat = {
@@ -171,42 +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: TypeCode.UINT_MAX
+	},
+	{
+		key: "GAS_PRICE",
+		code: 7,
+		label: "tx.gasprice",
+		typeCode: TypeCode.UINT_MAX
 	}
 ];
 /** Well-known context property IDs for context-scope rules. */
@@ -220,7 +250,9 @@ const CTX_KEY_MAP = {
 	BLOCK_TIMESTAMP: "blockTimestamp",
 	BLOCK_NUMBER: "blockNumber",
 	CHAIN_ID: "chainId",
-	TX_ORIGIN: "txOrigin"
+	TX_ORIGIN: "txOrigin",
+	BASE_FEE: "baseFee",
+	GAS_PRICE: "gasPrice"
 };
 const ctxPropByCode = new Map(CTX_PROP_TABLE.map((e) => [e.code, {
 	label: e.label,
@@ -411,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")}`);
@@ -562,11 +577,24 @@ function inspect$1(desc, offset) {
 * @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
 */
 function typeAt(desc, steps) {
+	return walkPath(desc, steps).typeInfo;
+}
+/**
+* Resolve the type at the path and the declared length of the static array a
+* quantifier step descends into (zero when the path holds no quantifier step
+* over a static array).
+* @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.
+*/
+function walkPath(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);
+	let quantifiedStaticLength = 0;
 	for (let stepIndex = 1; stepIndex < steps.length; stepIndex++) {
 		const typeCode = desc[cursor];
 		const step = steps[stepIndex];
@@ -574,10 +602,15 @@ function typeAt(desc, steps) {
 			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}.`);
+		} else if (typeCode === TypeCode.STATIC_ARRAY || typeCode === TypeCode.DYNAMIC_ARRAY) {
+			if (typeCode === TypeCode.STATIC_ARRAY && isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			cursor = arrayElementOffset(cursor);
+		} else throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type at offset ${cursor}.`);
 	}
-	return inspect$1(desc, cursor);
+	return {
+		typeInfo: inspect$1(desc, cursor),
+		quantifiedStaticLength
+	};
 }
 /**
 * Return tuple field count at a tuple node offset.
@@ -613,7 +646,8 @@ const Descriptor = {
 	tupleFieldCount,
 	staticArrayLength,
 	nodeLength,
-	arrayElementOffset
+	arrayElementOffset,
+	walkPath
 };
 //#endregion
 //#region src/type-desc.ts
@@ -939,7 +973,7 @@ function toTypes(desc) {
 	return types.join(",");
 }
 /** Recursively parse a single descriptor node starting at offset. */
-function parseNode(data, offset) {
+function parseNode(data, offset, depth) {
 	if (offset >= data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end of descriptor", offset);
 	const code = data[offset];
 	const info = classifyTypeCode(code);
@@ -957,6 +991,7 @@ function parseNode(data, offset) {
 		},
 		next: metaOffset
 	};
+	if (depth > DescriptorFormat.MAX_NESTING_DEPTH) throw new CallciumError("NESTING_TOO_DEEP", `Composite nesting exceeds maximum depth ${DescriptorFormat.MAX_NESTING_DEPTH}`, offset);
 	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);
@@ -977,7 +1012,7 @@ function parseNode(data, offset) {
 		const fields = [];
 		let cursor = offset + DescriptorFormat.TUPLE_HEADER_SIZE;
 		for (let i = 0; i < fieldCount; i++) {
-			const result = parseNode(data, cursor);
+			const result = parseNode(data, cursor, depth + 1);
 			fields.push(result.node);
 			cursor = result.next;
 		}
@@ -997,7 +1032,7 @@ function parseNode(data, offset) {
 		};
 	}
 	if (info.typeClass === "staticArray") {
-		const elemResult = parseNode(data, Descriptor.arrayElementOffset(offset));
+		const elemResult = parseNode(data, Descriptor.arrayElementOffset(offset), depth + 1);
 		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);
@@ -1025,7 +1060,7 @@ function parseNode(data, offset) {
 			typeCode: code,
 			isDynamic: true,
 			staticSize: 0,
-			element: parseNode(data, Descriptor.arrayElementOffset(offset)).node,
+			element: parseNode(data, Descriptor.arrayElementOffset(offset), depth + 1).node,
 			span: {
 				start: offset,
 				end: nodeEnd
@@ -1050,7 +1085,7 @@ function decodeDescriptor(data) {
 	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);
+		const { node, next } = parseNode(data, cursor, 1);
 		tree.push(node);
 		params.push({
 			index: params.length,
@@ -1161,10 +1196,15 @@ function decodePolicy(blob) {
 			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 (depthValue > Limits.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depthValue} exceeds maximum ${Limits.MAX_PATH_DEPTH}`, 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);
+			if (scopeValue === Scope.CONTEXT) {
+				const contextPropertyId = readU16(data, pathStart);
+				if (contextPropertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("INVALID_CONTEXT_PROPERTY", `Context rule references undefined context property 0x${contextPropertyId.toString(16).padStart(4, "0")}`, ruleOffset);
+			}
 			const opCodeOffset = pathStart + pathLength;
 			const opCodeValue = data[opCodeOffset];
 			const dataLengthOffset = opCodeOffset + PolicyFormat.RULE_OPCODE_SIZE;
@@ -1174,6 +1214,10 @@ function decodePolicy(blob) {
 			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);
+			if (opBase === Op.IN) {
+				const wordCount = dataLengthValue / 32;
+				for (let word = 1; word < wordCount; word++) if (compareBytes(data.subarray(dataStart + (word - 1) * 32, dataStart + word * 32), data.subarray(dataStart + word * 32, dataStart + (word + 1) * 32)) >= 0) throw new CallciumError("UNSORTED_IN_SET", "IN operands must be strictly ascending", ruleOffset);
+			}
 			rules.push({
 				ruleSize: field(ruleSizeValue, ruleOffset, ruleOffset + PolicyFormat.RULE_SIZE_SIZE),
 				scope: field(scopeValue, scopeOffset, scopeOffset + 1),
@@ -1264,7 +1308,7 @@ function encodeRule(rule) {
 	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 (depth > Limits.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `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);
@@ -1413,6 +1457,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
@@ -1446,6 +1497,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;
@@ -1485,7 +1545,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:
@@ -1517,32 +1582,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")}.`);
@@ -1552,173 +1599,394 @@ 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 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"
+	};
 }
-/** 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");
+/** 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() 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");
+/** 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");
+	return {
+		severity: "warning",
+		category: "redundancy",
+		groupIndex,
+		constraintIndex,
+		code: "DUPLICATE_CONSTRAINT",
+		value1: ZERO,
+		value2: ZERO,
+		message: "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)");
+/** 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)"
+	};
 }
-/** 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)");
+/** 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)"
+	};
 }
-/** 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");
+/** Path deeper than the reference enforcer's cap. */
+function pathDepthExceeded(groupIndex, constraintIndex, depth, maxDepth) {
+	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 {
+		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"
+	};
 }
-/** 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)");
+/** Context property ID outside the assigned set. */
+function unknownContextProperty(groupIndex, constraintIndex, contextId, maxContextId) {
+	return {
+		severity: "warning",
+		category: "compatibility",
+		groupIndex,
+		constraintIndex,
+		code: "UNKNOWN_CONTEXT_PROPERTY",
+		value1: contextId,
+		value2: maxContextId,
+		message: "Unknown context property ID"
+	};
 }
-/** Pre-select value or length issue factories for a bound domain. */
-function boundIssues(isLength) {
+/** Negated operator under the existential quantifier. */
+function negationUnderAny(groupIndex, constraintIndex, opCode) {
 	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
@@ -1741,25 +2009,11 @@ 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) {
@@ -1824,6 +2078,10 @@ function getIncompat(opBase, typeInfo) {
 			code: "VALUE_OP_ON_DYNAMIC",
 			message: "Value operator used on dynamic type"
 		};
+		if (classifyTypeCode(typeCode).typeClass !== "elementary") return {
+			code: "VALUE_OP_ON_COMPOSITE",
+			message: "Value operator used on composite type"
+		};
 		if (isComparisonOp(opBase) && !isNumericType(typeCode)) return {
 			code: "NUMERIC_OP_ON_NON_NUMERIC",
 			message: "Comparison operator used on non-numeric type"
@@ -1832,6 +2090,10 @@ function getIncompat(opBase, typeInfo) {
 			code: "BITMASK_ON_INVALID",
 			message: "Bitmask operator used on incompatible type"
 		};
+		if (opBase === Op.IN && typeCode === TypeCode.BOOL) return {
+			code: "IN_ON_BOOL",
+			message: "IN operator used on boolean type"
+		};
 		return null;
 	}
 	if (isLengthOp(opBase)) {
@@ -1846,22 +2108,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`.
@@ -1873,6 +2119,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);
@@ -1911,6 +2170,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);
@@ -1918,38 +2194,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: [],
@@ -1958,33 +2208,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);
+		} 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) {
@@ -1992,15 +2242,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;
@@ -2016,15 +2266,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;
@@ -2037,16 +2287,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)));
 		}
 	}
 }
@@ -2142,27 +2392,78 @@ 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;
+	const underAny = constraint.scope === Scope.CALLDATA && parsePathSteps(constraint.path).includes(Quantifier.ANY);
 	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))));
+		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 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) {
+					const { low, high } = readPair(opHex);
+					updateBound(ctx.numeric, Op.GTE, false, low, false, groupIndex, constraintIndex, issues);
+					updateBound(ctx.numeric, Op.LTE, false, high, 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);
+				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);
@@ -2172,12 +2473,14 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 				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);
+			if (!isNegated) {
+				const { low, high } = readPair(opHex);
+				updateBound(ctx.length, Op.GTE, false, low, true, groupIndex, constraintIndex, issues);
+				updateBound(ctx.length, Op.LTE, false, high, true, groupIndex, constraintIndex, issues);
+			}
 		} 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);
@@ -2198,10 +2501,20 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			let typeInfo;
 			if (constraint.scope === Scope.CALLDATA) {
 				const steps = parsePathSteps(constraint.path);
-				typeInfo = Descriptor.typeAt(descBytes, steps);
+				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);
+				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 {
 				const ctxId = parsePathSteps(constraint.path)[0];
-				typeInfo = {
+				if (ctxId > MAX_CONTEXT_PROPERTY_ID) {
+					issues.push(unknownContextProperty(groupIndex, constraintIndex, bigintToHex(BigInt(ctxId)), bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID))));
+					typeInfo = {
+						typeCode: TypeCode.UINT_MAX,
+						isDynamic: false,
+						staticSize: 32
+					};
+				} else typeInfo = {
 					typeCode: lookupContextProperty(ctxId).typeCode,
 					isDynamic: false,
 					staticSize: 32
@@ -2211,6 +2524,7 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			contexts.push(ctx);
 		}
 		validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues);
+		checkFusibleRange(ctx, constraint.operators, groupIndex, constraintIndex, issues);
 	}
 }
 /**
@@ -2379,18 +2693,31 @@ var PolicyBuilder = class PolicyBuilder {
 		return this;
 	}
 	/**
-	* Build the policy into an encoded binary blob.
+	* Build the policy into an encoded binary blob with strict validation.
+	* Throws on any issue, regardless of severity. Use {@link validate} to
+	* inspect issues, or {@link buildUnsafe} to encode without validation.
 	* @returns The policy as a 0x-prefixed hex string.
-	* @throws {CallciumError} If any group is empty or validation finds errors.
+	* @throws {CallciumError} If any group is empty or validation finds any issue.
 	*/
 	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);
+		const issues = PolicyValidator.validate(policyData);
+		if (issues.length > 0) throw new CallciumError("VALIDATION_ERROR", issues[0].message);
 		return PolicyCoder.encode(policyData);
 	}
 	/**
+	* Build the policy into an encoded binary blob without validation.
+	* The resulting policy may be invalid. Prefer {@link build}; use this
+	* only to knowingly bypass a reported issue.
+	* @returns The policy as a 0x-prefixed hex string.
+	* @throws {CallciumError} If any group is empty.
+	*/
+	buildUnsafe() {
+		this.checkGroups();
+		return PolicyCoder.encode(this.toPolicyData());
+	}
+	/**
 	* Validate the policy without encoding.
 	* @returns All validation issues found.
 	*/
@@ -2415,6 +2742,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);
@@ -2423,8 +2756,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}`);
@@ -2461,8 +2793,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 = [];
@@ -2611,6 +2942,14 @@ function chainId() {
 function txOrigin() {
 	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.TX_ORIGIN]));
 }
+/** Target the `block.basefee` context property. */
+function baseFee() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BASE_FEE]));
+}
+/** Target the `tx.gasprice` context property. */
+function gasPrice() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.GAS_PRICE]));
+}
 //#endregion
 //#region src/reader.ts
 /** Read 32 bytes at offset, bounds-checked. */
@@ -2653,7 +2992,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;
@@ -2664,42 +3003,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. */
@@ -2709,22 +3054,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
+		}
 	};
 }
 /**
@@ -2764,13 +3113,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,
@@ -2782,6 +3131,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;
@@ -2797,66 +3169,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}).`);
@@ -2914,9 +3246,16 @@ function loadSlice(callData, location) {
 		ok: false,
 		code: lengthResult.code
 	};
+	const dataOffset = dataStart + 32;
+	const node = location.node;
+	const stride = node.type === "dynamicArray" ? node.element.isDynamic ? 32 : node.element.staticSize : 1;
+	if (dataOffset > callData.length || lengthResult > Math.floor((callData.length - dataOffset) / stride)) return {
+		ok: false,
+		code: "CALLDATA_OUT_OF_BOUNDS"
+	};
 	return {
 		ok: true,
-		dataOffset: dataStart + 32,
+		dataOffset,
 		length: lengthResult
 	};
 }
@@ -2927,13 +3266,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,
@@ -2946,6 +3285,12 @@ function descendPath(callData, location, pathBytes) {
 }
 //#endregion
 //#region src/policy-enforcer.ts
+/** Violations that abort evaluation instead of failing only their group (spec §10.3). */
+const ABORT_VIOLATION_CODES = new Set([
+	"CALLDATA_OUT_OF_BOUNDS",
+	"ARRAY_INDEX_OUT_OF_BOUNDS",
+	"QUANTIFIER_LIMIT_EXCEEDED"
+]);
 /** Convert a hex address to a 256-bit bigint (zero-padded to 32 bytes). */
 function addressToBigInt(hex) {
 	const bytes = hexToBytes(hex);
@@ -2980,7 +3325,7 @@ function resolveLeafTypeCode(elementNode, remainingPath) {
 * @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.
+* @returns Pass with matched group index, or fail with one violation per evaluated failing group.
 * @throws {CallciumError} If the policy blob is structurally malformed.
 */
 function check(policy, callData, context) {
@@ -3012,6 +3357,10 @@ function check(policy, callData, context) {
 			const violation = evaluateRule(rule, tree, callDataBytes, baseOffset, groupIndex, ruleIndex, context);
 			if (violation !== null) {
 				allViolations.push(violation);
+				if (ABORT_VIOLATION_CODES.has(violation.code)) return {
+					ok: false,
+					violations: allViolations
+				};
 				groupFailed = true;
 				break;
 			}
@@ -3044,7 +3393,6 @@ function evaluateRule(rule, tree, callDataBytes, baseOffset, groupIndex, ruleInd
 	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 {
@@ -3110,6 +3458,7 @@ 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);
@@ -3266,6 +3615,6 @@ const PolicyEnforcer = {
 	enforce
 };
 //#endregion
-export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Limits, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, arg, blockNumber, blockTimestamp, bytesToHex, chainId, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Limits, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
 
 //# sourceMappingURL=index.js.map