@emilia-protocol/gate 0.9.5 → 0.11.0

package/action-escrow-package.js

@@ -0,0 +1,1669 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Strict adapter from one exact Action Escrow kernel snapshot to the portable
+ * Action Escrow evidence-package profile.
+ *
+ * This module does not accept package-field overrides. Every package field is
+ * either derived from the durable record or occupies one of the four external
+ * artifact slots that the kernel intentionally does not own.
+ */
+import crypto from 'node:crypto';
+
+import {
+  ACTION_ESCROW_PROFILE_VERSION,
+  ACTION_ESCROW_STATE_VERSION,
+  ACTION_ESCROW_STATES,
+  ACTION_ESCROW_TRANSITIONS,
+  computeActionEscrowReleaseBindingMomentDigest,
+  computeActionEscrowResolutionNonce,
+} from './action-escrow.js';
+import { buildActionEscrowEvidencePackage } from './action-escrow-evidence.js';
+import {
+  ACTION_ESCROW_STATE_STATEMENT_DOMAIN,
+  ACTION_ESCROW_STATE_STATEMENT_VERSION,
+} from './action-escrow-state.js';
+import {
+  computeActionEscrowAgreementDigest,
+  validateActionEscrowReleaseTemplate,
+} from './action-escrow-verifiers.js';
+import { canonicalize, hashCanonical } from './execution-binding.js';
+import {
+  computeDocumentActionBindingDigest,
+  computeDocumentSha256,
+  computeReleaseActionDigest,
+} from '@emilia-protocol/verify/document-action-binding';
+
+const HASH = /^sha256:[0-9a-f]{64}$/;
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:/#@+-]{0,255}$/;
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+const MAX_RECORD_NODES = 50_000;
+const MAX_RECORD_DEPTH = 64;
+const MAX_STRING_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_DOCUMENT_BYTES = 50 * 1024 * 1024;
+
+const INPUT_KEYS = new Set([
+  'kernelRecord',
+  'finalPdfBytes',
+  'documentFileName',
+  'documentExecution',
+  'operatorStateStatement',
+  'verificationProfile',
+]);
+const OPTION_KEYS = new Set(['now', 'maxDocumentBytes']);
+const RECORD_KEYS = new Set([
+  '@version',
+  'escrow_key',
+  'revision',
+  'state',
+  'agreement_digest',
+  'document_action_binding_digest',
+  'milestone_id',
+  'release_action_digest',
+  'parties',
+  'parties_digest',
+  'profile',
+  'profile_digest',
+  'document_action_binding',
+  'agreement_acceptances',
+  'funding',
+  'milestone_evidence',
+  'release_approvals',
+  'release',
+  'dispute',
+  'cancellation',
+  'completion',
+  'pending_amendment',
+  'superseded_bindings',
+  'operations',
+  'history',
+  'created_at',
+  'updated_at',
+]);
+const PROFILE_KEYS = new Set([
+  '@version',
+  'profile_id',
+  'provider_id',
+  'required_acceptance_party_ids',
+  'required_release_approver_party_ids',
+  'prohibit_self_approval',
+]);
+const PARTY_KEYS = new Set(['party_id', 'role']);
+const CONTAINER_KEYS = new Set(['artifact', 'verification']);
+const ACCEPTANCE_KEYS = new Set(['party_id', 'artifact', 'verification']);
+const RELEASE_APPROVAL_KEYS = new Set(['party_id', 'resolution', 'verification']);
+const CORE_VERIFICATION_KEYS = [
+  'valid',
+  'agreement_digest',
+  'document_action_binding_digest',
+  'milestone_id',
+  'release_action_digest',
+  'parties_digest',
+  'profile_digest',
+];
+const BINDING_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'verification_digest',
+  'document_digest',
+  'agreement_id',
+  'binding_id',
+  'release_action_template',
+  'supersedes_document_action_binding_digest',
+]);
+const ACCEPTANCE_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'party_id',
+  'principal_key_id',
+  'acceptance_digest',
+]);
+const FUNDING_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'authenticated',
+  'provider_id',
+  'statement_type',
+  'status',
+  'provider_transaction_id',
+  'provider_milestone_id',
+  'amount',
+  'currency',
+  'destination_id',
+  'statement_digest',
+]);
+const MILESTONE_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'evidence_digest',
+  'submitter_party_id',
+  'observed_at',
+]);
+const RELEASE_APPROVAL_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'authorizes_action',
+  'outcome',
+  'party_role',
+  'principal_key_id',
+  'nonce',
+  'issued_at',
+  'expires_at',
+  'resolution_digest',
+  'evidence_digest',
+]);
+const PROVIDER_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'authenticated',
+  'provider_id',
+  'provider_idempotency_key',
+  'provider_request_digest',
+  'provider_transaction_id',
+  'provider_milestone_id',
+  'amount',
+  'currency',
+  'destination_id',
+  'statement_type',
+  'status',
+  'statement_digest',
+]);
+const COMMAND_VERIFICATION_KEYS = new Set([
+  ...CORE_VERIFICATION_KEYS,
+  'authorizes_command',
+  'command',
+  'party_id',
+  'details_digest',
+  'command_digest',
+]);
+const OPERATION_KEYS = new Set([
+  'idempotency_key',
+  'operation',
+  'request_digest',
+  'code',
+  'ok',
+  'outcome',
+  'state',
+  'at',
+]);
+const HISTORY_KEYS = new Set([
+  'from',
+  'to',
+  'operation',
+  'idempotency_key',
+  'at',
+]);
+const SUPERSESSION_KEYS = new Set([
+  'document_action_binding_digest',
+  'release_action_digest',
+  'superseded_by_binding_digest',
+  'superseded_at',
+]);
+const RELEASE_KEYS = new Set([
+  'release_key',
+  'provider_idempotency_key',
+  'operation_idempotency_key',
+  'status',
+  'reserved_at',
+  'reconciled_at',
+  'provider_request',
+  'provider_statement',
+  'provider_verification',
+]);
+const PROVIDER_REQUEST_KEYS = new Set([
+  'method',
+  'provider_id',
+  'agreement_digest',
+  'document_action_binding_digest',
+  'milestone_id',
+  'release_action_digest',
+  'parties',
+  'parties_digest',
+  'profile',
+  'profile_digest',
+  'agreement_id',
+  'binding_id',
+  'document_digest',
+  'release_action_template',
+  'release_key',
+  'idempotency_key',
+  'request_digest',
+]);
+const PENDING_AMENDMENT_KEYS = new Set([
+  'from_state',
+  'document_action_binding_digest',
+  'release_action_digest',
+  'document_action_binding',
+  'agreement_acceptances',
+  'proposer_party_id',
+  'proposal_authorization',
+  'proposed_at',
+]);
+const COMMAND_CONTAINER_KEYS = new Set(['artifact', 'verification']);
+const DISPUTE_KEYS = new Set(['party_id', 'reason', 'authorization', 'opened_at']);
+const CANCELLATION_KEYS = new Set([
+  'party_id',
+  'reason',
+  'authorization',
+  'cancelled_at',
+]);
+const COMPLETION_KEYS = new Set([
+  'party_id',
+  'meaning',
+  'authorization',
+  'completed_at',
+]);
+const STATE_STATEMENT_KEYS = new Set([
+  'version',
+  'issuer',
+  'payload',
+  'statement_digest',
+  'signature',
+]);
+const STATE_ISSUER_KEYS = new Set(['operator_id', 'key_id']);
+const STATE_PAYLOAD_KEYS = new Set([
+  'statement_id',
+  'agreement_id',
+  'binding_digest',
+  'action_digest',
+  'profile_digest',
+  'state',
+  'revision',
+  'amendment_digests',
+  'state_record_digest',
+  'previous_statement_digest',
+  'occurred_at',
+]);
+const STATE_SIGNATURE_KEYS = new Set(['algorithm', 'signature_b64u']);
+const PROFILE_REFERENCE_KEYS = new Set(['id', 'digest']);
+
+const EXECUTED_AGREEMENT_STATES = new Set([
+  'effective',
+  'awaiting_funding',
+  'funded',
+  'milestone_submitted',
+  'release_reserved',
+  'released',
+  'disputed',
+  'amendment_pending',
+  'completed',
+  'release_indeterminate',
+]);
+const FUNDING_STATES = new Set([
+  'funded',
+  'milestone_submitted',
+  'release_reserved',
+  'released',
+  'disputed',
+  'completed',
+  'release_indeterminate',
+]);
+const MILESTONE_STATES = new Set([
+  'milestone_submitted',
+  'release_reserved',
+  'released',
+  'disputed',
+  'completed',
+  'release_indeterminate',
+]);
+const RELEASE_APPROVAL_STATES = new Set([
+  'milestone_submitted',
+  'release_reserved',
+  'released',
+  'disputed',
+  'completed',
+  'release_indeterminate',
+]);
+const COMPLETE_RELEASE_APPROVAL_STATES = new Set([
+  'release_reserved',
+  'released',
+  'completed',
+  'release_indeterminate',
+]);
+const REQUIRED_RELEASE_STATES = new Set([
+  'release_reserved',
+  'released',
+  'completed',
+  'release_indeterminate',
+]);
+const OPTIONAL_RELEASE_STATES = new Set([
+  'milestone_submitted',
+  'disputed',
+]);
+const KERNEL_OPERATIONS = new Set([
+  'create',
+  'begin_acceptance',
+  'accept_agreement',
+  'request_funding',
+  'record_funding',
+  'submit_milestone',
+  'approve_release',
+  'release',
+  'reconcile_release',
+  'open_dispute',
+  'propose_amendment',
+  'accept_amendment',
+  'cancel',
+  'complete',
+]);
+
+const SECRET_FIELD_NAMES = new Set([
+  'api_key',
+  'api_token',
+  'api_secret',
+  'access_key',
+  'access_key_id',
+  'access_token',
+  'refresh_token',
+  'session_token',
+  'oauth_token',
+  'bearer_token',
+  'client_secret',
+  'client_password',
+  'password',
+  'passwd',
+  'private_key',
+  'private_key_pem',
+  'secret',
+  'secret_key',
+  'secret_access_key',
+  'signing_secret',
+  'webhook_secret',
+  'credential',
+  'credentials',
+  'provider_credentials',
+  'authorization_header',
+  'cookie',
+  'set_cookie',
+  'request_headers',
+  'http_headers',
+  'headers',
+  'connection_string',
+  'database_url',
+]);
+
+function fail(reason) {
+  throw new TypeError(`action-escrow package: ${reason}`);
+}
+
+function isRecord(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function exactKeys(value, allowed, required = allowed) {
+  if (!isRecord(value)) return false;
+  const keys = Object.keys(value);
+  return keys.every((key) => allowed.has(key))
+    && [...required].every((key) => Object.hasOwn(value, key));
+}
+
+function validString(value, max = 512) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value.length <= max
+    && !/[\u0000-\u001f\u007f]/.test(value);
+}
+
+function validDigest(value) {
+  return typeof value === 'string' && HASH.test(value);
+}
+
+function validInstant(value) {
+  if (typeof value !== 'string') return false;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) && new Date(parsed).toISOString() === value;
+}
+
+function canonicalCopy(value, label) {
+  let nodes = 0;
+  let stringBytes = 0;
+  const seen = new WeakSet();
+
+  function copy(current, depth) {
+    nodes += 1;
+    if (nodes > MAX_RECORD_NODES || depth > MAX_RECORD_DEPTH) {
+      fail(`${label} exceeds resource limits`);
+    }
+    if (current === null || typeof current === 'boolean') return current;
+    if (typeof current === 'string') {
+      stringBytes += Buffer.byteLength(current, 'utf8');
+      if (stringBytes > MAX_STRING_BYTES) fail(`${label} exceeds string limits`);
+      return current;
+    }
+    if (typeof current === 'number') {
+      if (!Number.isSafeInteger(current) || Object.is(current, -0)) {
+        fail(`${label} contains a non-canonical number`);
+      }
+      return current;
+    }
+    if (!isRecord(current) && !Array.isArray(current)) {
+      fail(`${label} is not canonical JSON`);
+    }
+    if (seen.has(current)) fail(`${label} contains an alias or cycle`);
+    seen.add(current);
+    if (Array.isArray(current)) {
+      return current.map((entry) => copy(entry, depth + 1));
+    }
+    return Object.fromEntries(
+      Object.entries(current).map(([key, entry]) => [key, copy(entry, depth + 1)]),
+    );
+  }
+
+  return copy(value, 0);
+}
+
+function canonicalDigest(value) {
+  return `sha256:${hashCanonical(value)}`;
+}
+
+function sameCanonical(left, right) {
+  try {
+    return canonicalize(left) === canonicalize(right);
+  } catch {
+    return false;
+  }
+}
+
+function normalizeFieldName(value) {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^A-Za-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+}
+
+function assertNoSecrets(value, label) {
+  const stack = [{ value, path: label }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (typeof current.value === 'string') {
+      if (/-----BEGIN (?:ENCRYPTED )?PRIVATE KEY-----/.test(current.value)
+        || /^\s*Bearer\s+\S+/i.test(current.value)
+        || /^[a-z][a-z0-9+.-]*:\/\/[^/\s]*@/i.test(current.value)) {
+        fail(`${current.path} contains provider credentials or secrets`);
+      }
+      continue;
+    }
+    if (current.value === null || typeof current.value !== 'object') continue;
+    for (const [key, child] of Object.entries(current.value)) {
+      const normalized = normalizeFieldName(key);
+      if (SECRET_FIELD_NAMES.has(normalized)
+        || normalized.endsWith('_client_secret')
+        || normalized.endsWith('_private_key')
+        || normalized.endsWith('_access_token')
+        || normalized.endsWith('_refresh_token')
+        || normalized.endsWith('_password')) {
+        fail(`${current.path}.${key} contains provider credentials or secrets`);
+      }
+      stack.push({ value: child, path: `${current.path}.${key}` });
+    }
+  }
+}
+
+function expectedCore(record, overrides = {}) {
+  return {
+    agreement_digest: record.agreement_digest,
+    document_action_binding_digest:
+      overrides.document_action_binding_digest ?? record.document_action_binding_digest,
+    milestone_id: record.milestone_id,
+    release_action_digest: overrides.release_action_digest ?? record.release_action_digest,
+    parties_digest: record.parties_digest,
+    profile_digest: record.profile_digest,
+  };
+}
+
+function verificationMatchesCore(value, expected) {
+  return isRecord(value)
+    && value.valid === true
+    && Object.entries(expected).every(([key, entry]) => value[key] === entry);
+}
+
+function validateStringArray(value, allowed, label) {
+  if (!Array.isArray(value)
+    || value.length === 0
+    || value.some((entry) => !validString(entry, 256))
+    || new Set(value).size !== value.length
+    || value.some((entry) => !allowed.has(entry))) {
+    fail(`${label} is invalid`);
+  }
+}
+
+function partyIdentity(party) {
+  return `${party.role}\u0000${party.party_id}`;
+}
+
+function sameParties(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+  const expected = new Set(left.map(partyIdentity));
+  return expected.size === left.length && right.every((party) => (
+    exactKeys(party, PARTY_KEYS) && expected.has(partyIdentity(party))
+  ));
+}
+
+function validatePartiesAndProfile(record) {
+  if (!Array.isArray(record.parties)
+    || record.parties.length < 2
+    || record.parties.length > 16) {
+    fail('kernel record parties are invalid');
+  }
+  const ids = new Set();
+  for (const party of record.parties) {
+    if (!exactKeys(party, PARTY_KEYS)
+      || !validString(party.party_id, 256)
+      || !validString(party.role, 128)
+      || ids.has(party.party_id)) {
+      fail('kernel record party is malformed or duplicated');
+    }
+    ids.add(party.party_id);
+  }
+  if (record.parties_digest !== canonicalDigest(record.parties)) {
+    fail('kernel record parties digest mismatch');
+  }
+  if (!exactKeys(record.profile, PROFILE_KEYS)
+    || record.profile['@version'] !== ACTION_ESCROW_PROFILE_VERSION
+    || !validString(record.profile.profile_id, 256)
+    || !validString(record.profile.provider_id, 256)
+    || typeof record.profile.prohibit_self_approval !== 'boolean') {
+    fail('kernel record profile is malformed');
+  }
+  validateStringArray(
+    record.profile.required_acceptance_party_ids,
+    ids,
+    'required acceptance party roster',
+  );
+  validateStringArray(
+    record.profile.required_release_approver_party_ids,
+    ids,
+    'required release party roster',
+  );
+  if (record.profile.required_acceptance_party_ids.length !== record.parties.length) {
+    fail('required acceptance party roster does not cover the exact parties');
+  }
+  if (record.profile_digest !== canonicalDigest(record.profile)) {
+    fail('kernel record profile digest mismatch');
+  }
+}
+
+function validateHistory(record) {
+  if (!Array.isArray(record.operations)
+    || record.operations.length === 0
+    || !Array.isArray(record.history)
+    || record.history.length === 0) {
+    fail('kernel operation or state history is malformed');
+  }
+  const operationIds = new Set();
+  const operationsById = new Map();
+  let previousOperationTime = Number.NEGATIVE_INFINITY;
+  for (const operation of record.operations) {
+    if (!exactKeys(operation, OPERATION_KEYS)
+      || !validString(operation.idempotency_key, 512)
+      || operationIds.has(operation.idempotency_key)
+      || !validString(operation.operation, 128)
+      || !KERNEL_OPERATIONS.has(operation.operation)
+      || !validDigest(operation.request_digest)
+      || !validString(operation.code, 256)
+      || typeof operation.ok !== 'boolean'
+      || !validString(operation.outcome, 128)
+      || !ACTION_ESCROW_STATES.includes(operation.state)
+      || !validInstant(operation.at)) {
+      fail('kernel operation history is malformed');
+    }
+    const operationTime = Date.parse(operation.at);
+    if (operationTime < previousOperationTime) {
+      fail('kernel operation history is not time-monotonic');
+    }
+    operationIds.add(operation.idempotency_key);
+    operationsById.set(operation.idempotency_key, operation);
+    previousOperationTime = operationTime;
+  }
+  const firstOperation = record.operations[0];
+  if (firstOperation.operation !== 'create'
+    || firstOperation.state !== 'draft'
+    || firstOperation.code !== 'escrow_created'
+    || firstOperation.ok !== true) {
+    fail('kernel operation history has no valid creation root');
+  }
+
+  let previous = null;
+  let previousHistoryTime = Number.NEGATIVE_INFINITY;
+  const releaseHistoryCounts = new Map();
+  for (const [index, entry] of record.history.entries()) {
+    if (!exactKeys(entry, HISTORY_KEYS)
+      || entry.from !== previous
+      || !ACTION_ESCROW_STATES.includes(entry.to)
+      || !validString(entry.operation, 128)
+      || !validString(entry.idempotency_key, 512)
+      || !validInstant(entry.at)) {
+      fail('kernel state history is malformed');
+    }
+    const linkedOperation = operationsById.get(entry.idempotency_key);
+    const historyTime = Date.parse(entry.at);
+    if (!linkedOperation
+      || linkedOperation.operation !== entry.operation
+      || historyTime < previousHistoryTime) {
+      fail('kernel state history is not bound to its operation log');
+    }
+    if (entry.operation === 'release') {
+      if (historyTime < Date.parse(linkedOperation.at)) {
+        fail('kernel release history predates its reservation');
+      }
+      releaseHistoryCounts.set(
+        entry.idempotency_key,
+        (releaseHistoryCounts.get(entry.idempotency_key) ?? 0) + 1,
+      );
+    } else if (entry.at !== linkedOperation.at || entry.to !== linkedOperation.state) {
+      fail('kernel state history is inconsistent with its operation');
+    }
+    if (index === 0) {
+      if (entry.from !== null || entry.to !== 'draft' || entry.operation !== 'create') {
+        fail('kernel state history has no valid creation root');
+      }
+    } else if (!ACTION_ESCROW_TRANSITIONS[entry.from]?.includes(entry.to)) {
+      fail('kernel state history contains an invalid transition');
+    }
+    previous = entry.to;
+    previousHistoryTime = historyTime;
+  }
+  if (previous !== record.state) fail('kernel state does not match its history');
+  const internalReleaseTransitions = [...releaseHistoryCounts.values()]
+    .reduce((total, count) => total + Math.max(0, count - 1), 0);
+  if (record.revision !== record.operations.length - 1 + internalReleaseTransitions) {
+    fail('kernel revision does not match its complete operation history');
+  }
+
+  const eventTimes = [
+    ...record.operations.map((entry) => entry.at),
+    ...record.history.map((entry) => entry.at),
+  ];
+  if (record.created_at !== record.operations[0].at
+    || Date.parse(record.created_at) > Date.parse(record.updated_at)
+    || eventTimes.some((instant) => Date.parse(instant) > Date.parse(record.updated_at))
+    || Math.max(...eventTimes.map((instant) => Date.parse(instant)))
+      !== Date.parse(record.updated_at)) {
+    fail('kernel record timestamps do not match its history');
+  }
+}
+
+function validateBindingContainer(container, record, {
+  bindingDigest = record.document_action_binding_digest,
+  actionDigest = record.release_action_digest,
+  supersedesDigest = null,
+  documentDigest = null,
+  documentLength = null,
+} = {}) {
+  if (!exactKeys(container, CONTAINER_KEYS)
+    || !isRecord(container.artifact)
+    || !isRecord(container.verification)) {
+    fail('document-action binding container is malformed');
+  }
+  const binding = container.artifact;
+  const verification = container.verification;
+  const computedBindingDigest = computeDocumentActionBindingDigest(binding);
+  const computedActionDigest = computeReleaseActionDigest(binding.release_action?.template);
+  const bindingDocumentDigest = binding.document?.digest;
+  const releaseActionTemplate = validateActionEscrowReleaseTemplate(
+    binding.release_action?.template,
+    {
+      profileDigest: record.profile_digest,
+      agreementId: binding.agreement_id,
+      agreementDigest: record.agreement_digest,
+      milestoneId: record.milestone_id,
+      documentDigest: bindingDocumentDigest,
+      materialTerms: binding.material_terms,
+    },
+  );
+  const requiredVerification = new Set(BINDING_VERIFICATION_KEYS);
+  if (supersedesDigest === null) {
+    requiredVerification.delete('supersedes_document_action_binding_digest');
+  }
+  if (!exactKeys(verification, BINDING_VERIFICATION_KEYS, requiredVerification)
+    || !verificationMatchesCore(verification, expectedCore(record, {
+      document_action_binding_digest: bindingDigest,
+      release_action_digest: actionDigest,
+    }))
+    || computedBindingDigest !== bindingDigest
+    || binding.binding_digest !== bindingDigest
+    || verification.verification_digest !== bindingDigest
+    || computedActionDigest !== actionDigest
+    || binding.release_action?.digest !== actionDigest
+    || !validDigest(bindingDocumentDigest)
+    || verification.document_digest !== bindingDocumentDigest
+    || verification.agreement_id !== binding.agreement_id
+    || verification.binding_id !== binding.binding_id
+    || computeActionEscrowAgreementDigest(binding.agreement_id) !== record.agreement_digest
+    || releaseActionTemplate === null
+    || !sameCanonical(
+      verification.release_action_template,
+      releaseActionTemplate,
+    )
+    || !sameParties(record.parties, binding.parties)
+    || !sameParties(record.parties, binding.required_parties)
+    || (binding.supersedes_digest ?? null) !== supersedesDigest
+    || (verification.supersedes_document_action_binding_digest ?? null)
+      !== supersedesDigest) {
+    fail('document-action binding is inconsistent with the kernel record');
+  }
+  if (documentDigest !== null
+    && (bindingDocumentDigest !== documentDigest
+      || releaseActionTemplate.document_sha256 !== documentDigest)) {
+    fail('final PDF does not match the kernel document binding');
+  }
+  if (documentLength !== null && binding.document?.byte_length !== documentLength) {
+    fail('final PDF byte length does not match the kernel document binding');
+  }
+  return {
+    agreementId: binding.agreement_id,
+    binding,
+    documentDigest: bindingDocumentDigest,
+  };
+}
+
+function validateAcceptances(entries, record, core, { requireComplete, requireIncomplete = false } = {}) {
+  if (!Array.isArray(entries)) fail('agreement acceptances are malformed');
+  const parties = new Map(record.parties.map((party) => [party.party_id, party]));
+  const required = new Set(record.profile.required_acceptance_party_ids);
+  const seenParties = new Set();
+  const seenKeys = new Set();
+  const result = [];
+  for (const entry of entries) {
+    const verification = entry?.verification;
+    const party = parties.get(entry?.party_id);
+    if (!exactKeys(entry, ACCEPTANCE_KEYS)
+      || !party
+      || !required.has(entry.party_id)
+      || seenParties.has(entry.party_id)
+      || !isRecord(entry.artifact)
+      || !exactKeys(verification, ACCEPTANCE_VERIFICATION_KEYS)
+      || !verificationMatchesCore(verification, core)
+      || verification.party_id !== entry.party_id
+      || !validString(verification.principal_key_id, 512)
+      || seenKeys.has(verification.principal_key_id)
+      || verification.acceptance_digest !== canonicalDigest(entry.artifact)) {
+      fail('agreement acceptance is malformed or inconsistent');
+    }
+    seenParties.add(entry.party_id);
+    seenKeys.add(verification.principal_key_id);
+    result.push({
+      party_id: entry.party_id,
+      role: party.role,
+      evidence: entry.artifact,
+    });
+  }
+  if (requireComplete && seenParties.size !== required.size) {
+    fail('required agreement acceptance is missing');
+  }
+  if (requireIncomplete && seenParties.size >= required.size) {
+    fail('agreement acceptance count is inconsistent with the stage');
+  }
+  return result;
+}
+
+function validateFunding(record) {
+  const template = record.document_action_binding.verification.release_action_template;
+  if (!exactKeys(record.funding, new Set(['statement', 'verification']))
+    || !isRecord(record.funding.statement)
+    || !exactKeys(record.funding.verification, FUNDING_VERIFICATION_KEYS)
+    || !verificationMatchesCore(record.funding.verification, expectedCore(record))
+    || record.funding.verification.authenticated !== true
+    || record.funding.verification.provider_id !== record.profile.provider_id
+    || record.funding.verification.statement_type !== 'funding'
+    || record.funding.verification.status !== 'funded'
+    || record.funding.verification.provider_transaction_id
+      !== template.custodian_transaction_id
+    || record.funding.verification.provider_milestone_id
+      !== template.custodian_milestone_id
+    || record.funding.verification.amount !== template.amount
+    || record.funding.verification.currency !== template.currency
+    || record.funding.verification.destination_id !== template.destination_id
+    || record.funding.verification.statement_digest
+      !== canonicalDigest(record.funding.statement)) {
+    fail('funding statement is malformed or inconsistent');
+  }
+  return record.funding.statement;
+}
+
+function validateMilestone(record) {
+  if (!exactKeys(record.milestone_evidence, CONTAINER_KEYS)
+    || !isRecord(record.milestone_evidence.artifact)
+    || !exactKeys(
+      record.milestone_evidence.verification,
+      MILESTONE_VERIFICATION_KEYS,
+    )
+    || !verificationMatchesCore(
+      record.milestone_evidence.verification,
+      expectedCore(record),
+    )
+    || !validDigest(record.milestone_evidence.verification.evidence_digest)
+    || !record.parties.some(
+      (party) => party.party_id
+        === record.milestone_evidence.verification.submitter_party_id,
+    )
+    || !validInstant(record.milestone_evidence.verification.observed_at)) {
+    fail('milestone evidence is malformed or inconsistent');
+  }
+  const artifact = record.milestone_evidence.artifact;
+  const claimedDigest = artifact.evidence_digest
+    ?? artifact.payload?.claim?.evidence_manifest_digest;
+  if (claimedDigest !== undefined
+    && claimedDigest !== record.milestone_evidence.verification.evidence_digest) {
+    fail('milestone artifact digest does not match its kernel verification');
+  }
+  const submission = record.operations.find(
+    (operation) => operation.operation === 'submit_milestone',
+  );
+  if (!submission
+    || Date.parse(record.milestone_evidence.verification.observed_at)
+      > Date.parse(submission.at)) {
+    fail('milestone evidence was not valid at its submission operation');
+  }
+  return {
+    milestone_id: record.milestone_id,
+    evidence: artifact,
+    resolution: null,
+  };
+}
+
+function validateReleaseApprovals(record, milestoneVerification) {
+  if (!Array.isArray(record.release_approvals)) fail('release approvals are malformed');
+  const parties = new Map(record.parties.map((party) => [party.party_id, party]));
+  const required = new Set(record.profile.required_release_approver_party_ids);
+  const bindingInput = {
+    agreement_digest: record.agreement_digest,
+    document_action_binding_digest: record.document_action_binding_digest,
+    milestone_id: record.milestone_id,
+    release_action_digest: record.release_action_digest,
+    profile_digest: record.profile_digest,
+    evidence_digest: milestoneVerification.evidence_digest,
+    release_action_template:
+      record.document_action_binding.verification.release_action_template,
+  };
+  const bindingMomentDigest = computeActionEscrowReleaseBindingMomentDigest(bindingInput);
+  const expectedInitiator = milestoneVerification.submitter_party_id;
+  if (!validDigest(bindingMomentDigest) || !validString(expectedInitiator, 256)) {
+    fail('release approval binding context is malformed');
+  }
+  const seenParties = new Set();
+  const seenKeys = new Set();
+  const result = [];
+  const approvalOperations = record.operations.filter(
+    (operation) => operation.operation === 'approve_release',
+  );
+  for (const [index, entry] of record.release_approvals.entries()) {
+    const party = parties.get(entry?.party_id);
+    const verification = entry?.verification;
+    const context = entry?.resolution?.signoff?.context;
+    if (!exactKeys(entry, RELEASE_APPROVAL_KEYS)
+      || !party
+      || !required.has(entry.party_id)
+      || seenParties.has(entry.party_id)
+      || !isRecord(entry.resolution)
+      || entry.resolution.profile !== 'EP-RESOLUTION-v1'
+      || !isRecord(context)
+      || !exactKeys(verification, RELEASE_APPROVAL_VERIFICATION_KEYS)
+      || !verificationMatchesCore(verification, expectedCore(record))
+      || verification.authorizes_action !== true
+      || verification.outcome !== 'approved'
+      || verification.party_role !== party.role
+      || !validString(verification.principal_key_id, 512)
+      || seenKeys.has(verification.principal_key_id)
+      || !validString(verification.nonce, 512)
+      || !validInstant(verification.issued_at)
+      || !validInstant(verification.expires_at)
+      || Date.parse(verification.issued_at) < Date.parse(milestoneVerification.observed_at)
+      || Date.parse(verification.expires_at) <= Date.parse(verification.issued_at)
+      || verification.resolution_digest !== canonicalDigest(entry.resolution)
+      || verification.evidence_digest !== milestoneVerification.evidence_digest
+      || context.principal !== entry.party_id
+      || context.principal_key_id !== verification.principal_key_id
+      || context.envelope_hash !== bindingMomentDigest
+      || context.action_hash !== record.release_action_digest
+      || context.initiator !== expectedInitiator
+      || context.nonce !== computeActionEscrowResolutionNonce(bindingInput, entry.party_id)
+      || context.nonce !== verification.nonce
+      || context.issued_at !== verification.issued_at
+      || context.expires_at !== verification.expires_at
+      || context.resolution?.outcome !== 'approved'
+      || context.resolution?.selected_option !== 0) {
+      fail('release approval is malformed or inconsistent');
+    }
+    const approvalOperation = approvalOperations[index];
+    if (!approvalOperation
+      || Date.parse(verification.issued_at) > Date.parse(approvalOperation.at)
+      || Date.parse(verification.expires_at) <= Date.parse(approvalOperation.at)
+      || (
+        record.release !== null
+        && (
+          Date.parse(verification.issued_at) > Date.parse(record.release.reserved_at)
+          || Date.parse(verification.expires_at) <= Date.parse(record.release.reserved_at)
+        )
+      )) {
+      fail('release approval was not valid at its operation');
+    }
+    seenParties.add(entry.party_id);
+    seenKeys.add(verification.principal_key_id);
+    result.push({
+      party_id: entry.party_id,
+      role: party.role,
+      evidence: entry.resolution,
+    });
+  }
+  return { approvals: result, approvedPartyIds: seenParties };
+}
+
+function validateProviderVerification(value, record, release) {
+  const template = record.document_action_binding.verification.release_action_template;
+  if (!exactKeys(value, PROVIDER_VERIFICATION_KEYS)
+    || !verificationMatchesCore(value, expectedCore(record))
+    || value.authenticated !== true
+    || value.provider_id !== record.profile.provider_id
+    || value.provider_idempotency_key !== release.provider_idempotency_key
+    || value.provider_request_digest !== release.provider_request.request_digest
+    || value.provider_transaction_id !== template.custodian_transaction_id
+    || value.provider_milestone_id !== template.custodian_milestone_id
+    || value.amount !== template.amount
+    || value.currency !== template.currency
+    || value.destination_id !== template.destination_id
+    || value.statement_type !== 'release'
+    || !['released', 'not_released', 'pending'].includes(value.status)
+    || !validDigest(value.statement_digest)
+    || value.statement_digest !== canonicalDigest(release.provider_statement)) {
+    fail('provider release statement is malformed or inconsistent');
+  }
+}
+
+function validateRelease(record) {
+  const release = record.release;
+  if (!exactKeys(release, RELEASE_KEYS)
+    || !validString(release.release_key, 256)
+    || !validString(release.provider_idempotency_key, 256)
+    || !validString(release.operation_idempotency_key, 512)
+    || !['reserved', 'released', 'not_released', 'indeterminate'].includes(release.status)
+    || !validInstant(release.reserved_at)
+    || (release.reconciled_at !== null && !validInstant(release.reconciled_at))
+    || !exactKeys(release.provider_request, PROVIDER_REQUEST_KEYS)) {
+    fail('release record is malformed');
+  }
+  const expectedReleaseKey = `ep-ae-reservation:${hashCanonical({
+    '@version': 'EP-ACTION-ESCROW-RELEASE-KEY-v1',
+    agreement_digest: record.agreement_digest,
+    document_action_binding_digest: record.document_action_binding_digest,
+    milestone_id: record.milestone_id,
+    release_action_digest: record.release_action_digest,
+    profile_digest: record.profile_digest,
+  })}`;
+  const expectedProviderKey = `ep-ae-release:${hashCanonical({
+    '@version': 'EP-ACTION-ESCROW-PROVIDER-IDEMPOTENCY-v1',
+    agreement_digest: record.agreement_digest,
+    document_action_binding_digest: record.document_action_binding_digest,
+    milestone_id: record.milestone_id,
+    release_action_digest: record.release_action_digest,
+    profile_digest: record.profile_digest,
+  })}`;
+  if (release.release_key !== expectedReleaseKey
+    || release.provider_idempotency_key !== expectedProviderKey) {
+    fail('release reservation key mismatch');
+  }
+
+  const request = release.provider_request;
+  const { request_digest: requestDigest, ...requestScope } = request;
+  if (request.method !== 'POST'
+    || request.provider_id !== record.profile.provider_id
+    || request.agreement_digest !== record.agreement_digest
+    || request.document_action_binding_digest
+      !== record.document_action_binding_digest
+    || request.milestone_id !== record.milestone_id
+    || request.release_action_digest !== record.release_action_digest
+    || !sameCanonical(request.parties, record.parties)
+    || request.parties_digest !== record.parties_digest
+    || !sameCanonical(request.profile, record.profile)
+    || request.profile_digest !== record.profile_digest
+    || request.agreement_id
+      !== record.document_action_binding.verification.agreement_id
+    || request.binding_id !== record.document_action_binding.verification.binding_id
+    || request.document_digest
+      !== record.document_action_binding.verification.document_digest
+    || !sameCanonical(
+      request.release_action_template,
+      record.document_action_binding.verification.release_action_template,
+    )
+    || request.release_key !== release.release_key
+    || request.idempotency_key !== release.provider_idempotency_key
+    || requestDigest !== canonicalDigest({
+      '@version': 'EP-ACTION-ESCROW-PROVIDER-REQUEST-v1',
+      ...requestScope,
+    })) {
+    fail('provider release request is inconsistent with the kernel record');
+  }
+
+  const execution = record.operations.find((entry) => (
+    entry.operation === 'release'
+      && entry.idempotency_key === release.operation_idempotency_key
+  ));
+  if (!execution) fail('release execution record is missing');
+  if (release.reserved_at !== execution.at
+    || (
+      release.reconciled_at !== null
+      && Date.parse(release.reconciled_at) < Date.parse(release.reserved_at)
+    )) {
+    fail('release timestamps are inconsistent with the execution operation');
+  }
+  const expectedExecution = {
+    reserved: {
+      states: new Set(['release_reserved']),
+      operationStates: new Set(['release_reserved']),
+      codes: new Set(['release_reserved']),
+      ok: false,
+      outcomes: new Set(['reserved']),
+    },
+    released: {
+      states: new Set(['released', 'completed']),
+      operationStates: new Set(['released']),
+      codes: new Set(['release_committed', 'release_reconciled_released']),
+      ok: true,
+      outcomes: new Set(['applied']),
+    },
+    not_released: {
+      states: new Set(['milestone_submitted', 'disputed', 'amendment_pending']),
+      operationStates: new Set(['milestone_submitted', 'amendment_pending']),
+      codes: new Set([
+        'provider_release_not_released',
+        'release_reconciled_not_released',
+      ]),
+      ok: false,
+      outcomes: new Set(['refused']),
+    },
+    indeterminate: {
+      states: new Set(['release_indeterminate']),
+      operationStates: new Set(['release_indeterminate']),
+      codes: new Set([
+        'release_effect_indeterminate',
+        'release_commit_indeterminate',
+        'release_still_indeterminate',
+      ]),
+      ok: false,
+      outcomes: new Set(['indeterminate']),
+    },
+  }[release.status];
+  if (!expectedExecution.states.has(record.state)
+    || !expectedExecution.operationStates.has(execution.state)
+    || !expectedExecution.codes.has(execution.code)
+    || execution.ok !== expectedExecution.ok
+    || !expectedExecution.outcomes.has(execution.outcome)) {
+    fail('release execution record is inconsistent with the release state');
+  }
+
+  if (release.status === 'reserved') {
+    if (release.reconciled_at !== null
+      || release.provider_statement !== null
+      || release.provider_verification !== null) {
+      fail('reserved release carries premature provider evidence');
+    }
+  } else {
+    if (release.reconciled_at === null) fail('reconciled release is missing its instant');
+    const hasStatement = release.provider_statement !== null;
+    const hasVerification = release.provider_verification !== null;
+    if (hasStatement !== hasVerification) {
+      fail('provider release statement and verification must be paired');
+    }
+    if (release.status !== 'indeterminate' && !hasStatement) {
+      fail('authoritative provider release statement is missing');
+    }
+    if (hasStatement) {
+      if (!isRecord(release.provider_statement)) {
+        fail('provider release statement is malformed');
+      }
+      validateProviderVerification(release.provider_verification, record, release);
+      if (release.status !== 'indeterminate'
+        && release.provider_verification.status !== release.status) {
+        fail('provider release status mismatch');
+      }
+    }
+  }
+
+  return {
+    reservation: {
+      release_key: release.release_key,
+      provider_idempotency_key: release.provider_idempotency_key,
+      reserved_at: release.reserved_at,
+    },
+    provider_request: request,
+    provider_statement: release.provider_statement,
+    execution_record: execution,
+  };
+}
+
+function validateCommandAuthorization(container, record, command, partyId, details) {
+  if (!exactKeys(container, COMMAND_CONTAINER_KEYS)
+    || !isRecord(container.artifact)
+    || !exactKeys(container.verification, COMMAND_VERIFICATION_KEYS)
+    || !verificationMatchesCore(container.verification, expectedCore(record))) {
+    fail(`${command} authorization is malformed`);
+  }
+  const detailsDigest = canonicalDigest(details);
+  const commandDigest = canonicalDigest({
+    '@version': 'EP-ACTION-ESCROW-COMMAND-v1',
+    ...expectedCore(record),
+    command,
+    party_id: partyId,
+    details_digest: detailsDigest,
+  });
+  if (container.verification.authorizes_command !== true
+    || container.verification.command !== command
+    || container.verification.party_id !== partyId
+    || container.verification.details_digest !== detailsDigest
+    || container.verification.command_digest !== commandDigest) {
+    fail(`${command} authorization does not match the state change`);
+  }
+}
+
+function validateAncillaryState(record) {
+  if (record.state === 'disputed') {
+    if (!exactKeys(record.dispute, DISPUTE_KEYS)
+      || !record.parties.some((party) => party.party_id === record.dispute.party_id)
+      || !validString(record.dispute.reason, 2048)
+      || !validInstant(record.dispute.opened_at)) {
+      fail('dispute state is malformed');
+    }
+    validateCommandAuthorization(
+      record.dispute.authorization,
+      record,
+      'open_dispute',
+      record.dispute.party_id,
+      { reason: record.dispute.reason },
+    );
+  } else if (record.dispute !== null) {
+    fail('non-disputed stage carries a dispute');
+  }
+
+  if (record.state === 'cancelled') {
+    if (!exactKeys(record.cancellation, CANCELLATION_KEYS)
+      || !record.parties.some(
+        (party) => party.party_id === record.cancellation.party_id,
+      )
+      || (record.cancellation.reason !== null
+        && !validString(record.cancellation.reason, 2048))
+      || !validInstant(record.cancellation.cancelled_at)) {
+      fail('cancellation state is malformed');
+    }
+    validateCommandAuthorization(
+      record.cancellation.authorization,
+      record,
+      'cancel',
+      record.cancellation.party_id,
+      { reason: record.cancellation.reason },
+    );
+  } else if (record.cancellation !== null) {
+    fail('non-cancelled stage carries a cancellation');
+  }
+
+  if (record.state === 'completed') {
+    if (!exactKeys(record.completion, COMPLETION_KEYS)
+      || !record.parties.some((party) => party.party_id === record.completion.party_id)
+      || record.completion.meaning !== 'administrative_archive_only'
+      || !validInstant(record.completion.completed_at)) {
+      fail('completion state is malformed');
+    }
+    validateCommandAuthorization(
+      record.completion.authorization,
+      record,
+      'complete',
+      record.completion.party_id,
+      { meaning: 'administrative_archive_only' },
+    );
+  } else if (record.completion !== null) {
+    fail('non-completed stage carries a completion record');
+  }
+}
+
+function validateSupersessions(record) {
+  if (!Array.isArray(record.superseded_bindings)) {
+    fail('superseded binding history is malformed');
+  }
+  const amendments = [];
+  const amendmentDigests = [];
+  let previousNext = null;
+  const seen = new Set();
+  for (const entry of record.superseded_bindings) {
+    if (!exactKeys(entry, SUPERSESSION_KEYS)
+      || !validDigest(entry.document_action_binding_digest)
+      || !validDigest(entry.release_action_digest)
+      || !validDigest(entry.superseded_by_binding_digest)
+      || !validInstant(entry.superseded_at)
+      || entry.document_action_binding_digest === entry.superseded_by_binding_digest
+      || seen.has(entry.document_action_binding_digest)
+      || (previousNext !== null
+        && entry.document_action_binding_digest !== previousNext)) {
+      fail('superseded binding history is inconsistent');
+    }
+    seen.add(entry.document_action_binding_digest);
+    previousNext = entry.superseded_by_binding_digest;
+    amendments.push(entry);
+    amendmentDigests.push(canonicalDigest(entry));
+  }
+  if (previousNext !== null && previousNext !== record.document_action_binding_digest) {
+    fail('superseded binding history does not terminate at the current binding');
+  }
+  return {
+    amendments,
+    amendmentDigests,
+    currentSupersedes: amendments.at(-1)?.document_action_binding_digest ?? null,
+  };
+}
+
+function validatePendingAmendment(record) {
+  const pendingAllowed = record.state === 'amendment_pending'
+    || record.state === 'release_indeterminate'
+    || record.state === 'cancelled';
+  if (record.pending_amendment === null) {
+    if (record.state === 'amendment_pending') fail('pending amendment is missing');
+    return;
+  }
+  if (!pendingAllowed
+    || !exactKeys(record.pending_amendment, PENDING_AMENDMENT_KEYS)
+    || ![
+      'effective',
+      'awaiting_funding',
+      'funded',
+      'milestone_submitted',
+      'disputed',
+      'release_reserved',
+      'release_indeterminate',
+    ].includes(record.pending_amendment.from_state)
+    || !validDigest(record.pending_amendment.document_action_binding_digest)
+    || !validDigest(record.pending_amendment.release_action_digest)
+    || record.pending_amendment.document_action_binding_digest
+      === record.document_action_binding_digest
+    || !record.parties.some(
+      (party) => party.party_id === record.pending_amendment.proposer_party_id,
+    )
+    || !validInstant(record.pending_amendment.proposed_at)) {
+    fail('pending amendment is malformed');
+  }
+  if (record.state === 'amendment_pending'
+    && ['release_reserved', 'release_indeterminate'].includes(
+      record.pending_amendment.from_state,
+    )) {
+    fail('pending amendment stage is inconsistent with release reconciliation');
+  }
+  if (record.state === 'release_indeterminate'
+    && !['release_reserved', 'release_indeterminate'].includes(
+      record.pending_amendment.from_state,
+    )) {
+    fail('indeterminate amendment does not originate from an uncertain release');
+  }
+
+  validateBindingContainer(
+    record.pending_amendment.document_action_binding,
+    record,
+    {
+      bindingDigest: record.pending_amendment.document_action_binding_digest,
+      actionDigest: record.pending_amendment.release_action_digest,
+      supersedesDigest: record.document_action_binding_digest,
+    },
+  );
+  const pendingCore = expectedCore(record, {
+    document_action_binding_digest:
+      record.pending_amendment.document_action_binding_digest,
+    release_action_digest: record.pending_amendment.release_action_digest,
+  });
+  validateAcceptances(
+    record.pending_amendment.agreement_acceptances,
+    record,
+    pendingCore,
+    { requireComplete: false, requireIncomplete: true },
+  );
+  validateCommandAuthorization(
+    record.pending_amendment.proposal_authorization,
+    record,
+    'propose_amendment',
+    record.pending_amendment.proposer_party_id,
+    {
+      next_document_action_binding_digest:
+        record.pending_amendment.document_action_binding_digest,
+      next_release_action_digest: record.pending_amendment.release_action_digest,
+    },
+  );
+}
+
+function validateLifecycle(record) {
+  const requiresExecutedAgreement = EXECUTED_AGREEMENT_STATES.has(record.state);
+  const agreementAcceptances = validateAcceptances(
+    record.agreement_acceptances,
+    record,
+    expectedCore(record),
+    {
+      requireComplete: requiresExecutedAgreement,
+      requireIncomplete: record.state === 'awaiting_acceptance',
+    },
+  );
+  if (record.state === 'draft' && agreementAcceptances.length !== 0) {
+    fail('draft stage carries agreement acceptances');
+  }
+
+  const requiresFunding = FUNDING_STATES.has(record.state);
+  if (requiresFunding !== (record.funding !== null)) {
+    fail(requiresFunding
+      ? 'required funding statement is missing'
+      : 'stage carries an unexpected funding statement');
+  }
+  const fundingStatement = record.funding === null ? null : validateFunding(record);
+
+  const requiresMilestone = MILESTONE_STATES.has(record.state);
+  if (requiresMilestone !== (record.milestone_evidence !== null)) {
+    fail(requiresMilestone
+      ? 'required milestone evidence is missing'
+      : 'stage carries unexpected milestone evidence');
+  }
+  const milestone = record.milestone_evidence === null ? null : validateMilestone(record);
+
+  validateLifecycleOperationCoverage(record);
+  if (!RELEASE_APPROVAL_STATES.has(record.state)
+    && record.release_approvals.length !== 0) {
+    fail('stage carries unexpected release approvals');
+  }
+  if (record.release_approvals.length > 0 && milestone === null) {
+    fail('release approval has no milestone evidence');
+  }
+  const releaseApprovalResult = milestone === null
+    ? { approvals: [], approvedPartyIds: new Set() }
+    : validateReleaseApprovals(record, record.milestone_evidence.verification);
+  if (COMPLETE_RELEASE_APPROVAL_STATES.has(record.state)
+    && releaseApprovalResult.approvedPartyIds.size
+      !== record.profile.required_release_approver_party_ids.length) {
+    fail('required release approval is missing');
+  }
+
+  const hasRelease = record.release !== null;
+  if (REQUIRED_RELEASE_STATES.has(record.state) && !hasRelease) {
+    fail('required release artifacts are missing');
+  }
+  if (!REQUIRED_RELEASE_STATES.has(record.state)
+    && !OPTIONAL_RELEASE_STATES.has(record.state)
+    && hasRelease) {
+    fail('stage carries unexpected release artifacts');
+  }
+  const release = hasRelease ? validateRelease(record) : null;
+
+  validateAncillaryState(record);
+  validatePendingAmendment(record);
+
+  return {
+    requiresExecutedAgreement,
+    agreementAcceptances,
+    fundingStatement,
+    milestones: milestone === null ? [] : [milestone],
+    releaseApprovals: releaseApprovalResult.approvals,
+    release,
+  };
+}
+
+function validateLifecycleOperationCoverage(record) {
+  const count = (name) => record.operations
+    .filter((operation) => operation.operation === name).length;
+  const requireExact = (name, expected) => {
+    if (count(name) !== expected) {
+      fail(`kernel ${name} operation coverage does not match its artifacts`);
+    }
+  };
+  const acceptanceCount = record.profile.required_acceptance_party_ids.length;
+  const expectedInitialAcceptances = record.superseded_bindings.length > 0
+    ? acceptanceCount
+    : record.agreement_acceptances.length;
+  const expectedAmendmentAcceptances =
+    record.superseded_bindings.length * acceptanceCount
+      + (Array.isArray(record.pending_amendment?.agreement_acceptances)
+        ? record.pending_amendment.agreement_acceptances.length
+        : 0);
+
+  requireExact('create', 1);
+  requireExact(
+    'begin_acceptance',
+    record.history.some((entry) => entry.to === 'awaiting_acceptance') ? 1 : 0,
+  );
+  requireExact('accept_agreement', expectedInitialAcceptances);
+  requireExact(
+    'request_funding',
+    record.history.some((entry) => entry.to === 'awaiting_funding') ? 1 : 0,
+  );
+  requireExact('record_funding', record.funding === null ? 0 : 1);
+  requireExact('submit_milestone', record.milestone_evidence === null ? 0 : 1);
+  requireExact('approve_release', record.release_approvals.length);
+  requireExact(
+    'propose_amendment',
+    record.superseded_bindings.length + (record.pending_amendment === null ? 0 : 1),
+  );
+  requireExact('accept_amendment', expectedAmendmentAcceptances);
+  requireExact('open_dispute', record.dispute === null ? 0 : 1);
+  requireExact('cancel', record.cancellation === null ? 0 : 1);
+  requireExact('complete', record.completion === null ? 0 : 1);
+  if ((record.release === null) !== (count('release') === 0)) {
+    fail('kernel release operation coverage does not match its artifacts');
+  }
+  if (record.release === null && count('reconcile_release') !== 0) {
+    fail('kernel reconciliation operation has no release artifact');
+  }
+}
+
+function validateKernelRecord(record) {
+  if (!exactKeys(record, RECORD_KEYS)
+    || record['@version'] !== ACTION_ESCROW_STATE_VERSION
+    || !Number.isSafeInteger(record.revision)
+    || record.revision < 0
+    || !ACTION_ESCROW_STATES.includes(record.state)
+    || !validString(record.escrow_key, 256)
+    || !validDigest(record.agreement_digest)
+    || !validDigest(record.document_action_binding_digest)
+    || !validString(record.milestone_id, 256)
+    || !validDigest(record.release_action_digest)
+    || !validDigest(record.parties_digest)
+    || !validDigest(record.profile_digest)
+    || !validInstant(record.created_at)
+    || !validInstant(record.updated_at)) {
+    fail('kernel record is malformed');
+  }
+  const expectedEscrowKey = `ep-action-escrow:${hashCanonical({
+    '@version': 'EP-ACTION-ESCROW-KEY-v1',
+    agreement_digest: record.agreement_digest,
+    milestone_id: record.milestone_id,
+  })}`;
+  if (record.escrow_key !== expectedEscrowKey) fail('kernel escrow key mismatch');
+  validatePartiesAndProfile(record);
+  validateHistory(record);
+}
+
+function validateDocumentExecution(value, expected, required) {
+  if (value === null) {
+    if (required) fail('required document-execution artifact is missing');
+    return null;
+  }
+  if (!isRecord(value)
+    || value.agreement_id !== expected.agreementId
+    || value.binding_digest !== expected.bindingDigest
+    || value.document_digest !== expected.documentDigest
+    || value.authorizes_action !== false
+    || (value.state !== undefined && value.state !== 'executed')) {
+    fail('document-execution artifact does not match the kernel record');
+  }
+  return value;
+}
+
+function validateProfileReference(value, record) {
+  if (!exactKeys(value, PROFILE_REFERENCE_KEYS)
+    || value.id !== record.profile.profile_id
+    || value.digest !== record.profile_digest) {
+    fail('verification-profile reference mismatch');
+  }
+}
+
+function stateStatementDigest(statement) {
+  const body = {
+    version: statement.version,
+    issuer: statement.issuer,
+    payload: statement.payload,
+  };
+  const bytes = Buffer.from(
+    ACTION_ESCROW_STATE_STATEMENT_DOMAIN + canonicalize(body),
+    'utf8',
+  );
+  return `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`;
+}
+
+function validateStateStatement(
+  statement,
+  record,
+  agreementId,
+  amendmentDigests,
+  assembledAt,
+) {
+  if (!exactKeys(statement, STATE_STATEMENT_KEYS)
+    || statement.version !== ACTION_ESCROW_STATE_STATEMENT_VERSION
+    || !exactKeys(statement.issuer, STATE_ISSUER_KEYS)
+    || !validString(statement.issuer.operator_id, 256)
+    || !validString(statement.issuer.key_id, 256)
+    || !exactKeys(statement.payload, STATE_PAYLOAD_KEYS)
+    || !validString(statement.payload.statement_id, 256)
+    || statement.payload.agreement_id !== agreementId
+    || statement.payload.binding_digest !== record.document_action_binding_digest
+    || statement.payload.action_digest !== record.release_action_digest
+    || statement.payload.profile_digest !== record.profile_digest
+    || statement.payload.state !== record.state
+    || statement.payload.revision !== record.revision
+    || !Array.isArray(statement.payload.amendment_digests)
+    || statement.payload.amendment_digests.length !== amendmentDigests.length
+    || statement.payload.amendment_digests.some(
+      (digest, index) => digest !== amendmentDigests[index],
+    )
+    || statement.payload.state_record_digest !== canonicalDigest(record)
+    || (statement.payload.previous_statement_digest !== null
+      && !validDigest(statement.payload.previous_statement_digest))
+    || !validInstant(statement.payload.occurred_at)
+    || Date.parse(statement.payload.occurred_at) > assembledAt
+    || !exactKeys(statement.signature, STATE_SIGNATURE_KEYS)
+    || statement.signature.algorithm !== 'Ed25519'
+    || typeof statement.signature.signature_b64u !== 'string'
+    || !BASE64URL.test(statement.signature.signature_b64u)
+    || statement.signature.signature_b64u.length % 4 === 1
+    || !validDigest(statement.statement_digest)
+    || statement.statement_digest !== stateStatementDigest(statement)) {
+    fail('operator state statement mismatch');
+  }
+}
+
+function finalPdfBytes(value, maxDocumentBytes) {
+  if (!(Buffer.isBuffer(value) || value instanceof Uint8Array)) {
+    fail('finalPdfBytes must be bytes');
+  }
+  const bytes = Buffer.from(value);
+  if (bytes.length === 0 || bytes.length > maxDocumentBytes) {
+    fail(`finalPdfBytes must be between 1 and ${maxDocumentBytes} bytes`);
+  }
+  if (!bytes.subarray(0, 5).equals(Buffer.from('%PDF-', 'ascii'))
+    || !bytes.subarray(Math.max(0, bytes.length - 1024)).includes(Buffer.from('%%EOF'))) {
+    fail('finalPdfBytes is not a final PDF');
+  }
+  return bytes;
+}
+
+function evaluationInstant(value) {
+  const candidate = typeof value === 'function' ? value() : value;
+  const parsed = candidate instanceof Date
+    ? candidate.getTime()
+    : typeof candidate === 'number'
+      ? candidate
+      : Date.parse(candidate);
+  if (!Number.isFinite(parsed)) fail('now must be a valid instant');
+  return parsed;
+}
+
+/**
+ * Assemble an EP-ACTION-ESCROW-EVIDENCE-PACKAGE-v1 from one exact durable
+ * kernel record and the external artifacts the kernel deliberately does not
+ * retain. Invalid local assembly input throws before a package is produced.
+ */
+export function assembleActionEscrowEvidencePackage(input = {}, options = {}) {
+  if (!exactKeys(input, INPUT_KEYS)) {
+    fail('caller overrides are not accepted; use the closed assembler input');
+  }
+  if (!exactKeys(options, OPTION_KEYS, new Set())) {
+    fail('caller overrides are not accepted in assembler options');
+  }
+  const maxDocumentBytes = options.maxDocumentBytes ?? DEFAULT_MAX_DOCUMENT_BYTES;
+  if (!Number.isSafeInteger(maxDocumentBytes) || maxDocumentBytes <= 0) {
+    fail('maxDocumentBytes must be a positive safe integer');
+  }
+  const assembledAt = evaluationInstant(options.now ?? Date.now);
+  const bytes = finalPdfBytes(input.finalPdfBytes, maxDocumentBytes);
+  const record = canonicalCopy(input.kernelRecord, 'kernelRecord');
+  const documentExecution = input.documentExecution === null
+    ? null
+    : canonicalCopy(input.documentExecution, 'documentExecution');
+  const stateStatement = canonicalCopy(
+    input.operatorStateStatement,
+    'operatorStateStatement',
+  );
+  const verificationProfile = canonicalCopy(
+    input.verificationProfile,
+    'verificationProfile',
+  );
+
+  assertNoSecrets(record, 'kernelRecord');
+  assertNoSecrets(documentExecution, 'documentExecution');
+  assertNoSecrets(stateStatement, 'operatorStateStatement');
+  assertNoSecrets(verificationProfile, 'verificationProfile');
+
+  validateKernelRecord(record);
+  if (Date.parse(record.updated_at) > assembledAt) {
+    fail('kernel record is from the future');
+  }
+  const supersessions = validateSupersessions(record);
+  const documentDigest = computeDocumentSha256(bytes);
+  const binding = validateBindingContainer(record.document_action_binding, record, {
+    supersedesDigest: supersessions.currentSupersedes,
+    documentDigest,
+    documentLength: bytes.length,
+  });
+  const lifecycle = validateLifecycle(record);
+  const execution = validateDocumentExecution(
+    documentExecution,
+    {
+      agreementId: binding.agreementId,
+      bindingDigest: record.document_action_binding_digest,
+      documentDigest,
+    },
+    lifecycle.requiresExecutedAgreement,
+  );
+  validateProfileReference(verificationProfile, record);
+  validateStateStatement(
+    stateStatement,
+    record,
+    binding.agreementId,
+    supersessions.amendmentDigests,
+    assembledAt,
+  );
+
+  return buildActionEscrowEvidencePackage({
+    agreementId: binding.agreementId,
+    stage: record.state,
+    binding: binding.binding,
+    documentBytes: bytes,
+    documentFileName: input.documentFileName,
+    documentExecution: execution,
+    agreementAcceptances: lifecycle.agreementAcceptances,
+    releaseApprovals: lifecycle.releaseApprovals,
+    fundingStatement: lifecycle.fundingStatement,
+    milestones: lifecycle.milestones,
+    release: lifecycle.release,
+    stateRecord: {
+      snapshot: record,
+      statement: stateStatement,
+    },
+    amendments: supersessions.amendments,
+    verificationProfile,
+  }, {
+    now: assembledAt,
+    maxDocumentBytes,
+  });
+}
+
+export const buildActionEscrowEvidencePackageFromKernel =
+  assembleActionEscrowEvidencePackage;
+
+export default {
+  assembleActionEscrowEvidencePackage,
+  buildActionEscrowEvidencePackageFromKernel,
+};