@xyo-network/event-kit-statement-graph 0.1.9 → 1.0.1

package/dist/neutral/checkpointViewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpointViewer.d.ts","sourceRoot":"","sources":["../../src/checkpointViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,oBAAoB,EAIrB,MAAM,yCAAyC,CAAA;AAQhD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAA;AAmErE,+FAA+F;AAC/F,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,wBAAwB,GACnC,oBAAoB,CAwEtB"}
+{"version":3,"file":"checkpointViewer.d.ts","sourceRoot":"","sources":["../../src/checkpointViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,oBAAoB,EAIrB,MAAM,yCAAyC,CAAA;AAQhD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAA;AAmErE,+FAA+F;AAC/F,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,wBAAwB,GACnC,oBAAoB,CAmEtB"}

package/dist/neutral/finalizedReplayController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"finalizedReplayController.d.ts","sourceRoot":"","sources":["../../src/finalizedReplayController.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAA;AAMnF,OAAO,KAAK,EACV,UAAU,EAEX,MAAM,sCAAsC,CAAA;AAQ7C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAA;AAM7E,OAAO,KAAK,EACV,wBAAwB,EACxB,gCAAgC,EAChC,kBAAkB,EAGnB,MAAM,uBAAuB,CAAA;AAO9B,MAAM,WAAW,6BAA6B;IAC5C,yEAAyE;IACzE,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IACxB,oFAAoF;IACpF,IAAI,CAAC,UAAU,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1D;AAED,MAAM,WAAW,8BAA+B,SAAQ,gCAAgC;IACtF,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,4BAA4B,CAAA;IAC5C,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,eAAe,EAAE,6BAA6B,CAAA;IACvD,kEAAkE;IAClE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAChC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,kCAAkC;IACjD,+FAA+F;IAC/F,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED,MAAM,WAAW,iCAAiC;IAChD,6EAA6E;IAC7E,MAAM,IAAI,QAAQ,CAAC,6BAA6B,CAAC,GAAG,IAAI,CAAA;IACxD,8FAA8F;IAC9F,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAA;IACjE,QAAQ,IAAI,QAAQ,CAAC,wBAAwB,CAAC,CAAA;IAC9C,MAAM,IAAI,6BAA6B,CAAA;IACvC,yFAAyF;IACzF,IAAI,CAAC,OAAO,CAAC,EAAE,kCAAkC,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAAA;IAC1F,sFAAsF;IACtF,MAAM,IAAI,oBAAoB,CAAA;CAC/B;AA0YD,wBAAsB,uCAAuC,CAC3D,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,iCAAiC,CAAC,CAwB5C;AAED,uFAAuF;AACvF,wBAAgB,yCAAyC,CACvD,OAAO,CAAC,EAAE,OAAO,GAChB,6BAA6B,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,wBAAwB,EAAE,CAAA;CAAE,CAazF"}
+{"version":3,"file":"finalizedReplayController.d.ts","sourceRoot":"","sources":["../../src/finalizedReplayController.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAA;AAMnF,OAAO,KAAK,EACV,UAAU,EAEX,MAAM,sCAAsC,CAAA;AAQ7C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAA;AAM7E,OAAO,KAAK,EACV,wBAAwB,EACxB,gCAAgC,EAChC,kBAAkB,EAGnB,MAAM,uBAAuB,CAAA;AAO9B,MAAM,WAAW,6BAA6B;IAC5C,yEAAyE;IACzE,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IACxB,oFAAoF;IACpF,IAAI,CAAC,UAAU,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1D;AAED,MAAM,WAAW,8BAA+B,SAAQ,gCAAgC;IACtF,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,4BAA4B,CAAA;IAC5C,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,eAAe,EAAE,6BAA6B,CAAA;IACvD,kEAAkE;IAClE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAChC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,kCAAkC;IACjD,+FAA+F;IAC/F,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED,MAAM,WAAW,iCAAiC;IAChD,6EAA6E;IAC7E,MAAM,IAAI,QAAQ,CAAC,6BAA6B,CAAC,GAAG,IAAI,CAAA;IACxD,8FAA8F;IAC9F,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAA;IACjE,QAAQ,IAAI,QAAQ,CAAC,wBAAwB,CAAC,CAAA;IAC9C,MAAM,IAAI,6BAA6B,CAAA;IACvC,yFAAyF;IACzF,IAAI,CAAC,OAAO,CAAC,EAAE,kCAAkC,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAAA;IAC1F,sFAAsF;IACtF,MAAM,IAAI,oBAAoB,CAAA;CAC/B;AA8ZD,wBAAsB,uCAAuC,CAC3D,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,iCAAiC,CAAC,CAwB5C;AAED,uFAAuF;AACvF,wBAAgB,yCAAyC,CACvD,OAAO,CAAC,EAAE,OAAO,GAChB,6BAA6B,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,wBAAwB,EAAE,CAAA;CAAE,CAWzF"}

package/dist/neutral/grantReadModel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grantReadModel.d.ts","sourceRoot":"","sources":["../../src/grantReadModel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,4BAA4B,EAC7B,MAAM,iCAAiC,CAAA;AAExC,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,yCAAyC,CAAA;AAMhD,MAAM,WAAW,mCAAmC;IAClD;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,mCAAmC,GAC3C,4BAA4B,CAqB9B"}
+{"version":3,"file":"grantReadModel.d.ts","sourceRoot":"","sources":["../../src/grantReadModel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,4BAA4B,EAC7B,MAAM,iCAAiC,CAAA;AAExC,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,yCAAyC,CAAA;AAMhD,MAAM,WAAW,mCAAmC;IAClD;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,mCAAmC,GAC3C,4BAA4B,CAmB9B"}

package/dist/neutral/handshakeReadModel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handshakeReadModel.d.ts","sourceRoot":"","sources":["../../src/handshakeReadModel.ts"],"names":[],"mappings":"AAiDA,OAAO,KAAK,EAEV,0BAA0B,EAC1B,iCAAiC,EAWlC,MAAM,8BAA8B,CAAA;AAiZrC,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,iCAAiC,GACzC,0BAA0B,CA8D5B"}
+{"version":3,"file":"handshakeReadModel.d.ts","sourceRoot":"","sources":["../../src/handshakeReadModel.ts"],"names":[],"mappings":"AAiDA,OAAO,KAAK,EAEV,0BAA0B,EAC1B,iCAAiC,EAWlC,MAAM,8BAA8B,CAAA;AAsZrC,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,iCAAiC,GACzC,0BAA0B,CA2D5B"}

package/dist/neutral/index.mjs

@@ -20,7 +20,7 @@ function exactActiveTuple(subscriptions, binding, expectedHead) {
   if (tuples.length !== 1) return;
   const tuple = tuples[0];
   const service = tuple.service.body;
-  if (service.authorizationChainId !== binding.route.authorizationChainId || !service.events.some((event) => wakeSourcesEqual(event.source, binding.route.source))) return;
+  if (service.authorizationChainId !== binding.route.authorizationChainId || service.events.every((event) => !wakeSourcesEqual(event.source, binding.route.source))) return;
   return { selected, tuple };
 }
 function createActiveSourceWakeGrantAuthorizer(options) {
@@ -124,7 +124,7 @@ function buildClaims(applied) {
       claims.set(key, { ...prior, lastBlock: record.block });
     }
   }
-  return sortClaims([...claims.values()]);
+  return sortClaims(claims.values().toArray());
 }
 function withoutSchema(body) {
   return Object.fromEntries(Object.entries(body).filter(([key]) => key !== "schema"));
@@ -143,16 +143,12 @@ function createCheckpointStatementGraphViewer(checkpoint) {
       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);
-    },
+    claimsByObject: async (objectHash) => 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);
-    },
+    event: async (txHash, eventHash) => 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)));
@@ -176,16 +172,15 @@ function createCheckpointStatementGraphViewer(checkpoint) {
       const normalized = normalizeAddress(source);
       const records = applied.filter((record) => normalizeAddress(record.source) === normalized);
       const blocks = records.map((record) => record.block);
+      const uniqueClaims = new Set(records.map((record) => claimKey(record.source, record.subject, record.objectHash)));
       return {
-        claims: new Set(records.map((record) => claimKey(record.source, record.subject, record.objectHash))).size,
+        claims: uniqueClaims.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);
-    }
+    unresolved: async (txHash, eventHash) => unresolved.find((record) => record.txHash === txHash && record.eventHash === eventHash)
   });
 }
 
@@ -351,8 +346,7 @@ function checkpointIdentityError(checkpoint, identity) {
   if (checkpoint.floorBlock !== identity.floorBlock) return `floorBlock ${checkpoint.floorBlock} != ${identity.floorBlock}`;
   if (checkpoint.network !== identity.network) return `network ${checkpoint.network} != ${identity.network}`;
   if (checkpoint.sourceId !== identity.sourceId) return `sourceId ${checkpoint.sourceId} != ${identity.sourceId}`;
-  if (checkpoint.publisher !== identity.publisher) return `publisher ${checkpoint.publisher} != ${identity.publisher}`;
-  return void 0;
+  return checkpoint.publisher === identity.publisher ? void 0 : `publisher ${checkpoint.publisher} != ${identity.publisher}`;
 }
 function appliedKey(record) {
   return `${record.txHash}:${record.eventHash}:${record.hashIndex}`;
@@ -392,13 +386,12 @@ function expectedClaimRecords(applied) {
       records.set(key, { ...prior, lastBlock: event.block });
     }
   }
-  return sortClaimRecords([...records.values()]);
+  return sortClaimRecords(records.values().toArray());
 }
 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);
+    return candidate?.objectHash === record.objectHash && record.declaredObjectSchema === candidate.declaredObjectSchema && record.firstBlock === candidate.firstBlock && record.firstEventHash === candidate.firstEventHash && record.lastBlock === candidate.lastBlock && normalizeAddress2(record.source) === normalizeAddress2(candidate.source) && normalizeAddress2(record.subject) === normalizeAddress2(candidate.subject);
   });
 }
 function progressIntegrityError(checkpoint) {
@@ -421,10 +414,7 @@ function progressIntegrityError(checkpoint) {
   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;
+  return indexedThrough === null && checkpoint.bodies.length > 0 ? "resolved bodies exist before floorBlock has been indexed" : void 0;
 }
 function bodySetIntegrityError(checkpoint) {
   const hashes = /* @__PURE__ */ new Set();
@@ -523,10 +513,7 @@ function scanIntegrityError(checkpoint) {
   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);
+  return scan.watermark !== void 0 && scan.watermark.block > indexedThrough ? `scan watermark block ${scan.watermark.block} exceeds indexedThrough ${indexedThrough}` : watermarkIntegrityError(checkpoint);
 }
 function watermarkIntegrityError(checkpoint) {
   const scan = checkpoint.scan;
@@ -541,7 +528,8 @@ function watermarkIntegrityError(checkpoint) {
   }
   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();
+  const uniqueActualKeys = new Set(watermarkGroupEventKeys);
+  const actualKeys = uniqueActualKeys.values().toArray().toSorted();
   if (actualKeys.length !== watermarkGroupEventKeys.length) {
     return "scan watermark group event keys contain duplicates";
   }
@@ -549,11 +537,9 @@ function watermarkIntegrityError(checkpoint) {
     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;
+  const uniqueExpectedKeys = new Set(group.map(eventKey2));
+  const expectedKeys = uniqueExpectedKeys.values().toArray().toSorted();
+  return expectedKeys.some((key) => !actualKeys.includes(key)) ? "scan watermark group event keys omit publisher applied-event history" : void 0;
 }
 function blockedIntegrityError(checkpoint) {
   const { blocked, indexedThrough } = checkpoint;
@@ -565,10 +551,7 @@ function blockedIntegrityError(checkpoint) {
   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;
+  return blocked.unresolvedEvents.some((event) => event.block !== blocked.atBlock) ? "blocked unresolved event does not belong to blocked block" : void 0;
 }
 function checkpointIntegrityError(checkpoint) {
   return progressIntegrityError(checkpoint) ?? bodySetIntegrityError(checkpoint) ?? appliedIntegrityError(checkpoint) ?? scanIntegrityError(checkpoint) ?? blockedIntegrityError(checkpoint);
@@ -607,8 +590,7 @@ async function loadEventKitReplayCheckpoint(value, identity) {
   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" };
+  return integrityError === void 0 ? { checkpoint, status: "valid" } : { detail: integrityError, status: "corrupt" };
 }
 
 // src/finalizedReplayController.ts
@@ -672,10 +654,12 @@ function corruptKey(record) {
   return `${record.claimedHash ?? ""}:${record.computedHash}`;
 }
 function uniqueCorrupt(records) {
-  return [...new Map(records.map((record) => [corruptKey(record), record])).values()];
+  const unique = new Map(records.map((record) => [corruptKey(record), record]));
+  return unique.values().toArray();
 }
 function uniqueStrings(values) {
-  return [...new Set(values)];
+  const unique = new Set(values);
+  return unique.values().toArray();
 }
 function appliedKey2(record) {
   return `${record.txHash}:${record.eventHash}:${record.hashIndex}`;
@@ -690,7 +674,7 @@ function mergeApplied(existing, additions) {
     }
     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);
+  return merged.values().toArray().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]));
@@ -701,7 +685,7 @@ function mergeBodies(existing, additions) {
     }
     merged.set(hash, body);
   }
-  return [...merged].map(([hash, body]) => ({ body, hash: HashZod4.parse(hash) })).toSorted((left, right) => left.hash.localeCompare(right.hash));
+  return merged.entries().map(([hash, body]) => ({ body, hash: HashZod4.parse(hash) })).toArray().toSorted((left, right) => left.hash.localeCompare(right.hash));
 }
 async function stageAppliedBlock(options, applied) {
   const appliedObjectHashes = uniqueStrings(applied.map((record) => record.objectHash));
@@ -730,7 +714,10 @@ async function stageAppliedBlock(options, applied) {
     ...missingAttachments
   ]).map((hash) => HashZod4.parse(hash));
   return {
-    bodies: new Map([...objects.bodies, ...attachments.bodies]),
+    bodies: new Map([
+      ...objects.bodies,
+      ...attachments.bodies
+    ]),
     corrupt,
     objectHashes
   };
@@ -768,7 +755,11 @@ async function stageRange(options, prior, fromBlock, throughBlock, signal) {
     result.unresolved.filter((event) => event.block >= fromBlock && event.block <= throughBlock),
     (event) => event.block
   );
-  const relevantBlocks = [.../* @__PURE__ */ new Set([...appliedByBlock.keys(), ...unresolvedByBlock.keys()])].toSorted((left, right) => left - right);
+  const relevant = /* @__PURE__ */ new Set([
+    ...appliedByBlock.keys(),
+    ...unresolvedByBlock.keys()
+  ]);
+  const relevantBlocks = relevant.values().toArray().toSorted((left, right) => left - right);
   const bodies = /* @__PURE__ */ new Map();
   for (const block of relevantBlocks) {
     signal?.throwIfAborted();
@@ -822,11 +813,22 @@ var DefaultFinalizedEventKitReplayController = class {
     };
   }
   sync(options) {
-    const result = this.#syncTail.then(async () => await this.#syncOnce(options));
-    this.#syncTail = result.then(
-      () => true,
-      () => false
-    );
+    const previous = this.#syncTail;
+    const result = (async () => {
+      try {
+        await previous;
+      } catch {
+      }
+      return await this.#syncOnce(options);
+    })();
+    this.#syncTail = (async () => {
+      try {
+        await result;
+        return true;
+      } catch {
+        return false;
+      }
+    })();
     return result;
   }
   viewer() {
@@ -845,7 +847,7 @@ var DefaultFinalizedEventKitReplayController = class {
       signal?.throwIfAborted();
       if (exact.blocked === void 0) {
         await this.#commitStaged(exact, blockedAt, finalizedHead, signal);
-        return blockedAt === throughBlock ? false : await this.#commitRange(blockedAt + 1, throughBlock, finalizedHead, signal);
+        return blockedAt !== throughBlock && await this.#commitRange(blockedAt + 1, throughBlock, finalizedHead, signal);
       }
       const blocked = EventKitReplayCheckpointZod.parse({
         ...this.#checkpoint,
@@ -894,7 +896,7 @@ var DefaultFinalizedEventKitReplayController = class {
     let next = indexedThrough === null ? this.#options.floorBlock : indexedThrough + 1;
     const remaining = next <= finalizedHead ? finalizedHead - next + 1 : 0;
     const budget = maxBlocks === void 0 ? remaining : Math.min(maxBlocks, remaining);
-    const target = budget === 0 ? next - 1 : next + budget - 1;
+    const target = next + (budget === 0 ? -1 : budget - 1);
     const checkpointBatchSize = requirePositiveInteger(
       this.#options.checkpointBatchSize,
       DEFAULT_CHECKPOINT_BATCH_SIZE,
@@ -946,9 +948,7 @@ function createMemoryEventKitReplayCheckpointStore(initial) {
   let value = initial;
   const saved = [];
   return {
-    async load() {
-      return value;
-    },
+    load: async () => value,
     async save(checkpoint) {
       value = checkpoint;
       saved.push(checkpoint);
@@ -963,9 +963,7 @@ import { XyoAddressZod } from "@xyo-network/sdk-protocol/address";
 function createStatementGraphGrantReadModel(options) {
   const { viewer } = options;
   return Object.freeze({
-    async head() {
-      return await viewer.head();
-    },
+    head: async () => await viewer.head(),
     async claims(source, query) {
       const records = await viewer.claims(XyoAddressZod.parse(source), toClaimQuery(query));
       return Object.freeze(records.map(toGrantClaim));
@@ -1079,7 +1077,7 @@ function earliestByHash(records) {
       result.set(record.objectHash, record);
     }
   }
-  return [...result.values()];
+  return result.values().toArray();
 }
 async function verifiedHandshakeObjectBody(viewer, record) {
   const object = await viewer.object(record.objectHash);
@@ -1160,7 +1158,7 @@ async function buildHandshakeCatalogs(viewer, publisher) {
   }));
   return {
     keyByHash,
-    keyLifecycles: [...keyByHash.values()].map((key) => ({
+    keyLifecycles: keyByHash.values().map((key) => ({
       claimedAtBlock: key.evidence.block,
       expiresAtBlock: key.body.expiresAtBlock,
       keyId: key.body.keyId,
@@ -1168,9 +1166,9 @@ async function buildHandshakeCatalogs(viewer, publisher) {
       revokedAtBlock: key.revokedAtBlock,
       source: key.evidence.source,
       validFromBlock: key.body.validFromBlock
-    })),
+    })).toArray(),
     serviceByHash,
-    serviceLifecycles: [...serviceByHash.values()].map((service) => ({
+    serviceLifecycles: serviceByHash.values().map((service) => ({
       claimedAtBlock: service.evidence.block,
       encryptionKeys: service.body.encryptionKeys,
       eventKinds: service.body.events.map((event) => event.kind),
@@ -1183,7 +1181,7 @@ async function buildHandshakeCatalogs(viewer, publisher) {
       source: service.evidence.source,
       supersedes: service.body.supersedes,
       validFromBlock: service.body.validFromBlock
-    }))
+    })).toArray()
   };
 }
 async function viewHead(viewer, finalizedHead) {
@@ -1328,34 +1326,15 @@ function publisherSubjectViewer(viewer, 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);
-    }
+    claims: async (source, query) => await filterClaims(viewer.claims(source, claimQuery(query))),
+    claimsByObject: async (objectHash) => await filterClaims(viewer.claimsBySubject(publisher, claimQuery({ objectHash }))),
+    claimsBySubject: async (subject, query) => isPublisherSubject(subject, publisher) ? await filterClaims(viewer.claimsBySubject(publisher, claimQuery(query))) : [],
+    event: async (txHash, eventHash) => await filterEvents(viewer.event(txHash, eventHash)),
+    events: async (source, query) => await filterEvents(viewer.events(source, eventQuery(query))),
+    head: async () => await viewer.head(),
+    object: async (objectHash) => await viewer.object(objectHash),
+    source: async (source) => await viewer.source(source),
+    unresolved: async (txHash, eventHash) => await viewer.unresolved(txHash, eventHash)
   });
 }
 
@@ -1363,17 +1342,16 @@ function publisherSubjectViewer(viewer, publisher) {
 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)) {
+  if (tuples.some((tuple) => (tuple.grantRevokedAtBlock ?? Infinity) <= finalizedHead) || tuples.some((tuple) => (tuple.subscription.revokedAtBlock ?? Infinity) <= finalizedHead) || acceptances.some((item) => subscriptionHashes.has(item.lifecycle.subscription) && (item.lifecycle.revokedAtBlock ?? Infinity) <= finalizedHead)) {
     return "revoked";
   }
-  if (tuples.every((tuple) => tuple.subscription.body.expiresAtBlock <= finalizedHead)) return "expired";
-  return "inactive";
+  return tuples.every((tuple) => tuple.subscription.body.expiresAtBlock <= finalizedHead) ? "expired" : "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)) {
+  if ((latest.grantRevokedAtBlock ?? Infinity) <= finalizedHead || (latest.subscription.revokedAtBlock ?? Infinity) <= finalizedHead || matchingAcceptances.some((item) => (item.lifecycle.revokedAtBlock ?? Infinity) <= finalizedHead)) {
     return "revoked";
   }
   return latest.subscription.body.expiresAtBlock <= finalizedHead ? "expired" : "pending";
@@ -1527,14 +1505,14 @@ async function validateTuple(viewer, records, subscriber, service, catalogs, cha
   if (!subscriptionParsed.success) return reject("malformed-subscription");
   const grant = grantParsed.data;
   const subscription = subscriptionParsed.data;
-  const tupleBlock = subscriptionRecord.block;
   if (!hasMatchingHandshakeProfile(service.body, subscription, chainId)) return reject("subscription-binding-invalid");
   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);
+  const tupleBlock = subscriptionRecord.block;
   if (service.evidence.block >= tupleBlock) return reject("service-inactive-at-claim");
+  const claimedKey = catalogs.keyByHash.get(subscription.encryptionKey);
   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");
@@ -1575,7 +1553,10 @@ async function validateTuple(viewer, records, subscriber, service, catalogs, cha
 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 uniqueSources = new Set(
+    candidateSources ?? (await viewer.claimsBySubject(XyoAddressZod3.parse(query.publisher))).filter((claim) => serviceHashes.has(claim.objectHash)).map((claim) => claim.source)
+  );
+  const sources = uniqueSources.values().filter((source) => !isPublisherSubject(source, query.publisher)).toArray();
   const tuples = /* @__PURE__ */ new Map();
   const rejections = [];
   for (const source of sources) {
@@ -1609,7 +1590,7 @@ async function discoverTuples(viewer, services, catalogs, query, candidateSource
       }
     }
   }
-  return { rejections, tuples: [...tuples.values()] };
+  return { rejections, tuples: tuples.values().toArray() };
 }
 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;
@@ -1663,7 +1644,7 @@ async function handshakeLifecycle(options, rawQuery, candidateSources, subscript
   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 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).toArray();
   const found = await discoverTuples(
     scopedOptions.viewer,
     serviceRevisions,
@@ -1765,12 +1746,8 @@ function createEventKitHandshakeReadModel(options) {
         subscriptions: projection.subscriptions
       };
     },
-    async discoverPublisherService(query) {
-      return (await discoverHandshakeService(publisherSubjectOptions(options, query.publisher), query)).result;
-    },
-    async publisher(query) {
-      return handshakeView(await handshakeLifecycle(options, query));
-    },
+    discoverPublisherService: async (query) => (await discoverHandshakeService(publisherSubjectOptions(options, query.publisher), query)).result,
+    publisher: async (query) => handshakeView(await handshakeLifecycle(options, query)),
     async subscriber(rawQuery) {
       const subscriber = NormalizedAddressZod5.parse(rawQuery.subscriber);
       const subscriptionId = rawQuery.subscriptionId === void 0 ? void 0 : HandshakeIdZod.parse(rawQuery.subscriptionId);