@peac/protocol 0.13.3 → 0.14.0

package/dist/_internal/record-core/bounded-validator.d.ts

@@ -1,38 +1,42 @@
 /**
- * Bounded observation subset: composition aggregator.
+ * Canonical-composed shadow validation: composition aggregator.
  *
- * INTERNAL ONLY. Composes the six proven layer validators introduced
- * across this PR (kernel constraints; type-extension mapping; JOSE
- * header hardening; issuer form; occurred_at temporal skew;
- * extension byte budget) into a single aggregated result. The
- * canonical-truth sanity test, layer-isolated parity tests, and
- * differential same-path proof have already established that each
- * underlying validator is byte-equal with the existing canonical
- * surface for the layer it covers.
+ * INTERNAL ONLY. Composes layer validators into a single aggregated
+ * result. Each layer either delegates to a canonical helper from
+ * `@peac/schema` / `@peac/crypto` / `@peac/protocol` (canonical-
+ * composed wrapper pattern) or mirrors a canonical inline check
+ * verbatim. The canonical-vs-candidate differential test asserts
+ * byte-equality of the candidate verdict with the canonical verdict
+ * on every eligible fixture; any divergence indicates a defect in
+ * the projection logic.
  *
- * NOT WIRED. This module is NOT called from issue.ts, verify-local.ts,
- * or any runtime path in v0.13.1. It exists as a composition example
- * so PR D can wire the inert shadow-call hook to a real bounded
- * pipeline behind an internal feature flag without re-deriving the
- * composition shape.
+ * Always-on layers (run on every input):
+ *   - kernel-constraints (depth / array / keys / string / nodes)
+ *   - issuer-form (canonical iss)
+ *   - type-extension-mapping (warnings only)
+ *   - extension-byte-budget
+ *   - unknown-extension-grammar (warnings only)
  *
- * NOT FULL VALIDATION. The bounded subset deliberately EXCLUDES:
- *   - full Wire 0.2 schema parsing (parseReceiptClaims; the canonical
- *     parse continues to drive the runtime path)
- *   - signature verification and full JWS decode (decodeWire02;
- *     @peac/crypto remains canonical)
- *   - iat-not-yet-valid temporal check (lives inline at
- *     verify-local.ts:454 with no helper to import)
- *   - typ_missing strictness handling
- *   - policy binding verification
- *   - unknown_extension key grammar / plain-JSON guard / typed
- *     extension schema parse (only the byte-budget portion of
- *     validateKnownExtensions is in scope)
+ * Optional-input layers (skip when their inputs are absent):
+ *   - jose-header-hardening (header)
+ *   - temporal occurred_at skew (evidence kind)
+ *   - schema-parse (fullClaims)
+ *   - jose-typ-strictness (header + strictness)
+ *   - iat-not-yet-valid (maxClockSkew)
+ *   - policy-binding (receiptPolicyDigest + localPolicyDigest)
+ *   - type-extension-enforcement (strictness)
+ *
+ * Out of scope:
+ *   - signature verification (the standalone `validateSignatureInternal`
+ *     export is async and is not composed here; callers that need it
+ *     invoke it directly with serialized + publicKey)
  *   - any control-plane behavior (issuer resolver, JWKS fetch, etc.)
  *
- * Public-facing wording for this module: "bounded observation subset",
- * never "complete validator" or "primary validator".
+ * Public-facing wording for this module: "canonical-composed shadow
+ * validation" or "observational equivalence harness". Never
+ * "complete validator", "primary validator", or "divergent validator".
  */
+import { type Strictness } from './validators/index.js';
 /** Minimal claims shape required by the bounded subset. */
 export interface BoundedClaimsInput {
     readonly kind: string;
@@ -50,13 +54,45 @@ export interface BoundedValidationInput {
     readonly header?: BoundedHeaderInput;
     /** Fixed Unix-second clock for temporal evaluation; required. */
     readonly now: number;
+    /**
+     * Strictness profile for layers that promote warnings to errors
+     * under `'strict'` mode. When omitted, layers that consume
+     * strictness skip (they do not run). Mirrors the canonical
+     * `verifyLocal({ strictness })` option.
+     */
+    readonly strictness?: Strictness;
+    /**
+     * Maximum permitted clock skew in seconds for the iat-not-yet-valid
+     * check. When omitted, the iat layer skips. Mirrors
+     * `verifyLocal({ maxClockSkew })`; canonical default is 300.
+     */
+    readonly maxClockSkew?: number;
+    /**
+     * Receipt-side policy digest (`claims.policy.digest`). Used together
+     * with `localPolicyDigest` by the policy-binding layer. Either
+     * absent skips the layer.
+     */
+    readonly receiptPolicyDigest?: string;
+    /**
+     * Caller-supplied policy digest. Used together with
+     * `receiptPolicyDigest`. Either absent skips the layer.
+     */
+    readonly localPolicyDigest?: string;
+    /**
+     * Full receipt-claims object for the schema-parse layer. When
+     * omitted, the schema-parse layer falls back to running on the
+     * minimal `BoundedClaimsInput` projection (which may not surface
+     * field-level parse errors that depend on optional fields outside
+     * the bounded subset).
+     */
+    readonly fullClaims?: Record<string, unknown>;
 }
 /**
  * Layer tag identifies which underlying validator emitted each entry.
  * Useful for downstream filtering (e.g., a future shadow-mode reporter
  * that ignores warning-class entries from one layer but not another).
  */
-export type BoundedLayer = 'kernel-constraints' | 'type-extension-mapping' | 'jose-header-hardening' | 'issuer-form' | 'temporal' | 'extension-budget';
+export type BoundedLayer = 'kernel-constraints' | 'type-extension-mapping' | 'jose-header-hardening' | 'issuer-form' | 'temporal' | 'extension-budget' | 'schema-parse' | 'jose-typ-strictness' | 'iat-not-yet-valid' | 'policy-binding' | 'unknown-extension-grammar' | 'type-extension-enforcement';
 export interface BoundedViolation {
     readonly layer: BoundedLayer;
     readonly code: string;

package/dist/_internal/record-core/bounded-validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bounded-validator.d.ts","sourceRoot":"","sources":["../../../src/_internal/record-core/bounded-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAcH,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/C;AAED,4DAA4D;AAC5D,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;AAErE,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IACrC,iEAAiE;IACjE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,aAAa,GACb,UAAU,GACV,kBAAkB,CAAC;AAEvB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,CA8EhG"}
+{"version":3,"file":"bounded-validator.d.ts","sourceRoot":"","sources":["../../../src/_internal/record-core/bounded-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAcL,KAAK,UAAU,EAKhB,MAAM,uBAAuB,CAAC;AAE/B,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/C;AAED,4DAA4D;AAC5D,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;AAErE,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IACrC,iEAAiE;IACjE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/C;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,aAAa,GACb,UAAU,GACV,kBAAkB,GAClB,cAAc,GACd,qBAAqB,GACrB,mBAAmB,GACnB,gBAAgB,GAChB,2BAA2B,GAC3B,4BAA4B,CAAC;AAEjC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,CAsKhG"}

package/dist/_internal/record-core/validation-gate.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Production-facing bounded validation gate.
+ *
+ * INTERNAL ONLY. Not re-exported from `packages/protocol/src/index.ts`.
+ *
+ * The gate is the only production wrapper for the bounded validation
+ * path. The pre-existing `runBoundedValidatorShadow` from
+ * `bounded-validator.ts` remains the entry point for shadow / corpus
+ * / parity-harness consumers and is not the primary admission path
+ * for the protocol entry points; the production-wrapper boundary is
+ * enforced by `tests/tooling/production-gate-boundary.test.ts`.
+ *
+ * The gate is entrypoint-aware: callers identify themselves with a
+ * `surface` discriminator, and the gate applies a per-surface
+ * production projection allowlist. Layers in the bounded validator's
+ * broader composition that fall outside the allowlist for a given
+ * surface stay available to shadow / parity tests through
+ * `runBoundedValidatorShadow` but are not surfaced as production
+ * failure or production warning here.
+ *
+ * Allowlist for surface 'issueWire02':
+ *   - schema-parse only.
+ *
+ * Allowlist for surface 'verifyLocal':
+ *   - kernel-constraints (via canonical `validateKernelConstraints`).
+ *   - schema-parse (via the extended `validateSchemaParseInternal`).
+ *
+ * Out of scope here (kept inline-canonical on both branches by the
+ * caller): caller-option-bearing checks (issuer mismatch, subjectUri
+ * mismatch, policyDigest format), strictness routing for missing typ,
+ * iat-not-yet-valid, occurred_at temporal, type-extension warnings,
+ * type-extension enforcement, policy-binding compute, bindings
+ * construction, sortWarnings.
+ *
+ * The canonical materializer (claim encoding, JWS signing, JWS
+ * decoding, result-shape construction) is shared between the
+ * bounded-default and rollback branches and is not touched by the
+ * gate.
+ */
+import type { VerificationWarning } from '@peac/kernel';
+import type { Wire02Claims } from '@peac/schema';
+/**
+ * Discriminator identifying which protocol entry point invoked the
+ * gate. Drives the production projection allowlist. Adding a third
+ * surface requires a deliberate plan amendment, not an unannounced
+ * source change.
+ */
+export type GateSurface = 'issueWire02' | 'verifyLocal';
+/** Sanitized parse-issue projection surfaced on rejection. */
+export interface SanitizedParseIssue {
+    readonly path: string;
+    readonly message: string;
+}
+/** Parsed-claims projection surfaced on `verifyLocal` acceptance. */
+export interface ValidationGateParsed {
+    readonly wireVersion: '0.2';
+    readonly claims: Wire02Claims;
+    readonly parserWarnings: readonly VerificationWarning[];
+}
+/** Failure-detail projection. Smaller than the bounded layer set. */
+export interface ValidationGateFailureDetails {
+    readonly parse_code?: string;
+    readonly issues?: readonly SanitizedParseIssue[];
+}
+/** Successful gate result. */
+export interface ValidationGateSuccess {
+    readonly ok: true;
+    readonly parsed?: ValidationGateParsed;
+}
+/** Failed gate result. */
+export interface ValidationGateFailure {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+    readonly details?: ValidationGateFailureDetails;
+}
+export type ValidationGateResult = ValidationGateSuccess | ValidationGateFailure;
+/** Inputs to the gate. Only `surface` and `payload` are required. */
+export interface ValidationGateInput {
+    readonly surface: GateSurface;
+    /**
+     * Full claims object. For surface 'issueWire02' this is the just-
+     * constructed `Wire02Claims` cast to a plain record (the same
+     * object that today flows through `Wire02ClaimsSchema.safeParse`).
+     * For surface 'verifyLocal' this is the decoded JWS payload (the
+     * same object that today flows through `validateKernelConstraints`
+     * and `parseReceiptClaims`).
+     */
+    readonly payload: unknown;
+}
+/**
+ * Run the production projection of the bounded validation path.
+ *
+ * Behavior is byte-equivalent to the inline canonical sequences at
+ * `issue.ts` and `verify-local.ts` for every input on the covered
+ * runtime matrix. Any cross-branch divergence on JWS bytes, result
+ * shape, error code, warning order, thrown error class, success /
+ * failure classification, or observable default behavior is a
+ * validation-equivalence regression.
+ */
+export declare function runBoundedValidationGate(input: ValidationGateInput): ValidationGateResult;
+//# sourceMappingURL=validation-gate.d.ts.map

package/dist/_internal/record-core/validation-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-gate.d.ts","sourceRoot":"","sources":["../../../src/_internal/record-core/validation-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,aAAa,CAAC;AAExD,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,qEAAqE;AACrE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACzD;AAED,qEAAqE;AACrE,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAClD;AAED,8BAA8B;AAC9B,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED,0BAA0B;AAC1B,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,4BAA4B,CAAC;CACjD;AAED,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,GAAG,qBAAqB,CAAC;AAEjF,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,GAAG,oBAAoB,CAKzF"}

package/dist/_internal/record-core/validators/iat-not-yet-valid.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Bounded internal iat-not-yet-valid validator.
+ *
+ * INTERNAL ONLY. Parity-observed counterpart of the inline iat-not-yet-valid
+ * check in `verify-local.ts` (`if (claims.iat > now + maxClockSkew) ...`).
+ * Both implementations consume the same `iat`, `now`, and `maxClockSkew`
+ * inputs and apply the same comparison; behavioral parity is proven
+ * byte-equal by the parity tests.
+ *
+ * Existing canonical iat handling in `verify-local.ts` remains canonical.
+ * This module is observational only; it is not re-exported from
+ * `packages/protocol/src/index.ts` and is not wired into the public
+ * runtime path.
+ *
+ * SCOPE:
+ *   - Reject when `iat > now + maxClockSkew` (claim issued too far in the future).
+ *   - Accept when `iat <= now + maxClockSkew`.
+ *   - Never reads `Date.now()`; the caller injects `now` for determinism.
+ *
+ * Out of scope:
+ *   - `exp` / `nbf` checks (Wire 0.2 records do not expire and have no nbf).
+ *   - `occurred_at` skew (handled by `temporal.ts`).
+ */
+export interface IatNotYetValidResult {
+    readonly accepted: boolean;
+    readonly errorCode?: string;
+}
+export declare function validateIatNotYetValidInternal(iat: number, now: number, maxClockSkew: number): IatNotYetValidResult;
+//# sourceMappingURL=iat-not-yet-valid.d.ts.map

package/dist/_internal/record-core/validators/iat-not-yet-valid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iat-not-yet-valid.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/iat-not-yet-valid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAQD,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,GACnB,oBAAoB,CAGtB"}

package/dist/_internal/record-core/validators/index.d.ts

@@ -10,4 +10,11 @@ export { validateJoseHardeningInternal, type JoseHardeningInput, type JoseHarden
 export { validateIssuerFormInternal, type IssuerFormResult } from './issuer-form.js';
 export { validateTemporalInternal, type TemporalResult, type TemporalWarning } from './temporal.js';
 export { validateExtensionBudgetInternal, type ExtensionBudgetResult, type ExtensionBudgetViolation, } from './extension-budget.js';
+export { validateSchemaParseInternal, type SchemaParseResult } from './schema-parse.js';
+export { validateJoseTypStrictnessInternal, type JoseTypStrictnessResult, type JoseTypStrictnessWarning, type Strictness, } from './jose-typ-strictness.js';
+export { validateIatNotYetValidInternal, type IatNotYetValidResult } from './iat-not-yet-valid.js';
+export { validatePolicyBindingInternal, type PolicyBindingResult } from './policy-binding.js';
+export { validateUnknownExtensionGrammarInternal, type UnknownExtensionGrammarResult, type UnknownExtensionWarning, } from './unknown-extension-grammar.js';
+export { validateTypeExtensionEnforcementInternal, type TypeExtensionEnforcementResult, type TypeExtensionEnforcementWarning, } from './type-extension-enforcement.js';
+export { validateSignatureInternal, type SignatureResult } from './signature.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/_internal/record-core/validators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,EACL,oCAAoC,EACpC,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,GACjC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,6BAA6B,EAC7B,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,0BAA0B,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AACpG,OAAO,EACL,+BAA+B,EAC/B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,EACL,oCAAoC,EACpC,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,GACjC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,6BAA6B,EAC7B,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,0BAA0B,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AACpG,OAAO,EACL,+BAA+B,EAC/B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,2BAA2B,EAAE,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,EACL,iCAAiC,EACjC,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,UAAU,GAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,8BAA8B,EAAE,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnG,OAAO,EAAE,6BAA6B,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EACL,uCAAuC,EACvC,KAAK,6BAA6B,EAClC,KAAK,uBAAuB,GAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,wCAAwC,EACxC,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,GACrC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/_internal/record-core/validators/jose-typ-strictness.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bounded internal JOSE typ-strictness validator.
+ *
+ * INTERNAL ONLY. Parity-observed counterpart of the typ-strictness
+ * routing in `verify-local.ts` (the block that rejects a missing typ
+ * under `'strict'` mode and surfaces a `typ_missing` warning under
+ * `'interop'` mode). Both implementations consume the same protected-
+ * header `typ` value plus a `strictness` parameter and apply the same
+ * accept/reject/warning rules.
+ *
+ * Existing canonical strictness routing in `verify-local.ts` remains
+ * canonical. This module is observational only; not re-exported and
+ * not wired into the public runtime path.
+ *
+ * SCOPE:
+ *   - typ present (any string) -> accepted, no warning.
+ *   - typ absent (undefined or non-string) and strictness === 'strict'
+ *     -> rejected with E_INVALID_FORMAT.
+ *   - typ absent and strictness === 'interop' -> accepted with
+ *     typ_missing warning.
+ *
+ * Out of scope:
+ *   - typ value validation (`'interaction-record+jwt'` enforcement lives
+ *     in `@peac/crypto.validateWire02Header` / the JOSE-hardening layer).
+ *   - alg / kid / crit / b64 / zip checks (handled by `jose-hardening.ts`).
+ */
+export type Strictness = 'strict' | 'interop';
+export interface JoseTypStrictnessWarning {
+    readonly code: string;
+}
+export type JoseTypStrictnessResult = {
+    readonly accepted: true;
+    readonly warnings?: readonly JoseTypStrictnessWarning[];
+} | {
+    readonly accepted: false;
+    readonly errorCode: string;
+};
+export declare function validateJoseTypStrictnessInternal(typ: unknown, strictness: Strictness): JoseTypStrictnessResult;
+//# sourceMappingURL=jose-typ-strictness.d.ts.map

package/dist/_internal/record-core/validators/jose-typ-strictness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jose-typ-strictness.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/jose-typ-strictness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9C,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,uBAAuB,GAC/B;IAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAA;CAAE,GACpF;IAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAY7D,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,UAAU,GACrB,uBAAuB,CAKzB"}

package/dist/_internal/record-core/validators/policy-binding.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bounded internal policy-binding validator (canonical-composed).
+ *
+ * INTERNAL ONLY. Thin wrapper around `verifyPolicyBinding` from
+ * `@peac/schema`. Surfaces the canonical three-state result
+ * (`verified` / `failed` / `unavailable`) projected into the bounded
+ * validator's accept/reject contract, where `failed` is the only
+ * rejection.
+ *
+ * This is observational equivalence by construction, not a divergent
+ * binding check. Module is observational only; not re-exported from
+ * `packages/protocol/src/index.ts` and not wired into the public
+ * runtime path.
+ *
+ * SCOPE:
+ *   - Both digests present and equal -> accepted (`verified`).
+ *   - Either digest absent -> accepted (`unavailable`); no policy
+ *     check is performed when the receipt or caller omits the digest.
+ *   - Both present but unequal -> rejected with E_POLICY_BINDING_FAILED.
+ *
+ * Out of scope:
+ *   - Policy-document fetch and digest computation (lives in
+ *     `verifyLocal()` / caller responsibility).
+ *   - Policy URI handling (`policy.uri` is informational only).
+ */
+export interface PolicyBindingResult {
+    readonly accepted: boolean;
+    readonly errorCode?: string;
+    /** 'verified' | 'failed' | 'unavailable'. Surfaced unchanged from canonical. */
+    readonly status: 'verified' | 'failed' | 'unavailable';
+}
+export declare function validatePolicyBindingInternal(receiptPolicyDigest: string | undefined, localPolicyDigest: string | undefined): PolicyBindingResult;
+//# sourceMappingURL=policy-binding.d.ts.map

package/dist/_internal/record-core/validators/policy-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy-binding.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/policy-binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,aAAa,CAAC;CACxD;AAED,wBAAgB,6BAA6B,CAC3C,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACpC,mBAAmB,CASrB"}

package/dist/_internal/record-core/validators/schema-parse.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Bounded internal schema-parse validator.
+ *
+ * INTERNAL ONLY. Thin wrapper around the canonical
+ * `parseReceiptClaims` from `@peac/schema`. Projects the canonical
+ * accept/reject signal plus the full canonical projection (parsed
+ * claims, parser warnings, canonical error triple) so production
+ * callers can reproduce the canonical surface byte-equally without
+ * re-invoking `parseReceiptClaims`.
+ *
+ * Module is internal-only; not re-exported from
+ * `packages/protocol/src/index.ts`.
+ *
+ * SCOPE:
+ *   - Run `parseReceiptClaims(payload)` and surface its accept/reject.
+ *   - On acceptance: surface `wireVersion`, parsed `claims`, and
+ *     parser `warnings` (e.g., `type_unregistered`,
+ *     `unknown_extension_preserved`). Higher-layer aggregation merges
+ *     these into the caller's warning array.
+ *   - On rejection: surface the canonical error triple
+ *     (`errorCode`, `errorMessage`, `errorIssues`) so callers can
+ *     project the canonical `details: { parse_code, issues }` and
+ *     `message: 'Receipt schema validation failed: <message>'`
+ *     surface byte-equally.
+ */
+import type { ZodError } from 'zod';
+import type { VerificationWarning } from '@peac/kernel';
+import type { Wire02Claims } from '@peac/schema';
+export interface SchemaParseResult {
+    readonly accepted: boolean;
+    /**
+     * Canonical parse-error code from `parseReceiptClaims` when the
+     * parse rejects. Mirrors `pr.error.code`.
+     */
+    readonly errorCode?: string;
+    /**
+     * Canonical parse-error message from `parseReceiptClaims` when the
+     * parse rejects. Mirrors `pr.error.message`. Required for callers
+     * that reproduce the canonical surface message
+     * `Receipt schema validation failed: <message>` byte-equally.
+     */
+    readonly errorMessage?: string;
+    /**
+     * Canonical parse-error issues from `parseReceiptClaims` when the
+     * parse rejects. Mirrors `pr.error.issues`. Callers downstream
+     * apply their own bounded sanitization (path-join, length cap)
+     * before surfacing on a public verifier-result `details` payload.
+     */
+    readonly errorIssues?: ZodError['issues'];
+    /**
+     * Parsed Wire 0.2 claims when accepted. Internal-only; does not
+     * appear on any emitted record or public surface.
+     */
+    readonly claims?: Wire02Claims;
+    /**
+     * Wire version surfaced from `parseReceiptClaims` on acceptance.
+     * The bounded surface only admits `'0.2'`; Wire 0.1 acceptance from
+     * the canonical parser is rejected at this layer with
+     * `E_UNSUPPORTED_WIRE_VERSION` because the bounded composition is
+     * keyed on Wire 0.2 claim shapes.
+     */
+    readonly wireVersion?: '0.2';
+    /**
+     * Parser warnings surfaced on acceptance. Mirrors `pr.warnings` for
+     * Wire 0.2 acceptance. Callers that aggregate into a single
+     * canonical warning array merge this list at the canonical-equivalent
+     * flow position before the canonical sort.
+     */
+    readonly warnings?: readonly VerificationWarning[];
+}
+export declare function validateSchemaParseInternal(payload: unknown): SchemaParseResult;
+//# sourceMappingURL=schema-parse.d.ts.map

package/dist/_internal/record-core/validators/schema-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-parse.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/schema-parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACpD;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAuB/E"}

package/dist/_internal/record-core/validators/signature.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Bounded internal signature validator (canonical-composed).
+ *
+ * INTERNAL ONLY. Thin wrapper around `verify` from `@peac/crypto`.
+ * Surfaces the canonical Ed25519 signature-verification result
+ * projected into the bounded validator's accept/reject contract.
+ * The wrapper has no decision logic of its own and never re-implements
+ * Ed25519; it always delegates to the canonical signer/verifier.
+ *
+ * Module is observational only; not re-exported from
+ * `packages/protocol/src/index.ts` and not wired into the public
+ * runtime path.
+ *
+ * SCOPE:
+ *   - Run `verify(serialized, publicKey)` against the supplied compact JWS.
+ *   - On structural-format failure (CryptoError with a CRYPTO_* code),
+ *     surface the code unchanged.
+ *   - On signature mismatch, surface CRYPTO_INVALID_SIGNATURE.
+ *   - On success, accepted=true with no further claims projection.
+ *
+ * Out of scope:
+ *   - JOSE header hardening (handled by `jose-hardening.ts`).
+ *   - typ strictness routing (handled by `jose-typ-strictness.ts`).
+ *   - Schema parse on the verified payload (handled by `schema-parse.ts`).
+ */
+export interface SignatureResult {
+    readonly accepted: boolean;
+    readonly errorCode?: string;
+}
+export declare function validateSignatureInternal(serialized: string, publicKey: Uint8Array): Promise<SignatureResult>;
+//# sourceMappingURL=signature.d.ts.map

package/dist/_internal/record-core/validators/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/signature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,UAAU,GACpB,OAAO,CAAC,eAAe,CAAC,CAe1B"}

package/dist/_internal/record-core/validators/type-extension-enforcement.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Bounded internal type-extension-enforcement validator (canonical-composed).
+ *
+ * INTERNAL ONLY. Thin wrapper around `checkTypeExtensionMapping` from
+ * `@peac/protocol/src/type-extension-check` plus the strictness-mode
+ * routing performed by `verifyLocal`. Surfaces the canonical mapping
+ * result projected into the bounded validator's accept/reject and
+ * warning contract.
+ *
+ * Distinct from `type-extension-mapping.ts` (warnings-only) in this
+ * module's directory: this layer covers the strictness-mode path that
+ * promotes `missing` and `mismatch` to hard errors when
+ * `strictness === 'strict'`. Both layers consume the same canonical
+ * mapping result; they differ only in how they project it.
+ *
+ * Module is observational only; not re-exported from
+ * `packages/protocol/src/index.ts` and not wired into the public
+ * runtime path.
+ *
+ * SCOPE:
+ *   - `skip` -> accepted, no warning, no error.
+ *   - `ok` -> accepted, no warning, no error.
+ *   - `missing` + strict -> rejected with E_EXTENSION_GROUP_REQUIRED.
+ *   - `mismatch` + strict -> rejected with E_EXTENSION_GROUP_MISMATCH.
+ *   - `missing` + interop -> accepted with extension_group_missing warning at /type.
+ *   - `mismatch` + interop -> accepted with extension_group_mismatch warning at /type.
+ */
+import type { Strictness } from './jose-typ-strictness.js';
+export interface TypeExtensionEnforcementWarning {
+    readonly code: string;
+    readonly pointer: string;
+}
+export type TypeExtensionEnforcementResult = {
+    readonly accepted: true;
+    readonly warnings?: readonly TypeExtensionEnforcementWarning[];
+} | {
+    readonly accepted: false;
+    readonly errorCode: string;
+    readonly pointer?: string;
+};
+export declare function validateTypeExtensionEnforcementInternal(kind: string, type: string, extensions: Record<string, unknown> | undefined, strictness: Strictness): TypeExtensionEnforcementResult;
+//# sourceMappingURL=type-extension-enforcement.d.ts.map

package/dist/_internal/record-core/validators/type-extension-enforcement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-extension-enforcement.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/type-extension-enforcement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,8BAA8B,GACtC;IAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,+BAA+B,EAAE,CAAA;CAAE,GAC3F;IAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAIxF,wBAAgB,wCAAwC,CACtD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC/C,UAAU,EAAE,UAAU,GACrB,8BAA8B,CA0BhC"}

package/dist/_internal/record-core/validators/unknown-extension-grammar.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bounded internal unknown-extension-grammar validator (canonical-composed).
+ *
+ * INTERNAL ONLY. Thin wrapper around `isValidExtensionKey` and
+ * `REGISTERED_EXTENSION_GROUP_KEYS` from `@peac/schema`. Identifies
+ * unknown-but-well-formed extension keys and surfaces them as
+ * non-blocking warnings, mirroring the canonical
+ * `unknown_extension_preserved` warning emitted by `verifyLocal`.
+ *
+ * Malformed extension keys (failing `isValidExtensionKey`) are NOT
+ * surfaced here as warnings; they are hard errors at the canonical
+ * schema-parse layer (`E_INVALID_EXTENSION_KEY`) and therefore never
+ * reach this layer on an accepted record.
+ *
+ * Module is observational only; not re-exported from
+ * `packages/protocol/src/index.ts` and not wired into the public
+ * runtime path.
+ *
+ * SCOPE:
+ *   - Walk `claims.extensions` keys.
+ *   - For every key that is well-formed but not registered, emit a
+ *     warning with code `unknown_extension_preserved` and an
+ *     RFC 6901 JSON-pointer-encoded path.
+ *   - Always accepted; this layer never rejects.
+ *
+ * Out of scope:
+ *   - Malformed-key rejection (canonical schema-parse owns this).
+ *   - Per-extension content validation (extension-specific schemas).
+ */
+export interface UnknownExtensionWarning {
+    readonly code: string;
+    readonly pointer: string;
+}
+export interface UnknownExtensionGrammarResult {
+    readonly accepted: true;
+    readonly warnings: readonly UnknownExtensionWarning[];
+}
+export declare function validateUnknownExtensionGrammarInternal(extensions: Record<string, unknown> | undefined): UnknownExtensionGrammarResult;
+//# sourceMappingURL=unknown-extension-grammar.d.ts.map

package/dist/_internal/record-core/validators/unknown-extension-grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-extension-grammar.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/unknown-extension-grammar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACvD;AAeD,wBAAgB,uCAAuC,CACrD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC9C,6BAA6B,CAe/B"}

package/dist/_internal/test-helpers/candidate-runner.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Canonical-composed candidate-runner for parity tests.
+ *
+ * INTERNAL TEST HELPER. Wraps `runBoundedValidatorShadow` (the
+ * canonical-composed candidate validator) and projects its
+ * `BoundedValidationResult` into the same `ParityVerdict` shape that
+ * `canonical-runner` emits. The candidate-runner is the LEFT input to
+ * the canonical-vs-candidate differential test; the canonical-runner
+ * is the RIGHT input. Both produce verdicts; the differential test
+ * asserts byte-equality (or, where applicable, error-class
+ * equivalence).
+ *
+ * The candidate is canonical-composed by construction: every layer
+ * either delegates to a canonical helper from `@peac/schema` /
+ * `@peac/crypto` / `@peac/protocol`, or mirrors a canonical inline
+ * check verbatim. Divergence between canonical and candidate
+ * therefore indicates a defect in the bounded validator's projection
+ * logic, not a "different implementation disagreed."
+ *
+ * Pure: same input always yields the same verdict bytes.
+ */
+import { type ParityVerdict } from './parity-verdict.js';
+import type { CanonicalRunnerKind } from './canonical-runner.js';
+/**
+ * Run the canonical-composed candidate path on a Wire 0.2 envelope
+ * payload. Mirrors `runEnvelopeCanonical` shape-for-shape:
+ *
+ *   1. Kernel-constraints check via `runBoundedValidatorShadow`
+ *      (composes the parallel `validateKernelConstraintsInternal`).
+ *   2. Schema-parse projection (delegates to canonical
+ *      `parseReceiptClaims`).
+ *   3. Canonical claims digest on accepted records.
+ *
+ * Errors from bounded-validator are projected onto `ParityError`
+ * entries so the verdict shape is comparable byte-for-byte against
+ * `runEnvelopeCanonical`.
+ */
+export declare function runEnvelopeCandidate(payload: Record<string, unknown>): Promise<ParityVerdict>;
+/**
+ * Run the canonical-composed candidate JOSE-hardening path on a
+ * protected header. The bounded `validateJoseHardeningInternal`
+ * mirrors `validateWire02Header` from `@peac/crypto`; the candidate
+ * runner surfaces the same first-violation error code projected into
+ * the parity verdict shape.
+ */
+export declare function runJoseCandidate(header: Record<string, unknown> | undefined): ParityVerdict;
+/**
+ * Dispatch to the appropriate candidate runner by kind. Mirrors
+ * `runCanonicalForKind`. Always async so callers can uniformly await.
+ */
+export declare function runCandidateForKind(kind: CanonicalRunnerKind, input: Record<string, unknown>): Promise<ParityVerdict>;
+//# sourceMappingURL=candidate-runner.d.ts.map

package/dist/_internal/test-helpers/candidate-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-runner.d.ts","sourceRoot":"","sources":["../../../src/_internal/test-helpers/candidate-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACxF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAejE;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,aAAa,CAAC,CAsCxB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,aAAa,CAc3F;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,aAAa,CAAC,CAGxB"}