@peac/protocol 0.13.2 → 0.13.4

package/dist/_internal/legacy-path.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Internal rollback-path flag.
+ *
+ * INTERNAL ONLY. Both flag values currently use the same protocol path.
+ * The flag reader is exercised so rollback-path plumbing can be validated
+ * without changing public behavior.
+ *
+ * Public option types MUST NOT declare `_internal.legacyPath`; callers
+ * inside this package access the programmatic option only through
+ * internal casts. Flag identifiers are forbidden on the public TypeScript
+ * surface by `scripts/verify-dist-private-leaks.mjs` (Tier 1 + scoped
+ * runtime allowlist for `@peac/protocol` runtime files only) and by
+ * `scripts/verify-no-semantic-widening.mjs`.
+ */
+/**
+ * Programmatic-flag shape. Internal-only; never appears on any
+ * exported public option type. Mirrors the existing shadow-flag
+ * pattern at `_internal/shadow.ts` so the dist-leak gates and the
+ * semantic-widening gates apply uniformly.
+ *
+ * @internal
+ */
+export interface LegacyPathOptions {
+    readonly _internal?: {
+        readonly legacyPath?: boolean;
+    };
+}
+/**
+ * Read the rollback-path flag from environment or programmatic
+ * options. Read once per call, NOT cached at module scope, so tests
+ * can toggle the env var dynamically. Strict semantics: only the
+ * literal string `'1'` activates the flag, mirroring
+ * `PEAC_INTERNAL_SHADOW_CORE`.
+ *
+ * Environment access is guarded for browser / edge runtimes that do
+ * not expose `process`; the function never throws.
+ *
+ * Caller pattern at protocol hot paths:
+ *
+ *   void readLegacyPathFlag(options as unknown as LegacyPathOptions);
+ *
+ * The `void` discards the returned boolean intentionally: both flag
+ * values currently use the same protocol path, and the call exists
+ * so the read path is exercised.
+ *
+ * @internal
+ */
+export declare function readLegacyPathFlag(options?: LegacyPathOptions): boolean;
+//# sourceMappingURL=legacy-path.d.ts.map

package/dist/_internal/legacy-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-path.d.ts","sourceRoot":"","sources":["../../src/_internal/legacy-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAKvE"}

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/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,42 @@
+/**
+ * Bounded internal schema-parse validator (canonical-composed).
+ *
+ * INTERNAL ONLY. Thin wrapper around the canonical
+ * `parseReceiptClaims` from `@peac/schema`, projecting the canonical
+ * result into the bounded validator's normalized shape. The wrapper
+ * has no decision logic of its own: it delegates the parse, then
+ * surfaces the canonical accept/reject and the canonical error code.
+ *
+ * This is observational equivalence by construction, not a divergent
+ * parser. The layer boundary allows an alternate implementation
+ * without changing callers; the input/output shape is stable enough
+ * for a drop-in replacement should rigorous cross-implementation
+ * parity beyond observational evidence be required.
+ *
+ * Module is observational only; not re-exported from
+ * `packages/protocol/src/index.ts` and not wired into the public
+ * runtime path.
+ *
+ * SCOPE:
+ *   - Run `parseReceiptClaims(payload)` and surface its accept/reject.
+ *   - On rejection, surface `pr.error.code` (canonical parse-error code)
+ *     so the candidate's error taxonomy matches the canonical's.
+ *   - On acceptance, no warnings are surfaced from this layer; parser
+ *     warnings (e.g., `type_unregistered`, `unknown_extension_preserved`)
+ *     are emitted by the canonical parser and consumed at higher layers
+ *     (verifyLocal warning aggregation).
+ */
+import type { Wire02Claims } from '@peac/schema';
+export interface SchemaParseResult {
+    readonly accepted: boolean;
+    readonly errorCode?: string;
+    /**
+     * Parsed Wire 0.2 claims when accepted. Internal-only; does not
+     * appear on any emitted record or public surface. Callers that need
+     * a typed view of the parsed claims read this field; callers that
+     * only need the accept/reject signal ignore it.
+     */
+    readonly claims?: Wire02Claims;
+}
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;CAChC;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAS/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"}

package/dist/_internal/test-helpers/parity-verdict.d.ts

@@ -28,4 +28,39 @@ export declare function verdictKey(v: ParityVerdict): string;
  * encode digests). Example caller: corpus-canonical-truth sanity test.
  */
 export declare function verdictKeyShape(v: ParityVerdict): string;
+/**
+ * Stringify a ParityVerdict using error-class-equivalent semantics.
+ *
+ * Encodes ONLY:
+ *   - `accepted` boolean
+ *   - sorted error-code MULTISET preserving counts
+ *
+ * Ignores:
+ *   - error path
+ *   - warnings (codes and paths)
+ *   - canonicalClaimsDigest
+ *   - any other field
+ *
+ * Does NOT dedupe duplicate codes. Two errors emitted with the same
+ * `code` are encoded as two entries; this preserves multiset semantics
+ * because duplicate counts may carry meaningful diagnostic signal that
+ * dedup would erase.
+ *
+ * Use for diagnostic overlap comparisons where the goal is to assert
+ * agreement on what error CLASS was raised, independent of where it
+ * was emitted, what message it carried, or what warnings accompanied
+ * it. Path comparison is intentionally too strict for this gate;
+ * callers needing path-aware comparison should use `verdictKey` or
+ * `verdictKeyShape`.
+ *
+ * NOTE on input construction: `makeVerdict()` deduplicates errors by
+ * `(code, path)` before normalization. To preserve a true multiset of
+ * same-code entries through `verdictKeyErrorClass`, callers MUST
+ * construct the `ParityVerdict` literally (without `makeVerdict`) or
+ * supply errors with distinct `path` values that survive dedup. The
+ * function operates on the verdict's `.errors` array as given; it is
+ * the caller's responsibility to ensure that array carries the
+ * intended multiset shape.
+ */
+export declare function verdictKeyErrorClass(v: ParityVerdict): string;
 //# sourceMappingURL=parity-verdict.d.ts.map

package/dist/_internal/test-helpers/parity-verdict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parity-verdict.d.ts","sourceRoot":"","sources":["../../../src/_internal/test-helpers/parity-verdict.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAEpG,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC;AAwB1D;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,OAAO,EACjB,MAAM,GAAE,WAAW,EAAO,EAC1B,QAAQ,GAAE,aAAa,EAAO,EAC9B,qBAAqB,CAAC,EAAE,MAAM,GAC7B,aAAa,CAUf;AAgBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAMnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAExD"}
+{"version":3,"file":"parity-verdict.d.ts","sourceRoot":"","sources":["../../../src/_internal/test-helpers/parity-verdict.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAEpG,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC;AAwB1D;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,OAAO,EACjB,MAAM,GAAE,WAAW,EAAO,EAC1B,QAAQ,GAAE,aAAa,EAAO,EAC9B,qBAAqB,CAAC,EAAE,MAAM,GAC7B,aAAa,CAUf;AAgBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAMnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAExD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAO7D"}