@peac/protocol 0.13.2 → 0.13.4

package/dist/index.cjs

@@ -311,6 +311,127 @@ function validateExtensionBudgetInternal(extensions) {
   if (violations.length === 0) return ACCEPTED4;
   return { accepted: false, violations };
 }
+function validateSchemaParseInternal(payload) {
+  const pr = schema.parseReceiptClaims(payload);
+  if (!pr.ok) {
+    return { accepted: false, errorCode: pr.error.code };
+  }
+  if (pr.wireVersion !== "0.2") {
+    return { accepted: false, errorCode: "E_UNSUPPORTED_WIRE_VERSION" };
+  }
+  return { accepted: true, claims: pr.claims };
+}
+
+// src/_internal/record-core/validators/jose-typ-strictness.ts
+var ACCEPTED_NO_WARN = { accepted: true };
+var ACCEPTED_TYP_MISSING = {
+  accepted: true,
+  warnings: [{ code: "typ_missing" }]
+};
+var REJECTED_INVALID_FORMAT = {
+  accepted: false,
+  errorCode: "E_INVALID_FORMAT"
+};
+function validateJoseTypStrictnessInternal(typ, strictness) {
+  const present = typeof typ === "string" && typ.length > 0;
+  if (present) return ACCEPTED_NO_WARN;
+  if (strictness === "strict") return REJECTED_INVALID_FORMAT;
+  return ACCEPTED_TYP_MISSING;
+}
+
+// src/_internal/record-core/validators/iat-not-yet-valid.ts
+var ACCEPTED5 = { accepted: true };
+var REJECTED2 = {
+  accepted: false,
+  errorCode: "E_NOT_YET_VALID"
+};
+function validateIatNotYetValidInternal(iat, now, maxClockSkew) {
+  if (iat > now + maxClockSkew) return REJECTED2;
+  return ACCEPTED5;
+}
+function validatePolicyBindingInternal(receiptPolicyDigest, localPolicyDigest) {
+  if (receiptPolicyDigest === void 0 || localPolicyDigest === void 0) {
+    return { accepted: true, status: "unavailable" };
+  }
+  const status = schema.verifyPolicyBinding(receiptPolicyDigest, localPolicyDigest);
+  if (status === "failed") {
+    return { accepted: false, errorCode: "E_POLICY_BINDING_FAILED", status };
+  }
+  return { accepted: true, status };
+}
+var ACCEPTED_EMPTY = {
+  accepted: true,
+  warnings: []
+};
+function escapeJsonPointer(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function validateUnknownExtensionGrammarInternal(extensions) {
+  if (extensions === void 0) return ACCEPTED_EMPTY;
+  const keys = Object.keys(extensions);
+  if (keys.length === 0) return ACCEPTED_EMPTY;
+  const warnings = [];
+  for (const key of keys) {
+    if (!schema.REGISTERED_EXTENSION_GROUP_KEYS.has(key) && schema.isValidExtensionKey(key)) {
+      warnings.push({
+        code: "unknown_extension_preserved",
+        pointer: `/extensions/${escapeJsonPointer(key)}`
+      });
+    }
+  }
+  return { accepted: true, warnings };
+}
+
+// src/type-extension-check.ts
+function checkTypeExtensionMapping(kind, type, extensions, typeToExtensionMap, registeredExtensionGroupKeys) {
+  if (kind === "challenge") {
+    return { status: "skip" };
+  }
+  const expectedGroup = typeToExtensionMap.get(type);
+  if (expectedGroup === void 0) {
+    return { status: "skip" };
+  }
+  if (extensions !== void 0 && Object.prototype.hasOwnProperty.call(extensions, expectedGroup)) {
+    return { status: "ok" };
+  }
+  const presentRegistered = [];
+  if (extensions !== void 0) {
+    for (const key of Object.keys(extensions)) {
+      if (key !== expectedGroup && registeredExtensionGroupKeys.has(key)) {
+        presentRegistered.push(key);
+      }
+    }
+  }
+  return {
+    status: presentRegistered.length > 0 ? "mismatch" : "missing",
+    expected_extension_group: expectedGroup,
+    present_registered_extension_groups: presentRegistered
+  };
+}
+
+// src/_internal/record-core/validators/type-extension-enforcement.ts
+var ACCEPTED_NO_WARN2 = { accepted: true };
+function validateTypeExtensionEnforcementInternal(kind, type, extensions, strictness) {
+  const result = checkTypeExtensionMapping(
+    kind,
+    type,
+    extensions,
+    kernel.TYPE_TO_EXTENSION_MAP,
+    schema.REGISTERED_EXTENSION_GROUP_KEYS
+  );
+  if (result.status === "ok" || result.status === "skip") {
+    return ACCEPTED_NO_WARN2;
+  }
+  if (strictness === "strict") {
+    const errorCode = result.status === "missing" ? "E_EXTENSION_GROUP_REQUIRED" : "E_EXTENSION_GROUP_MISMATCH";
+    return { accepted: false, errorCode, pointer: "/type" };
+  }
+  const warningCode = result.status === "missing" ? "extension_group_missing" : "extension_group_mismatch";
+  return {
+    accepted: true,
+    warnings: [{ code: warningCode, pointer: "/type" }]
+  };
+}
 
 // src/_internal/record-core/bounded-validator.ts
 function runBoundedValidatorShadow(input) {
@@ -370,6 +491,68 @@ function runBoundedValidatorShadow(input) {
       violations.push({ layer: "extension-budget", code: v.code, path: v.path });
     }
   }
+  if (input.fullClaims !== void 0) {
+    const schemaRes = validateSchemaParseInternal(input.fullClaims);
+    if (!schemaRes.accepted && schemaRes.errorCode !== void 0) {
+      violations.push({ layer: "schema-parse", code: schemaRes.errorCode });
+    }
+  }
+  if (input.header !== void 0 && input.strictness !== void 0) {
+    const typRes = validateJoseTypStrictnessInternal(input.header.typ, input.strictness);
+    if (!typRes.accepted) {
+      violations.push({ layer: "jose-typ-strictness", code: typRes.errorCode });
+    } else if (typRes.warnings) {
+      for (const w of typRes.warnings) {
+        warnings.push({ layer: "jose-typ-strictness", code: w.code });
+      }
+    }
+  }
+  if (input.maxClockSkew !== void 0) {
+    const iatRes = validateIatNotYetValidInternal(input.claims.iat, input.now, input.maxClockSkew);
+    if (!iatRes.accepted && iatRes.errorCode !== void 0) {
+      violations.push({ layer: "iat-not-yet-valid", code: iatRes.errorCode });
+    }
+  }
+  if (input.receiptPolicyDigest !== void 0 && input.localPolicyDigest !== void 0) {
+    const policyRes = validatePolicyBindingInternal(
+      input.receiptPolicyDigest,
+      input.localPolicyDigest
+    );
+    if (!policyRes.accepted && policyRes.errorCode !== void 0) {
+      violations.push({ layer: "policy-binding", code: policyRes.errorCode });
+    }
+  }
+  const unknownExtRes = validateUnknownExtensionGrammarInternal(input.claims.extensions);
+  for (const w of unknownExtRes.warnings) {
+    warnings.push({
+      layer: "unknown-extension-grammar",
+      code: w.code,
+      path: w.pointer
+    });
+  }
+  if (input.strictness !== void 0) {
+    const enforceRes = validateTypeExtensionEnforcementInternal(
+      input.claims.kind,
+      input.claims.type,
+      input.claims.extensions,
+      input.strictness
+    );
+    if (!enforceRes.accepted) {
+      violations.push({
+        layer: "type-extension-enforcement",
+        code: enforceRes.errorCode,
+        path: enforceRes.pointer
+      });
+    } else if (enforceRes.warnings) {
+      for (const w of enforceRes.warnings) {
+        warnings.push({
+          layer: "type-extension-enforcement",
+          code: w.code,
+          path: w.pointer
+        });
+      }
+    }
+  }
   return {
     accepted: violations.length === 0,
     violations,
@@ -595,6 +778,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 +996,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 +2111,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;
@@ -2052,33 +2246,6 @@ async function verifyReceipt(optionsOrJws) {
   }
 }
 
-// src/type-extension-check.ts
-function checkTypeExtensionMapping(kind, type, extensions, typeToExtensionMap, registeredExtensionGroupKeys) {
-  if (kind === "challenge") {
-    return { status: "skip" };
-  }
-  const expectedGroup = typeToExtensionMap.get(type);
-  if (expectedGroup === void 0) {
-    return { status: "skip" };
-  }
-  if (extensions !== void 0 && Object.prototype.hasOwnProperty.call(extensions, expectedGroup)) {
-    return { status: "ok" };
-  }
-  const presentRegistered = [];
-  if (extensions !== void 0) {
-    for (const key of Object.keys(extensions)) {
-      if (key !== expectedGroup && registeredExtensionGroupKeys.has(key)) {
-        presentRegistered.push(key);
-      }
-    }
-  }
-  return {
-    status: presentRegistered.length > 0 ? "mismatch" : "missing",
-    expected_extension_group: expectedGroup,
-    present_registered_extension_groups: presentRegistered
-  };
-}
-
 // src/_internal/record-core/shadow-hook.ts
 function maybeRunShadowValidation(input) {
   return void 0;
@@ -2110,6 +2277,7 @@ function sanitizeParseIssues(issues) {
   }));
 }
 async function verifyLocal(jws, publicKey, options = {}) {
+  void readLegacyPathFlag(options);
   const {
     issuer,
     subjectUri,