agent-passport-system 7.2.0 → 8.0.0

package/dist/src/v2/payment-rails/cycles/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2/payment-rails/cycles/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2/payment-rails/cycles/index.ts"],"names":[],"mappings":"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"}

package/dist/src/v2/payment-rails/cycles/index.js

@@ -79,7 +79,7 @@ import { publicKeyFromPrivate, sign, verify as edVerify } from '../../../crypto/
 import { parseDidUri, publicKeyHexFromMethod, resolveVerificationMethod, } from '../../../core/did-uri.js';
 import { RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, RAIL_BUDGET_RESERVATION_DENIAL_CLAIM_TYPE, } from './types.js';
 export { CYCLES_PROTOCOL_VERSION, CYCLES_EVIDENCE_SCHEMA_VERSION, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, RAIL_BUDGET_RESERVATION_DENIAL_CLAIM_TYPE, } from './types.js';
-import { resolveEvidenceRef, toEvidenceDescriptorInput, } from './evidence-resolution.js';
+import { readEvidenceFetchResult, resolveEvidenceRef, toEvidenceDescriptorInput, } from './evidence-resolution.js';
 import { cyclesJwksUrl, isDIDCycles } from '../../key-resolution/index.js';
 // ── Internal helpers ──────────────────────────────────────────────
 function nowIso() {
@@ -269,18 +269,26 @@ export function signCyclesPermitReceipt(input, signerPrivateKeyHex) {
     return { ...unsigned, signature };
 }
 /** Verify a Cycles permit receipt (sync). With `options.evidence`, also
- *  checks the receipt↔envelope hash binding (see `_checkEvidenceJoin`).
+ *  checks the receipt↔envelope hash binding and that the envelope is the
+ *  referenced stage for the same reservation_id (see `_checkEvidenceJoin`).
+ *  Amount, unit, action and server identity are not compared.
  *  NOTE: `valid: true` does NOT assert the envelope's own Ed25519
  *  authenticity or signer authority — that is the v0.2 item (#43). Pin
  *  `expected_signer` for issuer trust until then. */
 export function verifyCyclesPermitReceipt(receipt, options = {}) {
-    return _verifyReceiptCore(receipt, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, options);
+    const captured = _captureInputs(receipt, options);
+    if (!captured.ok)
+        return captured.failure;
+    return _verifyReceiptCore(captured.receipt, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, captured.options);
 }
 /** Verify a Cycles permit receipt (async, DID-URI signers). Join-integrity
  *  caveat as in `verifyCyclesPermitReceipt`: `valid: true` does NOT assert
  *  the envelope's own Ed25519 authenticity (v0.2 — #43). */
 export async function verifyCyclesPermitReceiptWithDID(receipt, options = {}) {
-    return _verifyReceiptWithDID(receipt, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, options);
+    const captured = _captureInputs(receipt, options);
+    if (!captured.ok)
+        return captured.failure;
+    return _verifyReceiptWithDID(captured.receipt, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, captured.options);
 }
 // ── Sign / verify: release receipt ────────────────────────────────
 export function signCyclesReleaseReceipt(input, signerPrivateKeyHex) {
@@ -309,18 +317,26 @@ export function signCyclesReleaseReceipt(input, signerPrivateKeyHex) {
     return { ...unsigned, signature };
 }
 /** Verify a Cycles release receipt (sync). With `options.evidence`, also
- *  checks the receipt↔envelope hash binding (see `_checkEvidenceJoin`).
+ *  checks the receipt↔envelope hash binding and that the envelope is the
+ *  referenced stage for the same reservation_id (see `_checkEvidenceJoin`).
+ *  Amount, unit, action and server identity are not compared.
  *  NOTE: `valid: true` does NOT assert the envelope's own Ed25519
  *  authenticity or signer authority — that is the v0.2 item (#43). Pin
  *  `expected_signer` for issuer trust until then. */
 export function verifyCyclesReleaseReceipt(receipt, options = {}) {
-    return _verifyReceiptCore(receipt, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, options);
+    const captured = _captureInputs(receipt, options);
+    if (!captured.ok)
+        return captured.failure;
+    return _verifyReceiptCore(captured.receipt, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, captured.options);
 }
 /** Verify a Cycles release receipt (async, DID-URI signers). Join-integrity
  *  caveat as in `verifyCyclesReleaseReceipt`: `valid: true` does NOT assert
  *  the envelope's own Ed25519 authenticity (v0.2 — #43). */
 export async function verifyCyclesReleaseReceiptWithDID(receipt, options = {}) {
-    return _verifyReceiptWithDID(receipt, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, options);
+    const captured = _captureInputs(receipt, options);
+    if (!captured.ok)
+        return captured.failure;
+    return _verifyReceiptWithDID(captured.receipt, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, captured.options);
 }
 // ── Sign / verify: denial ─────────────────────────────────────────
 export function signCyclesDenial(input, signerPrivateKeyHex) {
@@ -385,6 +401,15 @@ export async function verifyCyclesDenialWithDID(denial, options = {}) {
  *      but `evidence_id` POPULATED — per cycles-evidence-v0.1's normative
  *      "Signature derivation". Failure → EVIDENCE_SIGNATURE_INVALID.
  *
+ *   3. CORRESPONDENCE (8.0.0, permit and release only): the envelope is the
+ *      event the receipt references, same stage and same reservation_id (see
+ *      `_evaluateCorrespondence`). Failure → EVIDENCE_CORRESPONDENCE_FIELD_MISSING
+ *      or EVIDENCE_CORRESPONDENCE_MISMATCH. Denials are not checked here.
+ *      The permit and release entry points pass captured inputs (see
+ *      `_captureInputs`), so checks 1 to 3 read one value whose fields are
+ *      exactly those in the hashed and signed bytes. The stage comes from the
+ *      entry point's receipt kind.
+ *
  * Scope boundary (the (a)/(b) split): check 2 proves the bytes were signed
  * by the key in `signer_did` — it does NOT prove that key is the legitimate
  * Cycles signer rather than an attacker key inside a self-consistent forgery.
@@ -398,7 +423,7 @@ export async function verifyCyclesDenialWithDID(denial, options = {}) {
  * fixture, so the empty-string-sentinel rules here are the SAME
  * canonicalizations the Cycles server used. Field omission would differ.
  */
-function _checkEvidenceJoin(obj, options) {
+function _checkEvidenceJoin(obj, options, stage) {
     const env = options.evidence;
     if (!env)
         return null;
@@ -407,14 +432,14 @@ function _checkEvidenceJoin(obj, options) {
         return {
             valid: false,
             reason: 'EVIDENCE_REF_HASH_MISMATCH',
-            detail: `envelope evidence_id ${String(env.evidence_id)} != recomputed ${recomputed}`,
+            detail: `envelope evidence_id ${_show(env.evidence_id)} != recomputed ${recomputed}`,
         };
     }
     if (recomputed !== obj.cycles_evidence.cycles_evidence_id_sha256) {
         return {
             valid: false,
             reason: 'EVIDENCE_REF_HASH_MISMATCH',
-            detail: `receipt cycles_evidence_id_sha256 ${obj.cycles_evidence.cycles_evidence_id_sha256} != envelope ${recomputed}`,
+            detail: `receipt cycles_evidence_id_sha256 ${_show(obj.cycles_evidence.cycles_evidence_id_sha256)} != envelope ${recomputed}`,
         };
     }
     // (a) Envelope authenticity: verify the envelope's own Ed25519 signature
@@ -438,8 +463,275 @@ function _checkEvidenceJoin(obj, options) {
             detail: 'envelope Ed25519 signature does not verify against signer_did',
         };
     }
+    // (c) Correspondence (permit and release): the envelope must be the event
+    // the receipt references. Runs only after the hash and signature checks
+    // pass, so a semantic failure is reported as such. The stage comes from
+    // the entry point's receipt kind, never from a field of the input.
+    if (!stage)
+        return null;
+    const correspondence = _evaluateCorrespondence(stage, obj, env);
+    if (correspondence.status === 'field_missing') {
+        return {
+            valid: false,
+            reason: 'EVIDENCE_CORRESPONDENCE_FIELD_MISSING',
+            detail: `${correspondence.field}: ${correspondence.detail}`,
+        };
+    }
+    if (correspondence.status === 'mismatch') {
+        return {
+            valid: false,
+            reason: 'EVIDENCE_CORRESPONDENCE_MISMATCH',
+            detail: `${correspondence.field}: ${correspondence.detail}`,
+        };
+    }
     return null;
 }
+/** Fields deliberately outside the correspondence check. No equivalence rule
+ *  is defined for them yet (estimate vs reserved vs actual amounts, unit
+ *  families, action naming, server identity). Reported, never compared. */
+const CORRESPONDENCE_NOT_COMPARED = Object.freeze([
+    'amount',
+    'unit',
+    'action',
+    'server_id',
+]);
+function _isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** The stage a receipt kind references. Taken from the verifier entry point,
+ *  never from the input, so a changing `claim_type` cannot switch the check off. */
+function _stageFor(claimType) {
+    if (claimType === RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE)
+        return 'reserve';
+    if (claimType === RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE)
+        return 'release';
+    return undefined;
+}
+/** Detail text for any value. `String()` throws on a prototype-free object,
+ *  so fall back to JSON. Ordinary values print exactly as before. */
+function _show(v) {
+    try {
+        return String(v);
+    }
+    catch {
+        try {
+            return JSON.stringify(v) ?? 'unprintable';
+        }
+        catch {
+            return 'unprintable';
+        }
+    }
+}
+function _parseTime(v) {
+    try {
+        return Date.parse(v);
+    }
+    catch {
+        return NaN;
+    }
+}
+/** JSON.parse reviver: every object becomes a prototype-free record, so a
+ *  property lookup finds own fields only, even if Object.prototype carries
+ *  extra properties. Arrays stay arrays. */
+function _prototypeFree(_key, value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        return Object.assign(Object.create(null), value);
+    }
+    return value;
+}
+/**
+ * Capture an input as the data its canonical bytes encode: one JCS
+ * canonicalization, parsed back into prototype-free records. Inherited,
+ * non-enumerable and accessor properties and non-JSON containers such as Date
+ * are absent or already reduced to their JSON form, and later reads cannot
+ * change. Hashing, signature checks and correspondence on the permit and
+ * release paths read only captured values.
+ */
+function _capture(value) {
+    let bytes;
+    try {
+        bytes = canonicalizeJCS(value);
+    }
+    catch (err) {
+        return { ok: false, detail: `has no canonical JSON form (${err instanceof Error ? err.message : _show(err)})` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(bytes, _prototypeFree);
+    }
+    catch (err) {
+        return { ok: false, detail: `has no capturable JSON form (${err instanceof Error ? err.message : _show(err)})` };
+    }
+    if (!_isPlainObject(parsed))
+        return { ok: false, detail: 'is not a JSON object' };
+    return { ok: true, value: parsed };
+}
+/** Every supported option, read by name. The check below fails the build if
+ *  VerifyCyclesOptions gains a key that is not listed here. */
+const VERIFY_OPTION_KEYS = [
+    'now',
+    'ttl_seconds',
+    'expected_signer',
+    'resolveDidDocument',
+    'resolveEvidence',
+    'evidenceFailurePolicy',
+    'cyclesKeyResolver',
+    'expectedEvidenceSigner',
+    'maxEvidenceClockSkewMs',
+    'evidence',
+];
+const _allOptionKeysListed = true;
+void _allOptionKeysListed;
+/** Snapshot of the caller's options: each supported option read once by
+ *  ordinary property lookup, as verification always has (own, non-enumerable
+ *  or inherited), into a prototype-free object. Later reads and writes touch
+ *  only this snapshot, so an accessor on Object.prototype cannot intercept
+ *  them, and no constraint the caller supplied is dropped. */
+function _snapshotOptions(options) {
+    const out = Object.create(null);
+    for (const key of VERIFY_OPTION_KEYS) {
+        const value = options[key];
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+function _isFetchFailureStatus(v) {
+    return v === 'not_found' || v === 'unreachable' || v === 'malformed';
+}
+/** The envelope a resolution result actually carries: an own property only,
+ *  so a value on Object.prototype is never mistaken for a fetched envelope. */
+function _ownEnvelope(evidence) {
+    return Object.prototype.hasOwnProperty.call(evidence, 'envelope') ? evidence.envelope : undefined;
+}
+/**
+ * Entry step for every permit and release verifier. Captures the receipt, the
+ * supplied envelope, and (through the resolver) any fetched envelope. A failed
+ * capture is a structured rejection. Verification never resumes on the
+ * uncaptured object. Denial verifiers do not use this.
+ */
+function _captureInputs(receipt, options) {
+    // One read of each supported option into a prototype-free snapshot (see
+    // `_snapshotOptions`). Captured values below replace the originals there.
+    const out = _snapshotOptions(options);
+    const supplied = out.evidence;
+    const inner = out.resolveEvidence;
+    delete out.evidence;
+    delete out.resolveEvidence;
+    const r = _capture(receipt);
+    if (!r.ok) {
+        const detail = `receipt ${r.detail}, so its signature cannot be checked`;
+        return { ok: false, field: 'receipt', detail, options: out, failure: { valid: false, reason: 'SIGNATURE_INVALID', detail } };
+    }
+    if (supplied) {
+        const e = _capture(supplied);
+        if (!e.ok) {
+            const detail = `envelope ${e.detail}, so its content hash cannot be recomputed`;
+            return { ok: false, field: 'envelope', detail, options: out, failure: { valid: false, reason: 'EVIDENCE_REF_HASH_MISMATCH', detail } };
+        }
+        out.evidence = e.value;
+    }
+    if (inner) {
+        out.resolveEvidence = {
+            canResolve: (url) => inner.canResolve(url),
+            resolve: async (url) => {
+                // Read the caller's result once and return a fresh object, never the
+                // caller's own, so resolution cannot re-read a changing field.
+                const got = readEvidenceFetchResult(await inner.resolve(url));
+                const ok = got.ok;
+                const envelope = got.envelope;
+                const status = got.status;
+                const reason = got.reason;
+                if (!ok || !envelope) {
+                    // A failure keeps only a status that means failure. Anything else,
+                    // including a value that is not the resolver's own, becomes malformed.
+                    const failed = Object.create(null);
+                    failed.ok = false;
+                    if (status !== undefined)
+                        failed.status = _isFetchFailureStatus(status) ? status : 'malformed';
+                    if (typeof reason === 'string')
+                        failed.reason = reason;
+                    return failed;
+                }
+                const e = _capture(envelope);
+                return e.ok
+                    ? { ok: true, envelope: e.value }
+                    : { ok: false, status: 'malformed', reason: `envelope ${e.detail}` };
+            },
+        };
+    }
+    return { ok: true, receipt: r.value, options: out };
+}
+/**
+ * Receipt-to-envelope correspondence (8.0.0). A permit references the reserve
+ * event for its reservation, a release references the release event for its
+ * reservation. Checks, in order: the receipt's reservation_id, the envelope's
+ * `artifact_type`, agreement of the single payload variant with that
+ * `artifact_type`, and the envelope's reservation_id at the stage path
+ * (reserve: payload.reserve.response.reservation_id, release:
+ * payload.release.reservation_id). A missing or malformed field is
+ * `field_missing`, never a pass. Callers pass the stage from the verifier
+ * entry point and captured inputs only (see `_captureInputs`).
+ */
+function _evaluateCorrespondence(stage, obj, env) {
+    const receiptReservation = obj.reservation_id;
+    if (typeof receiptReservation !== 'string' || receiptReservation.length === 0) {
+        return {
+            status: 'field_missing',
+            field: 'receipt.reservation_id',
+            detail: 'absent or not a non-empty string',
+        };
+    }
+    const artifactType = env.artifact_type;
+    if (typeof artifactType !== 'string' || artifactType.length === 0) {
+        return { status: 'field_missing', field: 'artifact_type', detail: 'absent or not a non-empty string' };
+    }
+    if (artifactType !== stage) {
+        return {
+            status: 'mismatch',
+            field: 'artifact_type',
+            detail: `receipt references a ${stage} event, envelope is ${artifactType}`,
+        };
+    }
+    const payload = env.payload;
+    if (!_isPlainObject(payload)) {
+        return { status: 'field_missing', field: 'payload', detail: 'absent or not an object' };
+    }
+    const variants = Object.keys(payload);
+    if (variants.length === 0) {
+        return { status: 'field_missing', field: 'payload', detail: 'no payload variant' };
+    }
+    if (variants.length !== 1 || variants[0] !== stage) {
+        return {
+            status: 'mismatch',
+            field: 'payload',
+            detail: `payload variant [${variants.join(', ')}] does not agree with artifact_type ${stage}`,
+        };
+    }
+    const variant = payload[stage];
+    if (!_isPlainObject(variant)) {
+        return { status: 'field_missing', field: `payload.${stage}`, detail: 'absent or not an object' };
+    }
+    const holder = stage === 'reserve' ? variant.response : variant;
+    const path = stage === 'reserve' ? 'payload.reserve.response.reservation_id' : 'payload.release.reservation_id';
+    const envReservation = _isPlainObject(holder) ? holder.reservation_id : undefined;
+    if (typeof envReservation !== 'string' || envReservation.length === 0) {
+        return { status: 'field_missing', field: path, detail: 'absent or not a non-empty string' };
+    }
+    if (envReservation !== receiptReservation) {
+        return {
+            status: 'mismatch',
+            field: 'reservation_id',
+            detail: `receipt ${receiptReservation} != envelope ${envReservation}`,
+        };
+    }
+    return {
+        status: 'matched',
+        stage,
+        reservation_id: receiptReservation,
+        not_compared: CORRESPONDENCE_NOT_COMPARED,
+    };
+}
 /**
  * Build the passing result, tagging envelope authenticity (APS#43) when an
  * envelope was supplied. Reaching here with `options.evidence` set means the
@@ -460,28 +752,32 @@ function _validResult(options) {
 function _verifyReceiptCore(obj, expectedClaimType, options) {
     const ttl = options.ttl_seconds ?? 24 * 60 * 60;
     if (obj.claim_type !== expectedClaimType) {
-        return { valid: false, reason: 'INVALID_CLAIM_TYPE', detail: `expected ${expectedClaimType} got ${obj.claim_type}` };
+        return { valid: false, reason: 'INVALID_CLAIM_TYPE', detail: `expected ${expectedClaimType} got ${_show(obj.claim_type)}` };
     }
     if (!obj.receipt_id || !obj.signer || !obj.agent_id || !obj.delegation_ref || !obj.action_ref) {
         return { valid: false, reason: 'MISSING_REQUIRED_FIELD' };
     }
     if (obj.rail_name !== 'cycles') {
-        return { valid: false, reason: 'INVALID_RAIL_NAME', detail: `expected 'cycles' got ${String(obj.rail_name)}` };
+        return { valid: false, reason: 'INVALID_RAIL_NAME', detail: `expected 'cycles' got ${_show(obj.rail_name)}` };
     }
-    if (!obj.cycles_evidence?.cycles_evidence_url || !obj.cycles_evidence?.cycles_evidence_id_sha256) {
+    // cycles_evidence must be an object. An array or other value would let its
+    // fields be looked up on a prototype instead of in the signed bytes.
+    if (!_isPlainObject(obj.cycles_evidence) ||
+        !obj.cycles_evidence.cycles_evidence_url ||
+        !obj.cycles_evidence.cycles_evidence_id_sha256) {
         return { valid: false, reason: 'MISSING_REQUIRED_FIELD', detail: 'cycles_evidence' };
     }
     // Join-integrity: when the fetched envelope is supplied, bind it to the
     // receipt. Runs before signature/DID checks so a broken receipt↔envelope
     // join surfaces regardless of signer type (the DID path calls this core
     // first and propagates any non-DID_RESOLVER_MISSING failure unchanged).
-    const joinFailure = _checkEvidenceJoin(obj, options);
+    const joinFailure = _checkEvidenceJoin(obj, options, _stageFor(expectedClaimType));
     if (joinFailure)
         return joinFailure;
     if (options.expected_signer && obj.signer !== options.expected_signer) {
         return { valid: false, reason: 'SIGNATURE_INVALID', detail: 'signer mismatch' };
     }
-    const issuedMs = Date.parse(obj.issued_at);
+    const issuedMs = _parseTime(obj.issued_at);
     if (!Number.isFinite(issuedMs)) {
         return { valid: false, reason: 'MISSING_REQUIRED_FIELD', detail: 'issued_at' };
     }
@@ -495,7 +791,7 @@ function _verifyReceiptCore(obj, expectedClaimType, options) {
     if (obj.timestamp !== obj.issued_at) {
         return { valid: false, reason: 'MISSING_REQUIRED_FIELD', detail: 'timestamp != issued_at' };
     }
-    if (!obj.scope_of_claim ||
+    if (!_isPlainObject(obj.scope_of_claim) ||
         typeof obj.scope_of_claim.asserts !== 'string' ||
         obj.scope_of_claim.asserts.length === 0) {
         return { valid: false, reason: 'MISSING_REQUIRED_FIELD', detail: 'scope_of_claim' };
@@ -530,7 +826,7 @@ async function _verifyReceiptWithDID(obj, expectedClaimType, options) {
     const didDoc = await options.resolveDidDocument(parsed.agentId);
     if (!didDoc)
         return { valid: false, reason: 'DID_DOC_NOT_FOUND' };
-    const issuedMs = Date.parse(obj.issued_at);
+    const issuedMs = _parseTime(obj.issued_at);
     const result = resolveVerificationMethod(didDoc, obj.signer, options.now ? options.now.getTime() : undefined, Number.isFinite(issuedMs) ? issuedMs : undefined);
     if (!result)
         return { valid: false, reason: 'DID_KEY_NOT_IN_DOC' };
@@ -559,6 +855,22 @@ const _verified = (disposition, signerDid, options, extra = {}) => {
     return { disposition, signerDid, ...extra };
 };
 const RAW_HEX_KEY = /^[0-9a-fA-F]{64}$/;
+/** The supported fields of a key resolver answer, each read once by name and
+ *  only when it is the answer's own property (enumerable or not), into a
+ *  prototype-free record. No other field is read. Undefined for anything that
+ *  is not an object. Callers read this inside their error guard, so a
+ *  throwing accessor on a supported field becomes a structured failure. */
+const KEY_ANSWER_FIELDS = ['ok', 'publicKeyHex', 'kid', 'status', 'reason'];
+function _readKeyAnswer(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const out = Object.create(null);
+    for (const key of KEY_ANSWER_FIELDS) {
+        if (Object.prototype.hasOwnProperty.call(value, key))
+            out[key] = value[key];
+    }
+    return out;
+}
 /** Map a non-ok KeyResolution status to the spec disposition. Failure to
  *  OBTAIN/parse the SET (network, or an unparseable set body) is
  *  resolution_failed; a parsed set with no single authorized key — incl. the
@@ -644,7 +956,7 @@ async function _resolveEnvelopeAuthority(env, options) {
         return _authority('signature_invalid', `envelope canonicalization failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     if (recomputedId !== env.evidence_id) {
-        return _authority('signature_invalid', `evidence_id does not re-derive (${recomputedId} != ${String(env.evidence_id)}) — envelope tampered`);
+        return _authority('signature_invalid', `evidence_id does not re-derive (${recomputedId} != ${_show(env.evidence_id)}) — envelope tampered`);
     }
     const resolver = options.cyclesKeyResolver;
     if (!resolver) {
@@ -664,44 +976,94 @@ async function _resolveEnvelopeAuthority(env, options) {
         : { jwksUrl: cyclesJwksUrl(serverId), publicKeyHex: signerDid, issuedAtMs };
     // The verify path must never throw — a non-conformant resolver that rejects
     // is treated as a resolution failure, never authentic.
-    let resolution;
+    // Read the key resolver's answer from its own supported properties only,
+    // once, inside the guard. A key or success flag found only on
+    // Object.prototype is not a resolution.
+    let res;
     try {
-        resolution = await resolver.resolve(locator);
+        res = _readKeyAnswer(await resolver.resolve(locator));
     }
     catch (err) {
         return _authority('signer_resolution_failed', `authority resolution threw: ${err instanceof Error ? err.message : String(err)}`);
     }
-    if (!resolution.ok || !resolution.publicKeyHex) {
-        return _authority(_authorityFromResolution(resolution.status, resolution.reason), `signer-key resolution failed (status=${resolution.status}${resolution.reason ? `: ${resolution.reason}` : ''})`);
+    if (!res) {
+        return _authority('signer_resolution_failed', 'key resolver did not return an object');
+    }
+    const resStatus = typeof res.status === 'string' ? res.status : '';
+    const resReason = typeof res.reason === 'string' ? res.reason : undefined;
+    const publicKeyHex = typeof res.publicKeyHex === 'string' ? res.publicKeyHex : '';
+    if (res.ok !== true || !publicKeyHex) {
+        return _authority(_authorityFromResolution(resStatus, resReason), `signer-key resolution failed (status=${resStatus || 'none'}${resReason ? `: ${resReason}` : ''})`);
     }
-    if (!edVerify(signingInput, signature, resolution.publicKeyHex)) {
+    if (!edVerify(signingInput, signature, publicKeyHex)) {
         return _authority('signature_invalid', 'envelope signature did not verify under the resolved key');
     }
-    return _verified('authentic', signerDid, options, { resolvedKid: resolution.kid });
+    return _verified('authentic', signerDid, options, typeof res.kid === 'string' ? { resolvedKid: res.kid } : {});
 }
 async function _verifyWithEvidence(obj, expectedClaimType, options) {
     // Run the full receipt verification (DID-aware) first.
     const verify = await _verifyReceiptWithDID(obj, expectedClaimType, options);
+    const stage = _stageFor(expectedClaimType);
     // Resolve the evidence ref regardless of the receipt verdict, so the
     // descriptor always reports the claimed-vs-resolved basis. Resolution
-    // records failure, never throws.
-    const evidence = await resolveEvidenceRef(obj.cycles_evidence, options.resolveEvidence, { failurePolicy: options.evidenceFailurePolicy });
+    // records failure, never throws. On the permit and release paths a ref that
+    // is not an object is not read (its fields could come from a prototype).
+    const evidence = stage && !_isPlainObject(obj.cycles_evidence)
+        ? await _unreadEvidence('receipt cycles_evidence is not an object', options)
+        : await resolveEvidenceRef(obj.cycles_evidence, options.resolveEvidence, { failurePolicy: options.evidenceFailurePolicy });
     // Signer authority (#43): resolve the fetched envelope's signer key and
     // verify the envelope's own signature. Independent of the receipt verdict
     // and the hash join; reports one of the five distinct dispositions, never throws.
-    const authority = await _resolveEnvelopeAuthority(evidence.envelope, options);
+    const fetchedEnvelope = _ownEnvelope(evidence);
+    const authority = await _resolveEnvelopeAuthority(fetchedEnvelope, options);
+    // Correspondence (8.0.0) on the FETCHED envelope, reported separately so
+    // verify / evidence / authority keep their meanings.
+    // Stage from the entry point. The fetched envelope reaching here on the
+    // permit and release paths is the captured one (see `_captureInputs`).
+    const correspondence = !stage
+        ? { status: 'not_applicable', reason: 'correspondence is evaluated for permit and release receipts only' }
+        : evidence.resolved === true && evidence.status === 'matched' && _isPlainObject(fetchedEnvelope)
+            ? _evaluateCorrespondence(stage, obj, fetchedEnvelope)
+            : { status: 'not_applicable', reason: `no matched envelope (status=${evidence.status})` };
     return {
         verify,
         evidence,
         descriptor: toEvidenceDescriptorInput(evidence),
         authority,
+        correspondence,
+    };
+}
+/** The fetched-path result when capture failed. Nothing further is read from
+ *  the uncaptured input: verify carries the structured rejection, the evidence
+ *  reference is reported malformed and unresolved, authority is not evaluated,
+ *  and correspondence names the field that could not be captured. */
+/** An evidence result reported as malformed and unresolved, built without
+ *  reading any caller input. */
+function _unreadEvidence(detail, options) {
+    const reason = `not read: ${detail}`;
+    return resolveEvidenceRef({ cycles_evidence_url: '', cycles_evidence_id_sha256: '', action_ref: '', delegation_ref: '' }, { canResolve: () => true, resolve: async () => ({ ok: false, status: 'malformed', reason }) }, { failurePolicy: options.evidenceFailurePolicy });
+}
+async function _rejectedWithEvidence(captured) {
+    const evidence = await _unreadEvidence(captured.detail, captured.options);
+    return {
+        verify: captured.failure,
+        evidence,
+        descriptor: toEvidenceDescriptorInput(evidence),
+        authority: _authority('signer_resolution_failed', `not evaluated: ${captured.detail}`),
+        correspondence: { status: 'field_missing', field: captured.field, detail: captured.detail },
     };
 }
 export async function verifyCyclesPermitReceiptWithEvidence(receipt, options = {}) {
-    return _verifyWithEvidence(receipt, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, options);
+    const captured = _captureInputs(receipt, options);
+    if (!captured.ok)
+        return _rejectedWithEvidence(captured);
+    return _verifyWithEvidence(captured.receipt, RAIL_BUDGET_RESERVATION_PERMIT_CLAIM_TYPE, captured.options);
 }
 export async function verifyCyclesReleaseReceiptWithEvidence(receipt, options = {}) {
-    return _verifyWithEvidence(receipt, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, options);
+    const captured = _captureInputs(receipt, options);
+    if (!captured.ok)
+        return _rejectedWithEvidence(captured);
+    return _verifyWithEvidence(captured.receipt, RAIL_BUDGET_RESERVATION_RELEASE_CLAIM_TYPE, captured.options);
 }
 /**
  * Verify a FETCHED CyclesEvidence envelope's own signer authority directly