chainlesschain 0.166.17 → 0.166.18

package/src/lib/evolution/evolution-ledger.js

@@ -26,6 +26,14 @@ export const EVOLUTION_LEDGER_WITNESS_ANCESTRY_SCHEMA =
   "chainlesschain.evolution-ledger-witness-ancestry/v1";
 export const EVOLUTION_LEDGER_STORE_MARKER_SCHEMA =
   "chainlesschain.evolution-ledger-store-marker/v1";
+export const EVOLUTION_LEDGER_AUDIT_EXPORT_SCHEMA =
+  "chainlesschain.evolution-ledger-audit-export/v1";
+export const EVOLUTION_LEDGER_AUDIT_ARTIFACT_SCHEMA =
+  "chainlesschain.evolution-ledger-audit-artifact/v1";
+export const EVOLUTION_LEDGER_AUDIT_VERIFICATION_SCHEMA =
+  "chainlesschain.evolution-ledger-audit-verification/v1";
+export const EVOLUTION_LEDGER_STATE_SNAPSHOT_SCHEMA =
+  "chainlesschain.evolution-ledger-state-snapshot/v1";
 export const EVOLUTION_ARTIFACT_REF_SCHEMA =
   "chainlesschain.content-addressed-artifact-ref/v1";
 export const EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA =
@@ -52,9 +60,15 @@ const DISCARD_ACCUMULATOR_DOMAIN =
   "chainlesschain.evolution-witness-discard-accumulator/v1\0";
 const ARTIFACT_VALIDATION_DOMAIN =
   "chainlesschain.evolution-artifact-validation/v1\0";
+const AUDIT_EXPORT_DOMAIN = "chainlesschain.evolution-ledger-audit-export/v1\0";
+const STATE_SNAPSHOT_DOMAIN =
+  "chainlesschain.evolution-ledger-state-snapshot/v1\0";
+const STATE_SNAPSHOT_CONTENT_DOMAIN =
+  "chainlesschain.evolution-ledger-state-snapshot-content/v1\0";
 const IDENTITY_FILE_NAME = "identity-v1.json";
 const STORE_MARKER_FILE_NAME = "store-marker-v1.json";
 const HEAD_FILE_NAME = "head-v1.json";
+const STATE_SNAPSHOT_FILE_PREFIX = "state-snapshot-v1-";
 const SEGMENT_DIRECTORY_NAME = "segments-v1";
 const ANCHOR_DIRECTORY_NAME = "head-anchors-v1";
 const LOCK_TARGET_NAME = "ledger-v2";
@@ -68,10 +82,15 @@ const SIGNATURE_VALUE_PATTERN = /^[A-Za-z0-9_-]{22,8192}$/u;
 const RANDOM_TOKEN_PATTERN = /^[A-Za-z0-9-]{16,128}$/u;
 const SEGMENT_FILE_PATTERN = /^(\d{12})-([a-f0-9]{64})\.json$/u;
 const ANCHOR_FILE_PATTERN = /^(\d{12})-([a-f0-9]{64})\.json$/u;
+const STATE_SNAPSHOT_FILE_PATTERN = /^state-snapshot-v1-([a-f0-9]{64})\.json$/u;
 const STAGE_FILE_PATTERN = /^\.stage-(.+)\.([A-Za-z0-9-]{16,128})\.tmp$/u;
 const HEAD_STAGE_FILE_PATTERN =
   /^\.replace-head-v1\.json\.([A-Za-z0-9-]{16,128})\.tmp$/u;
 const MAX_SOURCE_REFS = 256;
+const MAX_AUDIT_ARTIFACT_RECORDS = 1_000_000;
+const MAX_LEDGER_BATCH_QUERIES = 10_000;
+const MAX_STATE_SNAPSHOT_BYTES = 256 * 1024 * 1024;
+const STATE_QUERY_INDEXES = new WeakMap();
 const TYPED_ARRAY_PROTOTYPE = Object.getPrototypeOf(Uint8Array.prototype);
 const TYPED_ARRAY_BUFFER_GETTER = Object.getOwnPropertyDescriptor(
   TYPED_ARRAY_PROTOTYPE,
@@ -371,6 +390,67 @@ const STORE_MARKER_RECORD_KEYS = new Set([
 const QUERY_SELECTOR_KEYS = new Set(["eventDigest", "eventId", "sequence"]);
 const QUERY_OPTION_KEYS = new Set(["issueReceipt"]);
 const VERIFY_RECEIPT_OPTION_KEYS = new Set(["requireCurrentHead"]);
+const AUDIT_EXPORT_CORE_KEYS = new Set([
+  "anchors",
+  "artifacts",
+  "events",
+  "exportedAt",
+  "identity",
+  "schema",
+  "storeMarker",
+  "witness",
+]);
+const AUDIT_EXPORT_RECORD_KEYS = new Set([
+  ...AUDIT_EXPORT_CORE_KEYS,
+  "exportDigest",
+]);
+const AUDIT_ARTIFACT_KEYS = new Set([
+  "artifactRef",
+  "byteLength",
+  "bytesBase64",
+  "eventSequence",
+  "receiptDigest",
+  "schema",
+  "tenantId",
+]);
+const AUDIT_VERIFY_PORT_KEYS = new Set([
+  "trust",
+  "verifySignature",
+  "verifyWitnessSignature",
+  "witnessTrust",
+]);
+const STATE_SNAPSHOT_CORE_KEYS = new Set([
+  "algorithm",
+  "anchorDigest",
+  "createdAt",
+  "epoch",
+  "headDigest",
+  "identityDigest",
+  "keyId",
+  "ledgerId",
+  "schema",
+  "sequence",
+  "stateDigest",
+  "storeMarkerDigest",
+  "storeMarkerEntryDigest",
+  "trustPolicyDigest",
+  "witnessDigest",
+  "witnessGeneration",
+  "witnessId",
+]);
+const STATE_SNAPSHOT_RECORD_KEYS = new Set([
+  ...STATE_SNAPSHOT_CORE_KEYS,
+  "signature",
+  "snapshotDigest",
+  "state",
+]);
+const STATE_SNAPSHOT_CONTENT_KEYS = new Set([
+  "anchorFiles",
+  "anchors",
+  "events",
+  "segmentFiles",
+]);
+const STATE_SNAPSHOT_FILE_KEYS = new Set(["contentDigest", "name"]);
 
 const REQUIRED_FS_METHODS = Object.freeze([
   "closeSync",
@@ -1236,6 +1316,42 @@ function normalizeAnchorCore(value) {
   };
 }
 
+function normalizeStateSnapshotCore(value) {
+  assertExactKeys(value, STATE_SNAPSHOT_CORE_KEYS, "state snapshot core");
+  if (value.schema !== EVOLUTION_LEDGER_STATE_SNAPSHOT_SCHEMA) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_SCHEMA_INVALID",
+      "state snapshot schema is unsupported",
+    );
+  }
+  return {
+    algorithm: boundedString(value.algorithm, "algorithm", 64),
+    anchorDigest: digest(value.anchorDigest, "anchorDigest"),
+    createdAt: canonicalTimestamp(value.createdAt, "createdAt"),
+    epoch: identifier(value.epoch, "epoch"),
+    headDigest: digest(value.headDigest, "headDigest", { nullable: true }),
+    identityDigest: digest(value.identityDigest, "identityDigest"),
+    keyId: boundedString(value.keyId, "keyId", 256),
+    ledgerId: identifier(value.ledgerId, "ledgerId"),
+    schema: EVOLUTION_LEDGER_STATE_SNAPSHOT_SCHEMA,
+    sequence: safeSequence(value.sequence, "sequence", { allowZero: true }),
+    stateDigest: digest(value.stateDigest, "stateDigest"),
+    storeMarkerDigest: digest(value.storeMarkerDigest, "storeMarkerDigest"),
+    storeMarkerEntryDigest: digest(
+      value.storeMarkerEntryDigest,
+      "storeMarkerEntryDigest",
+    ),
+    trustPolicyDigest: digest(value.trustPolicyDigest, "trustPolicyDigest"),
+    witnessDigest: digest(value.witnessDigest, "witnessDigest"),
+    witnessGeneration: safeSequence(
+      value.witnessGeneration,
+      "witnessGeneration",
+      { allowZero: true },
+    ),
+    witnessId: identifier(value.witnessId, "witnessId"),
+  };
+}
+
 function normalizeReceiptCore(value, trust, witnessTrust) {
   assertExactKeys(value, RECEIPT_CORE_KEYS, "receipt core");
   if (value.schema !== EVOLUTION_LEDGER_RECEIPT_SCHEMA) {
@@ -1676,6 +1792,10 @@ function anchorFileName(sequence, anchorDigest) {
   return `${sequenceName(sequence)}-${anchorDigest.slice("sha256:".length)}.json`;
 }
 
+function stateSnapshotFileName(witnessDigest) {
+  return `${STATE_SNAPSHOT_FILE_PREFIX}${witnessDigest.slice("sha256:".length)}.json`;
+}
+
 function defaultRootDir() {
   return path.join(getHomeDir(), "evolution", "ledger", "events");
 }
@@ -2179,7 +2299,7 @@ export class EvolutionLedger {
     return deepFreeze({ ...core, signature, storeMarkerDigest });
   }
 
-  #verifyEvent(record, previous, identity) {
+  #verifyEvent(record, previous, identity, { verifySignature = true } = {}) {
     assertPlainDataObject(record, "event record");
     const schema = Object.getOwnPropertyDescriptor(record, "schema")?.value;
     const domainEvent = schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA;
@@ -2210,16 +2330,23 @@ export class EvolutionLedger {
         { sequence: core.sequence },
       );
     }
-    this.#verifyMessage({
-      digest: eventDigest,
-      message,
-      purpose: domainEvent ? "domain-event" : "event",
-      signature,
-    });
+    if (verifySignature) {
+      this.#verifyMessage({
+        digest: eventDigest,
+        message,
+        purpose: domainEvent ? "domain-event" : "event",
+        signature,
+      });
+    }
     return deepFreeze({ ...core, eventDigest, signature });
   }
 
-  #verifyAnchor(record, previous, identity, { standalone = false } = {}) {
+  #verifyAnchor(
+    record,
+    previous,
+    identity,
+    { standalone = false, verifySignature = true } = {},
+  ) {
     assertExactKeys(record, ANCHOR_RECORD_KEYS, "anchor record");
     const core = normalizeAnchorCore(
       Object.fromEntries(
@@ -2247,12 +2374,14 @@ export class EvolutionLedger {
         { sequence: core.sequence },
       );
     }
-    this.#verifyMessage({
-      digest: anchorDigest,
-      message,
-      purpose: "anchor",
-      signature,
-    });
+    if (verifySignature) {
+      this.#verifyMessage({
+        digest: anchorDigest,
+        message,
+        purpose: "anchor",
+        signature,
+      });
+    }
     return deepFreeze({ ...core, anchorDigest, signature });
   }
 
@@ -3004,7 +3133,10 @@ export class EvolutionLedger {
     this.#cleanupDirectoryDebris(this.#paths.anchorDir, ANCHOR_FILE_PATTERN);
     this.#cleanupDirectoryDebris(
       this.#paths.authorityRootDir,
-      new RegExp(`^${IDENTITY_FILE_NAME.replace(".", "\\.")}$`, "u"),
+      new RegExp(
+        `^(?:${IDENTITY_FILE_NAME.replace(".", "\\.")}|${STATE_SNAPSHOT_FILE_PATTERN.source.slice(1, -1)})$`,
+        "u",
+      ),
     );
     this.#cleanupDirectoryDebris(
       this.#paths.rootDir,
@@ -3249,6 +3381,331 @@ export class EvolutionLedger {
     }
   }
 
+  #snapshotFileRecords(values, label, expectedNames) {
+    const entries = readDenseDataArray(
+      values,
+      label,
+      EVOLUTION_LEDGER_MAX_EVENTS + 1,
+    );
+    if (entries.length !== expectedNames.length) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        `${label} does not cover the current immutable prefix`,
+      );
+    }
+    return entries.map((entry, index) => {
+      assertExactKeys(entry, STATE_SNAPSHOT_FILE_KEYS, `${label} entry`);
+      const normalized = {
+        contentDigest: digest(entry.contentDigest, "contentDigest"),
+        name: boundedString(entry.name, "name", 256),
+      };
+      if (normalized.name !== expectedNames[index]) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_CORRUPT",
+          `${label} is missing or reordered at index ${index}`,
+        );
+      }
+      return Object.freeze(normalized);
+    });
+  }
+
+  #verifyStateSnapshot(
+    record,
+    identity,
+    storeMarker,
+    witnessed,
+    head,
+    anchorNames,
+    segmentNames,
+  ) {
+    assertExactKeys(record, STATE_SNAPSHOT_RECORD_KEYS, "state snapshot");
+    const core = normalizeStateSnapshotCore(
+      Object.fromEntries(
+        [...STATE_SNAPSHOT_CORE_KEYS].map((key) => [key, record[key]]),
+      ),
+    );
+    const snapshotDigest = digest(record.snapshotDigest, "snapshotDigest");
+    const signature = normalizeSignature(record.signature, this.#trust);
+    const message = signedMessage(STATE_SNAPSHOT_DOMAIN, core);
+    if (snapshotDigest !== sha256(message)) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        "state snapshot digest does not match its signed core",
+      );
+    }
+    this.#verifyMessage({
+      digest: snapshotDigest,
+      message,
+      purpose: "state-snapshot",
+      signature,
+    });
+    if (
+      core.algorithm !== this.#trust.algorithm ||
+      core.keyId !== this.#trust.keyId ||
+      core.trustPolicyDigest !== this.#trust.trustPolicyDigest ||
+      core.ledgerId !== identity.ledgerId ||
+      core.epoch !== identity.epoch ||
+      core.identityDigest !== identity.identityDigest ||
+      core.storeMarkerDigest !== storeMarker.storeMarkerDigest ||
+      core.storeMarkerEntryDigest !== identity.storeMarkerEntryDigest ||
+      core.witnessId !== witnessed.witnessId ||
+      core.witnessDigest !== witnessed.witnessDigest ||
+      core.witnessGeneration !== witnessed.generation ||
+      core.sequence !== witnessed.sequence ||
+      core.sequence !== head.sequence ||
+      core.anchorDigest !== head.anchorDigest ||
+      core.headDigest !== head.headDigest
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        "state snapshot is stale or not bound to the current authority",
+      );
+    }
+
+    assertExactKeys(
+      record.state,
+      STATE_SNAPSHOT_CONTENT_KEYS,
+      "state snapshot content",
+    );
+    if (
+      core.stateDigest !==
+      domainDigest(STATE_SNAPSHOT_CONTENT_DOMAIN, record.state)
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        "state snapshot content digest does not match its signed core",
+      );
+    }
+    const anchorRecords = readDenseDataArray(
+      record.state.anchors,
+      "state snapshot anchors",
+      EVOLUTION_LEDGER_MAX_EVENTS + 1,
+    );
+    const eventRecords = readDenseDataArray(
+      record.state.events,
+      "state snapshot events",
+      EVOLUTION_LEDGER_MAX_EVENTS,
+    );
+    if (
+      anchorRecords.length !== eventRecords.length + 1 ||
+      eventRecords.length !== core.sequence
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        "state snapshot chain length does not match its authority checkpoint",
+      );
+    }
+
+    const anchors = [];
+    const events = [];
+    const eventIds = new Set();
+    for (let index = 0; index < anchorRecords.length; index += 1) {
+      const anchor = this.#verifyAnchor(
+        anchorRecords[index],
+        anchors.at(-1),
+        identity,
+        { verifySignature: false },
+      );
+      anchors.push(anchor);
+      if (index === 0) continue;
+      const event = this.#verifyEvent(
+        eventRecords[index - 1],
+        events.at(-1),
+        identity,
+        { verifySignature: false },
+      );
+      if (
+        event.sequence !== anchor.sequence ||
+        event.eventDigest !== anchor.headDigest ||
+        domainDigest(SEGMENT_DOMAIN, event) !== anchor.segmentDigest ||
+        eventIds.has(event.eventId)
+      ) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_CORRUPT",
+          `state snapshot event/anchor binding failed at sequence ${index}`,
+        );
+      }
+      eventIds.add(event.eventId);
+      events.push(event);
+    }
+    if (anchors.at(-1).anchorDigest !== core.anchorDigest) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        "state snapshot chain does not terminate at its signed anchor",
+      );
+    }
+    const derivedAnchorNames = anchors.map((anchor) =>
+      anchorFileName(anchor.sequence, anchor.anchorDigest),
+    );
+    const derivedSegmentNames = anchors
+      .slice(1)
+      .map((anchor) => segmentFileName(anchor.sequence, anchor.segmentDigest));
+    if (
+      derivedAnchorNames.some((name, index) => name !== anchorNames[index]) ||
+      derivedSegmentNames.some((name, index) => name !== segmentNames[index])
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_CORRUPT",
+        "state snapshot records do not address the current immutable files",
+      );
+    }
+
+    const anchorFiles = this.#snapshotFileRecords(
+      record.state.anchorFiles,
+      "state snapshot anchor files",
+      anchorNames,
+    );
+    const segmentFiles = this.#snapshotFileRecords(
+      record.state.segmentFiles,
+      "state snapshot segment files",
+      segmentNames,
+    );
+    const anchorFingerprints = {};
+    const segmentFingerprints = {};
+    for (let index = 0; index < anchorFiles.length; index += 1) {
+      const entry = anchorFiles[index];
+      const snapshotRecordDigest = sha256(
+        Buffer.from(`${canonicalJson(anchorRecords[index])}\n`, "utf8"),
+      );
+      if (entry.contentDigest !== snapshotRecordDigest) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_CORRUPT",
+          `state snapshot anchor bytes are not bound at index ${index}`,
+        );
+      }
+      const file = this.#readCanonicalFile(
+        path.join(this.#paths.anchorDir, entry.name),
+        64 * 1024,
+        `state snapshot anchor file ${entry.name}`,
+      );
+      if (file.contentDigest !== entry.contentDigest) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_CORRUPT",
+          `state snapshot anchor file changed: ${entry.name}`,
+        );
+      }
+      anchorFingerprints[entry.name] = Object.freeze({
+        contentDigest: file.contentDigest,
+        fingerprint: file.fingerprint,
+      });
+    }
+    for (let index = 0; index < segmentFiles.length; index += 1) {
+      const entry = segmentFiles[index];
+      const snapshotRecordDigest = sha256(
+        Buffer.from(`${canonicalJson(eventRecords[index])}\n`, "utf8"),
+      );
+      if (entry.contentDigest !== snapshotRecordDigest) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_CORRUPT",
+          `state snapshot event bytes are not bound at index ${index}`,
+        );
+      }
+      const file = this.#readCanonicalFile(
+        path.join(this.#paths.segmentDir, entry.name),
+        EVOLUTION_LEDGER_MAX_EVENT_BYTES,
+        `state snapshot segment file ${entry.name}`,
+      );
+      if (file.contentDigest !== entry.contentDigest) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_CORRUPT",
+          `state snapshot segment file changed: ${entry.name}`,
+        );
+      }
+      segmentFingerprints[entry.name] = Object.freeze({
+        contentDigest: file.contentDigest,
+        fingerprint: file.fingerprint,
+      });
+    }
+
+    const maximumAnchor = anchors.at(-1);
+    const maximumEvent = events.at(-1) || null;
+    this.#assertWitnessSnapshot(
+      witnessed,
+      identity,
+      storeMarker,
+      maximumAnchor,
+      maximumEvent,
+    );
+    const state = deepFreeze({
+      anchors,
+      events,
+      head,
+      identity,
+      storeMarker,
+      witness: witnessed,
+    });
+    return this.#rememberState(
+      state,
+      anchorNames,
+      segmentNames,
+      anchorFingerprints,
+      segmentFingerprints,
+    );
+  }
+
+  #tryStateSnapshot(
+    identity,
+    storeMarker,
+    witnessed,
+    head,
+    anchorNames,
+    segmentNames,
+  ) {
+    if (witnessed.status !== "committed") return null;
+    const snapshotPath = path.join(
+      this.#paths.authorityRootDir,
+      stateSnapshotFileName(witnessed.witnessDigest),
+    );
+    try {
+      const snapshotFile = this.#readCanonicalFile(
+        snapshotPath,
+        MAX_STATE_SNAPSHOT_BYTES,
+        "state snapshot",
+        { allowMissing: true },
+      );
+      if (!snapshotFile) return null;
+      return this.#verifyStateSnapshot(
+        snapshotFile.record,
+        identity,
+        storeMarker,
+        witnessed,
+        head,
+        anchorNames,
+        segmentNames,
+      );
+    } catch (cause) {
+      if (cause?.code === "CC_EVOLUTION_LEDGER_STORE_UNSAFE") throw cause;
+      return null;
+    }
+  }
+
+  #pruneStateSnapshots(currentName) {
+    let changed = false;
+    for (const entry of this.#fs.readdirSync(this.#paths.authorityRootDir, {
+      withFileTypes: true,
+    })) {
+      if (!STATE_SNAPSHOT_FILE_PATTERN.test(entry.name)) continue;
+      const snapshotPath = path.join(this.#paths.authorityRootDir, entry.name);
+      const stat = this.#fs.lstatSync(snapshotPath);
+      if (
+        !entry.isFile() ||
+        entry.isSymbolicLink() ||
+        !stat.isFile() ||
+        stat.isSymbolicLink() ||
+        stat.nlink !== 1
+      ) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_STORE_UNSAFE",
+          `state snapshot retention encountered an unsafe entry: ${entry.name}`,
+        );
+      }
+      if (entry.name === currentName) continue;
+      this.#fs.unlinkSync(snapshotPath);
+      changed = true;
+    }
+    if (changed) syncDirectory(this.#fs, this.#paths.authorityRootDir);
+  }
+
   #cachedPrefix(identity, anchorNames, segmentNames, incremental) {
     const cached = incremental ? this.#stateCache : null;
     if (
@@ -3291,6 +3748,13 @@ export class EvolutionLedger {
     anchorFingerprints,
     segmentFingerprints,
   ) {
+    const byEventDigest = new Map();
+    const byEventId = new Map();
+    for (const event of state.events) {
+      byEventDigest.set(event.eventDigest, event);
+      byEventId.set(event.eventId, event);
+    }
+    STATE_QUERY_INDEXES.set(state, Object.freeze({ byEventDigest, byEventId }));
     this.#stateCache = Object.freeze({
       anchorFingerprints: Object.freeze({ ...anchorFingerprints }),
       anchorNames: Object.freeze([...anchorNames]),
@@ -3416,12 +3880,29 @@ export class EvolutionLedger {
       );
     }
 
+    const authenticatedHead = this.#verifyAnchor(
+      headFile.record,
+      null,
+      identity,
+      { standalone: true },
+    );
     const cached = this.#cachedPrefix(
       identity,
       anchorNames,
       segmentNames,
       incremental,
     );
+    if (!cached) {
+      const snapshotted = this.#tryStateSnapshot(
+        identity,
+        storeMarker,
+        witnessed,
+        authenticatedHead,
+        anchorNames,
+        segmentNames,
+      );
+      if (snapshotted) return snapshotted;
+    }
     const anchors = cached ? [...cached.state.anchors] : [];
     const events = cached ? [...cached.state.events] : [];
     const anchorFingerprints = cached ? { ...cached.anchorFingerprints } : {};
@@ -3536,9 +4017,7 @@ export class EvolutionLedger {
     }
     if (removedOrphan) syncDirectory(this.#fs, this.#paths.segmentDir);
 
-    const head = this.#verifyAnchor(headFile.record, null, identity, {
-      standalone: true,
-    });
+    const head = authenticatedHead;
     const matchingHead = anchors.find(
       (anchor) => anchor.anchorDigest === head.anchorDigest,
     );
@@ -3713,8 +4192,9 @@ export class EvolutionLedger {
     );
   }
 
-  #resolveArtifacts(input, identity) {
+  #resolveArtifactEvidence(input, identity, { includeBytes = false } = {}) {
     const validations = [];
+    const artifacts = [];
     const artifactTenantId = Object.hasOwn(input, "artifactTenantId")
       ? input.artifactTenantId
       : input.tenantId;
@@ -3755,7 +4235,7 @@ export class EvolutionLedger {
             `artifact bytes do not match their digest: ${ref.ref}`,
           );
         }
-        validations.push({
+        const validation = {
           byteLength: bytes.length,
           digest: ref.digest,
           receiptDigest: digest(
@@ -3763,7 +4243,18 @@ export class EvolutionLedger {
             "artifact resolution receiptDigest",
           ),
           ref: ref.ref,
-        });
+        };
+        validations.push(validation);
+        if (includeBytes) {
+          artifacts.push({
+            artifactRef: ref,
+            byteLength: validation.byteLength,
+            bytesBase64: bytes.toString("base64"),
+            receiptDigest: validation.receiptDigest,
+            schema: EVOLUTION_LEDGER_AUDIT_ARTIFACT_SCHEMA,
+            tenantId: artifactTenantId,
+          });
+        }
       } catch (cause) {
         if (cause?.code === "CC_EVOLUTION_LEDGER_ARTIFACT_INVALID") {
           throw cause;
@@ -3775,7 +4266,14 @@ export class EvolutionLedger {
         );
       }
     }
-    return domainDigest(ARTIFACT_VALIDATION_DOMAIN, validations);
+    return {
+      artifacts,
+      digest: domainDigest(ARTIFACT_VALIDATION_DOMAIN, validations),
+    };
+  }
+
+  #resolveArtifacts(input, identity) {
+    return this.#resolveArtifactEvidence(input, identity).digest;
   }
 
   #buildEvent(input, previous, identity, artifactValidationDigest) {
@@ -4078,17 +4576,135 @@ export class EvolutionLedger {
   }
 
   #queryState(state, selector) {
-    return (
-      state.events.find(
-        (event) =>
-          (selector.eventId === undefined ||
-            event.eventId === selector.eventId) &&
-          (selector.eventDigest === undefined ||
-            event.eventDigest === selector.eventDigest) &&
-          (selector.sequence === undefined ||
-            event.sequence === selector.sequence),
-      ) || null
-    );
+    const indexes = STATE_QUERY_INDEXES.get(state);
+    const event =
+      selector.sequence !== undefined
+        ? state.events[selector.sequence - 1] || null
+        : selector.eventId !== undefined
+          ? indexes?.byEventId.get(selector.eventId) || null
+          : indexes?.byEventDigest.get(selector.eventDigest) || null;
+    return event &&
+      (selector.eventId === undefined || event.eventId === selector.eventId) &&
+      (selector.eventDigest === undefined ||
+        event.eventDigest === selector.eventDigest) &&
+      (selector.sequence === undefined || event.sequence === selector.sequence)
+      ? event
+      : null;
+  }
+
+  #queryResult(state, event, issueReceipt) {
+    if (!event) return null;
+    const anchor = state.anchors[event.sequence];
+    const receipt = issueReceipt
+      ? this.#issueReceipt(state, event, anchor, "verified-existing")
+      : null;
+    return deepFreeze({
+      anchor,
+      authenticated: true,
+      authority: this.#authorityProjection(state),
+      durable: true,
+      event,
+      receipt,
+      schema: EVOLUTION_LEDGER_QUERY_SCHEMA,
+    });
+  }
+
+  checkpointState() {
+    return this.#withLock(() => {
+      const state = this.#loadState({
+        allowInitialize: false,
+        incremental: true,
+      });
+      const snapshotPath = path.join(
+        this.#paths.authorityRootDir,
+        stateSnapshotFileName(state.witness.witnessDigest),
+      );
+      const existing = this.#readCanonicalFile(
+        snapshotPath,
+        MAX_STATE_SNAPSHOT_BYTES,
+        "state snapshot",
+        { allowMissing: true },
+      );
+      if (existing) {
+        this.#verifyStateSnapshot(
+          existing.record,
+          state.identity,
+          state.storeMarker,
+          state.witness,
+          state.head,
+          this.#stateCache.anchorNames,
+          this.#stateCache.segmentNames,
+        );
+        this.#pruneStateSnapshots(path.basename(snapshotPath));
+        return deepFreeze(existing.record);
+      }
+
+      const content = deepFreeze({
+        anchorFiles: this.#stateCache.anchorNames.map((name) => ({
+          contentDigest:
+            this.#stateCache.anchorFingerprints[name].contentDigest,
+          name,
+        })),
+        anchors: state.anchors,
+        events: state.events,
+        segmentFiles: this.#stateCache.segmentNames.map((name) => ({
+          contentDigest:
+            this.#stateCache.segmentFingerprints[name].contentDigest,
+          name,
+        })),
+      });
+      const core = normalizeStateSnapshotCore({
+        algorithm: this.#trust.algorithm,
+        anchorDigest: state.head.anchorDigest,
+        createdAt: clockTimestamp(this.#clock),
+        epoch: state.identity.epoch,
+        headDigest: state.head.headDigest,
+        identityDigest: state.identity.identityDigest,
+        keyId: this.#trust.keyId,
+        ledgerId: state.identity.ledgerId,
+        schema: EVOLUTION_LEDGER_STATE_SNAPSHOT_SCHEMA,
+        sequence: state.head.sequence,
+        stateDigest: domainDigest(STATE_SNAPSHOT_CONTENT_DOMAIN, content),
+        storeMarkerDigest: state.storeMarker.storeMarkerDigest,
+        storeMarkerEntryDigest: state.identity.storeMarkerEntryDigest,
+        trustPolicyDigest: this.#trust.trustPolicyDigest,
+        witnessDigest: state.witness.witnessDigest,
+        witnessGeneration: state.witness.generation,
+        witnessId: state.witness.witnessId,
+      });
+      const signed = this.#signRecord(
+        STATE_SNAPSHOT_DOMAIN,
+        core,
+        "snapshotDigest",
+        "state-snapshot",
+      );
+      const snapshot = deepFreeze({
+        ...signed,
+        state: content,
+      });
+      const bytes = serializeRecord(
+        snapshot,
+        MAX_STATE_SNAPSHOT_BYTES,
+        "state snapshot",
+      );
+      this.#writeImmutable(snapshotPath, bytes, "state snapshot");
+      const persisted = this.#readCanonicalFile(
+        snapshotPath,
+        MAX_STATE_SNAPSHOT_BYTES,
+        "state snapshot",
+      );
+      this.#verifyStateSnapshot(
+        persisted.record,
+        state.identity,
+        state.storeMarker,
+        state.witness,
+        state.head,
+        this.#stateCache.anchorNames,
+        this.#stateCache.segmentNames,
+      );
+      this.#pruneStateSnapshots(path.basename(snapshotPath));
+      return deepFreeze(persisted.record);
+    });
   }
 
   query(selector, options = {}) {
@@ -4098,22 +4714,49 @@ export class EvolutionLedger {
     });
     const issueReceipt = options.issueReceipt !== false;
     return this.#withLock(() => {
-      const state = this.#loadState({ allowInitialize: false });
-      const event = this.#queryState(state, safeSelector);
-      if (!event) return null;
-      const anchor = state.anchors[event.sequence];
-      const receipt = issueReceipt
-        ? this.#issueReceipt(state, event, anchor, "verified-existing")
-        : null;
-      return deepFreeze({
-        anchor,
-        authenticated: true,
-        authority: this.#authorityProjection(state),
-        durable: true,
-        event,
-        receipt,
-        schema: EVOLUTION_LEDGER_QUERY_SCHEMA,
+      const state = this.#loadState({
+        allowInitialize: false,
+        incremental: true,
       });
+      return this.#queryResult(
+        state,
+        this.#queryState(state, safeSelector),
+        issueReceipt,
+      );
+    });
+  }
+
+  queryMany(selectors, options = {}) {
+    const entries = readDenseDataArray(
+      selectors,
+      "query selectors",
+      MAX_LEDGER_BATCH_QUERIES,
+    );
+    if (entries.length === 0) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_SCHEMA_INVALID",
+        "query selectors must not be empty",
+      );
+    }
+    const safeSelectors = entries.map(normalizeQuerySelector);
+    assertExactKeys(options, QUERY_OPTION_KEYS, "query options", {
+      optional: [...QUERY_OPTION_KEYS],
+    });
+    const issueReceipt = options.issueReceipt === true;
+    return this.#withLock(() => {
+      const state = this.#loadState({
+        allowInitialize: false,
+        incremental: true,
+      });
+      return deepFreeze(
+        safeSelectors.map((selector) =>
+          this.#queryResult(
+            state,
+            this.#queryState(state, selector),
+            issueReceipt,
+          ),
+        ),
+      );
     });
   }
 
@@ -4142,7 +4785,10 @@ export class EvolutionLedger {
       );
     }
     return this.#withLock(() => {
-      const state = this.#loadState({ allowInitialize: false });
+      const state = this.#loadState({
+        allowInitialize: false,
+        incremental: true,
+      });
       const event = this.#queryState(state, {
         eventDigest: verifiedReceipt.eventDigest,
         eventId: verifiedReceipt.eventId,
@@ -4213,6 +4859,50 @@ export class EvolutionLedger {
     });
   }
 
+  exportAuditBundle() {
+    return this.#withLock(() => {
+      const state = this.#loadState({
+        allowInitialize: false,
+        incremental: true,
+      });
+      const artifacts = [];
+      for (const event of state.events) {
+        const evidence = this.#resolveArtifactEvidence(event, state.identity, {
+          includeBytes: true,
+        });
+        if (evidence.digest !== event.artifactValidationDigest) {
+          throw ledgerError(
+            "CC_EVOLUTION_LEDGER_ARTIFACT_INVALID",
+            `artifact evidence changed since event ${event.sequence} was committed`,
+          );
+        }
+        for (const artifact of evidence.artifacts) {
+          artifacts.push({ ...artifact, eventSequence: event.sequence });
+          if (artifacts.length > MAX_AUDIT_ARTIFACT_RECORDS) {
+            throw ledgerError(
+              "CC_EVOLUTION_LEDGER_CAPACITY_EXCEEDED",
+              "audit export artifact evidence exceeds its bounded capacity",
+            );
+          }
+        }
+      }
+      const core = {
+        anchors: state.anchors,
+        artifacts,
+        events: state.events,
+        exportedAt: clockTimestamp(this.#clock),
+        identity: state.identity,
+        schema: EVOLUTION_LEDGER_AUDIT_EXPORT_SCHEMA,
+        storeMarker: state.storeMarker,
+        witness: state.witness,
+      };
+      return deepFreeze({
+        ...core,
+        exportDigest: domainDigest(AUDIT_EXPORT_DOMAIN, core),
+      });
+    });
+  }
+
   read({ afterSequence = 0, limit = 10_000 } = {}) {
     if (
       !Number.isSafeInteger(afterSequence) ||
@@ -4227,11 +4917,12 @@ export class EvolutionLedger {
       );
     }
     return this.#withLock(() => {
-      const state = this.#loadState({ allowInitialize: false });
+      const state = this.#loadState({
+        allowInitialize: false,
+        incremental: true,
+      });
       return deepFreeze(
-        state.events
-          .filter((event) => event.sequence > afterSequence)
-          .slice(0, limit),
+        state.events.slice(afterSequence, afterSequence + limit),
       );
     });
   }
@@ -4267,7 +4958,9 @@ export class EvolutionLedger {
 
   verify() {
     return this.#withLock(() =>
-      this.#authorityProjection(this.#loadState({ allowInitialize: false })),
+      this.#authorityProjection(
+        this.#loadState({ allowInitialize: false, incremental: true }),
+      ),
     );
   }
 
@@ -4276,5 +4969,613 @@ export class EvolutionLedger {
   }
 }
 
+function artifactRefsForAudit(input) {
+  const refs = Object.hasOwn(input, "subjectRef")
+    ? [input.subjectRef, ...input.sourceRefs]
+    : [
+        ...input.sourceRefs,
+        input.parentRef,
+        input.candidateRef,
+        input.diffRef,
+        input.evalRef,
+        input.policyRef,
+        input.actorRef,
+        input.targetRef,
+      ].filter(Boolean);
+  const byRef = new Map();
+  for (const ref of refs) {
+    const existing = byRef.get(ref.ref);
+    if (existing && existing.digest !== ref.digest) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        `audit event binds one artifact ref to conflicting digests: ${ref.ref}`,
+      );
+    }
+    byRef.set(ref.ref, ref);
+  }
+  return [...byRef.values()].sort((left, right) =>
+    compareStrings(left.ref, right.ref),
+  );
+}
+
+function verifyAuditSignature({
+  digest: recordDigest,
+  message,
+  port,
+  purpose,
+  signature,
+  trust,
+  witness = false,
+}) {
+  let valid;
+  try {
+    valid = port({
+      digest: recordDigest,
+      message: Buffer.from(message),
+      purpose,
+      signature: frozenClone(signature),
+      trust,
+    });
+  } catch (cause) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      `offline ${purpose} signature verification failed`,
+      { cause },
+    );
+  }
+  if (isUnsafeAsyncResult(valid) || valid !== true) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      `offline ${purpose} signature was not accepted synchronously${witness ? " by the witness authority" : ""}`,
+    );
+  }
+}
+
+function assertAuditTrustBinding(
+  record,
+  identity,
+  trust,
+  witnessTrust,
+  witnessId,
+) {
+  if (
+    record.algorithm !== trust.algorithm ||
+    record.keyId !== trust.keyId ||
+    record.trustPolicyDigest !== trust.trustPolicyDigest ||
+    record.witnessAlgorithm !== witnessTrust.algorithm ||
+    record.witnessId !== witnessId ||
+    record.witnessKeyId !== witnessTrust.keyId ||
+    record.witnessTrustPolicyDigest !== witnessTrust.trustPolicyDigest ||
+    (identity &&
+      (record.ledgerId !== identity.ledgerId ||
+        record.epoch !== identity.epoch ||
+        record.identityDigest !== identity.identityDigest))
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline audit record is not bound to the exported identity and trust roots",
+    );
+  }
+}
+
+function verifyAuditIdentity(record, trust, witnessTrust, verifySignature) {
+  assertExactKeys(record, IDENTITY_RECORD_KEYS, "audit identity");
+  const core = normalizeIdentityCore(
+    Object.fromEntries(
+      [...IDENTITY_CORE_KEYS].map((key) => [key, record[key]]),
+    ),
+  );
+  assertAuditTrustBinding(core, null, trust, witnessTrust, core.witnessId);
+  const identityDigest = digest(record.identityDigest, "identityDigest");
+  const signature = normalizeSignature(record.signature, trust);
+  const message = signedMessage(IDENTITY_DOMAIN, core);
+  if (identityDigest !== sha256(message)) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline audit identity digest is invalid",
+    );
+  }
+  verifyAuditSignature({
+    digest: identityDigest,
+    message,
+    port: verifySignature,
+    purpose: "identity",
+    signature,
+    trust,
+  });
+  return deepFreeze({ ...core, identityDigest, signature });
+}
+
+function verifyAuditStoreMarker(record, identity, trust, witnessTrust, port) {
+  assertExactKeys(record, STORE_MARKER_RECORD_KEYS, "audit store marker");
+  const core = normalizeStoreMarkerCore(
+    Object.fromEntries(
+      [...STORE_MARKER_CORE_KEYS].map((key) => [key, record[key]]),
+    ),
+  );
+  assertAuditTrustBinding(core, null, trust, witnessTrust, identity.witnessId);
+  const storeMarkerDigest = digest(
+    record.storeMarkerDigest,
+    "storeMarkerDigest",
+  );
+  const signature = normalizeSignature(record.signature, trust);
+  const message = signedMessage(STORE_MARKER_DOMAIN, core);
+  if (
+    storeMarkerDigest !== sha256(message) ||
+    core.ledgerId !== identity.ledgerId ||
+    core.epoch !== identity.epoch ||
+    core.createdAt !== identity.createdAt ||
+    core.storeBindingDigest !== identity.storeBindingDigest ||
+    core.storeMarkerId !== identity.storeMarkerId ||
+    storeMarkerDigest !== identity.storeMarkerDigest
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline audit store marker is not bound to the signed identity",
+    );
+  }
+  verifyAuditSignature({
+    digest: storeMarkerDigest,
+    message,
+    port,
+    purpose: "store-marker",
+    signature,
+    trust,
+  });
+  return deepFreeze({ ...core, signature, storeMarkerDigest });
+}
+
+function verifyAuditEvent(
+  record,
+  previous,
+  identity,
+  trust,
+  witnessTrust,
+  port,
+) {
+  assertPlainDataObject(record, "audit event");
+  const domainEvent = record.schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA;
+  const recordKeys = domainEvent ? DOMAIN_EVENT_RECORD_KEYS : EVENT_RECORD_KEYS;
+  const coreKeys = domainEvent ? DOMAIN_EVENT_CORE_KEYS : EVENT_CORE_KEYS;
+  assertExactKeys(record, recordKeys, "audit event");
+  const core = domainEvent
+    ? normalizeDomainEventCore(
+        Object.fromEntries([...coreKeys].map((key) => [key, record[key]])),
+      )
+    : normalizeEventCore(
+        Object.fromEntries([...coreKeys].map((key) => [key, record[key]])),
+      );
+  assertAuditTrustBinding(
+    core,
+    identity,
+    trust,
+    witnessTrust,
+    identity.witnessId,
+  );
+  const eventDigest = digest(record.eventDigest, "eventDigest");
+  const signature = normalizeSignature(record.signature, trust);
+  const signatureDomain = domainEvent ? DOMAIN_EVENT_DOMAIN : EVENT_DOMAIN;
+  const message = signedMessage(signatureDomain, core);
+  if (
+    core.sequence !== (previous?.sequence || 0) + 1 ||
+    core.prevDigest !== (previous?.eventDigest || null) ||
+    eventDigest !== sha256(message)
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      `offline audit event chain failed at sequence ${core.sequence}`,
+    );
+  }
+  verifyAuditSignature({
+    digest: eventDigest,
+    message,
+    port,
+    purpose: domainEvent ? "domain-event" : "event",
+    signature,
+    trust,
+  });
+  return deepFreeze({ ...core, eventDigest, signature });
+}
+
+function verifyAuditAnchor(
+  record,
+  previous,
+  identity,
+  trust,
+  witnessTrust,
+  port,
+) {
+  assertExactKeys(record, ANCHOR_RECORD_KEYS, "audit anchor");
+  const core = normalizeAnchorCore(
+    Object.fromEntries([...ANCHOR_CORE_KEYS].map((key) => [key, record[key]])),
+  );
+  assertAuditTrustBinding(
+    core,
+    identity,
+    trust,
+    witnessTrust,
+    identity.witnessId,
+  );
+  const anchorDigest = digest(record.anchorDigest, "anchorDigest");
+  const signature = normalizeSignature(record.signature, trust);
+  const message = signedMessage(ANCHOR_DOMAIN, core);
+  if (
+    core.sequence !== (previous ? previous.sequence + 1 : 0) ||
+    core.previousAnchorDigest !== (previous?.anchorDigest || null) ||
+    anchorDigest !== sha256(message) ||
+    (core.sequence === 0 &&
+      (core.headDigest !== null || core.segmentDigest !== null)) ||
+    (core.sequence > 0 &&
+      (core.headDigest === null || core.segmentDigest === null))
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      `offline audit anchor chain failed at sequence ${core.sequence}`,
+    );
+  }
+  verifyAuditSignature({
+    digest: anchorDigest,
+    message,
+    port,
+    purpose: "anchor",
+    signature,
+    trust,
+  });
+  return deepFreeze({ ...core, anchorDigest, signature });
+}
+
+function decodeAuditArtifactBytes(value, expectedLength) {
+  if (typeof value !== "string" || value.length > 24 * 1024 * 1024) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline audit artifact encoding is invalid or oversized",
+    );
+  }
+  const bytes = Buffer.from(value, "base64");
+  if (
+    bytes.length !== expectedLength ||
+    bytes.length > EVOLUTION_LEDGER_MAX_ARTIFACT_BYTES ||
+    bytes.toString("base64") !== value
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline audit artifact bytes are not canonical or complete",
+    );
+  }
+  return bytes;
+}
+
+function verifyAuditArtifacts(records, events) {
+  const byEventAndRef = new Map();
+  let previousOrder = null;
+  for (const record of records) {
+    assertExactKeys(record, AUDIT_ARTIFACT_KEYS, "audit artifact");
+    if (record.schema !== EVOLUTION_LEDGER_AUDIT_ARTIFACT_SCHEMA) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit artifact schema is unsupported",
+      );
+    }
+    if (
+      !Number.isSafeInteger(record.eventSequence) ||
+      record.eventSequence < 1 ||
+      record.eventSequence > events.length ||
+      !Number.isSafeInteger(record.byteLength) ||
+      record.byteLength < 0
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit artifact bounds are invalid",
+      );
+    }
+    const tenantId = identifier(record.tenantId, "audit artifact tenantId");
+    const artifactRef = normalizeArtifactRef(
+      record.artifactRef,
+      "audit artifactRef",
+    );
+    const receiptDigest = digest(
+      record.receiptDigest,
+      "audit artifact receiptDigest",
+    );
+    const bytes = decodeAuditArtifactBytes(
+      record.bytesBase64,
+      record.byteLength,
+    );
+    if (sha256(bytes) !== artifactRef.digest) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        `offline audit artifact digest is invalid: ${artifactRef.ref}`,
+      );
+    }
+    const order = [record.eventSequence, tenantId, artifactRef.ref];
+    if (
+      previousOrder &&
+      (order[0] < previousOrder[0] ||
+        (order[0] === previousOrder[0] &&
+          (compareStrings(order[1], previousOrder[1]) < 0 ||
+            (order[1] === previousOrder[1] &&
+              compareStrings(order[2], previousOrder[2]) <= 0))))
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit artifact evidence must be unique and canonically ordered",
+      );
+    }
+    previousOrder = order;
+    const key = `${record.eventSequence}\0${tenantId}\0${artifactRef.ref}`;
+    byEventAndRef.set(key, {
+      artifactRef,
+      byteLength: bytes.length,
+      receiptDigest,
+    });
+  }
+
+  const consumed = new Set();
+  for (const event of events) {
+    const tenantId = Object.hasOwn(event, "artifactTenantId")
+      ? event.artifactTenantId
+      : event.tenantId;
+    const validations = [];
+    for (const ref of artifactRefsForAudit(event)) {
+      const key = `${event.sequence}\0${tenantId}\0${ref.ref}`;
+      const evidence = byEventAndRef.get(key);
+      if (!evidence || evidence.artifactRef.digest !== ref.digest) {
+        throw ledgerError(
+          "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+          `offline audit artifact evidence is missing or substituted: ${ref.ref}`,
+        );
+      }
+      consumed.add(key);
+      validations.push({
+        byteLength: evidence.byteLength,
+        digest: ref.digest,
+        receiptDigest: evidence.receiptDigest,
+        ref: ref.ref,
+      });
+    }
+    if (
+      domainDigest(ARTIFACT_VALIDATION_DOMAIN, validations) !==
+      event.artifactValidationDigest
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        `offline artifact validation receipt changed at event ${event.sequence}`,
+      );
+    }
+  }
+  if (consumed.size !== records.length) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline audit contains unreferenced artifact evidence",
+    );
+  }
+}
+
+function verifyAuditWitness(
+  record,
+  identity,
+  storeMarker,
+  anchor,
+  event,
+  witnessTrust,
+  port,
+) {
+  const witness = normalizeWitnessRecordShape(record, witnessTrust);
+  if (
+    witness.witnessId !== identity.witnessId ||
+    witness.algorithm !== witnessTrust.algorithm ||
+    witness.keyId !== witnessTrust.keyId ||
+    witness.trustPolicyDigest !== witnessTrust.trustPolicyDigest
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline witness is not bound to the independent trust root",
+    );
+  }
+  const core = Object.fromEntries(
+    [...WITNESS_CORE_KEYS].map((key) => [key, witness[key]]),
+  );
+  const message = signedMessage(WITNESS_DOMAIN, core);
+  if (witness.witnessDigest !== sha256(message)) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline witness digest is invalid",
+    );
+  }
+  verifyAuditSignature({
+    digest: witness.witnessDigest,
+    message,
+    port,
+    purpose: "witness",
+    signature: witness.signature,
+    trust: witnessTrust,
+    witness: true,
+  });
+  const expected = {
+    algorithm: witnessTrust.algorithm,
+    anchorDigest: anchor.anchorDigest,
+    epoch: identity.epoch,
+    headDigest: anchor.headDigest,
+    identityDigest: identity.identityDigest,
+    keyId: witnessTrust.keyId,
+    ledgerId: identity.ledgerId,
+    payloadDigest: domainDigest(WITNESS_PAYLOAD_DOMAIN, {
+      anchor,
+      event,
+      identity,
+      storeMarker,
+    }),
+    segmentDigest: anchor.segmentDigest,
+    sequence: anchor.sequence,
+    storeMarkerDigest: identity.storeMarkerDigest,
+    storeMarkerEntryDigest: identity.storeMarkerEntryDigest,
+    storeMarkerId: identity.storeMarkerId,
+    trustPolicyDigest: witnessTrust.trustPolicyDigest,
+    witnessId: identity.witnessId,
+  };
+  if (
+    witness.status !== "committed" ||
+    witness.authenticated !== true ||
+    witness.durable !== true ||
+    Object.entries(expected).some(([key, value]) => witness[key] !== value)
+  ) {
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline witness does not authenticate the exported ledger head",
+    );
+  }
+  return witness;
+}
+
+export function verifyEvolutionLedgerAuditBundle(bundle, ports) {
+  try {
+    assertExactKeys(ports, AUDIT_VERIFY_PORT_KEYS, "audit verifier ports");
+    if (
+      typeof ports.verifySignature !== "function" ||
+      typeof ports.verifyWitnessSignature !== "function"
+    ) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit requires synchronous ledger and witness verifiers",
+      );
+    }
+    const verifySignatureImplementation = ports.verifySignature;
+    const verifyWitnessSignatureImplementation = ports.verifyWitnessSignature;
+    const verifySignature = Object.freeze((...args) =>
+      Reflect.apply(verifySignatureImplementation, undefined, args),
+    );
+    const verifyWitnessSignature = Object.freeze((...args) =>
+      Reflect.apply(verifyWitnessSignatureImplementation, undefined, args),
+    );
+    const trust = normalizeTrust(ports.trust);
+    const witnessTrust = normalizeTrust(ports.witnessTrust);
+    assertExactKeys(bundle, AUDIT_EXPORT_RECORD_KEYS, "audit export");
+    if (bundle.schema !== EVOLUTION_LEDGER_AUDIT_EXPORT_SCHEMA) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit export schema is unsupported",
+      );
+    }
+    canonicalTimestamp(bundle.exportedAt, "audit exportedAt");
+    const core = Object.fromEntries(
+      [...AUDIT_EXPORT_CORE_KEYS].map((key) => [key, bundle[key]]),
+    );
+    const exportDigest = digest(bundle.exportDigest, "audit exportDigest");
+    if (exportDigest !== domainDigest(AUDIT_EXPORT_DOMAIN, core)) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit export digest is invalid",
+      );
+    }
+    // Capture the fully traversed plain-data graph before invoking either
+    // external trust port. A verifier closure must not be able to mutate the
+    // caller's bundle between signature checks.
+    const capturedBundle = JSON.parse(canonicalJson(bundle));
+    const rawEvents = readDenseDataArray(
+      capturedBundle.events,
+      "audit events",
+      EVOLUTION_LEDGER_MAX_EVENTS,
+    );
+    const rawAnchors = readDenseDataArray(
+      capturedBundle.anchors,
+      "audit anchors",
+      EVOLUTION_LEDGER_MAX_EVENTS + 1,
+    );
+    const rawArtifacts = readDenseDataArray(
+      capturedBundle.artifacts,
+      "audit artifacts",
+      MAX_AUDIT_ARTIFACT_RECORDS,
+    );
+
+    const identity = verifyAuditIdentity(
+      capturedBundle.identity,
+      trust,
+      witnessTrust,
+      verifySignature,
+    );
+    const storeMarker = verifyAuditStoreMarker(
+      capturedBundle.storeMarker,
+      identity,
+      trust,
+      witnessTrust,
+      verifySignature,
+    );
+    const events = [];
+    for (const rawEvent of rawEvents) {
+      events.push(
+        verifyAuditEvent(
+          rawEvent,
+          events.at(-1) || null,
+          identity,
+          trust,
+          witnessTrust,
+          verifySignature,
+        ),
+      );
+    }
+    if (rawAnchors.length !== events.length + 1) {
+      throw ledgerError(
+        "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+        "offline audit anchor coverage is incomplete",
+      );
+    }
+    const anchors = [];
+    for (const rawAnchor of rawAnchors) {
+      const anchor = verifyAuditAnchor(
+        rawAnchor,
+        anchors.at(-1) || null,
+        identity,
+        trust,
+        witnessTrust,
+        verifySignature,
+      );
+      if (anchor.sequence > 0) {
+        const event = events[anchor.sequence - 1];
+        if (
+          !event ||
+          anchor.headDigest !== event.eventDigest ||
+          anchor.segmentDigest !== domainDigest(SEGMENT_DOMAIN, event)
+        ) {
+          throw ledgerError(
+            "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+            `offline audit anchor is not bound to event ${anchor.sequence}`,
+          );
+        }
+      }
+      anchors.push(anchor);
+    }
+    verifyAuditArtifacts(rawArtifacts, events);
+    const head = anchors.at(-1);
+    const witness = verifyAuditWitness(
+      capturedBundle.witness,
+      identity,
+      storeMarker,
+      head,
+      events.at(-1) || null,
+      witnessTrust,
+      verifyWitnessSignature,
+    );
+    return deepFreeze({
+      artifactCount: rawArtifacts.length,
+      eventCount: events.length,
+      exportDigest,
+      headDigest: head.headDigest,
+      identityDigest: identity.identityDigest,
+      ledgerId: identity.ledgerId,
+      schema: EVOLUTION_LEDGER_AUDIT_VERIFICATION_SCHEMA,
+      sequence: head.sequence,
+      valid: true,
+      witnessDigest: witness.witnessDigest,
+    });
+  } catch (cause) {
+    if (cause?.code === "CC_EVOLUTION_LEDGER_AUDIT_INVALID") throw cause;
+    throw ledgerError(
+      "CC_EVOLUTION_LEDGER_AUDIT_INVALID",
+      "offline evolution ledger audit verification failed closed",
+      { cause },
+    );
+  }
+}
+
 Object.freeze(EvolutionLedger.prototype);
 Object.freeze(EvolutionLedger);