@peac/protocol 0.13.2 → 0.13.3

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/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"}

package/dist/index.cjs

@@ -595,6 +595,14 @@ function pruneStale() {
   while (SHADOW_LOG.length > 0 && SHADOW_LOG[0].timestamp < cutoffIso) SHADOW_LOG.shift();
 }
 
+// src/_internal/legacy-path.ts
+function readLegacyPathFlag(options) {
+  if (options?._internal?.legacyPath === true) return true;
+  if (typeof process === "undefined" || process === null) return false;
+  const env = process.env;
+  return env?.PEAC_INTERNAL_LEGACY_PATH === "1";
+}
+
 // src/_internal/shadow-observe.ts
 function realObservationForIssue() {
   return EMPTY_ACCEPTED;
@@ -805,6 +813,7 @@ async function issue(options) {
   return issueWire02(options);
 }
 async function issueWire02(options) {
+  void readLegacyPathFlag(options);
   if (!schema.isCanonicalIss(options.iss)) {
     throw new IssueError({
       code: "E_ISS_NOT_CANONICAL",
@@ -1919,6 +1928,8 @@ function jwkToPublicKey(jwk) {
   return new Uint8Array(xBytes);
 }
 async function verifyReceipt(optionsOrJws) {
+  const legacyPathOptions = typeof optionsOrJws === "string" ? void 0 : optionsOrJws;
+  void readLegacyPathFlag(legacyPathOptions);
   const receiptJws = typeof optionsOrJws === "string" ? optionsOrJws : optionsOrJws.receiptJws;
   const inputSnapshot = typeof optionsOrJws === "string" ? void 0 : optionsOrJws.subject_snapshot;
   const telemetry = typeof optionsOrJws === "string" ? void 0 : optionsOrJws.telemetry;
@@ -2110,6 +2121,7 @@ function sanitizeParseIssues(issues) {
   }));
 }
 async function verifyLocal(jws, publicKey, options = {}) {
+  void readLegacyPathFlag(options);
   const {
     issuer,
     subjectUri,