@peac/protocol 0.13.0 → 0.13.2

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

@@ -0,0 +1,50 @@
+/**
+ * Bounded internal temporal validator (occurred_at skew only).
+ *
+ * INTERNAL ONLY. This is the parity-observed counterpart of
+ * @peac/schema.checkOccurredAtSkew (referenced by verify-local.ts when
+ * claims.kind === 'evidence'). Both implementations consume the same
+ * OCCURRED_AT_TOLERANCE_SECONDS constant from @peac/kernel and apply
+ * the same skew classification rules in the same order; behavioral
+ * parity is proven byte-equal by the parity tests, not by code copy.
+ *
+ * Existing canonical checkOccurredAtSkew in @peac/schema remains
+ * canonical. This module is observational only; it is NOT re-exported
+ * from packages/protocol/src/index.ts and is NOT wired into runtime
+ * paths (issue.ts, verify-local.ts) in v0.13.1.
+ *
+ * SCOPE (deliberately narrow):
+ *   - occurred_at canonical skew classification ONLY
+ *   - the iat-not-yet-valid check (`iat > now + maxClockSkew`) lives
+ *     inline at verify-local.ts:454 with no helper to import; wrapping
+ *     it would make LEFT and RIGHT identical 1-line predicates that
+ *     prove nothing, so it is explicitly deferred to a later step
+ *     (extraction first, parity second)
+ *
+ * Rules (must mirror checkOccurredAtSkew exactly; evidence-kind-only
+ * is the caller's responsibility):
+ *   1. occurredAt undefined -> accepted, no warning
+ *   2. parse occurredAt as ISO/RFC 3339; if NaN -> accepted, no warning
+ *      (the parse failure surfaces from schema validation elsewhere)
+ *   3. ts > now + tolerance -> rejected with E_OCCURRED_AT_FUTURE
+ *   4. ts > iat (within tolerance) -> accepted with occurred_at_skew
+ *      warning at pointer /occurred_at
+ *   5. ts <= iat -> accepted, no warning
+ *
+ * The injected `now` parameter is required; this module never reads
+ * Date.now() so tests are deterministic.
+ */
+export interface TemporalWarning {
+    readonly code: string;
+    readonly pointer?: string;
+}
+export type TemporalResult = {
+    readonly accepted: true;
+    readonly warnings?: readonly TemporalWarning[];
+} | {
+    readonly accepted: false;
+    readonly errorCode: string;
+    readonly pointer?: string;
+};
+export declare function validateTemporalInternal(occurredAt: string | undefined, iat: number, now: number, tolerance?: number): TemporalResult;
+//# sourceMappingURL=temporal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/temporal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAIH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,GAC3E;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,wBAAwB,CACtC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,SAAS,GAAE,MAAsC,GAChD,cAAc,CAsBhB"}

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

@@ -0,0 +1,51 @@
+/**
+ * Bounded internal type-extension mapping validator.
+ *
+ * INTERNAL ONLY. This is the parity-observed counterpart of the
+ * type/extension warning-emission block at verify-local.ts:477-540
+ * (interop strictness branch). Both implementations consume the same
+ * registries (REGISTERED_RECEIPT_TYPES, REGISTERED_EXTENSION_GROUP_KEYS,
+ * TYPE_TO_EXTENSION_MAP) and the same warning-code constants from
+ * @peac/schema; behavioral parity is proven byte-equal by the parity
+ * tests, not by code copy.
+ *
+ * Existing canonical emission in @peac/protocol/verifyLocal remains
+ * canonical. This module is observational only; it is NOT re-exported
+ * from packages/protocol/src/index.ts and is NOT wired into runtime
+ * paths (issue.ts, verify-local.ts) in v0.13.1.
+ *
+ * Output shape: a deterministically-ordered list of warning records,
+ * each carrying only `code` and `pointer`. The canonical emission also
+ * carries a `message` field; messages are intentionally omitted from
+ * the parity comparison because the missing/mismatch messages embed
+ * claim values (claims.type and the expected extension group), and
+ * comparison on (code, pointer) is what the verifier output API
+ * actually exposes to consumers via the warning code/pointer pair.
+ *
+ * Emission order (must mirror verify-local.ts exactly; tests assert):
+ *   1. type_unregistered (when claims.type is not in REGISTERED_RECEIPT_TYPES)
+ *   2. unknown_extension_preserved (one per unknown-but-well-formed
+ *      extension key, in Object.keys iteration order)
+ *   3. extension_group_missing OR extension_group_mismatch (when
+ *      checkTypeExtensionMapping returns missing/mismatch; not emitted
+ *      for kind === 'challenge' or for unmapped/custom types)
+ */
+/** Minimal claims shape required by the type-extension warning surface. */
+export interface TypeExtensionMappingInput {
+    readonly kind: string;
+    readonly type: string;
+    readonly extensions?: Record<string, unknown>;
+}
+/** Normalized warning entry. Comparison shape; canonical messages omitted. */
+export interface TypeExtensionMappingWarning {
+    readonly code: string;
+    readonly pointer: string;
+}
+/**
+ * Evaluate the type-extension mapping warning surface for parsed Wire 0.2
+ * claims. Returns warnings in canonical emission order; emits no warnings
+ * when the claims are fully registered and the expected extension group
+ * is present (or when no expected group exists for the given type).
+ */
+export declare function validateTypeExtensionMappingInternal(input: TypeExtensionMappingInput): TypeExtensionMappingWarning[];
+//# sourceMappingURL=type-extension-mapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-extension-mapping.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/type-extension-mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAaH,2EAA2E;AAC3E,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/C;AAED,8EAA8E;AAC9E,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAiCD;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,yBAAyB,GAC/B,2BAA2B,EAAE,CA6B/B"}

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

@@ -0,0 +1,42 @@
+/**
+ * Internal validator types for the bounded shadow-mode validator foundation.
+ *
+ * INTERNAL ONLY. These names MUST NOT appear in any emitted .d.ts file from
+ * the published @peac/protocol package. Enforced by Tier 2 + Tier 2b
+ * dist-leak gates in scripts/verify-dist-private-leaks.mjs.
+ */
+/**
+ * Stable, normalized verdict shape for parity comparison between two
+ * validators. The differential harness compares JCS-canonicalized JSON
+ * forms of two verdicts; raw exception messages, raw Zod issues, raw
+ * stack traces, and object key order are NEVER compared.
+ */
+export interface ParityVerdict {
+    /** Did the validator accept the input? */
+    readonly accepted: boolean;
+    /** Normalized error codes; sorted by code then path; deduplicated. */
+    readonly errors: readonly ParityError[];
+    /** Normalized warning codes; sorted by code then path; deduplicated. */
+    readonly warnings: readonly ParityWarning[];
+    /**
+     * SHA-256 hex of the JCS-canonicalized accepted claims object. Present
+     * only when accepted is true. Asserts canonical-claims agreement, not
+     * just accept/reject agreement.
+     */
+    readonly canonicalClaimsDigest?: string;
+}
+/** Normalized error entry. `code` is a canonical identifier. */
+export interface ParityError {
+    /** Canonical error code (e.g., from @peac/kernel/errors). */
+    readonly code: string;
+    /** Stable JSON-pointer-like path. Omitted when not applicable. */
+    readonly path?: string;
+}
+/** Normalized warning entry. `code` is a canonical identifier. */
+export interface ParityWarning {
+    /** Canonical warning code (e.g., from @peac/schema/wire-02-warnings). */
+    readonly code: string;
+    /** Stable JSON-pointer-like path. Omitted when not applicable. */
+    readonly path?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/_internal/record-core/validators/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC;AAED,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,kEAAkE;AAClE,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/_internal/shadow-observe.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Normalized internal observation shape for shadow-vs-real comparison.
+ *
+ * @internal
+ *
+ * INTERNAL ONLY. Not re-exported from packages/protocol/src/index.ts.
+ *
+ * The shadow scheduler compares real-path and shadow-path results via
+ * canonical hashes. To make that comparison meaningful (not just an
+ * accept/reject boolean) and free of false positives, both sides
+ * project onto the SAME stable normalized `ShadowObservation` shape
+ * before the hash:
+ *
+ *   - `accepted`: did the validator accept the input?
+ *   - `violationCodes`: sorted, deduplicated registered error codes.
+ *   - `warningCodes`: sorted, deduplicated registered warning codes.
+ *
+ * Layer-tag metadata is intentionally NOT part of the comparable
+ * shape. The bounded validator emits per-layer tags; the canonical
+ * Zod path does not. Including them would cause a hash divergence
+ * even on full functional agreement, masking true divergence as
+ * noise.
+ *
+ * Issue path projection:
+ *
+ *   `IssueResult` does not expose warning codes; canonical issuance
+ *   either succeeds (and surfaces no warnings to the caller) or
+ *   throws. To prevent the bounded validator's warnings from
+ *   producing false `output-byte-diff` records on a successful
+ *   issuance, the issue-side comparison runs in ACCEPTED-ONLY mode:
+ *   `warningCodes` is projected to `[]` on BOTH sides.
+ *
+ * VerifyLocal success path projection:
+ *
+ *   `VerifyLocalSuccess` exposes a `warnings` array of registered
+ *   warning codes. The verifyLocal-side comparison includes
+ *   `warningCodes` from both sides (canonical surfaces them
+ *   directly; the bounded validator's warningCodes are mapped from
+ *   `BoundedWarning.code`).
+ */
+import type { BoundedValidationResult } from './record-core/bounded-validator.js';
+/**
+ * Canonical observation projected from either the real path or the
+ * shadow path.
+ *
+ * @internal
+ */
+export interface ShadowObservation {
+    readonly accepted: boolean;
+    /** Registered error codes, sorted, deduplicated. */
+    readonly violationCodes: readonly string[];
+    /** Registered warning codes, sorted, deduplicated. */
+    readonly warningCodes: readonly string[];
+}
+/**
+ * Real-path observation for a successful `issue()` call. Always
+ * projects to the empty accepted-only shape; canonical issuance
+ * surfaces no warning codes through `IssueResult`.
+ *
+ * @internal
+ */
+export declare function realObservationForIssue(): ShadowObservation;
+/**
+ * Real-path observation for a successful `verifyLocal()` call. Maps
+ * the canonical `warnings: VerificationWarning[]` array onto the
+ * normalized warningCodes set.
+ *
+ * @internal
+ */
+export declare function realObservationForVerifyLocalSuccess(warnings: readonly {
+    code: string;
+}[] | undefined): ShadowObservation;
+/**
+ * Project a `BoundedValidationResult` into the shared observation
+ * shape with full warning-code parity. Use on the verifyLocal path
+ * where canonical exposes warning codes through
+ * `VerifyLocalSuccess.warnings`.
+ *
+ * @internal
+ */
+export declare function shadowObservationFromBounded(bounded: BoundedValidationResult): ShadowObservation;
+/**
+ * Project a `BoundedValidationResult` into the shared observation
+ * shape with `warningCodes` flattened to `[]`. Use on the issue path
+ * where canonical issuance does not surface warning codes through
+ * `IssueResult`. Without this projection the bounded validator's
+ * type-extension or temporal warnings would create false
+ * `output-byte-diff` records on every otherwise-successful issuance.
+ *
+ * @internal
+ */
+export declare function shadowObservationFromBoundedAcceptedOnly(bounded: BoundedValidationResult): ShadowObservation;
+//# sourceMappingURL=shadow-observe.d.ts.map

package/dist/_internal/shadow-observe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-observe.d.ts","sourceRoot":"","sources":["../../src/_internal/shadow-observe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAElF;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,sDAAsD;IACtD,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,SAAS,GAChD,iBAAiB,CAOnB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,uBAAuB,GAAG,iBAAiB,CAMhG;AAED;;;;;;;;;GASG;AACH,wBAAgB,wCAAwC,CACtD,OAAO,EAAE,uBAAuB,GAC/B,iBAAiB,CAMnB"}

package/dist/_internal/shadow-redact.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Shadow-mode telemetry redaction and canonical hashing.
+ *
+ * @internal
+ *
+ * INTERNAL ONLY. Not re-exported from packages/protocol/src/index.ts.
+ *
+ * Two responsibilities:
+ *
+ *   1. `redactNote(input, maxBytes)`: scrub known secret classes from
+ *      a free-form string and bound it to a UTF-8 byte ceiling. Used
+ *      for the `notes` field on every shadow divergence record so
+ *      that an accidental string concatenation cannot leak credential
+ *      material into the in-memory shadow log.
+ *
+ *   2. `canonicalHashOf(value)` / `hashJws(jws)`: produce a SHA-256
+ *      hex digest of a canonicalized representation. Used as the
+ *      comparison primitive between real-path and shadow-path results
+ *      so the divergence log never needs to store raw output.
+ *
+ * SECRET_PATTERNS is the ground-truth contract for what counts as a
+ * leakable secret class. Adding a regex here REQUIRES a paired
+ * adversarial test vector in shadow-redact-adversarial.test.ts (one
+ * matching vector + one adjacent benign-not-matched vector). Removing
+ * a regex here REQUIRES the same justification.
+ *
+ * Platform neutrality: this module avoids Node-only globals (`Buffer`,
+ * `node:crypto`) so it can ship inside the platform-neutral
+ * @peac/protocol bundle. UTF-8 byte work uses TextEncoder/TextDecoder;
+ * SHA-256 hashing delegates to @peac/crypto.sha256Hex which uses the
+ * Web Crypto API with a dynamic Node fallback.
+ */
+/**
+ * UTF-8 byte length of a string. Platform-neutral replacement for
+ * `Buffer.byteLength(s, 'utf8')`.
+ *
+ * @internal
+ */
+export declare function utf8ByteLength(value: string): number;
+/**
+ * Redact known secret classes from `input` and bound the result to
+ * `maxBytes` UTF-8 bytes. The output always either matches the input
+ * (when no secret was found and the byte budget permits) or contains
+ * the `[REDACTED]` marker.
+ *
+ * Truncation is byte-aware so multibyte UTF-8 sequences are not split
+ * mid-character. When the redacted string exceeds `maxBytes`, the
+ * tail is replaced with the marker.
+ *
+ * @internal
+ */
+export declare function redactNote(input: string, maxBytes: number): string;
+/**
+ * SHA-256 hex digest of a canonical-stringified value. Used by the
+ * shadow comparator to detect output-byte-diff WITHOUT logging raw
+ * content. Object keys are sorted recursively so equivalent objects
+ * with different key orders produce identical digests.
+ *
+ * Async because SHA-256 hashing in this codebase is platform-neutral
+ * via @peac/crypto.sha256Hex (Web Crypto API with dynamic Node
+ * fallback). Callers run inside the shadow scheduler's microtask /
+ * macrotask boundary, so an additional await is free.
+ *
+ * @internal
+ */
+export declare function canonicalHashOf(value: unknown): Promise<string>;
+/**
+ * SHA-256 hex digest of a JWS string. Used as the primary
+ * `recordRefHash` input for divergence records.
+ *
+ * @internal
+ */
+export declare function hashJws(jws: string): Promise<string>;
+//# sourceMappingURL=shadow-redact.d.ts.map

package/dist/_internal/shadow-redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-redact.d.ts","sourceRoot":"","sources":["../../src/_internal/shadow-redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAuEH;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiBlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAErE;AAED;;;;;GAKG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE1D"}

package/dist/_internal/shadow-types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shadow-mode divergence types.
+ *
+ * @internal
+ *
+ * INTERNAL ONLY. Not re-exported from packages/protocol/src/index.ts.
+ * The dist-leak Tier 2 (.d.ts) and Tier 2b (runtime-export) gates
+ * assert these names never appear in any public emitted file.
+ *
+ * Divergence records describe the difference between the canonical
+ * (real-path) result of a public call and a shadow-path result. They
+ * NEVER carry raw secret material, raw error messages, raw payloads,
+ * or stringified results. All comparison is done via canonical hashes
+ * (SHA-256 over a canonical-stringified value); all error reporting is
+ * done via registered error codes (not message text); all free-form
+ * notes are bounded and redacted before storage.
+ */
+/**
+ * The class of divergence between real-path and shadow-path results.
+ *
+ * @internal
+ */
+export type ShadowDivergenceKind = 'output-byte-diff' | 'error-code-diff' | 'timing-diff' | 'resource-limit-diff' | 'shadow-error';
+/**
+ * Which public call produced this divergence record.
+ *
+ * @internal
+ */
+export type ShadowCall = 'issue' | 'verifyLocal' | 'verify';
+/**
+ * A single divergence record. Fields are intentionally narrow:
+ *
+ *   - hashes (SHA-256 hex of canonicalized values), never raw values;
+ *   - error codes (registered identifiers), never message text;
+ *   - byte lengths (counts), never payload contents;
+ *   - notes (short category labels, ≤128 bytes, redaction-marked).
+ *
+ * @internal
+ */
+export interface ShadowDivergence {
+    readonly kind: ShadowDivergenceKind;
+    readonly call: ShadowCall;
+    /** SHA-256 hex of the recordRef (e.g., the produced JWS). Never the raw ref. */
+    readonly recordRefHash: string;
+    /** SHA-256 hex of the canonical real-path result, when defined. */
+    readonly realResultHash?: string;
+    /** SHA-256 hex of the canonical shadow-path result, when defined. */
+    readonly shadowResultHash?: string;
+    /** Registered error code from the real-path failure, when present. */
+    readonly realErrorCode?: string;
+    /** Registered error code from the shadow-path failure, when present. */
+    readonly shadowErrorCode?: string;
+    /** Byte length of the real-path result. */
+    readonly realByteLen?: number;
+    /** Byte length of the shadow-path result. */
+    readonly shadowByteLen?: number;
+    /** Short category label, ≤128 bytes, redaction-marked. */
+    readonly notes: string;
+    /** ISO 8601 UTC timestamp. */
+    readonly timestamp: string;
+}
+//# sourceMappingURL=shadow-types.d.ts.map

package/dist/_internal/shadow-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-types.d.ts","sourceRoot":"","sources":["../../src/_internal/shadow-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAC5B,kBAAkB,GAClB,iBAAiB,GACjB,aAAa,GACb,qBAAqB,GACrB,cAAc,CAAC;AAEnB;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,aAAa,GAAG,QAAQ,CAAC;AAE5D;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,qEAAqE;IACrE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,wEAAwE;IACxE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,2CAA2C;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,6CAA6C;IAC7C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B"}

package/dist/_internal/shadow.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Shadow-mode scheduler.
+ *
+ * @internal
+ *
+ * INTERNAL ONLY. Not re-exported from packages/protocol/src/index.ts.
+ *
+ * Schedules a shadow function to run AFTER the public-call boundary
+ * has returned its real-path result to the caller. The shadow run:
+ *
+ *   - is gated by `isShadowEnabled(options)` (env or programmatic);
+ *   - starts on a MACROTASK boundary (`setTimeout(..., 0)`), NOT on a
+ *     microtask, because microtasks can run before promise
+ *     continuations attached to the public async call and would still
+ *     add observable latency for CPU-heavy shadow work;
+ *   - has a bounded wall-clock REPORTING timeout (250ms by default;
+ *     see "Timeout guarantee class" below);
+ *   - reports comparison results into a bounded in-memory log;
+ *   - SWALLOWS every error, never propagating to the real-path return
+ *     value or surfacing as an unhandled-rejection event.
+ *
+ * The public function:
+ *
+ *   - returns the real-path value FIRST (the macrotask boundary is
+ *     past every async continuation already attached to the call
+ *     site);
+ *   - never awaits shadow work;
+ *   - is byte-identical in its return value with shadow ON vs OFF.
+ *
+ * Timeout guarantee class. The 250ms timeout is a REPORTING bound,
+ * not a hard preemption guarantee. Where the shadow function consults
+ * the supplied `AbortSignal`, the runner aborts and bounds CPU; where
+ * the shadow function is pure-CPU and ignores the signal (the v0.13.1
+ * record-core validators are this shape), JavaScript cannot preempt
+ * it. The runner stops awaiting and records `timing-diff`; the work
+ * may continue to completion off the runner's await chain. Either
+ * way, the public-call boundary returns its real-path value
+ * immediately.
+ *
+ * Test-only helpers (`_peekShadowLog`, `_resetShadowLog`,
+ * `_drainShadowQueueForTests`) are exposed for deterministic
+ * assertions in vitest. Production code MUST NOT call them.
+ *
+ * Platform neutrality: this module avoids Node-only globals
+ * (`Buffer`, `node:crypto`, unguarded `process`). Hashing delegates
+ * to @peac/crypto; environment reads guard for the absence of
+ * `process` so the module loads cleanly under browser / edge
+ * runtimes.
+ */
+import type { ShadowCall, ShadowDivergence } from './shadow-types.js';
+/**
+ * Programmatic-flag shape. Internal-only; never appears in any
+ * exported public option type.
+ *
+ * @internal
+ */
+export interface ShadowEnableOptions {
+    readonly _internal?: {
+        readonly shadowCore?: boolean;
+    };
+}
+/**
+ * Read the shadow-enable flag from environment or programmatic
+ * options. Read once per call, NOT cached at module scope, so tests
+ * can toggle the env var dynamically. Environment access is guarded
+ * for browser / edge runtimes that do not expose `process`.
+ *
+ * @internal
+ */
+export declare function isShadowEnabled(options?: ShadowEnableOptions): boolean;
+/**
+ * Inputs to `scheduleShadow`. The `shadowFn` factory receives an
+ * `AbortSignal` so cancellable implementations can opt in. v0.13.1
+ * shadow paths are pure-CPU and ignore the signal; the runner still
+ * passes one for forward-compat.
+ *
+ * @internal
+ */
+export interface ScheduleShadowArgs<T> {
+    readonly call: ShadowCall;
+    readonly realResult: T | undefined;
+    readonly realError: {
+        code?: string;
+    } | undefined;
+    readonly shadowFn: (signal?: AbortSignal) => Promise<T>;
+    readonly recordRef: string;
+}
+/**
+ * Schedule shadow work AFTER the real-path return.
+ *
+ * The shadow run starts on the next MACROTASK boundary (via
+ * `setTimeout(..., 0)`). The public function returns its real-path
+ * value before the macrotask fires, including for async callers
+ * whose `.then` / `await` continuations execute on microtasks.
+ * `queueMicrotask` would interleave with those continuations and is
+ * intentionally avoided.
+ *
+ * Tasks are tracked internally so test helpers can drain them for
+ * deterministic assertions; production callers ignore the (void)
+ * return.
+ *
+ * Failures inside the shadow path are converted to divergence records
+ * inside the task body. The outer `task.catch(() => {})` is defense
+ * in depth: if anything inside `runShadowTask` throws after the inner
+ * try/catch (e.g., a hash failure during canonical comparison), the
+ * outer catch swallows the rejection so no unhandled-rejection event
+ * fires.
+ *
+ * @internal
+ */
+export declare function scheduleShadow<T>(args: ScheduleShadowArgs<T>): void;
+/**
+ * Read the in-memory shadow log without mutating it. TEST USE ONLY.
+ *
+ * @internal
+ */
+export declare function _peekShadowLog(): readonly ShadowDivergence[];
+/**
+ * Clear the in-memory shadow log. TEST USE ONLY.
+ *
+ * @internal
+ */
+export declare function _resetShadowLog(): void;
+/**
+ * Drain the pending-shadow-tasks set so deterministic assertions can
+ * run after a sequence of shadow-enabled calls. Yields to the event
+ * loop until every scheduled `setTimeout` has fired AND every
+ * resulting task has settled. TEST USE ONLY. Production code MUST
+ * NOT call this.
+ *
+ * @internal
+ */
+export declare function _drainShadowQueueForTests(): Promise<void>;
+//# sourceMappingURL=shadow.d.ts.map

package/dist/_internal/shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow.d.ts","sourceRoot":"","sources":["../../src/_internal/shadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAYtE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAGtE;AAQD;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,IAAI,CAiBnE;AAyHD;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,SAAS,gBAAgB,EAAE,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAU/D"}

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

@@ -0,0 +1,43 @@
+/**
+ * Canonical-path runner for parity tests.
+ *
+ * INTERNAL TEST HELPER. Wraps the existing canonical validator path
+ * (validateKernelConstraints + parseReceiptClaims for envelope; or
+ * validateWire02Header for JOSE) and returns a normalized ParityVerdict.
+ *
+ * Used by both the canonical-truth sanity test and the differential
+ * harness. Pure: same input always yields the same verdict bytes.
+ */
+import { type ParityVerdict } from './parity-verdict.js';
+/** Kind of canonical runner to dispatch to. */
+export type CanonicalRunnerKind = 'envelope' | 'jose';
+/**
+ * Run JOSE-hardening canonical path on a JOSE protected header. Returns
+ * accepted=true if the header passes validateWire02Header, accepted=false
+ * with the CryptoError code on rejection.
+ */
+export declare function runJoseCanonical(header: Record<string, unknown> | undefined): ParityVerdict;
+/**
+ * Run Wire 0.2 envelope canonical path on parsed claims. Layer 1 only:
+ * kernel constraints (depth / total nodes / key counts) followed by Zod
+ * schema parse. Type-extension warnings live at Layer 3 (verifyLocal)
+ * and are intentionally out of scope for the parity foundation.
+ *
+ * Accepted records carry canonicalClaimsDigest computed from the parsed
+ * claims via JCS + SHA-256 + "sha256:" prefix. This anchors the verdict
+ * to the canonical normalized claims, not just the accept/reject bit:
+ * two validators that both accept but disagree on parsed/normalized
+ * claims will produce different digests and the harness will catch it.
+ */
+export declare function runEnvelopeCanonical(payload: Record<string, unknown>): Promise<ParityVerdict>;
+/**
+ * Dispatch to the appropriate canonical runner by kind.
+ *
+ *   kind === 'jose'     → runJoseCanonical(input as header)   (sync)
+ *   kind === 'envelope' → runEnvelopeCanonical(input as payload) (async)
+ *
+ * The dispatcher always returns a Promise so callers can uniformly
+ * await regardless of kind.
+ */
+export declare function runCanonicalForKind(kind: CanonicalRunnerKind, input: Record<string, unknown>): Promise<ParityVerdict>;
+//# sourceMappingURL=canonical-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-runner.d.ts","sourceRoot":"","sources":["../../../src/_internal/test-helpers/canonical-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAmBxF,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,aAAa,CAY3F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,aAAa,CAAC,CAmBxB;AAED;;;;;;;;GAQG;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/corpus-loader.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Parity corpus loader.
+ *
+ * INTERNAL TEST HELPER. Loads parity-corpus families under
+ * specs/conformance/parity-corpus/ and validates each family's vectors.json
+ * against its vectors.schema.json (JSON Schema 2020-12) using ajv strict +
+ * ajv-formats.
+ *
+ * Used by the differential harness in __tests__/_internal/. Not exported
+ * from packages/protocol/src/index.ts. Not part of the published surface.
+ */
+/** Canonical family identifiers shipped at the v0.13.1 floor. */
+export declare const PARITY_FAMILIES: readonly ["default-flows", "jose-hardening", "runtime-governance", "commerce-bridges"];
+export type ParityFamily = (typeof PARITY_FAMILIES)[number];
+/** Floor vector counts per family (per plan amendment §0S.5). */
+export declare const PARITY_FLOOR_COUNTS: Readonly<Record<ParityFamily, number>>;
+export interface ParityVectorInput {
+    readonly payload: Record<string, unknown>;
+    readonly header?: Record<string, unknown>;
+}
+export interface ParityVectorExpected {
+    readonly accepted: boolean;
+    readonly errors?: ReadonlyArray<{
+        readonly code: string;
+        readonly path?: string;
+    }>;
+    readonly warnings?: ReadonlyArray<{
+        readonly code: string;
+        readonly path?: string;
+    }>;
+}
+export interface ParityVector {
+    readonly id: string;
+    readonly description: string;
+    readonly input: ParityVectorInput;
+    readonly expected: ParityVectorExpected;
+}
+export interface ParityCorpusFamily {
+    readonly family: ParityFamily;
+    readonly description: string;
+    readonly version: string;
+    readonly generator?: string;
+    readonly vectors: ReadonlyArray<ParityVector>;
+}
+/**
+ * Resolve the parity-corpus root directory.
+ *
+ * Walks up from `process.cwd()` looking for `specs/conformance/parity-corpus/`.
+ * Works whether tests run from the repo root or from any package directory.
+ * Override allowed via the optional argument.
+ */
+export declare function resolveCorpusRoot(override?: string): string;
+/**
+ * Load and schema-validate one parity family. Throws an Error with a
+ * structured message if the family's vectors.json does not match its
+ * vectors.schema.json or if the floor count is not met.
+ */
+export declare function loadFamily(family: ParityFamily, corpusRoot?: string): ParityCorpusFamily;
+/** Load all four families. Returns them in declared family order. */
+export declare function loadAllFamilies(corpusRoot?: string): ReadonlyArray<ParityCorpusFamily>;
+//# sourceMappingURL=corpus-loader.d.ts.map

package/dist/_internal/test-helpers/corpus-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corpus-loader.d.ts","sourceRoot":"","sources":["../../../src/_internal/test-helpers/corpus-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,iEAAiE;AACjE,eAAO,MAAM,eAAe,wFAKlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAKtE,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnF,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtF;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;CAC/C;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAc3D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAuCxF;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAEtF"}