@xyo-network/event-kit-statement-graph 0.0.1 → 0.1.0

package/dist/neutral/index.mjs

@@ -1,5 +1,712 @@
-// src/grantReadModel.ts
+// src/checkpointViewer.ts
+function eventKey(record) {
+  return `${record.txHash}:${record.eventHash}`;
+}
+function recordKey(record) {
+  return `${eventKey(record)}:${record.hashIndex}`;
+}
+function compareApplied(left, right) {
+  return left.block - right.block || left.blockEventOrdinal.tx - right.blockEventOrdinal.tx || left.blockEventOrdinal.event - right.blockEventOrdinal.event || left.hashIndex - right.hashIndex || recordKey(left).localeCompare(recordKey(right));
+}
+var LegacyHexAddress = /^[A-Fa-f0-9]{40}$/;
+function normalizeAddress(value) {
+  return LegacyHexAddress.test(value) ? value.toLowerCase() : value;
+}
+function claimKey(source, subject, objectHash) {
+  return `${normalizeAddress(source)}|${normalizeAddress(subject)}|${objectHash}`;
+}
+function matchesClaim(record, query) {
+  return (query?.objectHash === void 0 || record.objectHash === query.objectHash) && (query?.subject === void 0 || normalizeAddress(record.subject) === normalizeAddress(query.subject)) && (query?.declaredObjectSchemaPrefix === void 0 || record.declaredObjectSchema.startsWith(query.declaredObjectSchemaPrefix));
+}
+function sortClaims(records) {
+  return records.toSorted((left, right) => claimKey(left.source, left.subject, left.objectHash).localeCompare(claimKey(right.source, right.subject, right.objectHash)));
+}
+function buildClaims(applied) {
+  const claims = /* @__PURE__ */ new Map();
+  for (const record of applied.toSorted(compareApplied)) {
+    const key = claimKey(record.source, record.subject, record.objectHash);
+    const prior = claims.get(key);
+    if (prior === void 0) {
+      claims.set(key, {
+        declaredObjectSchema: record.objectSchema,
+        firstBlock: record.block,
+        firstEventHash: record.eventHash,
+        lastBlock: record.block,
+        objectHash: record.objectHash,
+        source: record.source,
+        subject: record.subject
+      });
+    } else if (record.block > prior.lastBlock) {
+      claims.set(key, { ...prior, lastBlock: record.block });
+    }
+  }
+  return sortClaims([...claims.values()]);
+}
+function withoutSchema(body) {
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== "schema"));
+}
+function createCheckpointStatementGraphViewer(checkpoint) {
+  const applied = checkpoint.applied.toSorted(compareApplied);
+  const claims = buildClaims(applied);
+  const bodies = new Map(checkpoint.bodies.map((entry) => [entry.hash, entry.body]));
+  const declaredSchemas = /* @__PURE__ */ new Map();
+  for (const record of applied) {
+    if (!declaredSchemas.has(record.objectHash)) declaredSchemas.set(record.objectHash, record.objectSchema);
+  }
+  const unresolved = checkpoint.blocked?.unresolvedEvents ?? [];
+  return Object.freeze({
+    async claims(source, query) {
+      const normalized = normalizeAddress(source);
+      return claims.filter((record) => normalizeAddress(record.source) === normalized && matchesClaim(record, query));
+    },
+    async claimsByObject(objectHash) {
+      return claims.filter((record) => record.objectHash === objectHash);
+    },
+    async claimsBySubject(subject, query) {
+      const normalized = normalizeAddress(subject);
+      return claims.filter((record) => normalizeAddress(record.subject) === normalized && matchesClaim(record, query));
+    },
+    async event(txHash, eventHash) {
+      return applied.filter((record) => record.txHash === txHash && record.eventHash === eventHash);
+    },
+    async events(source, query) {
+      const normalized = normalizeAddress(source);
+      return applied.filter((record) => normalizeAddress(record.source) === normalized && (query?.fromBlock === void 0 || record.block >= query.fromBlock) && (query?.toBlock === void 0 || record.block <= query.toBlock) && (query?.objectSchemaPrefix === void 0 || record.objectSchema.startsWith(query.objectSchemaPrefix)) && (query?.subject === void 0 || normalizeAddress(record.subject) === normalizeAddress(query.subject)));
+    },
+    async head() {
+      if (checkpoint.indexedThrough === null) throw new Error("Event Kit replay has not indexed its floor block");
+      return checkpoint.indexedThrough;
+    },
+    async object(objectHash) {
+      const body = bodies.get(objectHash);
+      const declaredSchema = declaredSchemas.get(objectHash);
+      if (body === void 0 || declaredSchema === void 0) return void 0;
+      return {
+        assurance: "resolved",
+        declaredSchema,
+        objectHash,
+        params: withoutSchema(body)
+      };
+    },
+    async source(source) {
+      const normalized = normalizeAddress(source);
+      const records = applied.filter((record) => normalizeAddress(record.source) === normalized);
+      const blocks = records.map((record) => record.block);
+      return {
+        claims: new Set(records.map((record) => claimKey(record.source, record.subject, record.objectHash))).size,
+        firstBlock: blocks.length === 0 ? null : Math.min(...blocks),
+        lastBlock: blocks.length === 0 ? null : Math.max(...blocks),
+        source: normalized
+      };
+    },
+    async unresolved(txHash, eventHash) {
+      return unresolved.find((record) => record.txHash === txHash && record.eventHash === eventHash);
+    }
+  });
+}
+
+// src/eventKitSchemaPolicy.ts
+import {
+  EncryptedWakeSubscriptionSchema,
+  PublisherEncryptionKeyRevocationSchema,
+  PublisherEncryptionKeySchema,
+  PublisherServiceRevocationSchema,
+  PublisherServiceSchema,
+  WakeGrantObjectSchema,
+  WakeGrantRevocationSchema,
+  WakeSubscriptionAcceptanceRevocationSchema,
+  WakeSubscriptionAcceptanceSchema,
+  WakeSubscriptionRevocationSchema
+} from "@xyo-network/event-kit-schemas";
+var EventKitClaimedObjectSchemas = Object.freeze([
+  PublisherServiceSchema,
+  PublisherEncryptionKeySchema,
+  PublisherServiceRevocationSchema,
+  PublisherEncryptionKeyRevocationSchema,
+  EncryptedWakeSubscriptionSchema,
+  WakeGrantObjectSchema,
+  WakeSubscriptionRevocationSchema,
+  WakeGrantRevocationSchema,
+  WakeSubscriptionAcceptanceSchema,
+  WakeSubscriptionAcceptanceRevocationSchema
+]);
+var EventKitClaimedObjectSchemaSet = new Set(EventKitClaimedObjectSchemas);
+
+// src/finalizedReplayController.ts
+import { HashZod as HashZod2 } from "@ariestools/sdk";
+import {
+  ChainIdZod as ChainIdZod2,
+  normalizeAddress as normalizeAddress3,
+  NormalizedAddressZod as NormalizedAddressZod2,
+  WakeSubscriptionAcceptanceSchema as WakeSubscriptionAcceptanceSchema2,
+  WakeSubscriptionAcceptanceZod
+} from "@xyo-network/event-kit-schemas";
+import { STATEMENT_FOLD_VERSION as STATEMENT_FOLD_VERSION2 } from "@xyo-network/xl1-statement-graph-schemas";
+import {
+  resolveVerifiedBodies,
+  scanFinalizedStatements
+} from "@xyo-network/xl1-statement-graph-sdk";
+
+// src/replayCheckpoint.ts
 import { HashZod } from "@ariestools/sdk";
+import { ChainIdZod, NormalizedAddressZod } from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder } from "@xyo-network/sdk";
+import {
+  AppliedEventRecordZod,
+  BlockNumberZod,
+  STATEMENT_FOLD_VERSION,
+  UnresolvedEventReferenceZod
+} from "@xyo-network/xl1-statement-graph-schemas";
+import {
+  assembleCheckpointRecords,
+  StatementScanCheckpointZod
+} from "@xyo-network/xl1-statement-graph-sdk";
+import { z } from "zod";
+var EVENT_KIT_REPLAY_CHECKPOINT_VERSION = 2;
+var ResolvedReplayBodyZod = z.strictObject({
+  body: z.record(z.string(), z.unknown()),
+  hash: HashZod
+});
+var ReplayCorruptBodyZod = z.strictObject({
+  claimedHash: z.string().optional(),
+  computedHash: z.string()
+});
+var ReplayBlockedStateZod = z.strictObject({
+  atBlock: BlockNumberZod,
+  corrupt: z.array(ReplayCorruptBodyZod),
+  objectHashes: z.array(HashZod),
+  unresolvedEvents: z.array(UnresolvedEventReferenceZod)
+});
+var EventKitReplayCheckpointZod = z.strictObject({
+  applied: z.array(AppliedEventRecordZod),
+  blocked: ReplayBlockedStateZod.optional(),
+  bodies: z.array(ResolvedReplayBodyZod),
+  chainId: ChainIdZod,
+  finalizedHead: BlockNumberZod,
+  floorBlock: BlockNumberZod,
+  foldVersion: z.literal(STATEMENT_FOLD_VERSION),
+  indexedThrough: z.union([BlockNumberZod, z.null()]),
+  network: z.string().min(1),
+  objectSchemas: z.tuple(EventKitClaimedObjectSchemas.map((schema) => z.literal(schema))),
+  publisher: NormalizedAddressZod,
+  scan: z.union([StatementScanCheckpointZod, z.null()]),
+  sourceId: z.string().min(1),
+  version: z.literal(EVENT_KIT_REPLAY_CHECKPOINT_VERSION)
+});
+function sameSchemas(actual) {
+  return actual.length === EventKitClaimedObjectSchemas.length && actual.every((schema, index) => schema === EventKitClaimedObjectSchemas[index]);
+}
+function appliedKey(record) {
+  return `${record.txHash}:${record.eventHash}:${record.hashIndex}`;
+}
+function compareApplied2(left, right) {
+  return left.block - right.block || left.blockEventOrdinal.tx - right.blockEventOrdinal.tx || left.blockEventOrdinal.event - right.blockEventOrdinal.event || left.hashIndex - right.hashIndex || appliedKey(left).localeCompare(appliedKey(right));
+}
+var LegacyHexAddress2 = /^[A-Fa-f0-9]{40}$/;
+function normalizeAddress2(value) {
+  return LegacyHexAddress2.test(value) ? value.toLowerCase() : value;
+}
+function claimKey2(source, subject, objectHash) {
+  return `${normalizeAddress2(source)}|${normalizeAddress2(subject)}|${objectHash}`;
+}
+function eventKey2(record) {
+  return `${record.txHash}:${record.eventHash}`;
+}
+function sortClaimRecords(records) {
+  return records.toSorted((left, right) => claimKey2(left.source, left.subject, left.objectHash).localeCompare(claimKey2(right.source, right.subject, right.objectHash)));
+}
+function expectedClaimRecords(applied) {
+  const records = /* @__PURE__ */ new Map();
+  for (const event of applied.toSorted(compareApplied2)) {
+    const key = claimKey2(event.source, event.subject, event.objectHash);
+    const prior = records.get(key);
+    if (prior === void 0) {
+      records.set(key, {
+        declaredObjectSchema: event.objectSchema,
+        firstBlock: event.block,
+        firstEventHash: event.eventHash,
+        lastBlock: event.block,
+        objectHash: event.objectHash,
+        source: event.source,
+        subject: event.subject
+      });
+    } else if (event.block > prior.lastBlock) {
+      records.set(key, { ...prior, lastBlock: event.block });
+    }
+  }
+  return sortClaimRecords([...records.values()]);
+}
+function sameClaimRecords(left, right) {
+  return left.length === right.length && left.every((record, index) => {
+    const candidate = right[index];
+    if (candidate === void 0) return false;
+    return record.declaredObjectSchema === candidate.declaredObjectSchema && record.firstBlock === candidate.firstBlock && record.firstEventHash === candidate.firstEventHash && record.lastBlock === candidate.lastBlock && record.objectHash === candidate.objectHash && normalizeAddress2(record.source) === normalizeAddress2(candidate.source) && normalizeAddress2(record.subject) === normalizeAddress2(candidate.subject);
+  });
+}
+function progressIntegrityError(checkpoint) {
+  const { indexedThrough } = checkpoint;
+  if (indexedThrough !== null && indexedThrough > checkpoint.finalizedHead) {
+    return `indexedThrough ${indexedThrough} exceeds finalizedHead ${checkpoint.finalizedHead}`;
+  }
+  if (indexedThrough !== null && indexedThrough < checkpoint.floorBlock) {
+    return `indexedThrough ${indexedThrough} precedes floorBlock ${checkpoint.floorBlock}`;
+  }
+  if (indexedThrough === null && checkpoint.scan !== null) {
+    return "scan checkpoint exists before floorBlock has been indexed";
+  }
+  if (indexedThrough !== null && checkpoint.scan === null) {
+    return "scan checkpoint is missing for indexed state";
+  }
+  if (indexedThrough === null && checkpoint.applied.length > 0) {
+    return "applied events exist before floorBlock has been indexed";
+  }
+  if (indexedThrough === null && checkpoint.bodies.length > 0) {
+    return "resolved bodies exist before floorBlock has been indexed";
+  }
+  return void 0;
+}
+function bodySetIntegrityError(checkpoint) {
+  const hashes = /* @__PURE__ */ new Set();
+  for (const entry of checkpoint.bodies) {
+    if (hashes.has(entry.hash)) return `duplicate persisted body ${entry.hash}`;
+    if (typeof entry.body.schema !== "string" || entry.body.schema.length === 0) {
+      return `persisted body ${entry.hash} has no schema`;
+    }
+    hashes.add(entry.hash);
+  }
+  return void 0;
+}
+function appliedIntegrityError(checkpoint) {
+  const { indexedThrough } = checkpoint;
+  const bodyByHash = new Map(checkpoint.bodies.map((entry) => [entry.hash, entry]));
+  const appliedIdentities = /* @__PURE__ */ new Set();
+  const eventObjects = /* @__PURE__ */ new Set();
+  const eventLocations = /* @__PURE__ */ new Map();
+  let prior;
+  for (const event of checkpoint.applied) {
+    const key = appliedKey(event);
+    if (normalizeAddress2(event.subject) !== normalizeAddress2(checkpoint.publisher)) {
+      return `applied event ${key} subject ${event.subject} != publisher ${checkpoint.publisher}`;
+    }
+    if (appliedIdentities.has(key)) return `duplicate applied-event identity ${key}`;
+    appliedIdentities.add(key);
+    const objectKey = `${event.txHash}:${event.eventHash}:${event.objectHash}`;
+    if (eventObjects.has(objectKey)) return `duplicate applied-event object ${objectKey}`;
+    eventObjects.add(objectKey);
+    if (prior !== void 0 && compareApplied2(prior, event) > 0) return "applied events are not in canonical order";
+    prior = event;
+    if (indexedThrough === null || event.block < checkpoint.floorBlock || event.block > indexedThrough) {
+      return `applied event ${key} lies outside the indexed block range`;
+    }
+    const eventKey3 = `${event.txHash}:${event.eventHash}`;
+    const location = [
+      event.block,
+      event.blockEventOrdinal.tx,
+      event.blockEventOrdinal.event,
+      normalizeAddress2(event.source),
+      normalizeAddress2(event.subject)
+    ].join(":");
+    const priorLocation = eventLocations.get(eventKey3);
+    if (priorLocation !== void 0 && priorLocation !== location) {
+      return `applied event ${eventKey3} has inconsistent provenance`;
+    }
+    eventLocations.set(eventKey3, location);
+    const body = bodyByHash.get(event.objectHash)?.body;
+    if (body === void 0) return `applied object body ${event.objectHash} is missing`;
+    if (body.schema !== event.objectSchema) {
+      return `applied object ${event.objectHash} schema ${String(body.schema)} != ${event.objectSchema}`;
+    }
+  }
+  return void 0;
+}
+function scanRecordIntegrityError(records, checkpoint, indexedThrough) {
+  const indexedSchemas = new Set(checkpoint.objectSchemas);
+  for (const record of records) {
+    const key = claimKey2(record.source, record.subject, record.objectHash);
+    if (record.firstBlock < checkpoint.floorBlock || record.lastBlock > indexedThrough) {
+      return `scan claim record ${key} lies outside the indexed block range`;
+    }
+    if (record.lastBlock < record.firstBlock) return `scan claim record ${key} has a regressing clock`;
+    if (!indexedSchemas.has(record.declaredObjectSchema)) {
+      return `scan claim record ${key} has an unindexed declared schema`;
+    }
+  }
+  return void 0;
+}
+function scanIntegrityError(checkpoint) {
+  const { indexedThrough, scan } = checkpoint;
+  if (scan === null || indexedThrough === null) return void 0;
+  const contract = scan.contract;
+  if (contract.throughBlock !== indexedThrough) {
+    return `scan throughBlock ${contract.throughBlock} != indexedThrough ${indexedThrough}`;
+  }
+  if (contract.floorBlock !== checkpoint.floorBlock) return "scan floorBlock differs from checkpoint";
+  if (contract.foldVersion !== checkpoint.foldVersion) return "scan foldVersion differs from checkpoint";
+  if (contract.network !== checkpoint.network) return "scan network differs from checkpoint";
+  if (contract.eventBodyCorpus.sourceId !== checkpoint.sourceId) return "scan body source differs from checkpoint";
+  if (contract.eventBodyCorpus.unresolvedDigest !== void 0) {
+    return "scan body corpus unresolved digest is invalid for finalized replay";
+  }
+  if (JSON.stringify(contract.indexedSchemaPolicy) !== JSON.stringify({ foldedObjectSchemas: checkpoint.objectSchemas })) {
+    return "scan indexed schema policy differs from checkpoint";
+  }
+  if (scan.unresolved.length > 0) return "committed scan checkpoint contains unresolved events";
+  if (scan.recordShards.length > 0) return "Event Kit scan checkpoint is not self-contained";
+  const assembled = assembleCheckpointRecords(scan, []);
+  if (assembled.status !== "valid") return `scan claim records do not assemble: ${assembled.detail}`;
+  const recordIntegrityError = scanRecordIntegrityError(assembled.records, checkpoint, indexedThrough);
+  if (recordIntegrityError !== void 0) return recordIntegrityError;
+  const actualRecords = sortClaimRecords(
+    assembled.records.filter((record) => normalizeAddress2(record.subject) === normalizeAddress2(checkpoint.publisher))
+  );
+  if (!sameClaimRecords(actualRecords, expectedClaimRecords(checkpoint.applied))) {
+    return "scan claim records differ from applied-event history";
+  }
+  if (scan.watermark !== void 0 && scan.watermark.block > indexedThrough) {
+    return `scan watermark block ${scan.watermark.block} exceeds indexedThrough ${indexedThrough}`;
+  }
+  return watermarkIntegrityError(checkpoint);
+}
+function watermarkIntegrityError(checkpoint) {
+  const scan = checkpoint.scan;
+  if (scan === null) return void 0;
+  const { watermark, watermarkGroupEventKeys } = scan;
+  if (watermark === void 0) {
+    if (checkpoint.applied.length > 0) return "scan watermark is missing for applied-event history";
+    return watermarkGroupEventKeys.length === 0 ? void 0 : "scan has group event keys without a watermark";
+  }
+  if (watermark.block < checkpoint.floorBlock) {
+    return `scan watermark block ${watermark.block} precedes floorBlock ${checkpoint.floorBlock}`;
+  }
+  const aboveWatermark = checkpoint.applied.find((event) => event.block > watermark.block || event.block === watermark.block && event.blockEventOrdinal.tx > watermark.ordinal.tx || event.block === watermark.block && event.blockEventOrdinal.tx === watermark.ordinal.tx && event.blockEventOrdinal.event > watermark.ordinal.event);
+  if (aboveWatermark !== void 0) return "applied event lies above the scan watermark";
+  const actualKeys = [...new Set(watermarkGroupEventKeys)].toSorted();
+  if (actualKeys.length !== watermarkGroupEventKeys.length) {
+    return "scan watermark group event keys contain duplicates";
+  }
+  if (actualKeys.some((key) => !/^[0-9a-f]{64}:[0-9a-f]{64}$/u.test(key))) {
+    return "scan watermark group contains a malformed event key";
+  }
+  const group = checkpoint.applied.filter((event) => event.block === watermark.block && event.blockEventOrdinal.tx === watermark.ordinal.tx);
+  const expectedKeys = [...new Set(group.map(eventKey2))].toSorted();
+  if (expectedKeys.some((key) => !actualKeys.includes(key))) {
+    return "scan watermark group event keys omit publisher applied-event history";
+  }
+  return void 0;
+}
+function blockedIntegrityError(checkpoint) {
+  const { blocked, indexedThrough } = checkpoint;
+  if (blocked === void 0) return void 0;
+  const expectedBlock = indexedThrough === null ? checkpoint.floorBlock : indexedThrough + 1;
+  if (blocked.atBlock !== expectedBlock) {
+    return `blocked atBlock ${blocked.atBlock} != next unindexed block ${expectedBlock}`;
+  }
+  if (blocked.atBlock > checkpoint.finalizedHead) {
+    return `blocked atBlock ${blocked.atBlock} exceeds finalizedHead ${checkpoint.finalizedHead}`;
+  }
+  if (blocked.unresolvedEvents.some((event) => event.block !== blocked.atBlock)) {
+    return "blocked unresolved event does not belong to blocked block";
+  }
+  return void 0;
+}
+function checkpointIntegrityError(checkpoint) {
+  return progressIntegrityError(checkpoint) ?? bodySetIntegrityError(checkpoint) ?? appliedIntegrityError(checkpoint) ?? scanIntegrityError(checkpoint) ?? blockedIntegrityError(checkpoint);
+}
+async function persistedBodyIntegrityError(checkpoint) {
+  for (const entry of checkpoint.bodies) {
+    let computedHash;
+    try {
+      computedHash = await PayloadBuilder.dataHash(entry.body);
+    } catch {
+      return `persisted body ${entry.hash} cannot be hashed`;
+    }
+    if (computedHash !== entry.hash) {
+      return `persisted body ${entry.hash} hashes to ${computedHash}`;
+    }
+  }
+  return void 0;
+}
+async function loadEventKitReplayCheckpoint(value, identity) {
+  if (value === void 0 || value === null) return { status: "missing" };
+  const parsed = EventKitReplayCheckpointZod.safeParse(value);
+  if (!parsed.success) {
+    return { detail: "recognized Event Kit replay checkpoint has invalid content", status: "corrupt" };
+  }
+  const checkpoint = parsed.data;
+  if (checkpoint.chainId !== identity.chainId) {
+    return { detail: `chainId ${checkpoint.chainId} != ${identity.chainId}`, status: "identity-mismatch" };
+  }
+  if (checkpoint.floorBlock !== identity.floorBlock) {
+    return { detail: `floorBlock ${checkpoint.floorBlock} != ${identity.floorBlock}`, status: "identity-mismatch" };
+  }
+  if (checkpoint.network !== identity.network) {
+    return { detail: `network ${checkpoint.network} != ${identity.network}`, status: "identity-mismatch" };
+  }
+  if (checkpoint.sourceId !== identity.sourceId) {
+    return { detail: `sourceId ${checkpoint.sourceId} != ${identity.sourceId}`, status: "identity-mismatch" };
+  }
+  if (checkpoint.publisher !== identity.publisher) {
+    return { detail: `publisher ${checkpoint.publisher} != ${identity.publisher}`, status: "identity-mismatch" };
+  }
+  if (!sameSchemas(checkpoint.objectSchemas)) {
+    return { detail: "Event Kit indexed schema policy differs", status: "identity-mismatch" };
+  }
+  const bodyIntegrityError = await persistedBodyIntegrityError(checkpoint);
+  if (bodyIntegrityError !== void 0) return { detail: bodyIntegrityError, status: "corrupt" };
+  const integrityError = checkpointIntegrityError(checkpoint);
+  if (integrityError !== void 0) return { detail: integrityError, status: "corrupt" };
+  return { checkpoint, status: "valid" };
+}
+
+// src/finalizedReplayController.ts
+function requireHead(value) {
+  const head = Number(value);
+  if (!Number.isSafeInteger(head) || head < 0) {
+    throw new TypeError(`finalized head must be a nonnegative safe integer, received ${String(value)}`);
+  }
+  return head;
+}
+function requireFloor(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`floorBlock must be a nonnegative safe integer, received ${String(value)}`);
+  }
+  return value;
+}
+function replayContract(options, throughBlock) {
+  return {
+    eventBodyCorpus: { sourceId: options.sourceId },
+    floorBlock: options.floorBlock,
+    foldVersion: STATEMENT_FOLD_VERSION2,
+    indexedSchemaPolicy: { foldedObjectSchemas: [...EventKitClaimedObjectSchemas] },
+    network: options.network,
+    throughBlock
+  };
+}
+function initialCheckpoint(options) {
+  return EventKitReplayCheckpointZod.parse({
+    applied: [],
+    bodies: [],
+    chainId: options.chainId,
+    finalizedHead: 0,
+    floorBlock: options.floorBlock,
+    foldVersion: STATEMENT_FOLD_VERSION2,
+    indexedThrough: null,
+    network: options.network,
+    objectSchemas: [...EventKitClaimedObjectSchemas],
+    publisher: options.publisher,
+    scan: null,
+    sourceId: options.sourceId,
+    version: EVENT_KIT_REPLAY_CHECKPOINT_VERSION
+  });
+}
+function corruptKey(record) {
+  return `${record.claimedHash ?? ""}:${record.computedHash}`;
+}
+function uniqueCorrupt(records) {
+  return [...new Map(records.map((record) => [corruptKey(record), record])).values()];
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function appliedKey2(record) {
+  return `${record.txHash}:${record.eventHash}:${record.hashIndex}`;
+}
+function mergeApplied(existing, additions) {
+  const merged = new Map(existing.map((record) => [appliedKey2(record), record]));
+  for (const record of additions) {
+    const key = appliedKey2(record);
+    const prior = merged.get(key);
+    if (prior !== void 0 && JSON.stringify(prior) !== JSON.stringify(record)) {
+      throw new Error(`applied-event identity collision at ${key}`);
+    }
+    merged.set(key, record);
+  }
+  return [...merged.values()].toSorted((left, right) => left.block - right.block || left.blockEventOrdinal.tx - right.blockEventOrdinal.tx || left.blockEventOrdinal.event - right.blockEventOrdinal.event || left.hashIndex - right.hashIndex);
+}
+function mergeBodies(existing, additions) {
+  const merged = new Map(existing.map((entry) => [entry.hash, entry.body]));
+  for (const [hash, body] of additions) {
+    const prior = merged.get(hash);
+    if (prior !== void 0 && JSON.stringify(prior) !== JSON.stringify(body)) {
+      throw new Error(`content-addressed body collision for ${hash}`);
+    }
+    merged.set(hash, body);
+  }
+  return [...merged].map(([hash, body]) => ({ body, hash: HashZod2.parse(hash) })).toSorted((left, right) => left.hash.localeCompare(right.hash));
+}
+async function stageBlock(options, prior, block) {
+  const result = await scanFinalizedStatements(
+    options.chain,
+    options.bodies,
+    replayContract(options, block),
+    {
+      batchSize: 1,
+      ...prior.scan === null ? {} : { resumeFrom: prior.scan },
+      strict: { rejectAmbiguousSchemaDeclarations: true },
+      through: block
+    }
+  );
+  const applied = result.fold.applied.filter(
+    (record) => normalizeAddress3(record.subject) === options.publisher
+  );
+  const appliedObjectHashes = uniqueStrings(applied.map((record) => record.objectHash));
+  const objects = await resolveVerifiedBodies(options.bodies, appliedObjectHashes);
+  const missingObjects = appliedObjectHashes.filter((hash) => !objects.bodies.has(hash));
+  const schemaMismatchedObjects = uniqueStrings(applied.flatMap((record) => {
+    const body = objects.bodies.get(record.objectHash);
+    return body !== void 0 && body.schema !== record.objectSchema ? [record.objectHash] : [];
+  }));
+  const acceptanceAttachments = [];
+  for (const record of applied) {
+    if (normalizeAddress3(record.source) !== options.publisher || record.objectSchema !== WakeSubscriptionAcceptanceSchema2) continue;
+    const acceptance = WakeSubscriptionAcceptanceZod.safeParse(objects.bodies.get(record.objectHash));
+    if (acceptance.success) acceptanceAttachments.push(acceptance.data.challenge, acceptance.data.response);
+  }
+  const attachmentHashes = uniqueStrings(acceptanceAttachments);
+  const attachments = await resolveVerifiedBodies(options.bodies, attachmentHashes);
+  const missingAttachments = attachmentHashes.filter((hash) => !attachments.bodies.has(hash));
+  const corrupt = uniqueCorrupt([
+    ...objects.corrupt,
+    ...attachments.corrupt
+  ]);
+  const objectHashes = uniqueStrings([
+    ...missingObjects,
+    ...schemaMismatchedObjects,
+    ...missingAttachments
+  ]).map((hash) => HashZod2.parse(hash));
+  const isBlocked = result.unresolved.length > 0 || objectHashes.length > 0 || corrupt.length > 0;
+  return {
+    applied,
+    bodies: new Map([...objects.bodies, ...attachments.bodies]),
+    scan: result.checkpoint,
+    ...isBlocked ? {
+      blocked: {
+        atBlock: block,
+        corrupt,
+        objectHashes,
+        unresolvedEvents: result.unresolved
+      }
+    } : {}
+  };
+}
+var DefaultFinalizedEventKitReplayController = class {
+  #checkpoint;
+  #options;
+  #syncTail = Promise.resolve();
+  constructor(options, checkpoint) {
+    this.#options = options;
+    this.#checkpoint = checkpoint;
+  }
+  body(hash) {
+    return this.#checkpoint.bodies.find((entry) => entry.hash === hash)?.body;
+  }
+  snapshot() {
+    return this.#checkpoint;
+  }
+  status() {
+    return {
+      ...this.#checkpoint.blocked === void 0 ? {} : { blocked: this.#checkpoint.blocked },
+      finalizedHead: this.#checkpoint.finalizedHead,
+      indexedThrough: this.#checkpoint.indexedThrough
+    };
+  }
+  sync() {
+    const result = this.#syncTail.then(async () => await this.#syncOnce());
+    this.#syncTail = result.then(
+      () => true,
+      () => false
+    );
+    return result;
+  }
+  viewer() {
+    return createCheckpointStatementGraphViewer(this.#checkpoint);
+  }
+  async #syncOnce() {
+    const finalizedHead = requireHead(await this.#options.chain.finalization.headNumber());
+    if (finalizedHead < this.#checkpoint.finalizedHead) {
+      throw new RangeError(
+        `finalized head regressed from ${this.#checkpoint.finalizedHead} to ${finalizedHead}; refusing to roll back`
+      );
+    }
+    const indexedThrough = this.#checkpoint.indexedThrough;
+    if (indexedThrough !== null && finalizedHead < indexedThrough) {
+      throw new RangeError(`finalized head ${finalizedHead} is behind indexedThrough ${indexedThrough}`);
+    }
+    let next = indexedThrough === null ? this.#options.floorBlock : indexedThrough + 1;
+    let changed = finalizedHead !== this.#checkpoint.finalizedHead;
+    while (next <= finalizedHead) {
+      const staged = await stageBlock(this.#options, this.#checkpoint, next);
+      if (staged.blocked !== void 0) {
+        const blocked = EventKitReplayCheckpointZod.parse({
+          ...this.#checkpoint,
+          blocked: staged.blocked,
+          finalizedHead
+        });
+        await this.#options.checkpointStore.save(blocked);
+        this.#checkpoint = blocked;
+        return this.status();
+      }
+      const committed = EventKitReplayCheckpointZod.parse({
+        ...this.#checkpoint,
+        applied: mergeApplied(this.#checkpoint.applied, staged.applied),
+        bodies: mergeBodies(this.#checkpoint.bodies, staged.bodies),
+        blocked: void 0,
+        finalizedHead,
+        indexedThrough: next,
+        scan: staged.scan
+      });
+      await this.#options.checkpointStore.save(committed);
+      this.#checkpoint = committed;
+      changed = false;
+      next += 1;
+    }
+    if (changed || this.#checkpoint.blocked !== void 0) {
+      const observed = EventKitReplayCheckpointZod.parse({
+        ...this.#checkpoint,
+        blocked: void 0,
+        finalizedHead
+      });
+      await this.#options.checkpointStore.save(observed);
+      this.#checkpoint = observed;
+    }
+    return this.status();
+  }
+};
+async function createFinalizedEventKitReplayController(rawOptions) {
+  const options = {
+    ...rawOptions,
+    chainId: ChainIdZod2.parse(rawOptions.chainId),
+    floorBlock: requireFloor(rawOptions.floorBlock),
+    network: rawOptions.network.trim(),
+    publisher: NormalizedAddressZod2.parse(rawOptions.publisher),
+    sourceId: rawOptions.sourceId.trim()
+  };
+  if (options.network.length === 0) throw new TypeError("network must not be empty");
+  if (options.sourceId.length === 0) throw new TypeError("sourceId must not be empty");
+  const loaded = await loadEventKitReplayCheckpoint(await options.checkpointStore.load(), options);
+  if (loaded.status === "corrupt" || loaded.status === "identity-mismatch") {
+    throw new Error(`cannot load Event Kit replay checkpoint: ${loaded.detail}`);
+  }
+  const checkpoint = loaded.status === "valid" ? loaded.checkpoint : initialCheckpoint(options);
+  return new DefaultFinalizedEventKitReplayController(options, checkpoint);
+}
+function createMemoryEventKitReplayCheckpointStore(initial) {
+  let value = initial;
+  const saved = [];
+  return {
+    async load() {
+      return value;
+    },
+    async save(checkpoint) {
+      value = checkpoint;
+      saved.push(checkpoint);
+    },
+    saved
+  };
+}
+
+// src/grantReadModel.ts
+import { HashZod as HashZod3 } from "@ariestools/sdk";
 import { XyoAddressZod } from "@xyo-network/sdk-protocol/address";
 function createStatementGraphGrantReadModel(options) {
   const { viewer } = options;
@@ -12,7 +719,7 @@ function createStatementGraphGrantReadModel(options) {
       return Object.freeze(records.map(toGrantClaim));
     },
     async object(objectHash) {
-      const record = await viewer.object(HashZod.parse(objectHash));
+      const record = await viewer.object(HashZod3.parse(objectHash));
       return record === void 0 ? void 0 : toGrantObject(record);
     }
   });
@@ -21,7 +728,8 @@ function toClaimQuery(query) {
   if (query === void 0) return void 0;
   return {
     ...query.declaredObjectSchemaPrefix === void 0 ? {} : { declaredObjectSchemaPrefix: query.declaredObjectSchemaPrefix },
-    ...query.objectHash === void 0 ? {} : { objectHash: HashZod.parse(query.objectHash) }
+    ...query.objectHash === void 0 ? {} : { objectHash: HashZod3.parse(query.objectHash) },
+    ...query.subject === void 0 ? {} : { subject: XyoAddressZod.parse(query.subject) }
   };
 }
 function toGrantClaim(record) {
@@ -31,7 +739,8 @@ function toGrantClaim(record) {
     firstEventHash: record.firstEventHash,
     lastBlock: record.lastBlock,
     objectHash: record.objectHash,
-    source: record.source
+    source: record.source,
+    subject: record.subject
   });
 }
 function toGrantObject(record) {
@@ -42,7 +751,782 @@ function toGrantObject(record) {
     params: record.params === null ? null : Object.freeze({ ...record.params })
   });
 }
+
+// src/handshakeReadModel.ts
+import {
+  EncryptedWakeSubscriptionSchema as EncryptedWakeSubscriptionSchema2,
+  EncryptedWakeSubscriptionZod,
+  EndpointChallengeResponseZod,
+  EndpointChallengeZod,
+  FINALIZED_HEAD_EVENT_KIND as FINALIZED_HEAD_EVENT_KIND2,
+  HandshakeIdZod,
+  NormalizedAddressZod as NormalizedAddressZod4,
+  PublisherServiceSchema as PublisherServiceSchema3,
+  WakeGrantObjectSchema as WakeGrantObjectSchema2,
+  WakeGrantObjectZod,
+  WakeGrantRevocationSchema as WakeGrantRevocationSchema2,
+  WakeGrantRevocationZod,
+  WakeSubscriptionAcceptanceRevocationSchema as WakeSubscriptionAcceptanceRevocationSchema2,
+  WakeSubscriptionAcceptanceRevocationZod,
+  WakeSubscriptionAcceptanceSchema as WakeSubscriptionAcceptanceSchema3,
+  WakeSubscriptionAcceptanceZod as WakeSubscriptionAcceptanceZod2,
+  WakeSubscriptionRevocationSchema as WakeSubscriptionRevocationSchema2,
+  WakeSubscriptionRevocationZod
+} from "@xyo-network/event-kit-schemas";
+import { XyoAddressZod as XyoAddressZod3 } from "@xyo-network/sdk-protocol/address";
+
+// src/handshakeCatalog.ts
+import {
+  resolvePreferredEncryptionKey,
+  selectPublisherService
+} from "@xyo-network/event-kit-protocol";
+import {
+  ChainIdZod as ChainIdZod3,
+  FINALIZED_HEAD_EVENT_KIND,
+  NormalizedAddressZod as NormalizedAddressZod3,
+  PublisherEncryptionKeyRevocationSchema as PublisherEncryptionKeyRevocationSchema2,
+  PublisherEncryptionKeyRevocationZod,
+  PublisherEncryptionKeySchema as PublisherEncryptionKeySchema2,
+  PublisherEncryptionKeyZod,
+  PublisherServiceRevocationSchema as PublisherServiceRevocationSchema2,
+  PublisherServiceRevocationZod,
+  PublisherServiceSchema as PublisherServiceSchema2,
+  PublisherServiceZod
+} from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-protocol/address";
+function handshakeEvidence(record) {
+  return {
+    block: record.block,
+    eventHash: record.eventHash,
+    hashIndex: record.hashIndex,
+    objectHash: record.objectHash,
+    ordinal: record.blockEventOrdinal,
+    source: record.source,
+    txHash: record.txHash
+  };
+}
+function handshakeEventEvidence(record) {
+  const item = handshakeEvidence(record);
+  return {
+    block: item.block,
+    eventHash: item.eventHash,
+    ordinal: item.ordinal,
+    source: item.source,
+    txHash: item.txHash
+  };
+}
+function handshakeEventKey(record) {
+  return `${record.txHash}:${record.eventHash}`;
+}
+function earliestByHash(records) {
+  const result = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const prior = result.get(record.objectHash);
+    if (prior === void 0 || record.block < prior.block || record.block === prior.block && record.blockEventOrdinal.tx < prior.blockEventOrdinal.tx || record.block === prior.block && record.blockEventOrdinal.tx === prior.blockEventOrdinal.tx && record.blockEventOrdinal.event < prior.blockEventOrdinal.event) {
+      result.set(record.objectHash, record);
+    }
+  }
+  return [...result.values()];
+}
+async function verifiedHandshakeObjectBody(viewer, record) {
+  const object = await viewer.object(record.objectHash);
+  if (object?.assurance !== "resolved" || object.declaredSchema !== record.objectSchema || object.params === null) return void 0;
+  const body = { schema: object.declaredSchema, ...object.params };
+  return await PayloadBuilder2.dataHash(body) === record.objectHash ? body : void 0;
+}
+async function verifiedHandshakeAttachmentBody(resolver, hash) {
+  const body = resolver?.(hash);
+  if (body === void 0) return void 0;
+  return await PayloadBuilder2.dataHash(body) === hash ? { ...body } : void 0;
+}
+function firstHandshakeRevocation(revocations, target) {
+  const blocks = revocations.filter((item) => item.target === target).map((item) => item.block);
+  return blocks.length === 0 ? void 0 : Math.min(...blocks);
+}
+async function parsedHandshakeObjects(viewer, records, parse) {
+  const objects = [];
+  for (const record of earliestByHash(records)) {
+    const body = await verifiedHandshakeObjectBody(viewer, record);
+    const parsed = parse(body);
+    if (!parsed.success) continue;
+    objects.push({
+      body: parsed.data,
+      evidence: handshakeEvidence(record),
+      objectHash: record.objectHash
+    });
+  }
+  return objects;
+}
+async function handshakeRevocations(viewer, records, parse, field) {
+  const result = [];
+  for (const record of earliestByHash(records)) {
+    const parsed = parse(await verifiedHandshakeObjectBody(viewer, record));
+    if (parsed.success && typeof parsed.data[field] === "string") {
+      result.push({ block: record.block, target: parsed.data[field] });
+    }
+  }
+  return result;
+}
+async function buildHandshakeCatalogs(viewer, publisher) {
+  const events = await viewer.events(XyoAddressZod2.parse(publisher));
+  const services = await parsedHandshakeObjects(
+    viewer,
+    events.filter((record) => record.objectSchema === PublisherServiceSchema2),
+    (value) => PublisherServiceZod.safeParse(value)
+  );
+  const keys = await parsedHandshakeObjects(
+    viewer,
+    events.filter((record) => record.objectSchema === PublisherEncryptionKeySchema2),
+    (value) => PublisherEncryptionKeyZod.safeParse(value)
+  );
+  const serviceRevocations = await handshakeRevocations(
+    viewer,
+    events.filter((record) => record.objectSchema === PublisherServiceRevocationSchema2),
+    (value) => PublisherServiceRevocationZod.safeParse(value),
+    "service"
+  );
+  const keyRevocations = await handshakeRevocations(
+    viewer,
+    events.filter((record) => record.objectSchema === PublisherEncryptionKeyRevocationSchema2),
+    (value) => PublisherEncryptionKeyRevocationZod.safeParse(value),
+    "key"
+  );
+  const serviceByHash = new Map(services.map((service) => {
+    const revokedAtBlock = firstHandshakeRevocation(serviceRevocations, service.objectHash);
+    return [service.objectHash, {
+      ...service,
+      ...revokedAtBlock === void 0 ? {} : { revokedAtBlock }
+    }];
+  }));
+  const keyByHash = new Map(keys.map((key) => {
+    const revokedAtBlock = firstHandshakeRevocation(keyRevocations, key.objectHash);
+    return [key.objectHash, {
+      ...key,
+      ...revokedAtBlock === void 0 ? {} : { revokedAtBlock }
+    }];
+  }));
+  return {
+    keyByHash,
+    keyLifecycles: [...keyByHash.values()].map((key) => ({
+      claimedAtBlock: key.evidence.block,
+      expiresAtBlock: key.body.expiresAtBlock,
+      keyId: key.body.keyId,
+      objectHash: key.objectHash,
+      revokedAtBlock: key.revokedAtBlock,
+      source: key.evidence.source,
+      validFromBlock: key.body.validFromBlock
+    })),
+    serviceByHash,
+    serviceLifecycles: [...serviceByHash.values()].map((service) => ({
+      claimedAtBlock: service.evidence.block,
+      encryptionKeys: service.body.encryptionKeys,
+      eventKinds: service.body.events.map((event) => event.kind),
+      expiresAtBlock: service.body.expiresAtBlock,
+      objectHash: service.objectHash,
+      preferredEncryptionKey: service.body.preferredEncryptionKey,
+      revision: service.body.revision,
+      revokedAtBlock: service.revokedAtBlock,
+      serviceId: service.body.serviceId,
+      source: service.evidence.source,
+      supersedes: service.body.supersedes,
+      validFromBlock: service.body.validFromBlock
+    }))
+  };
+}
+async function viewHead(viewer, finalizedHead) {
+  if (!Number.isSafeInteger(finalizedHead) || finalizedHead < 0) {
+    throw new TypeError("finalizedHead must be a nonnegative safe integer");
+  }
+  let indexedThrough;
+  try {
+    indexedThrough = await viewer.head();
+  } catch {
+    return {
+      finalizedHead,
+      indexedThrough: null,
+      ok: false,
+      reason: "view-unavailable"
+    };
+  }
+  if (indexedThrough < finalizedHead) return {
+    finalizedHead,
+    indexedThrough,
+    ok: false,
+    reason: "stale-view"
+  };
+  if (indexedThrough > finalizedHead) return {
+    finalizedHead,
+    indexedThrough,
+    ok: false,
+    reason: "ahead-of-finality"
+  };
+  return { indexedThrough };
+}
+function exactHandshakeServiceAt(catalogs, service, publisher, finalizedHead) {
+  const selection = selectPublisherService({
+    eventKind: FINALIZED_HEAD_EVENT_KIND,
+    finalizedHead,
+    publisherSource: publisher,
+    serviceId: service.body.serviceId,
+    services: catalogs.serviceLifecycles
+  });
+  return selection.ok && selection.service.objectHash === service.objectHash;
+}
+function exactHandshakeKeyAt(catalogs, service, keyHash, finalizedHead) {
+  const serviceLifecycle = catalogs.serviceLifecycles.find((item) => item.objectHash === service.objectHash);
+  if (serviceLifecycle === void 0) return false;
+  const resolution = resolvePreferredEncryptionKey({
+    finalizedHead,
+    keys: catalogs.keyLifecycles,
+    service: serviceLifecycle
+  });
+  return resolution.ok && resolution.key.objectHash === keyHash;
+}
+function hasPendingPublisherService(catalogs, query) {
+  return catalogs.serviceLifecycles.some((service) => service.source === query.publisher && service.claimedAtBlock <= query.finalizedHead && service.validFromBlock > query.finalizedHead && (service.revokedAtBlock === void 0 || service.revokedAtBlock > query.finalizedHead) && (query.serviceId === void 0 || service.serviceId === query.serviceId) && service.eventKinds.includes(query.eventKind ?? FINALIZED_HEAD_EVENT_KIND));
+}
+async function discoverHandshakeService(options, rawQuery) {
+  const query = {
+    ...rawQuery,
+    chainId: ChainIdZod3.parse(rawQuery.chainId),
+    eventKind: rawQuery.eventKind ?? FINALIZED_HEAD_EVENT_KIND,
+    publisher: NormalizedAddressZod3.parse(rawQuery.publisher)
+  };
+  const head = await viewHead(options.viewer, query.finalizedHead);
+  if ("ok" in head) return { query, result: head };
+  const catalogs = await buildHandshakeCatalogs(options.viewer, query.publisher);
+  const serviceSelection = selectPublisherService({
+    eventKind: query.eventKind ?? FINALIZED_HEAD_EVENT_KIND,
+    finalizedHead: query.finalizedHead,
+    publisherSource: query.publisher,
+    ...query.serviceId === void 0 ? {} : { serviceId: query.serviceId },
+    services: catalogs.serviceLifecycles
+  });
+  if (!serviceSelection.ok) {
+    const reason = serviceSelection.reason === "service-not-found" && hasPendingPublisherService(catalogs, query) ? "service-pending" : serviceSelection.reason;
+    return {
+      catalogs,
+      query,
+      result: {
+        finalizedHead: query.finalizedHead,
+        indexedThrough: head.indexedThrough,
+        ok: false,
+        reason
+      }
+    };
+  }
+  const service = catalogs.serviceByHash.get(serviceSelection.service.objectHash);
+  if (service === void 0) throw new Error("selected service body is unavailable");
+  const keySelection = resolvePreferredEncryptionKey({
+    finalizedHead: query.finalizedHead,
+    keys: catalogs.keyLifecycles,
+    service: serviceSelection.service
+  });
+  if (!keySelection.ok) {
+    return {
+      catalogs,
+      query,
+      result: {
+        finalizedHead: query.finalizedHead,
+        indexedThrough: head.indexedThrough,
+        ok: false,
+        reason: keySelection.reason
+      }
+    };
+  }
+  const key = catalogs.keyByHash.get(keySelection.key.objectHash);
+  if (key === void 0) throw new Error("selected encryption-key body is unavailable");
+  return {
+    catalogs,
+    query,
+    result: {
+      finalizedHead: query.finalizedHead,
+      indexedThrough: head.indexedThrough,
+      key,
+      ok: true,
+      service
+    }
+  };
+}
+
+// src/publisherSubjectViewer.ts
+var LegacyHexAddress3 = /^[A-Fa-f0-9]{40}$/;
+function normalizeAddress4(value) {
+  return LegacyHexAddress3.test(value) ? value.toLowerCase() : value;
+}
+function isPublisherSubject(subject, publisher) {
+  return normalizeAddress4(subject) === normalizeAddress4(publisher);
+}
+function publisherSubjectViewer(viewer, publisher) {
+  const claimQuery = (query) => ({ ...query, subject: publisher });
+  const eventQuery = (query) => ({ ...query, subject: publisher });
+  const filterClaims = async (records) => (await records).filter((record) => isPublisherSubject(record.subject, publisher));
+  const filterEvents = async (records) => (await records).filter((record) => isPublisherSubject(record.subject, publisher));
+  return Object.freeze({
+    async claims(source, query) {
+      return await filterClaims(viewer.claims(source, claimQuery(query)));
+    },
+    async claimsByObject(objectHash) {
+      return await filterClaims(viewer.claimsBySubject(publisher, claimQuery({ objectHash })));
+    },
+    async claimsBySubject(subject, query) {
+      if (!isPublisherSubject(subject, publisher)) return [];
+      return await filterClaims(viewer.claimsBySubject(publisher, claimQuery(query)));
+    },
+    async event(txHash, eventHash) {
+      return await filterEvents(viewer.event(txHash, eventHash));
+    },
+    async events(source, query) {
+      return await filterEvents(viewer.events(source, eventQuery(query)));
+    },
+    async head() {
+      return await viewer.head();
+    },
+    async object(objectHash) {
+      return await viewer.object(objectHash);
+    },
+    async source(source) {
+      return await viewer.source(source);
+    },
+    async unresolved(txHash, eventHash) {
+      return await viewer.unresolved(txHash, eventHash);
+    }
+  });
+}
+
+// src/subscriptionLifecycleView.ts
+import { selectSubscriptionActivation } from "@xyo-network/event-kit-protocol";
+function inactiveState(tuples, acceptances, finalizedHead) {
+  const subscriptionHashes = new Set(tuples.map((tuple) => tuple.subscription.objectHash));
+  if (tuples.some((tuple) => (tuple.grantRevokedAtBlock ?? Number.POSITIVE_INFINITY) <= finalizedHead) || tuples.some((tuple) => (tuple.subscription.revokedAtBlock ?? Number.POSITIVE_INFINITY) <= finalizedHead) || acceptances.some((item) => subscriptionHashes.has(item.lifecycle.subscription) && (item.lifecycle.revokedAtBlock ?? Number.POSITIVE_INFINITY) <= finalizedHead)) {
+    return "revoked";
+  }
+  if (tuples.every((tuple) => tuple.subscription.body.expiresAtBlock <= finalizedHead)) return "expired";
+  return "inactive";
+}
+function pendingState(tuples, acceptances, finalizedHead) {
+  const latest = tuples.reduce((selected, candidate) => selected === void 0 || candidate.subscriptionLifecycle.revision > selected.subscriptionLifecycle.revision ? candidate : selected, void 0);
+  if (latest === void 0) return "inactive";
+  const matchingAcceptances = acceptances.filter((item) => item.lifecycle.subscription === latest.subscription.objectHash);
+  if ((latest.grantRevokedAtBlock ?? Number.POSITIVE_INFINITY) <= finalizedHead || (latest.subscription.revokedAtBlock ?? Number.POSITIVE_INFINITY) <= finalizedHead || matchingAcceptances.some((item) => (item.lifecycle.revokedAtBlock ?? Number.POSITIVE_INFINITY) <= finalizedHead)) {
+    return "revoked";
+  }
+  return latest.subscription.body.expiresAtBlock <= finalizedHead ? "expired" : "pending";
+}
+function buildPublisherSubscriptionViews(tuples, acceptances, publisher, finalizedHead) {
+  const grouped = Map.groupBy(tuples, (tuple) => `${tuple.subscriber}:${tuple.subscription.body.subscriptionId}`);
+  const result = [];
+  for (const group of grouped.values()) {
+    const first = group[0];
+    const groupAcceptances = acceptances.filter((item) => item.subscriber === first.subscriber);
+    const activation = selectSubscriptionActivation({
+      acceptances: groupAcceptances.map((item) => item.lifecycle),
+      finalizedHead,
+      publisherSource: publisher,
+      subscriberSource: first.subscriber,
+      subscriptionId: first.subscription.body.subscriptionId,
+      subscriptions: group.map((item) => item.subscriptionLifecycle)
+    });
+    if (activation.ok) {
+      const selected = group.find((item) => item.subscription.objectHash === activation.subscription.objectHash);
+      const acceptance = groupAcceptances.find((item) => item.lifecycle.objectHash === activation.acceptance.objectHash);
+      if (selected?.grantRevokedAtBlock !== void 0 && selected.grantRevokedAtBlock <= finalizedHead) {
+        result.push({
+          reason: "grant-revoked",
+          state: "revoked",
+          subscriber: first.subscriber,
+          subscriptionId: first.subscription.body.subscriptionId,
+          tuples: group
+        });
+      } else {
+        result.push({
+          ...acceptance === void 0 ? {} : { acceptance: acceptance.claimed },
+          activeFromBlock: activation.activeFromBlock,
+          pendingReplacement: activation.pendingReplacement,
+          selectedSubscription: activation.subscription.objectHash,
+          state: "active",
+          subscriber: first.subscriber,
+          subscriptionId: first.subscription.body.subscriptionId,
+          tuples: group
+        });
+      }
+    } else {
+      result.push({
+        reason: activation.reason,
+        state: activation.reason === "subscription-pending" ? pendingState(group, groupAcceptances, finalizedHead) : activation.reason === "invalid-revision-chain" || activation.reason === "ambiguous-acceptance" ? "rejected" : inactiveState(group, groupAcceptances, finalizedHead),
+        subscriber: first.subscriber,
+        subscriptionId: first.subscription.body.subscriptionId,
+        tuples: group
+      });
+    }
+  }
+  return result;
+}
+function publicSubscriptionTuple(tuple) {
+  return {
+    grant: tuple.grant,
+    service: tuple.service,
+    subscriber: tuple.subscriber,
+    subscription: tuple.subscription,
+    tupleEvent: tuple.tupleEvent
+  };
+}
+function isAcceptanceEligibleAtHead(tuple, catalogs, serviceHash, key, finalizedHead, publisher) {
+  return tuple.service.objectHash === serviceHash && tuple.subscription.body.encryptionKey === key.objectHash && tuple.subscription.body.keyId === key.body.keyId && exactHandshakeServiceAt(catalogs, tuple.service, publisher, finalizedHead) && exactHandshakeKeyAt(catalogs, tuple.service, key.objectHash, finalizedHead) && (tuple.grantRevokedAtBlock === void 0 || tuple.grantRevokedAtBlock > finalizedHead) && (tuple.subscription.revokedAtBlock === void 0 || tuple.subscription.revokedAtBlock > finalizedHead) && finalizedHead < Number.MAX_SAFE_INTEGER && tuple.subscription.body.expiresAtBlock - finalizedHead > 2;
+}
+function selectPublisherAcceptanceCandidates(input) {
+  const acceptedSubscriptions = new Set(input.acceptances.map((item) => item.lifecycle.subscription));
+  const candidates = [];
+  for (const subscription of input.subscriptions) {
+    if (subscription.state !== "pending" && !(subscription.state === "active" && subscription.pendingReplacement === true)) continue;
+    const highestRevision = Math.max(...subscription.tuples.map((tuple2) => tuple2.subscription.body.revision));
+    const latest = input.tuples.filter((tuple2) => tuple2.subscriber === subscription.subscriber && tuple2.subscription.body.subscriptionId === subscription.subscriptionId && tuple2.subscription.body.revision === highestRevision);
+    if (latest.length !== 1) continue;
+    const tuple = latest[0];
+    if (acceptedSubscriptions.has(tuple.subscription.objectHash) || !isAcceptanceEligibleAtHead(
+      tuple,
+      input.catalogs,
+      input.service.objectHash,
+      input.key,
+      input.finalizedHead,
+      input.publisher
+    )) continue;
+    candidates.push({
+      key: input.key,
+      subscriber: tuple.subscriber,
+      subscriptionId: tuple.subscription.body.subscriptionId,
+      tuple: publicSubscriptionTuple(tuple)
+    });
+  }
+  return candidates;
+}
+
+// src/handshakeReadModel.ts
+function publisherSubjectOptions(options, publisher) {
+  return {
+    ...options,
+    viewer: publisherSubjectViewer(options.viewer, XyoAddressZod3.parse(publisher))
+  };
+}
+function hasExactGrantBinding(grant, publisher) {
+  return grant.publisher === publisher && grant.permissions.length === 1 && grant.permissions[0] === "enqueue";
+}
+function hasExactSubscriptionBinding(subscription, chainId, publisher, serviceHash, grantHash) {
+  return subscription.publisher === publisher && subscription.chainId === chainId && subscription.service === serviceHash && subscription.grant === grantHash && subscription.eventKind === FINALIZED_HEAD_EVENT_KIND2;
+}
+function hasExactKeyBinding(subscription, service, catalogs, tupleBlock) {
+  const key = catalogs.keyByHash.get(subscription.encryptionKey);
+  return subscription.encryptionKey === service.body.preferredEncryptionKey && key?.body.keyId === subscription.keyId && service.body.encryptionKeys.includes(key.objectHash) && exactHandshakeKeyAt(catalogs, service, key.objectHash, tupleBlock);
+}
+function expiryIsInsideServicePolicy(subscription, service, tupleBlock) {
+  return subscription.expiresAtBlock > tupleBlock && subscription.expiresAtBlock <= tupleBlock + service.limits.maxSubscriptionLifetimeBlocks;
+}
+async function tupleRevocations(viewer, records) {
+  return {
+    grants: await handshakeRevocations(
+      viewer,
+      records.filter((record) => record.objectSchema === WakeGrantRevocationSchema2),
+      (value) => WakeGrantRevocationZod.safeParse(value),
+      "grant"
+    ),
+    subscriptions: await handshakeRevocations(
+      viewer,
+      records.filter((record) => record.objectSchema === WakeSubscriptionRevocationSchema2),
+      (value) => WakeSubscriptionRevocationZod.safeParse(value),
+      "subscription"
+    )
+  };
+}
+async function validateTuple(viewer, records, subscriber, service, catalogs, chainId, publisher, sourceEvents) {
+  const serviceEntries = records.filter((record) => record.objectSchema === PublisherServiceSchema3);
+  const grantEntries = records.filter((record) => record.objectSchema === WakeGrantObjectSchema2);
+  const subscriptionEntries = records.filter((record) => record.objectSchema === EncryptedWakeSubscriptionSchema2);
+  const baseEvidence = handshakeEventEvidence(records[0]);
+  const reject = (reason) => ({
+    rejection: {
+      evidence: baseEvidence,
+      reason,
+      subscriber
+    }
+  });
+  if (serviceEntries.length !== 1 || serviceEntries[0]?.objectHash !== service.objectHash || grantEntries.length !== 1 || subscriptionEntries.length !== 1) {
+    return reject("ambiguous-fan");
+  }
+  const grantRecord = grantEntries[0];
+  const subscriptionRecord = subscriptionEntries[0];
+  const grantParsed = WakeGrantObjectZod.safeParse(await verifiedHandshakeObjectBody(viewer, grantRecord));
+  if (!grantParsed.success) return reject("malformed-grant");
+  const subscriptionParsed = EncryptedWakeSubscriptionZod.safeParse(
+    await verifiedHandshakeObjectBody(viewer, subscriptionRecord)
+  );
+  if (!subscriptionParsed.success) return reject("malformed-subscription");
+  const grant = grantParsed.data;
+  const subscription = subscriptionParsed.data;
+  const tupleBlock = subscriptionRecord.block;
+  if (!hasExactGrantBinding(grant, publisher)) return reject("grant-binding-invalid");
+  if (!hasExactSubscriptionBinding(subscription, chainId, publisher, service.objectHash, grantRecord.objectHash)) {
+    return reject("subscription-binding-invalid");
+  }
+  const claimedKey = catalogs.keyByHash.get(subscription.encryptionKey);
+  if (service.evidence.block >= tupleBlock) return reject("service-inactive-at-claim");
+  if (claimedKey === void 0 || claimedKey.evidence.block >= tupleBlock) return reject("key-binding-invalid");
+  if (!exactHandshakeServiceAt(catalogs, service, publisher, tupleBlock)) return reject("service-inactive-at-claim");
+  if (!hasExactKeyBinding(subscription, service, catalogs, tupleBlock)) return reject("key-binding-invalid");
+  if (!expiryIsInsideServicePolicy(subscription, service.body, tupleBlock)) return reject("expiry-out-of-policy");
+  const revoked = await tupleRevocations(viewer, sourceEvents);
+  const subscriptionRevokedAtBlock = firstHandshakeRevocation(revoked.subscriptions, subscriptionRecord.objectHash);
+  const grantRevokedAtBlock = firstHandshakeRevocation(revoked.grants, grantRecord.objectHash);
+  return {
+    tuple: {
+      grant: {
+        body: grant,
+        evidence: handshakeEvidence(grantRecord),
+        objectHash: grantRecord.objectHash
+      },
+      grantRevokedAtBlock,
+      service,
+      subscriber,
+      subscription: {
+        body: subscription,
+        evidence: handshakeEvidence(subscriptionRecord),
+        objectHash: subscriptionRecord.objectHash,
+        ...subscriptionRevokedAtBlock === void 0 ? {} : { revokedAtBlock: subscriptionRevokedAtBlock }
+      },
+      subscriptionLifecycle: {
+        claimedAtBlock: tupleBlock,
+        expiresAtBlock: subscription.expiresAtBlock,
+        objectHash: subscriptionRecord.objectHash,
+        revision: subscription.revision,
+        revokedAtBlock: subscriptionRevokedAtBlock,
+        source: subscriber,
+        subscriptionId: subscription.subscriptionId,
+        supersedes: subscription.supersedes
+      },
+      tupleEvent: baseEvidence
+    }
+  };
+}
+async function discoverTuples(viewer, services, catalogs, query, candidateSources) {
+  const serviceByHash = new Map(services.map((service) => [service.objectHash, service]));
+  const serviceHashes = new Set(serviceByHash.keys());
+  const sources = candidateSources === void 0 ? [...new Set((await viewer.claimsBySubject(XyoAddressZod3.parse(query.publisher))).filter((claim) => serviceHashes.has(claim.objectHash)).map((claim) => claim.source))].filter((source) => !isPublisherSubject(source, query.publisher)) : [...new Set(candidateSources)].filter((source) => !isPublisherSubject(source, query.publisher));
+  const tuples = /* @__PURE__ */ new Map();
+  const rejections = [];
+  for (const source of sources) {
+    const sourceAddress = XyoAddressZod3.parse(source);
+    const events = await viewer.events(sourceAddress, { subject: XyoAddressZod3.parse(query.publisher) });
+    const groups = Map.groupBy(events, handshakeEventKey);
+    for (const records of groups.values()) {
+      const referencedServices = records.flatMap((record) => {
+        const service = serviceByHash.get(record.objectHash);
+        return service === void 0 ? [] : [service];
+      });
+      for (const service of referencedServices) {
+        const result = await validateTuple(
+          viewer,
+          records,
+          source,
+          service,
+          catalogs,
+          query.chainId,
+          query.publisher,
+          events
+        );
+        if (result.rejection !== void 0) rejections.push(result.rejection);
+        if (result.tuple !== void 0) {
+          const tupleKey = `${result.tuple.subscriber}:${result.tuple.subscription.objectHash}`;
+          const prior = tuples.get(tupleKey);
+          if (prior === void 0 || result.tuple.subscription.evidence.block < prior.subscription.evidence.block) {
+            tuples.set(tupleKey, result.tuple);
+          }
+        }
+      }
+    }
+  }
+  return { rejections, tuples: [...tuples.values()] };
+}
+function challengeMatchesTuple(challenge, response, acceptance, tuple, chainId, publisher) {
+  return challenge.chainId === chainId && challenge.publisher === publisher && challenge.subscriber === tuple.subscriber && challenge.service === tuple.service.objectHash && challenge.encryptionKey === tuple.subscription.body.encryptionKey && challenge.keyId === tuple.subscription.body.keyId && challenge.subscription === tuple.subscription.objectHash && challenge.grant === tuple.grant.objectHash && challenge.eventKind === tuple.subscription.body.eventKind && response.challenge === acceptance.challenge;
+}
+async function validatedAcceptances(options, catalogs, tuples, chainId, publisher) {
+  const publisherAddress = XyoAddressZod3.parse(publisher);
+  const events = await options.viewer.events(publisherAddress, { subject: publisherAddress });
+  const acceptances = await parsedHandshakeObjects(
+    options.viewer,
+    events.filter((record) => record.objectSchema === WakeSubscriptionAcceptanceSchema3),
+    (value) => WakeSubscriptionAcceptanceZod2.safeParse(value)
+  );
+  const acceptanceRevocations = await handshakeRevocations(
+    options.viewer,
+    events.filter((record) => record.objectSchema === WakeSubscriptionAcceptanceRevocationSchema2),
+    (value) => WakeSubscriptionAcceptanceRevocationZod.safeParse(value),
+    "acceptance"
+  );
+  const result = [];
+  for (const claimed of acceptances) {
+    const candidates = tuples.filter((candidate) => claimed.body.service === candidate.service.objectHash && claimed.body.encryptionKey === candidate.subscription.body.encryptionKey && claimed.body.subscription === candidate.subscription.objectHash && claimed.body.grant === candidate.grant.objectHash);
+    if (candidates.length === 0) continue;
+    const challengeBody = await verifiedHandshakeAttachmentBody(options.body, claimed.body.challenge);
+    const responseBody = await verifiedHandshakeAttachmentBody(options.body, claimed.body.response);
+    const challenge = EndpointChallengeZod.safeParse(challengeBody);
+    const response = EndpointChallengeResponseZod.safeParse(responseBody);
+    if (!challenge.success || !response.success) continue;
+    const eligible = candidates.filter((tuple2) => claimed.evidence.block > tuple2.subscription.evidence.block && exactHandshakeServiceAt(catalogs, tuple2.service, publisher, claimed.evidence.block) && exactHandshakeKeyAt(catalogs, tuple2.service, claimed.body.encryptionKey, claimed.evidence.block) && claimed.evidence.block + 1 < tuple2.subscription.body.expiresAtBlock && (tuple2.grantRevokedAtBlock === void 0 || tuple2.grantRevokedAtBlock > claimed.evidence.block) && (tuple2.subscription.revokedAtBlock === void 0 || tuple2.subscription.revokedAtBlock > claimed.evidence.block) && challengeMatchesTuple(challenge.data, response.data, claimed.body, tuple2, chainId, publisher));
+    if (eligible.length !== 1) continue;
+    const tuple = eligible[0];
+    const revokedAtBlock = firstHandshakeRevocation(acceptanceRevocations, claimed.objectHash);
+    const withRevocation = {
+      ...claimed,
+      ...revokedAtBlock === void 0 ? {} : { revokedAtBlock }
+    };
+    result.push({
+      claimed: withRevocation,
+      lifecycle: {
+        acceptanceBlock: claimed.evidence.block,
+        objectHash: claimed.objectHash,
+        revokedAtBlock,
+        source: publisher,
+        subscription: tuple.subscription.objectHash
+      },
+      subscriber: tuple.subscriber
+    });
+  }
+  return result;
+}
+async function handshakeLifecycle(options, rawQuery, candidateSources, subscriptionId) {
+  const scopedOptions = publisherSubjectOptions(options, rawQuery.publisher);
+  const discovery = await discoverHandshakeService(scopedOptions, rawQuery);
+  if (discovery.catalogs === void 0) return { discovery };
+  const serviceRevisions = [...discovery.catalogs.serviceByHash.values()].filter((service) => service.evidence.source === discovery.query.publisher && (discovery.query.serviceId === void 0 || service.body.serviceId === discovery.query.serviceId) && service.body.events.some((event) => event.kind === discovery.query.eventKind) && service.evidence.block <= discovery.query.finalizedHead);
+  const found = await discoverTuples(
+    scopedOptions.viewer,
+    serviceRevisions,
+    discovery.catalogs,
+    { chainId: discovery.query.chainId, publisher: discovery.query.publisher },
+    candidateSources
+  );
+  const tuples = subscriptionId === void 0 ? found.tuples : found.tuples.filter((tuple) => tuple.subscription.body.subscriptionId === subscriptionId);
+  const acceptances = await validatedAcceptances(
+    scopedOptions,
+    discovery.catalogs,
+    tuples,
+    discovery.query.chainId,
+    discovery.query.publisher
+  );
+  return {
+    acceptances,
+    discovery,
+    rejections: found.rejections,
+    subscriptions: buildPublisherSubscriptionViews(
+      tuples,
+      acceptances,
+      discovery.query.publisher,
+      discovery.query.finalizedHead
+    ),
+    tuples
+  };
+}
+function handshakeView(projection) {
+  if (!("subscriptions" in projection)) {
+    if (projection.discovery.result.ok) {
+      throw new Error("successful service discovery produced no catalogs");
+    }
+    return projection.discovery.result;
+  }
+  const {
+    discovery,
+    rejections,
+    subscriptions
+  } = projection;
+  const lifecycle = { rejections, subscriptions };
+  if (discovery.result.ok) {
+    return {
+      ...discovery.result,
+      ...lifecycle,
+      hasCurrentAdvertisement: true,
+      serviceDiscovery: discovery.result
+    };
+  }
+  if (discovery.result.indexedThrough === null) {
+    throw new Error("catalog-backed service discovery must have an indexed head");
+  }
+  return {
+    finalizedHead: discovery.result.finalizedHead,
+    hasCurrentAdvertisement: false,
+    indexedThrough: discovery.result.indexedThrough,
+    ok: true,
+    serviceDiscovery: discovery.result,
+    ...lifecycle
+  };
+}
+function createEventKitHandshakeReadModel(options) {
+  return Object.freeze({
+    async acceptanceCandidates(rawQuery) {
+      const subscriber = rawQuery.subscriber === void 0 ? void 0 : NormalizedAddressZod4.parse(rawQuery.subscriber);
+      const subscriptionId = rawQuery.subscriptionId === void 0 ? void 0 : HandshakeIdZod.parse(rawQuery.subscriptionId);
+      const projection = await handshakeLifecycle(
+        options,
+        rawQuery,
+        subscriber === void 0 ? void 0 : [subscriber],
+        subscriptionId
+      );
+      if (!("subscriptions" in projection)) {
+        if (projection.discovery.result.ok) {
+          throw new Error("successful service discovery produced no catalogs");
+        }
+        return projection.discovery.result;
+      }
+      if (!projection.discovery.result.ok) return projection.discovery.result;
+      const {
+        catalogs,
+        query,
+        result
+      } = projection.discovery;
+      if (catalogs === void 0) throw new Error("catalog-backed candidate discovery requires catalogs");
+      return {
+        ...result,
+        candidates: selectPublisherAcceptanceCandidates({
+          acceptances: projection.acceptances,
+          catalogs,
+          finalizedHead: query.finalizedHead,
+          key: result.key,
+          publisher: query.publisher,
+          service: result.service,
+          subscriptions: projection.subscriptions,
+          tuples: projection.tuples
+        }),
+        rejections: projection.rejections,
+        subscriptions: projection.subscriptions
+      };
+    },
+    async discoverPublisherService(query) {
+      return (await discoverHandshakeService(publisherSubjectOptions(options, query.publisher), query)).result;
+    },
+    async publisher(query) {
+      return handshakeView(await handshakeLifecycle(options, query));
+    },
+    async subscriber(rawQuery) {
+      const subscriber = NormalizedAddressZod4.parse(rawQuery.subscriber);
+      const subscriptionId = rawQuery.subscriptionId === void 0 ? void 0 : HandshakeIdZod.parse(rawQuery.subscriptionId);
+      const view = handshakeView(await handshakeLifecycle(options, rawQuery, [subscriber], subscriptionId));
+      return view.ok ? { ...view, subscriber } : view;
+    }
+  });
+}
 export {
-  createStatementGraphGrantReadModel
+  EVENT_KIT_REPLAY_CHECKPOINT_VERSION,
+  EventKitClaimedObjectSchemaSet,
+  EventKitClaimedObjectSchemas,
+  EventKitReplayCheckpointZod,
+  ReplayBlockedStateZod,
+  ReplayCorruptBodyZod,
+  ResolvedReplayBodyZod,
+  createCheckpointStatementGraphViewer,
+  createEventKitHandshakeReadModel,
+  createFinalizedEventKitReplayController,
+  createMemoryEventKitReplayCheckpointStore,
+  createStatementGraphGrantReadModel,
+  loadEventKitReplayCheckpoint
 };
 //# sourceMappingURL=index.mjs.map