@callcium/sdk 0.11.1 → 0.13.0

package/dist/index.d.ts

@@ -1,3 +1,295 @@
+//#region src/constants.d.ts
+/**
+ * Extract a `{ KEY: code }` map from a table with `key` and `code` fields.
+ * @internal
+ */
+type CodeMap<T extends readonly {
+  readonly key: string;
+  readonly code: number;
+}[]> = { readonly [E in T[number] as E["key"]]: E["code"]; };
+/** ABI type code ranges and sentinel values for the descriptor format. */
+export declare const TypeCode: {
+  readonly UINT_MIN: 1;
+  readonly UINT_MAX: 32;
+  readonly INT_MIN: 33;
+  readonly INT_MAX: 64;
+  readonly ADDRESS: 65;
+  readonly BOOL: 66;
+  readonly FUNCTION: 67;
+  readonly FIXED_BYTES_MIN: 80;
+  readonly FIXED_BYTES_MAX: 111;
+  readonly BYTES: 112;
+  readonly STRING: 113;
+  readonly STATIC_ARRAY: 128;
+  readonly DYNAMIC_ARRAY: 129;
+  readonly TUPLE: 144;
+};
+/** Well-known context property IDs for context-scope rules. */
+export declare const ContextProperty: CodeMap<readonly [{
+  readonly key: "MSG_SENDER";
+  readonly code: 0;
+  readonly label: "msg.sender";
+  readonly contextKey: "msgSender";
+  readonly typeCode: 65;
+}, {
+  readonly key: "MSG_VALUE";
+  readonly code: 1;
+  readonly label: "msg.value";
+  readonly contextKey: "msgValue";
+  readonly typeCode: 32;
+}, {
+  readonly key: "BLOCK_TIMESTAMP";
+  readonly code: 2;
+  readonly label: "block.timestamp";
+  readonly contextKey: "blockTimestamp";
+  readonly typeCode: 32;
+}, {
+  readonly key: "BLOCK_NUMBER";
+  readonly code: 3;
+  readonly label: "block.number";
+  readonly contextKey: "blockNumber";
+  readonly typeCode: 32;
+}, {
+  readonly key: "CHAIN_ID";
+  readonly code: 4;
+  readonly label: "block.chainid";
+  readonly contextKey: "chainId";
+  readonly typeCode: 32;
+}, {
+  readonly key: "TX_ORIGIN";
+  readonly code: 5;
+  readonly label: "tx.origin";
+  readonly contextKey: "txOrigin";
+  readonly typeCode: 65;
+}, {
+  readonly key: "BASE_FEE";
+  readonly code: 6;
+  readonly label: "block.basefee";
+  readonly contextKey: "baseFee";
+  readonly typeCode: 32;
+}, {
+  readonly key: "GAS_PRICE";
+  readonly code: 7;
+  readonly label: "tx.gasprice";
+  readonly contextKey: "gasPrice";
+  readonly typeCode: 32;
+}]>;
+/** Display metadata for a context property code. */
+type ContextPropertyInfo = {
+  label: string;
+  contextKey: keyof Context;
+  typeCode: number;
+};
+/**
+ * Map a context property code to its display label and ABI type code.
+ * @param code - Context property ID.
+ * @returns Display metadata including the ABI type code for the property value.
+ * @throws {CallciumError} If the code is not a recognised context property.
+ */
+export declare function lookupContextProperty(code: number): ContextPropertyInfo;
+declare const SCOPE_TABLE: readonly [{
+  readonly key: "CONTEXT";
+  readonly code: 0;
+  readonly label: "context";
+}, {
+  readonly key: "CALLDATA";
+  readonly code: 1;
+  readonly label: "calldata";
+}, {
+  readonly key: "LOOP";
+  readonly code: 2;
+  readonly label: "loop";
+}];
+/** Rule scope discriminant: context (EVM environment), calldata (ABI payload) or loop (array elements). */
+export declare const Scope: CodeMap<readonly [{
+  readonly key: "CONTEXT";
+  readonly code: 0;
+  readonly label: "context";
+}, {
+  readonly key: "CALLDATA";
+  readonly code: 1;
+  readonly label: "calldata";
+}, {
+  readonly key: "LOOP";
+  readonly code: 2;
+  readonly label: "loop";
+}]>;
+/** A defined scope code. */
+type ScopeCode = (typeof SCOPE_TABLE)[number]["code"];
+/** Display metadata for a scope code. */
+type ScopeInfo = {
+  label: string;
+};
+/**
+ * Map a scope code to its display label.
+ * @param code - Scope byte value.
+ * @returns Display metadata for the scope.
+ * @throws {CallciumError} If the code is not a recognised scope.
+ */
+export declare function lookupScope(code: number): ScopeInfo;
+declare const QUANTIFIER_TABLE: readonly [{
+  readonly key: "ALL";
+  readonly code: 1;
+  readonly label: "all";
+}, {
+  readonly key: "ANY";
+  readonly code: 2;
+  readonly label: "any";
+}];
+/** Loop quantifier: the body holds for every element (`ALL`) or for some element (`ANY`). */
+export declare const LoopQuantifier: CodeMap<readonly [{
+  readonly key: "ALL";
+  readonly code: 1;
+  readonly label: "all";
+}, {
+  readonly key: "ANY";
+  readonly code: 2;
+  readonly label: "any";
+}]>;
+/** A defined loop quantifier code. */
+type QuantifierCode = (typeof QUANTIFIER_TABLE)[number]["code"];
+/** Display metadata for a loop quantifier code. */
+type QuantifierInfo = {
+  label: string;
+};
+/**
+ * Map a loop quantifier code to its display label.
+ * @param code - Quantifier byte value.
+ * @returns Display metadata for the quantifier.
+ * @throws {CallciumError} If the code is not a recognised quantifier.
+ */
+export declare function lookupQuantifier(code: number): QuantifierInfo;
+/** Operand count category of an operator. */
+type Operands = "single" | "range" | "variadic";
+/** @internal */
+declare const OP_TABLE: readonly [{
+  readonly key: "EQ";
+  readonly code: 1;
+  readonly label: "==";
+  readonly operands: "single";
+}, {
+  readonly key: "GT";
+  readonly code: 2;
+  readonly label: ">";
+  readonly operands: "single";
+}, {
+  readonly key: "LT";
+  readonly code: 3;
+  readonly label: "<";
+  readonly operands: "single";
+}, {
+  readonly key: "GTE";
+  readonly code: 4;
+  readonly label: ">=";
+  readonly operands: "single";
+}, {
+  readonly key: "LTE";
+  readonly code: 5;
+  readonly label: "<=";
+  readonly operands: "single";
+}, {
+  readonly key: "BETWEEN";
+  readonly code: 6;
+  readonly label: "between";
+  readonly operands: "range";
+}, {
+  readonly key: "IN";
+  readonly code: 7;
+  readonly label: "in";
+  readonly operands: "variadic";
+}, {
+  readonly key: "BITMASK_ALL";
+  readonly code: 16;
+  readonly label: "bitmask all";
+  readonly operands: "single";
+}, {
+  readonly key: "BITMASK_ANY";
+  readonly code: 17;
+  readonly label: "bitmask any";
+  readonly operands: "single";
+}, {
+  readonly key: "BITMASK_NONE";
+  readonly code: 18;
+  readonly label: "bitmask none";
+  readonly operands: "single";
+}, {
+  readonly key: "LENGTH_EQ";
+  readonly code: 24;
+  readonly label: "length ==";
+  readonly operands: "single";
+}, {
+  readonly key: "LENGTH_GT";
+  readonly code: 25;
+  readonly label: "length >";
+  readonly operands: "single";
+}, {
+  readonly key: "LENGTH_LT";
+  readonly code: 26;
+  readonly label: "length <";
+  readonly operands: "single";
+}, {
+  readonly key: "LENGTH_GTE";
+  readonly code: 27;
+  readonly label: "length >=";
+  readonly operands: "single";
+}, {
+  readonly key: "LENGTH_LTE";
+  readonly code: 28;
+  readonly label: "length <=";
+  readonly operands: "single";
+}, {
+  readonly key: "LENGTH_BETWEEN";
+  readonly code: 29;
+  readonly label: "length between";
+  readonly operands: "range";
+}];
+/** Callcium policy operator codes, with the NOT flag and the operand source fields. */
+export declare const Op: {
+  readonly NOT: 128;
+  readonly SOURCE_SHIFT: 5;
+  readonly COMPARISON_MASK: 31;
+  readonly BETWEEN: 6;
+  readonly BITMASK_ALL: 16;
+  readonly BITMASK_ANY: 17;
+  readonly BITMASK_NONE: 18;
+  readonly EQ: 1;
+  readonly GT: 2;
+  readonly GTE: 4;
+  readonly IN: 7;
+  readonly LENGTH_BETWEEN: 29;
+  readonly LENGTH_EQ: 24;
+  readonly LENGTH_GT: 25;
+  readonly LENGTH_GTE: 27;
+  readonly LENGTH_LT: 26;
+  readonly LENGTH_LTE: 28;
+  readonly LT: 3;
+  readonly LTE: 5;
+};
+/** A defined comparison code. */
+type ComparisonCode = (typeof OP_TABLE)[number]["code"];
+/** Operand source: constant values, or a context property. */
+export declare const Source: CodeMap<readonly [{
+  readonly key: "CONSTANT";
+  readonly code: 0;
+  readonly labelSuffix: "";
+}, {
+  readonly key: "CONTEXT";
+  readonly code: 1;
+  readonly labelSuffix: " ctx";
+}]>;
+/** Display metadata for an operator code. */
+type OpInfo = {
+  label: string;
+  operands: Operands;
+};
+/**
+ * Map an operator code to its display label. Strips the NOT flag automatically. A context source adds ` ctx`.
+ * @param code - Operator byte value (can include the NOT flag).
+ * @returns Display metadata for the base operator.
+ * @throws {CallciumError} If the base code is not a recognised operator.
+ */
+export declare function lookupOp(code: number): OpInfo;
+//#endregion
 //#region src/types.d.ts
 /** Hex-encoded byte string, 0x-prefixed. */
 type Hex = `0x${string}`;
@@ -8,10 +300,14 @@ type Span = {
   start: number;
   end: number;
 };
+/** A decoded value with its byte position in the source blob. */
+type Field<T> = {
+  value: T;
+  span: Span;
+};
 /**
- * Execution context for context-scoped rules.
- * Each property maps to a well-known EVM execution environment value.
- * Only the properties referenced by the policy need to be supplied.
+ * Execution context for context-scoped rules. Each property maps to a well-known EVM execution environment value. Only
+ * the properties referenced by the policy need to be supplied.
  */
 type Context = {
   msgSender?: Address;
@@ -39,51 +335,60 @@ type MissingSelectorViolation = {
 };
 /** Calldata selector does not match the policy's expected selector. */
 type SelectorMismatchViolation = {
-  code: "SELECTOR_MISMATCH"; /** Selector declared by the policy. */
-  expectedValue: Hex; /** Selector observed in the calldata. */
+  code: "SELECTOR_MISMATCH";
+  /** Selector declared by the policy. */
+  expectedValue: Hex;
+  /** Selector observed in the calldata. */
   resolvedValue: Hex;
 };
 /**
- * A rule referenced a context property not supplied in the execution context — a context-scoped
- * subject, or an `EQ_CTX` operand on either scope.
+ * A test read a context property not supplied in the execution context — a context test's subject, or a context
+ * operand on either kind of test.
+ *
+ * `group` and `rule` locate the root rule. A test in a loop body adds `bodyRule` and `elementIndex`.
  */
 type MissingContextViolation = {
   code: "MISSING_CONTEXT";
   group: number;
   rule: number;
-  scope: number;
-  path: Hex; /** Declared type of the missing context property. */
-  typeCode: number; /** Operator code with the `Op.NOT` bit intact; absent for a context-scoped subject. */
-  opCode?: number; /** Operator payload; absent for a context-scoped subject. */
-  operandData?: Hex;
+  scope: ScopeCode;
+  /** The test's path: a context test's property ID, or a calldata test's steps (in a loop body, from the element). */
+  path: Hex;
+  /** Declared type of the missing context property. */
+  typeCode: number;
+  /** The test's operator, absent for a context test's subject. */
+  operator?: DecodedOperator;
+  /** Position of the test in the loop body, absent for a root test. */
+  bodyRule?: number;
+  /** Position of the element the body test read, absent for a root test. */
+  elementIndex?: number;
 };
 /**
- * A rule's operator returned false against the loaded value.
- *
- * Field combinations:
- * - `resolvedValue` present, `elementIndex` absent — scalar leaf or context value that failed the operator.
- * - `resolvedValue` present, `elementIndex` present — universal-quantifier per-element failure.
- * - `resolvedValue` absent, `elementIndex` absent — existential-aggregate failure (no element satisfied).
- * - `resolvedValue` absent, `elementIndex` present — per-element failure where the leaf could not be loaded.
+ * A test's operator returned false against the loaded value.
  *
- * For length operations (`isLengthOp(opCode)`), `resolvedValue` is a hex-encoded count
- * rather than a 32-byte ABI word.
+ * `resolvedValue` is the value the operator compared: a word, or for length operators the length as a 32-byte word.
+ * `group` and `rule` locate the root rule. A test in a loop body adds `bodyRule` and `elementIndex`.
  */
 type ValueMismatchViolation = {
   code: "VALUE_MISMATCH";
   group: number;
   rule: number;
-  scope: number;
-  path: Hex; /** Operator code with the `Op.NOT` bit intact. */
-  opCode: number; /** Full untruncated operand bytes declared by the rule. */
-  operandData: Hex; /** Type code of the failing value's leaf. */
+  scope: ScopeCode;
+  /** The test's path: a context test's property ID, or a calldata test's steps (in a loop body, from the element). */
+  path: Hex;
+  /** The test's operator. */
+  operator: DecodedOperator;
+  /** Type code of the failing value. */
   typeCode: number;
-  resolvedValue?: Hex;
+  resolvedValue: Hex;
   /**
-   * Resolved runtime value of a reference operand as a 32-byte word; present when the
-   * operator's operand names a reference resolved at enforcement, not a literal.
+   * Resolved runtime value of a context operand as a 32-byte word, present when the operator's operand names a context
+   * property, not a constant.
    */
   resolvedOperand?: Hex;
+  /** Position of the test in the loop body, absent for a root test. */
+  bodyRule?: number;
+  /** Position of the element the body test read, absent for a root test. */
   elementIndex?: number;
 };
 /**
@@ -94,29 +399,33 @@ type CalldataNavigationVariant<C extends NavigationViolationCode> = {
   code: C;
   group: number;
   rule: number;
-  scope: number;
+  scope: ScopeCode;
   path: Hex;
-  opCode?: number;
-  operandData?: Hex;
+  operator?: DecodedOperator;
   typeCode?: number;
+  bodyRule?: number;
   elementIndex?: number;
 };
 /**
- * Calldata structure prevented the rule from being evaluated.
+ * Calldata structure prevented a rule from being evaluated.
  *
- * The operator was never applied; `opCode`, `operandData`, `typeCode`, and `elementIndex`
- * are diagnostic context describing the failing site, not a constraint claim.
+ * The operator was never applied. `operator`, `typeCode`, `bodyRule` and `elementIndex` are diagnostic context
+ * describing the failing site, not a constraint claim. A failure resolving a loop's array carries the loop
+ * rule's scope and array path and no operator. A failure resolving an element adds `elementIndex`. A failure in a body
+ * test adds the test's fields and `bodyRule`.
  *
  * A union of per-code variants, narrowable with `Extract<Violation, { code: "..." }>`.
  */
 type CalldataNavigationViolation = CalldataNavigationVariant<"CALLDATA_OUT_OF_BOUNDS"> | CalldataNavigationVariant<"ARRAY_INDEX_OUT_OF_BOUNDS">;
-/** A quantified array exceeded `PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH`. */
+/** A loop's array exceeded `MAX_QUANTIFIED_ARRAY_LENGTH`. */
 type QuantifierLimitExceededViolation = {
   code: "QUANTIFIER_LIMIT_EXCEEDED";
   group: number;
   rule: number;
-  scope: number;
-  path: Hex; /** Hex-encoded element count of the offending array. */
+  scope: ScopeCode;
+  /** The loop's array path. */
+  path: Hex;
+  /** Hex-encoded element count of the offending array. */
   resolvedValue: Hex;
 };
 /**
@@ -128,117 +437,238 @@ type NonCanonicalValueViolation = {
   code: "NON_CANONICAL_VALUE";
   group: number;
   rule: number;
-  scope: number;
-  path: Hex; /** Type code of the target whose encoding was violated. */
-  typeCode: number; /** Raw 32-byte word as it appeared in calldata, before any masking. */
+  scope: ScopeCode;
+  path: Hex;
+  /** Type code of the target whose encoding was violated. */
+  typeCode: number;
+  /** Raw 32-byte word as it appeared in calldata, before any masking. */
   resolvedValue: Hex;
-  opCode?: number;
-  operandData?: Hex;
+  /** The test's operator. */
+  operator: DecodedOperator;
+  /** Position of the test in the loop body, absent for a root test. */
+  bodyRule?: number;
+  /** Position of the element the body test read, absent for a root test. */
   elementIndex?: number;
 };
-/** An `ANY` quantifier was applied to an empty array. */
-type QuantifierEmptyArrayViolation = {
-  code: "QUANTIFIER_EMPTY_ARRAY";
+/** No element satisfied an `ANY` loop's body, the empty array included. No element and no test is to blame. */
+type QuantifierNoMatchViolation = {
+  code: "QUANTIFIER_NO_MATCH";
   group: number;
   rule: number;
-  scope: number;
+  scope: ScopeCode;
+  /** The loop's array path. */
   path: Hex;
 };
 /**
  * Structured details of a single rule failure during enforcement.
  *
- * Carries semantic data only; no message strings.
- * Discriminate on `code` to narrow to the matching variant.
+ * Carries semantic data only, with no message strings. Discriminate on `code` to narrow to the matching variant.
  */
-type Violation = MissingSelectorViolation | SelectorMismatchViolation | MissingContextViolation | ValueMismatchViolation | CalldataNavigationViolation | NonCanonicalValueViolation | QuantifierLimitExceededViolation | QuantifierEmptyArrayViolation;
+type Violation = MissingSelectorViolation | SelectorMismatchViolation | MissingContextViolation | ValueMismatchViolation | CalldataNavigationViolation | NonCanonicalValueViolation | QuantifierLimitExceededViolation | QuantifierNoMatchViolation;
 /** Machine-readable reason code for an enforcement violation. Derived from `Violation` to prevent drift. */
 type ViolationCode = Violation["code"];
-/** Canonical structured representation of a policy. */
+/** A test or a context test of a loop body, or of a group. */
+type BodyRule = {
+  scope: typeof Scope.CONTEXT | typeof Scope.CALLDATA;
+  /** BE16-encoded path from the starting point. A context test's path is its property ID. */
+  path: Hex;
+  /** The hint a blob carries for the path, absent for a context test and in data not read from a blob. */
+  hint?: Hex;
+  /** Encoded operator: opCode(1) || each operand value as a 32-byte word, a context property as its ID. */
+  operator: Hex;
+};
+/** A loop: its body over each element of the array at `path`. */
+type LoopRule = {
+  scope: typeof Scope.LOOP;
+  quantifier: QuantifierCode;
+  /** BE16-encoded path from the arguments to the array. */
+  path: Hex;
+  /** The frame hint a blob carries for the path, absent in data not read from a blob. */
+  hint?: Hex;
+  body: BodyRule[];
+};
+/** A rule of a group: a test, a context test or a loop. */
+type Rule = BodyRule | LoopRule;
+/** A policy: its selector, its descriptor and its groups of rules. */
 type PolicyData = {
   isSelectorless: boolean;
   selector: Hex;
   descriptor: Hex;
-  groups: Constraint[][];
-  span?: Span;
+  groups: Rule[][];
 };
+/**
+ * An operator as a policy stores it: its comparison, its polarity and its operands. Constants are loaded to 32-byte
+ * words of `operandType`. A context operand names its property.
+ */
+type DecodedOperator = {
+  /** Operator code with the `Op.NOT` bit intact. */
+  opCode: number;
+  /** Comparison bits of `opCode`. */
+  comparison: ComparisonCode;
+  /** True when `opCode` carries the `Op.NOT` bit. */
+  negated: boolean;
+  /**
+   * Type code of the operands: the target's type, the type a length compares as for a length comparison,
+   * or the context property's type.
+   */
+  operandType: number;
+} & ({
+  source: typeof Source.CONSTANT;
+  /** Each constant loaded to its 32-byte word. */
+  values: Hex[];
+} | {
+  source: typeof Source.CONTEXT;
+  /** The context property the operand names. */
+  contextPropertyId: number;
+});
 /** A collection of operators targeting a specific value. */
 type Constraint = {
-  scope: number;
+  scope: typeof Scope.CONTEXT | typeof Scope.CALLDATA;
   path: Hex;
-  operators: Hex[]; /** Compiled hint block as carried on the wire; absent when the constraint has no encoding. */
-  hint?: Hex;
-  span?: Span;
+  operators: Hex[];
 };
-/** A decoded value with its byte position in the source blob. */
-type Field<T> = {
-  value: T;
-  span: Span;
-};
-/** Structural representation of a decoded parameter within the descriptor. */
-type DecodedParam = {
-  index: number;
+/** A descriptor node: its type, its head size and the bytes it spans, with its fields or its element. */
+type DecodedNode = {
   typeCode: number;
   isDynamic: boolean;
+  /** Head size in bytes, zero for a dynamic type. */
   staticSize: number;
-  path: Hex;
+  span: Span;
+} & ({
+  typeClass: "elementary";
+} | {
+  typeClass: "tuple";
+  fields: DecodedNode[];
+} | {
+  typeClass: "staticArray";
+  length: number;
+  element: DecodedNode;
+} | {
+  typeClass: "dynamicArray";
+  element: DecodedNode;
+});
+/** A descriptor: its header fields and one node per parameter. */
+type DecodedDescriptor = {
+  version: Field<number>;
+  paramCount: Field<number>;
+  params: DecodedNode[];
+  span: Span;
+};
+/** An array's meta word. */
+type ArrayMeta = {
+  /** The element type is dynamic. An offset word points to each element. */
+  isElementDynamic: boolean;
+  /** The array is dynamic. A length word is before the elements. */
+  isDynamicArray: boolean;
+  /** Element head size in words. */
+  strideWords: number;
+};
+/** A hop of a compiled hint: a plain hop enters the node behind an offset word, an element hop selects an element. */
+type DecodedHop = {
+  kind: "plain" | "element";
+  delta: Field<number>;
+  index: Field<number>;
+  meta: Field<ArrayMeta>;
+  span: Span;
+};
+/** A test hint: its hops, then the target's position, meta word and type code. */
+type DecodedHint = {
+  hopCount: Field<number>;
+  hops: DecodedHop[];
+  targetDelta: Field<number>;
+  /** The target's meta word. Every field is false or zero unless the target is a dynamic array. */
+  targetMeta: Field<ArrayMeta>;
+  typeCode: Field<number>;
+  span: Span;
+};
+/** A frame hint: its hops, then the array's position, declared length and meta word. */
+type DecodedFrameHint = {
+  hopCount: Field<number>;
+  hops: DecodedHop[];
+  arrayDelta: Field<number>;
+  /** Declared length of a static array, or zero for a dynamic array. */
+  count: Field<number>;
+  meta: Field<ArrayMeta>;
   span: Span;
 };
-/** Structural representation of a decoded rule with per-field spans. */
-type DecodedRule = {
+/** A test or a context test, each field with the bytes that contain it. */
+type DecodedTest = {
   ruleSize: Field<number>;
-  scope: Field<number>;
+  scope: Field<typeof Scope.CONTEXT | typeof Scope.CALLDATA>;
   pathDepth: Field<number>;
-  path: Field<Hex>; /** Compiled hint block; present for calldata rules only. */
-  hint?: Field<Hex>;
+  /** The path steps, or a context test's property ID. */
+  path: Field<Hex>;
+  /** The test hint, absent for a context test. */
+  hint?: DecodedHint;
+  /** Type code of the target: the hint's, or the context property's. */
+  targetType: number;
   opCode: Field<number>;
   dataLength: Field<number>;
+  /** The operands as stored. */
   data: Field<Hex>;
+  operator: DecodedOperator;
+  span: Span;
+};
+/** A loop rule, each field with the bytes that contain it. */
+type DecodedLoop = {
+  ruleSize: Field<number>;
+  scope: Field<typeof Scope.LOOP>;
+  quantifier: Field<QuantifierCode>;
+  pathDepth: Field<number>;
+  /** The array's path. */
+  path: Field<Hex>;
+  hint: DecodedFrameHint;
+  ruleCount: Field<number>;
+  body: DecodedTest[];
   span: Span;
 };
-/** Structural representation of a decoded group with metadata spans. */
+/** A rule of a group: a test, a context test or a loop. */
+type DecodedRule = DecodedTest | DecodedLoop;
+/** A group, each field with the bytes that contain it. */
 type DecodedGroup = {
   ruleCount: Field<number>;
   groupSize: Field<number>;
   rules: DecodedRule[];
   span: Span;
 };
-/** Structural representation of a decoded policy with full byte-level spans. */
+/** A policy blob, each field with the bytes that contain it. */
 type DecodedPolicy = {
-  header: Field<number>;
+  header: Field<{
+    major: number;
+    minor: number;
+    isSelectorless: boolean;
+  }>;
+  /** The selector slot, zero for a selectorless policy. */
   selector: Field<Hex>;
   descLength: Field<number>;
-  descriptor: {
-    raw: Hex;
-    header: Field<{
-      version: number;
-      paramCount: number;
-    }>;
-    params: DecodedParam[];
-    span: Span;
-  };
+  descriptor: DecodedDescriptor;
   groupCount: Field<number>;
   groups: DecodedGroup[];
   span: Span;
-  version: number;
-  isSelectorless: boolean;
 };
 /** Severity of a validation issue. */
 type IssueSeverity = "info" | "warning" | "error";
-/** Category of a validation issue. */
+/** Kind of defect a validation issue reports. */
 type IssueCategory = "typeMismatch" | "contradiction" | "redundancy" | "vacuity" | "compatibility";
+/** Machine-readable code of a validation issue. */
+type IssueCode = "INVALID_DESCRIPTOR" | "UNNAVIGABLE_PATH" | "QUANTIFIER_ON_NON_ARRAY" | "HINT_MISMATCH" | "NUMERIC_OP_ON_NON_NUMERIC" | "BITMASK_ON_INVALID" | "IN_ON_BOOL" | "CONTEXT_TYPE_MISMATCH" | "OUT_OF_PHYSICAL_BOUNDS" | "CONTRADICTORY_RULE" | "REDUNDANT_RULE" | "DOMINATED_BOUND" | "DOMINATED_LENGTH_BOUND" | "VACUOUS_RULE" | "QUANTIFIER_OVER_STATIC_LIMIT" | "CONTEXT_ONLY_BODY";
 /**
- * Machine-readable code for a policy validation issue.
- *
- * Each code names one finding of the semantic validator and matches the constant of the same
- * name in the Solidity `IssueCode` library.
+ * The rule an issue names: its group, its position in the group and, for a test in a loop body, its position in the
+ * body. The location also carries the rule's scope, path and operator as decoded.
+ * A path in a body starts at the element.
  */
-type IssueCode = "VALUE_OP_ON_DYNAMIC" | "VALUE_OP_ON_COMPOSITE" | "NUMERIC_OP_ON_NON_NUMERIC" | "BITMASK_ON_INVALID" | "IN_ON_BOOL" | "LENGTH_ON_STATIC" | "CONTEXT_TYPE_MISMATCH" | "UNKNOWN_OPERATOR" | "NON_CANONICAL_OPERAND" | "UNNAVIGABLE_PATH" | "NESTED_QUANTIFIER" | "HINT_MISMATCH" | "EQ_NEQ_CONTRADICTION" | "CONFLICTING_EQUALITY" | "OUT_OF_PHYSICAL_BOUNDS" | "IMPOSSIBLE_GT" | "IMPOSSIBLE_LT" | "BOUNDS_EXCLUDE_EQUALITY" | "IMPOSSIBLE_RANGE" | "SET_EXCLUDES_EQUALITY" | "EMPTY_SET_INTERSECTION" | "SET_FULLY_EXCLUDED" | "LENGTH_EQ_NEQ_CONTRADICTION" | "CONFLICTING_LENGTH" | "BOUNDS_EXCLUDE_LENGTH" | "IMPOSSIBLE_LENGTH_RANGE" | "OUT_OF_PHYSICAL_LENGTH_BOUNDS" | "IMPOSSIBLE_LENGTH_GT" | "IMPOSSIBLE_LENGTH_LT" | "BITMASK_CONTRADICTION" | "BITMASK_ANY_IMPOSSIBLE" | "UNSORTED_IN_SET" | "EMPTY_GROUP" | "DOMINATED_BOUND" | "REDUNDANT_BOUND" | "SET_REDUCTION" | "SET_REDUNDANCY" | "SET_PARTIALLY_EXCLUDED" | "DOMINATED_LENGTH_BOUND" | "REDUNDANT_LENGTH_BOUND" | "REDUNDANT_BITMASK" | "DUPLICATE_CONSTRAINT" | "FUSIBLE_RANGE" | "FUSIBLE_LENGTH_RANGE" | "VACUOUS_GTE" | "VACUOUS_LTE" | "VACUOUS_LENGTH_GTE" | "VACUOUS_LENGTH_LTE" | "VACUOUS_NEGATED_RANGE" | "VACUOUS_NEGATED_LENGTH_RANGE" | "PATH_DEPTH_EXCEEDED" | "QUANTIFIER_OVER_STATIC_LIMIT" | "UNKNOWN_CONTEXT_PROPERTY" | "NEGATION_UNDER_ANY";
-/** A single validation issue found during policy analysis. */
-type Issue = {
+type RuleLocation = {
+  groupIndex: number;
+  ruleIndex: number;
+  bodyRuleIndex?: number;
+  scope: ScopeCode;
+  path: Hex;
+  operator?: Hex;
+};
+/** A validation issue: the rule it names, absent for one about the descriptor, and the values that show the defect. */
+type Issue = Partial<RuleLocation> & {
   severity: IssueSeverity;
   category: IssueCategory;
-  groupIndex: number;
-  constraintIndex: number;
   code: IssueCode;
   value1: Hex;
   value2: Hex;
@@ -246,233 +676,140 @@ type Issue = {
 };
 //#endregion
 //#region src/policy-builder.d.ts
-/** Fluent builder for constructing Callcium policies. */
-declare class PolicyBuilder {
+/** Fluent API for drafting policies from constraints. */
+export declare class PolicyBuilder {
   private draft;
   private constructor();
   /**
    * Create a builder from a function signature.
-   * @param signature - ABI function signature, e.g. `"transfer(address,uint256)"`.
+   * @param signature - The function signature (for example "transfer(address,uint256)").
+   * @returns A new builder.
+   * @throws {CallciumError} If the signature is malformed.
    */
   static create(signature: string): PolicyBuilder;
   /**
-   * Create a selectorless builder from a raw type string.
-   * @param typesCsv - Comma-separated ABI type strings, e.g. `"address,uint256"`.
+   * Create a selectorless builder from a comma-separated type list.
+   * @param typesCsv - The comma-separated ABI types (for example "uint256,address").
+   * @returns A new builder.
+   * @throws {CallciumError} If a type is malformed.
    */
   static createRaw(typesCsv: string): PolicyBuilder;
   /**
-   * Add a constraint to the current group.
-   * @param constraint - A `Constraint` object or a `ConstraintBuilder` instance.
-   * @throws {CallciumError} With code `OUT_OF_PHYSICAL_BOUNDS` when a numeric operand lies outside
-   * the target type's range and encodes as a value inside it. Operands are read as written, so a
-   * `Constraint` carrying encoded operator bytes is left to {@link validate}.
+   * Add a constraint to the active group. A path through `Quantifier.ALL` or `Quantifier.ANY` adds its operators to the
+   * body of the group's loop over that array with that quantifier.
+   * @param constraint - The constraint to add.
+   * @returns This builder.
+   * @throws {CallciumError} If the constraint has no operator, or its path does not reach a target in the signature.
+   * If a comparison does not apply to its target, or an operand is a value its target's type cannot represent.
    */
   add(constraint: Constraint): this;
-  /** Start a new constraint group (OR branch). */
+  /**
+   * Start a new constraint group (OR semantics between groups).
+   * @returns This builder.
+   * @throws {CallciumError} If the current group is empty.
+   */
   or(): this;
   /**
-   * 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.
-   * @throws {ValidationError} If validation finds any issue.
-   * @throws {CallciumError} With code `RULE_SIZE_OVERFLOW` when a rule's encoded bytes exceed the
-   * width of the rule size field.
+   * Build the policy blob and validate it.
+   * @returns The encoded policy.
+   * @throws {ValidationError} If validation reports any issue.
+   * @throws {CallciumError} If the encoder refuses the policy, or the blob fails storage validation.
    */
   build(): Hex;
   /**
-   * 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.
+   * Validate the policy the builder contains.
+   * @returns Every issue validation reports on the encoded policy.
+   * @throws {CallciumError} If the encoder refuses the policy, or the blob fails storage validation.
+   */
+  validate(): Issue[];
+  /**
+   * Build the policy blob without validation. The resulting policy can be invalid.
+   * @returns The encoded policy.
+   * @throws {CallciumError} If the encoder refuses the policy.
    */
   buildUnsafe(): Hex;
+  /** Append a context test per operator of `constraint`, whose path names a context property. */
+  private addContextTests;
   /**
-   * Validate the policy without encoding.
-   * @returns All validation issues found.
+   * Append a calldata test per operator of `constraint`. If the path of `constraint` passes a quantifier step, append a
+   * body test per operator to the group's loop over that array instead.
    */
-  validate(): Issue[];
-  /** Throw if any group is empty. */
-  private checkGroups;
-  /** Convert the draft to a PolicyData structure. */
+  private addCalldataTests;
+  /** The active group. */
+  private currentGroup;
+  /** The draft as the encoder takes it. */
   private toPolicyData;
 }
 //#endregion
 //#region src/policy-coder.d.ts
 /**
- * Encode a PolicyData structure into the canonical binary format.
- * @param data - The policy data to encode.
- * @returns The encoded policy as a 0x-prefixed hex string.
+ * Encode the canonical form of a policy: each group normalized, its rules and the groups sorted by their
+ * size-free bytes, repeats dropped.
+ * @param data - The policy.
+ * @returns The policy blob as a 0x-prefixed hex string.
+ * @throws {CallciumError} When a field does not have the shape the encoder reads, or a path does not compile.
+ * When an operator does not apply to its target, or a constant is not a value of its operand type.
+ * When a count or size overflows its field.
  */
 declare function encode(data: PolicyData): Hex;
 /**
- * Decode a binary policy blob into a PolicyData structure.
- * @param blob - Binary policy as 0x-prefixed hex string.
- * @returns The decoded policy data with constraints grouped by scope and path.
- * @throws {CallciumError} If the blob is structurally malformed.
+ * Decode a policy blob into the policy it states.
+ * @param blob - The policy blob.
+ * @returns The decoded policy, each operand loaded to its 32-byte word.
+ * @throws {CallciumError} When the blob fails storage validation or its descriptor fails DV-1 or DV-2.
  */
 declare function decode(blob: Hex): PolicyData;
 /**
- * Inspect a binary policy blob, returning the structural representation with full byte-level spans.
- * @param blob - Binary policy as 0x-prefixed hex string.
- * @returns The inspected policy with per-field spans for every structural element.
- * @throws {CallciumError} If the blob is structurally malformed.
+ * Inspect a policy blob: every field it stores with the bytes that contain it. The descriptor is a node tree, the hints
+ * are split into their fields and the operators are parsed.
+ * @param blob - The policy blob.
+ * @returns The inspected policy, each operand loaded to its 32-byte word.
+ * @throws {CallciumError} When the blob fails storage validation or its descriptor fails DV-1 or DV-2.
  */
 declare function inspect$1(blob: Hex): DecodedPolicy;
-/** Encode, decode, and inspect policies in the canonical binary format. */
-declare const PolicyCoder: {
+/** Encode policies in canonical form, and decode and inspect policy blobs. */
+export declare const PolicyCoder: {
   encode: typeof encode;
   decode: typeof decode;
   inspect: typeof inspect$1;
 };
 //#endregion
 //#region src/path.d.ts
-/** Reserved path step values that trigger quantified evaluation over array elements. */
-declare const Quantifier: {
+/** Path steps that quantify over the array before them: `ALL` over every element, `ANY` over some element. */
+export declare const Quantifier: {
   readonly ALL: 65535;
   readonly ANY: 65534;
 };
-/** Display metadata for a quantifier step. */
-type QuantifierInfo = {
-  label: string;
-};
-/** Check whether a path step is a quantifier (ALL or ANY). */
-declare function isQuantifier(step: number): boolean;
-/**
- * Map a quantifier path step to its display label.
- * @param code - Quantifier step value.
- * @returns Display metadata for the quantifier.
- * @throws {CallciumError} If the code is not a recognised quantifier.
- */
-declare function lookupQuantifier(code: number): QuantifierInfo;
 /**
  * Parse a BE16-encoded hex path into an array of step values.
  * @param path - 0x-prefixed hex string containing BE16-encoded path steps.
  * @returns Array of numeric step values.
  */
-declare function parsePathSteps(path: Hex): number[];
-//#endregion
-//#region src/descriptor.d.ts
-/** Structural type information extracted from a descriptor node. */
-type TypeInfo = {
-  typeCode: number;
-  isDynamic: boolean;
-  staticSize: number;
-};
-/**
- * Return the byte length of the node at `offset`.
- * @throws {CallciumError} When the descriptor holds no readable node at `offset`.
- */
-declare function nodeLength(desc: Uint8Array, offset: number): number;
-/**
- * Return the byte offset of the `fieldIndex`-th field inside a tuple node.
- * Starts at the first field and skips `fieldIndex` nodes using `nodeLength`.
- */
-declare function tupleFieldOffset(desc: Uint8Array, tupleOffset: number, fieldIndex: number): number;
-/**
- * Return the declared top-level parameter count.
- * @throws {CallciumError} When the descriptor is too short to hold a header.
- */
-declare function paramCount(desc: Uint8Array): number;
-/** Return byte offset of the N-th top-level param (0-indexed). */
-declare function paramOffset(desc: Uint8Array, index: number): number;
-/**
- * Inspect the type node at a given byte offset.
- * @param desc - Raw descriptor bytes.
- * @param offset - Byte position of the node.
- * @returns typeCode, isDynamic, and staticSize in bytes.
- * @throws {CallciumError} When the descriptor holds no readable node at `offset`.
- */
-declare function inspect(desc: Uint8Array, offset: number): TypeInfo;
-/**
- * Resolve the type at a calldata path (array of step indices).
- *
- * The first step selects a top-level param. Each subsequent step descends
- * into the current node: for tuples it selects a field, for arrays it
- * advances to the element descriptor.
- *
- * @param desc - Raw descriptor bytes.
- * @param steps - Path steps, length >= 1.
- * @returns TypeInfo for the node at the resolved path.
- * @throws {CallciumError} On empty steps, out-of-bounds param or array index, or descent into elementary type.
- */
-declare function typeAt(desc: Uint8Array, steps: number[]): 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 array index, or descent into elementary type.
- */
-declare function walkPath(desc: Uint8Array, steps: number[]): {
-  typeInfo: TypeInfo;
-  quantifiedStaticLength: number;
-};
-/**
- * Return tuple field count at a tuple node offset.
- * @param desc - Raw descriptor bytes.
- * @param offset - Byte position of the tuple node.
- */
-declare function tupleFieldCount(desc: Uint8Array, offset: number): number;
-/**
- * Return static array length at a static array node offset.
- * @param desc - Raw descriptor bytes.
- * @param offset - Byte position of the static array node.
- */
-declare function staticArrayLength(desc: Uint8Array, offset: number): number;
-/**
- * Return the byte offset of the array element descriptor.
- * @param offset - Byte position of the array node (static or dynamic).
- */
-declare function arrayElementOffset(offset: number): number;
-/**
- * Compile a calldata rule path into its wire hint block.
- *
- * @param desc - Raw descriptor bytes.
- * @param steps - Path steps, length >= 1.
- * @returns The hint block bytes.
- * @throws {CallciumError} When a step leaves the structure the descriptor declares, quantifies over
- * a non-array node, or repeats a quantifier.
- */
-declare function compileHint(desc: Uint8Array, steps: number[]): Uint8Array;
-/** Inspect and navigate raw descriptor bytes. */
-declare const Descriptor: {
-  paramCount: typeof paramCount;
-  paramOffset: typeof paramOffset;
-  inspect: typeof inspect;
-  typeAt: typeof typeAt;
-  tupleFieldOffset: typeof tupleFieldOffset;
-  tupleFieldCount: typeof tupleFieldCount;
-  staticArrayLength: typeof staticArrayLength;
-  nodeLength: typeof nodeLength;
-  arrayElementOffset: typeof arrayElementOffset;
-  walkPath: typeof walkPath;
-  compileHint: typeof compileHint;
-};
+export declare function parsePathSteps(path: Hex): number[];
 //#endregion
 //#region src/policy-validator.d.ts
 /**
- * True if operator `opCode` is allowed on a target with the given type info.
- * Tolerates the NOT flag on `opCode`.
+ * Determine whether the compatibility matrix admits an operator on a target type. A context operand is admitted on a
+ * target its comparison can pair with a context property. These targets are `uintN` under `EQ`, `GT`, `LT`, `GTE` and
+ * `LTE`, and `address` under `EQ`.
+ * @param opCode - The operator code, with or without the NOT flag.
+ * @param typeCode - The target's type code.
+ * @returns True when the operator applies to the target.
  */
-declare function isOpAllowed(opCode: number, typeInfo: TypeInfo): boolean;
+export declare function isOpAllowed(opCode: number, typeCode: number): boolean;
 /**
- * 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.
- * @throws {CallciumError} With code `EMPTY_PATH` when a constraint carries no path step, and
- * `INVALID_HEX` or `INVALID_OPERATOR_BYTES` when an operator is not a readable encoding. Analysis
- * is defined over canonical data, so these reject the input rather than report an issue on it.
+ * Validate a policy blob (PV-1 to PV-9). Storage validation runs first, since the descriptor check reads the descriptor
+ * before anything is decoded. Issues of PV-1 to PV-7 name a rule where the blob stores it. Issues of PV-8 and PV-9 name
+ * the group where the blob stores it and the rule's position in the normal form of that group. Only rules that raise no
+ * PV-2, PV-3, PV-5 or PV-6 issue and no PV-4 issue on a test enter the normal form. PV-8 skips a loop that lost a body
+ * test to such an issue.
+ * @param blob - A policy blob that passes storage validation.
+ * @returns Every issue found, or one issue alone when the descriptor is not valid.
+ * @throws {CallciumError} When the blob fails storage validation, or a group's normal form exceeds a format limit.
  */
-declare function validate(data: PolicyData): Issue[];
-/** Semantic validation for policies. */
-declare const PolicyValidator: {
+declare function validate(blob: Hex): Issue[];
+/** Build-time validation of policy blobs. */
+export declare const PolicyValidator: {
   validate: typeof validate;
 };
 //#endregion
@@ -480,33 +817,33 @@ declare const PolicyValidator: {
 /** Accepted scalar value types for operator arguments. */
 type ScalarValue = bigint | boolean | string;
 /**
- * Extremes of the numeric operands a builder's value operators received, as written. Encoding folds
- * a negative operand onto its unsigned alias, so the sign survives nowhere else.
+ * Extremes of the numeric operands a builder's equality, comparison and set operators received, as written. Encoding
+ * folds a negative operand onto its unsigned alias, so the sign survives nowhere else.
  */
 type OperandExtremes = {
-  /** Most negative operand written, or zero when none was negative. */leastNegative: bigint; /** Greatest operand written, or zero when none exceeded it. */
+  /** Most negative operand written, or zero when none was negative. */
+  leastNegative: bigint;
+  /** Greatest operand written, or zero when none exceeded it. */
   greatest: bigint;
 };
 /**
- * Mutable builder that accumulates operators targeting a single path.
- * Implements the `Constraint` interface so it can be passed directly to policy builders.
+ * Mutable builder that accumulates operators targeting a single path. Implements the `Constraint` interface so it can
+ * be passed directly to policy builders.
  */
 declare class ConstraintBuilder<Operand extends ScalarValue = ScalarValue> implements Constraint {
-  readonly scope: number;
+  readonly scope: Constraint["scope"];
   readonly path: Hex;
   readonly operators: Hex[];
   /**
-   * Extremes of the numeric operands the value operators received, as written. Only the extremes
-   * can offend: an operand folds into a target's range from below it or from above it, and
-   * whichever reaches furthest arrives first. Read it through {@link readOperandExtremes}.
+   * Extremes of the numeric operands the value operators received, as written.
    * @internal
    */
   readonly operandExtremes: OperandExtremes;
   /** @internal */
-  constructor(scope: number, path: Hex);
+  constructor(scope: Constraint["scope"], path: Hex);
   /**
-   * Push a pre-encoded operator hex string and return this for chaining.
-   * `values` are the operands as written; the numeric ones join the record.
+   * Push a pre-encoded operator hex string and return this for chaining. `values` are the operands as written. The
+   * numeric ones join the record.
    */
   private push;
   /** Assert the value equals `value`. */
@@ -517,6 +854,14 @@ declare class ConstraintBuilder<Operand extends ScalarValue = ScalarValue> imple
   eqCtx(contextPropertyId: number): this;
   /** Assert the value does not equal the context property `contextPropertyId`. */
   neqCtx(contextPropertyId: number): this;
+  /** Assert the value is greater than the context property `contextPropertyId`. */
+  gtCtx(contextPropertyId: number): this;
+  /** Assert the value is less than the context property `contextPropertyId`. */
+  ltCtx(contextPropertyId: number): this;
+  /** Assert the value is greater than or equal to the context property `contextPropertyId`. */
+  gteCtx(contextPropertyId: number): this;
+  /** Assert the value is less than or equal to the context property `contextPropertyId`. */
+  lteCtx(contextPropertyId: number): this;
   /** Assert the value is greater than `bound`. */
   gt(bound: bigint): this;
   /** Assert the value is less than `bound`. */
@@ -531,14 +876,13 @@ declare class ConstraintBuilder<Operand extends ScalarValue = ScalarValue> imple
    */
   between(min: bigint, max: bigint): this;
   /**
-   * Assert the value is a member of the set.
-   * Values are sorted and deduplicated before encoding.
-   * @throws {CallciumError} If the set is empty after deduplication.
+   * Assert the value is a member of the set. Values are sorted and deduplicated before encoding.
+   * @throws {CallciumError} If the set is empty or a value is not encodable as an operand word.
    */
   isIn(values: readonly Operand[]): this;
   /**
    * Assert the value is not a member of the set.
-   * @throws {CallciumError} If the set is empty after deduplication.
+   * @throws {CallciumError} If the set is empty or a value is not encodable as an operand word.
    */
   notIn(values: readonly Operand[]): this;
   /** Assert all bits in `mask` are set. */
@@ -564,67 +908,68 @@ declare class ConstraintBuilder<Operand extends ScalarValue = ScalarValue> imple
   lengthBetween(min: bigint, max: bigint): this;
 }
 /**
- * Target a calldata argument by path.
- * Each argument is a big-endian uint16 step; multiple steps navigate into nested types.
+ * Target a calldata argument by path. Each argument is a big-endian uint16 step. Further steps navigate nested types.
  */
-declare function arg(p0: number, ...rest: number[]): ConstraintBuilder;
+export declare function arg(p0: number, ...rest: number[]): ConstraintBuilder;
 /** Target the `msg.sender` context property. */
-declare function msgSender(): ConstraintBuilder<Address>;
+export declare function msgSender(): ConstraintBuilder<Address>;
 /** Target the `msg.value` context property. */
-declare function msgValue(): ConstraintBuilder<bigint>;
+export declare function msgValue(): ConstraintBuilder<bigint>;
 /** Target the `block.timestamp` context property. */
-declare function blockTimestamp(): ConstraintBuilder<bigint>;
+export declare function blockTimestamp(): ConstraintBuilder<bigint>;
 /** Target the `block.number` context property. */
-declare function blockNumber(): ConstraintBuilder<bigint>;
+export declare function blockNumber(): ConstraintBuilder<bigint>;
 /** Target the `block.chainid` context property. */
-declare function chainId(): ConstraintBuilder<bigint>;
+export declare function chainId(): ConstraintBuilder<bigint>;
 /** Target the `tx.origin` context property. */
-declare function txOrigin(): ConstraintBuilder<Address>;
+export declare function txOrigin(): ConstraintBuilder<Address>;
 /** Target the `block.basefee` context property. */
-declare function baseFee(): ConstraintBuilder<bigint>;
+export declare function baseFee(): ConstraintBuilder<bigint>;
 /** Target the `tx.gasprice` context property. */
-declare function gasPrice(): ConstraintBuilder<bigint>;
+export declare function gasPrice(): ConstraintBuilder<bigint>;
 //#endregion
 //#region src/policy-enforcer.d.ts
 /**
- * Check a policy against ABI-encoded call data without throwing on violations.
+ * Check a policy against ABI-encoded call data without throwing on violations. Requires a policy blob that passes
+ * storage validation. The outcome on any other blob past its header is undefined.
  * @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 evaluated failing group.
- * @throws {CallciumError} If the policy blob is structurally malformed, or a context value a rule
- * reads is not an address or an integer a 32-byte word represents.
+ * @throws {CallciumError} If the policy blob is shorter than its fixed prefix or of an unsupported format version.
+ * If the policy or call data is not valid hex.
+ * If a context value is not of its property's type or does not fit a 32-byte word.
  */
 declare function check(policy: Hex, callData: Hex, context?: Context): EnforceResult;
 /**
- * Enforce a policy against ABI-encoded call data, throwing on violation.
+ * Enforce a policy against ABI-encoded call data, throwing on violation. Requires a policy blob that passes storage
+ * validation. The outcome on any other blob past its header is undefined.
  * @param policy - Binary policy blob as 0x-prefixed hex string.
  * @param callData - ABI-encoded call data as 0x-prefixed hex string.
  * @param context - Optional execution context for context-scoped rules.
  * @throws {PolicyViolationError} If the policy rejects the call data.
- * @throws {CallciumError} If the policy blob is structurally malformed, or a context value a rule
- * reads is not an address or an integer a 32-byte word represents.
+ * @throws {CallciumError} If the policy blob is shorter than its fixed prefix or of an unsupported format version.
+ * If the policy or call data is not valid hex.
+ * If a context value is not of its property's type or does not fit a 32-byte word.
  */
 declare function enforce(policy: Hex, callData: Hex, context?: Context): void;
 /** Check and enforce policies against ABI-encoded call data. */
-declare const PolicyEnforcer: {
+export declare const PolicyEnforcer: {
   check: typeof check;
   enforce: typeof enforce;
 };
 //#endregion
 //#region src/bytes.d.ts
 /** Convert a hex string to a byte array, stripping the 0x prefix if present. */
-declare function hexToBytes(hex: string): Uint8Array;
+export declare function hexToBytes(hex: string): Uint8Array;
 /** Convert a byte array to a 0x-prefixed lowercase hex string. */
-declare function bytesToHex(bytes: Uint8Array): Hex;
-/** Validate and brand a hex string as an address. Throws if the runtime length is not exactly 20 bytes. */
-declare function toAddress(hex: string): Address;
+export declare function bytesToHex(bytes: Uint8Array): Hex;
 //#endregion
 //#region src/descriptor-coder.d.ts
 /**
  * Encode a comma-separated list of ABI type strings into a binary descriptor.
  *
- * @param typesCsv - Comma-separated ABI type strings, e.g. `"address,uint256,(bool,bytes32)[],string"`.
+ * @param typesCsv - Comma-separated ABI type strings, for example `"address,uint256,(bool,bytes32)[],string"`.
  * @returns Binary descriptor bytes starting with the version+paramCount header.
  * @throws {CallciumError} With code `MALFORMED_TYPE_STRING` for malformed input.
  * @throws {CallciumError} With code `UNKNOWN_TYPE` for unrecognised type names.
@@ -632,307 +977,28 @@ declare function toAddress(hex: string): Address;
  */
 declare function fromTypes(typesCsv: string): Uint8Array;
 /**
- * Reconstruct a comma-separated list of ABI type strings from a binary descriptor.
- *
- * Inverse of `fromTypes`: `toTypes(fromTypes(s))` returns `s` for any valid input.
- *
+ * Inspect a binary descriptor: its header fields and its parameters as a tree of nodes, each with the bytes it spans.
+ * @param desc - Binary descriptor bytes (with version+paramCount header).
+ * @returns The decoded descriptor.
+ * @throws {CallciumError} If the descriptor is malformed, or a composite node disagrees with its children.
+ */
+declare function inspect(desc: Uint8Array): DecodedDescriptor;
+/**
+ * Reconstruct a comma-separated list of ABI type strings from a binary descriptor. `fromTypes(toTypes(desc))` returns
+ * `desc` for every descriptor `inspect` accepts.
  * @param desc - Binary descriptor bytes (with version+paramCount header).
- * @returns Comma-separated ABI type strings, e.g. `"address,uint256,(bool,bytes32)[]"`.
- * @throws {CallciumError} If the descriptor is malformed.
+ * @returns Comma-separated ABI type strings, for example `"address,uint256,(bool,bytes32)[]"`.
+ * @throws {CallciumError} If the descriptor is malformed, or a composite node disagrees with its children.
  */
 declare function toTypes(desc: Uint8Array): string;
-/** Encode and decode descriptors. */
-declare const DescriptorCoder: {
+/** Encode descriptors from type strings, inspect them and read their type strings back. */
+export declare const DescriptorCoder: {
   fromTypes: typeof fromTypes;
+  inspect: typeof inspect;
   toTypes: typeof toTypes;
 };
 //#endregion
-//#region src/constants.d.ts
-/** Binary layout constants and normative limits for the Callcium policy format. */
-declare const PolicyFormat: {
-  readonly VERSION: 2;
-  readonly VERSION_MASK: 15;
-  readonly FLAG_NO_SELECTOR: 16;
-  readonly RESERVED_MASK: 224;
-  readonly HEADER_SIZE: 1;
-  readonly SELECTOR_OFFSET: 1;
-  readonly SELECTOR_SIZE: 4;
-  readonly DESC_LENGTH_OFFSET: 5;
-  readonly DESC_LENGTH_SIZE: 2;
-  readonly DESC_OFFSET: 7;
-  readonly GROUP_COUNT_SIZE: 1;
-  readonly GROUP_RULECOUNT_SIZE: 2;
-  readonly GROUP_SIZE_SIZE: 4;
-  readonly GROUP_HEADER_SIZE: 6;
-  readonly RULE_SIZE_SIZE: 2;
-  readonly RULE_SCOPE_OFFSET: 2;
-  readonly RULE_DEPTH_OFFSET: 3;
-  readonly RULE_PATH_OFFSET: 4;
-  readonly PATH_STEP_SIZE: 2;
-  readonly PATH_STEP_MAX: number;
-  readonly RULE_OPCODE_SIZE: 1;
-  readonly RULE_DATALENGTH_SIZE: 2;
-  readonly RULE_FIXED_OVERHEAD: 7;
-  readonly RULE_MIN_SIZE: number;
-  readonly HINT_HEADER_SIZE: 1;
-  readonly HINT_HOP_SIZE: 8;
-  readonly HINT_HOP_INDEX_OFFSET: 4;
-  readonly HINT_HOP_META_OFFSET: 6;
-  readonly HINT_FRAME_PREFIX_SIZE: 8;
-  readonly HINT_FRAME_COUNT_OFFSET: 4;
-  readonly HINT_FRAME_META_OFFSET: 6;
-  readonly HINT_TARGET_SIZE: 7;
-  readonly HINT_TARGET_META_OFFSET: 4;
-  readonly HINT_TARGET_TYPECODE_OFFSET: 6;
-  readonly HINT_KIND_NONE: 0;
-  readonly HINT_KIND_ALL: 1;
-  readonly HINT_KIND_ANY: 2;
-  readonly HINT_KIND_MAX: 2;
-  readonly HINT_KIND_SHIFT: 6;
-  readonly HINT_HOP_COUNT_MASK: 63;
-  readonly HINT_SUFFIX_RESERVED_MASK: 192;
-  readonly HINT_NO_INDEX: 65535;
-  readonly HINT_INDEX_RESERVED: 65534;
-  readonly HINT_META_ELEM_DYNAMIC: 32768;
-  readonly HINT_META_DYNAMIC_ARRAY: 16384;
-  readonly HINT_META_RESERVED_MASK: 12288;
-  readonly HINT_META_STRIDE_MASK: 4095;
-  readonly MAX_PATH_DEPTH: 32;
-  readonly MAX_QUANTIFIED_ARRAY_LENGTH: 256;
-  readonly MAX_SET_MEMBERS: number;
-};
-/**
- * Extract a `{ KEY: code }` map from a table with `key` and `code` fields.
- * @internal
- */
-type CodeMap<T extends readonly {
-  readonly key: string;
-  readonly code: number;
-}[]> = { readonly [E in T[number] as E["key"]]: E["code"] };
-/**
- * Render a wire code as fixed-width hex.
- * @param code - Code value.
- * @param byteWidth - Byte width of the field the code occupies.
- * @returns The code as `0x`-prefixed hex, or its decimal form when no such field holds it.
- */
-/** Rule scope discriminant: context (EVM environment) vs. calldata (ABI payload). */
-declare const Scope: CodeMap<readonly [{
-  readonly key: "CONTEXT";
-  readonly code: 0;
-  readonly label: "context";
-}, {
-  readonly key: "CALLDATA";
-  readonly code: 1;
-  readonly label: "calldata";
-}]>;
-/** Display metadata for a scope code. */
-type ScopeInfo = {
-  label: string;
-};
-/**
- * Map a scope code to its display label.
- * @param code - Scope byte value.
- * @returns Display metadata for the scope.
- * @throws {CallciumError} If the code is not a recognised scope.
- */
-declare function lookupScope(code: number): ScopeInfo;
-/** ABI type code ranges and sentinel values for the descriptor format. */
-declare const TypeCode: {
-  readonly UINT_MIN: 1;
-  readonly UINT_MAX: 32;
-  readonly INT_MIN: 33;
-  readonly INT_MAX: 64;
-  readonly ADDRESS: 65;
-  readonly BOOL: 66;
-  readonly FUNCTION: 67;
-  readonly FIXED_BYTES_MIN: 80;
-  readonly FIXED_BYTES_MAX: 111;
-  readonly BYTES: 112;
-  readonly STRING: 113;
-  readonly STATIC_ARRAY: 128;
-  readonly DYNAMIC_ARRAY: 129;
-  readonly TUPLE: 144;
-};
-/** Well-known context property IDs for context-scope rules. */
-declare const ContextProperty: CodeMap<readonly [{
-  readonly key: "MSG_SENDER";
-  readonly code: 0;
-  readonly label: "msg.sender";
-  readonly contextKey: "msgSender";
-  readonly typeCode: 65;
-}, {
-  readonly key: "MSG_VALUE";
-  readonly code: 1;
-  readonly label: "msg.value";
-  readonly contextKey: "msgValue";
-  readonly typeCode: 32;
-}, {
-  readonly key: "BLOCK_TIMESTAMP";
-  readonly code: 2;
-  readonly label: "block.timestamp";
-  readonly contextKey: "blockTimestamp";
-  readonly typeCode: 32;
-}, {
-  readonly key: "BLOCK_NUMBER";
-  readonly code: 3;
-  readonly label: "block.number";
-  readonly contextKey: "blockNumber";
-  readonly typeCode: 32;
-}, {
-  readonly key: "CHAIN_ID";
-  readonly code: 4;
-  readonly label: "block.chainid";
-  readonly contextKey: "chainId";
-  readonly typeCode: 32;
-}, {
-  readonly key: "TX_ORIGIN";
-  readonly code: 5;
-  readonly label: "tx.origin";
-  readonly contextKey: "txOrigin";
-  readonly typeCode: 65;
-}, {
-  readonly key: "BASE_FEE";
-  readonly code: 6;
-  readonly label: "block.basefee";
-  readonly contextKey: "baseFee";
-  readonly typeCode: 32;
-}, {
-  readonly key: "GAS_PRICE";
-  readonly code: 7;
-  readonly label: "tx.gasprice";
-  readonly contextKey: "gasPrice";
-  readonly typeCode: 32;
-}]>;
-/** Maximum valid context property ID. */
-declare const MAX_CONTEXT_PROPERTY_ID: number;
-/** Display metadata for a context property code. */
-type ContextPropertyInfo = {
-  label: string;
-  contextKey: keyof Context;
-  typeCode: number;
-};
-/**
- * Look up a context property code in the assigned set.
- * @param code - Context property ID.
- * @returns Display metadata, or undefined when the ID names no assigned property.
- */
-declare function findContextProperty(code: number): ContextPropertyInfo | undefined;
-/**
- * Map a context property code to its display label and ABI type code.
- * @param code - Context property ID.
- * @returns Display metadata including the ABI type code for the property value.
- * @throws {CallciumError} If the code is not a recognised context property.
- */
-declare function lookupContextProperty(code: number): ContextPropertyInfo;
-/** Operand count category for operator data validation. */
-type Operands = "single" | "range" | "variadic";
-/** @internal */
-declare const OP_TABLE: readonly [{
-  readonly key: "EQ";
-  readonly code: 1;
-  readonly label: "==";
-  readonly operands: "single";
-}, {
-  readonly key: "GT";
-  readonly code: 2;
-  readonly label: ">";
-  readonly operands: "single";
-}, {
-  readonly key: "LT";
-  readonly code: 3;
-  readonly label: "<";
-  readonly operands: "single";
-}, {
-  readonly key: "GTE";
-  readonly code: 4;
-  readonly label: ">=";
-  readonly operands: "single";
-}, {
-  readonly key: "LTE";
-  readonly code: 5;
-  readonly label: "<=";
-  readonly operands: "single";
-}, {
-  readonly key: "BETWEEN";
-  readonly code: 6;
-  readonly label: "between";
-  readonly operands: "range";
-}, {
-  readonly key: "IN";
-  readonly code: 7;
-  readonly label: "in";
-  readonly operands: "variadic";
-}, {
-  readonly key: "EQ_CTX";
-  readonly code: 8;
-  readonly label: "== ctx";
-  readonly operands: "single";
-}, {
-  readonly key: "BITMASK_ALL";
-  readonly code: 16;
-  readonly label: "bitmask all";
-  readonly operands: "single";
-}, {
-  readonly key: "BITMASK_ANY";
-  readonly code: 17;
-  readonly label: "bitmask any";
-  readonly operands: "single";
-}, {
-  readonly key: "BITMASK_NONE";
-  readonly code: 18;
-  readonly label: "bitmask none";
-  readonly operands: "single";
-}, {
-  readonly key: "LENGTH_EQ";
-  readonly code: 32;
-  readonly label: "length ==";
-  readonly operands: "single";
-}, {
-  readonly key: "LENGTH_GT";
-  readonly code: 33;
-  readonly label: "length >";
-  readonly operands: "single";
-}, {
-  readonly key: "LENGTH_LT";
-  readonly code: 34;
-  readonly label: "length <";
-  readonly operands: "single";
-}, {
-  readonly key: "LENGTH_GTE";
-  readonly code: 35;
-  readonly label: "length >=";
-  readonly operands: "single";
-}, {
-  readonly key: "LENGTH_LTE";
-  readonly code: 36;
-  readonly label: "length <=";
-  readonly operands: "single";
-}, {
-  readonly key: "LENGTH_BETWEEN";
-  readonly code: 37;
-  readonly label: "length between";
-  readonly operands: "range";
-}];
-/** Callcium policy operator codes. */
-declare const Op: CodeMap<typeof OP_TABLE> & {
-  readonly NOT: 0x80;
-};
-/** Display metadata for an operator code. */
-type OpInfo = {
-  label: string;
-  operands: Operands;
-};
-/**
- * Map an operator code to its display label. Strips the NOT flag automatically.
- * @param code - Operator byte value (may include the NOT flag).
- * @returns Display metadata for the base operator.
- * @throws {CallciumError} If the base code is not a recognised operator.
- */
-declare function lookupOp(code: number): OpInfo;
-//#endregion
 //#region src/operators.d.ts
-/** Return true when the operator code (with or without NOT flag) is a LENGTH_* variant. */
-declare function isLengthOp(opCode: number): boolean;
 /** Structural category for a descriptor type code. */
 type TypeClass = "elementary" | "tuple" | "staticArray" | "dynamicArray";
 /** Structural classification without label. */
@@ -947,27 +1013,24 @@ type TypeCodeInfo = TypeClassInfo & {
 /**
  * Map a raw type code byte to its ABI type label, structural category, and dynamism.
  * @param code - A single-byte descriptor type code.
- * @returns Label, type class, and whether the type is ABI-dynamic.
+ * @returns Label, type class, and whether the code alone implies ABI dynamism (false for tuples and static arrays).
  * @throws {CallciumError} If the code is not a recognised type code.
  */
-declare function lookupTypeCode(code: number): TypeCodeInfo;
+export declare function lookupTypeCode(code: number): TypeCodeInfo;
 //#endregion
 //#region src/errors.d.ts
 /**
  * Machine-readable error code for structural decoding and validation failures.
  *
- * Each code names one invariant. Where Solidity detects the same invariant, the code is its error
- * name transliterated from `PascalCase` to `SCREAMING_SNAKE_CASE`. The codes under "Inputs and
- * validation" have no counterpart: they name input a Solidity signature cannot express.
- * `OUT_OF_PHYSICAL_BOUNDS` names an invariant Solidity carries twice, as the error
- * `PolicyBuilder.OutOfPhysicalBounds` and as an issue code, so the name is shared with `IssueCode`.
+ * Each code names one invariant. Where Solidity detects the same invariant, the code is its error name transliterated
+ * from `PascalCase` to `SCREAMING_SNAKE_CASE`. The codes under "Inputs and validation" have no counterpart: they name
+ * input a Solidity signature cannot express.
  */
-type CallciumErrorCode = "UNSUPPORTED_VERSION" | "MALFORMED_HEADER" | "UNEXPECTED_END" | "TRAILING_BYTES" | "EMPTY_POLICY" | "EMPTY_GROUP" | "GROUP_TOO_SMALL" | "GROUP_SIZE_MISMATCH" | "GROUP_OVERFLOW" | "RULE_TOO_SMALL" | "RULE_SIZE_MISMATCH" | "RULE_FIELD_OUT_OF_BOUNDS" | "RULE_OVERFLOW" | "EMPTY_PATH" | "MALFORMED_PATH" | "PATH_TOO_DEEP" | "PARAM_INDEX_OUT_OF_BOUNDS" | "TUPLE_FIELD_OUT_OF_BOUNDS" | "STATIC_ARRAY_INDEX_OUT_OF_BOUNDS" | "NOT_COMPOSITE" | "UNCOMPILABLE_PATH" | "QUANTIFIER_ON_NON_ARRAY" | "NESTED_QUANTIFIER" | "INVALID_SCOPE" | "INVALID_CONTEXT_PATH" | "UNKNOWN_CONTEXT_PROPERTY" | "UNKNOWN_OPERATOR" | "INVALID_OPERATOR_BYTES" | "OPERATOR_TARGET_MISMATCH" | "UNSORTED_IN_SET" | "MALFORMED_HINT" | "NO_CONSTRAINT_OPERATORS" | "DUPLICATE_PATH_IN_GROUP" | "EMPTY_SET" | "SET_TOO_LARGE" | "INVALID_RANGE" | "OUT_OF_PHYSICAL_BOUNDS" | "UNKNOWN_TYPE_CODE" | "NODE_LENGTH_TOO_SMALL" | "NODE_LENGTH_TOO_LARGE" | "NODE_OVERFLOW" | "NESTING_TOO_DEEP" | "INVALID_ARRAY_LENGTH" | "INVALID_TUPLE_FIELD_COUNT" | "STATIC_WORDS_TOO_LARGE" | "PARAM_COUNT_MISMATCH" | "TOO_MANY_PARAMS" | "MALFORMED_TYPE_STRING" | "UNKNOWN_TYPE" | "MALFORMED_SIGNATURE" | "SIGNATURE_CONTAINS_WHITESPACE" | "INVALID_FUNCTION_NAME" | "GROUP_COUNT_OVERFLOW" | "RULE_COUNT_OVERFLOW" | "RULE_SIZE_OVERFLOW" | "DESC_LENGTH_OVERFLOW" | "UNKNOWN_QUANTIFIER" | "INVALID_HEX" | "MALFORMED_SELECTOR" | "PATH_STEP_OVERFLOW" | "OPERAND_OVERFLOW" | "CONTEXT_VALUE_OVERFLOW" | "VALIDATION_ERROR";
+type CallciumErrorCode = "UNSUPPORTED_VERSION" | "UNSUPPORTED_MINOR" | "MINOR_MISMATCH" | "MALFORMED_HEADER" | "UNEXPECTED_END" | "TRAILING_BYTES" | "EMPTY_POLICY" | "EMPTY_GROUP" | "GROUP_SIZE_MISMATCH" | "GROUP_OVERFLOW" | "RULE_TOO_SMALL" | "RULE_SIZE_MISMATCH" | "RULE_OVERFLOW" | "EMPTY_PATH" | "MALFORMED_PATH" | "PATH_TOO_DEEP" | "PARAM_INDEX_OUT_OF_BOUNDS" | "TUPLE_FIELD_OUT_OF_BOUNDS" | "STATIC_ARRAY_INDEX_OUT_OF_BOUNDS" | "NOT_COMPOSITE" | "QUANTIFIER_ON_NON_ARRAY" | "UNKNOWN_PATH_STEP" | "UNKNOWN_QUANTIFIER" | "INVALID_NESTED_LOOP" | "UNKNOWN_SCOPE" | "INVALID_CONTEXT_PATH" | "UNKNOWN_CONTEXT_PROPERTY" | "UNKNOWN_OPERATOR" | "INVALID_OPERATOR_BYTES" | "OPERATOR_TARGET_MISMATCH" | "INVALID_CONTEXT_OPERAND" | "DATA_LENGTH_MISMATCH" | "UNSORTED_IN_SET" | "MALFORMED_HINT" | "NO_CONSTRAINT_OPERATORS" | "EMPTY_SET" | "SET_TOO_LARGE" | "INVALID_RANGE" | "OUT_OF_PHYSICAL_BOUNDS" | "UNKNOWN_TYPE_CODE" | "NODE_LENGTH_TOO_SMALL" | "NODE_LENGTH_TOO_LARGE" | "NODE_OVERFLOW" | "NESTING_TOO_DEEP" | "INVALID_ARRAY_LENGTH" | "INVALID_TUPLE_FIELD_COUNT" | "STATIC_WORDS_TOO_LARGE" | "PARAM_COUNT_MISMATCH" | "TOO_MANY_PARAMS" | "NODE_LENGTH_MISMATCH" | "STATIC_WORDS_MISMATCH" | "INVALID_UINT_BITS" | "INVALID_INT_BITS" | "INVALID_BYTES_LENGTH" | "MALFORMED_TYPE_STRING" | "UNKNOWN_TYPE" | "MALFORMED_SIGNATURE" | "SIGNATURE_CONTAINS_WHITESPACE" | "INVALID_FUNCTION_NAME" | "GROUP_COUNT_OVERFLOW" | "RULE_COUNT_OVERFLOW" | "RULE_SIZE_OVERFLOW" | "DESC_LENGTH_OVERFLOW" | "VALIDATION_ERROR" | "INVALID_HEX" | "MALFORMED_SELECTOR" | "PATH_STEP_OVERFLOW" | "OPERAND_OVERFLOW" | "CONTEXT_VALUE_OVERFLOW" | "MALFORMED_CONTEXT_VALUE" | "MALFORMED_OPERAND";
 /**
- * Thrown when a policy or descriptor blob is structurally malformed.
- * The optional `offset` indicates the byte position in the source blob where the error was detected.
+ * Thrown on malformed or inadmissible SDK input. `offset`, when set, is the error's byte position in the source blob.
  */
-declare class CallciumError extends Error {
+export declare class CallciumError extends Error {
   readonly code: CallciumErrorCode;
   /** Byte position in the source blob where the error was detected, if applicable. */
   readonly offset?: number;
@@ -976,27 +1039,25 @@ declare class CallciumError extends Error {
 /**
  * Thrown by `PolicyBuilder.build` when validation reports any issue.
  *
- * Carries every issue the validator found. The `Error.message` is the first issue's
- * message — a diagnostic summary, not a presentation contract. Consumers rendering
- * issues to users should iterate `issues` directly.
+ * Carries every issue the validator found. The `Error.message` is the first issue's message — a diagnostic summary, not
+ * a presentation contract. To render issues to users, iterate `issues` directly.
  */
-declare class ValidationError extends CallciumError {
+export declare class ValidationError extends CallciumError {
   readonly issues: Issue[];
   constructor(issues: Issue[]);
 }
 /**
- * Thrown by `PolicyEnforcer.enforce` when calldata fails policy enforcement.
- * Distinct from `ValidationError`, which signals static issues in the policy itself.
+ * Thrown by `PolicyEnforcer.enforce` when calldata fails policy enforcement. Distinct from `ValidationError`, which
+ * signals static issues in the policy itself.
  *
- * Carries the full list of structured violations (one per failed group). The
- * `Error.message` is a minimal non-lossy diagnostic summary built from the
- * first violation's structured fields — not a presentation contract. Consumers
- * rendering violations to users should iterate `violations` directly.
+ * Carries the full list of structured violations (one per failed group). The `Error.message` is a minimal non-lossy
+ * diagnostic summary built from the first violation's structured fields — not a presentation contract. To render
+ * violations to users, iterate `violations` directly.
  */
-declare class PolicyViolationError extends Error {
+export declare class PolicyViolationError extends Error {
   readonly violations: Violation[];
   constructor(violations: Violation[]);
 }
 //#endregion
-export { type Address, CallciumError, type CallciumErrorCode, type CalldataNavigationViolation, type Constraint, type ConstraintBuilder, type Context, ContextProperty, type ContextPropertyInfo, type DecodedGroup, type DecodedParam, type DecodedPolicy, type DecodedRule, Descriptor, DescriptorCoder, type EnforceResult, type Field, type Hex, type Issue, type IssueCategory, type IssueCode, type IssueSeverity, MAX_CONTEXT_PROPERTY_ID, type MissingContextViolation, type MissingSelectorViolation, type NavigationViolationCode, type NonCanonicalValueViolation, Op, type OpInfo, type Operands, PolicyBuilder, PolicyCoder, type PolicyData, PolicyEnforcer, PolicyFormat, PolicyValidator, PolicyViolationError, Quantifier, type QuantifierEmptyArrayViolation, type QuantifierInfo, type QuantifierLimitExceededViolation, type ScalarValue, Scope, type ScopeInfo, type SelectorMismatchViolation, type Span, type TypeClass, type TypeClassInfo, TypeCode, type TypeCodeInfo, type TypeInfo, ValidationError, type ValueMismatchViolation, type Violation, type ViolationCode, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, findContextProperty, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+export type { Address, ArrayMeta, BodyRule, CallciumErrorCode, CalldataNavigationViolation, ComparisonCode, Constraint, ConstraintBuilder, Context, ContextPropertyInfo, DecodedDescriptor, DecodedFrameHint, DecodedGroup, DecodedHint, DecodedHop, DecodedLoop, DecodedNode, DecodedOperator, DecodedPolicy, DecodedRule, DecodedTest, EnforceResult, Field, Hex, Issue, IssueCategory, IssueCode, IssueSeverity, LoopRule, MissingContextViolation, MissingSelectorViolation, NavigationViolationCode, NonCanonicalValueViolation, OpInfo, Operands, PolicyData, QuantifierCode, QuantifierInfo, QuantifierLimitExceededViolation, QuantifierNoMatchViolation, Rule, RuleLocation, ScalarValue, ScopeCode, ScopeInfo, SelectorMismatchViolation, Span, TypeClass, TypeClassInfo, TypeCodeInfo, ValueMismatchViolation, Violation, ViolationCode };
 //# sourceMappingURL=index.d.ts.map