@powerhousedao/reactor 6.0.0-dev.84 → 6.0.0-dev.89

package/dist/src/index.js

@@ -11080,6 +11080,11 @@ class CollectionMembershipCache {
   constructor(operationIndex) {
     this.operationIndex = operationIndex;
   }
+  withScopedIndex(operationIndex) {
+    const scoped = new CollectionMembershipCache(operationIndex);
+    scoped.cache = this.cache;
+    return scoped;
+  }
   async getCollectionsForDocuments(documentIds) {
     const result = {};
     const missing = [];
@@ -11435,6 +11440,12 @@ class DocumentMetaCache {
     this.cache = new Map;
     this.lruTracker = new LRUTracker;
   }
+  withScopedStore(operationStore) {
+    const scoped = new DocumentMetaCache(operationStore, this.config);
+    scoped.cache = this.cache;
+    scoped.lruTracker = this.lruTracker;
+    return scoped;
+  }
   async startup() {
     return Promise.resolve();
   }
@@ -11585,9 +11596,18 @@ class KyselyOperationIndexTxn {
 
 class KyselyOperationIndex {
   db;
+  trx;
   constructor(db) {
     this.db = db;
   }
+  get queryExecutor() {
+    return this.trx ?? this.db;
+  }
+  withTransaction(trx) {
+    const instance = new KyselyOperationIndex(this.db);
+    instance.trx = trx;
+    return instance;
+  }
   start() {
     return new KyselyOperationIndexTxn;
   }
@@ -11596,70 +11616,76 @@ class KyselyOperationIndex {
       throw new Error("Operation aborted");
     }
     const kyselyTxn = txn;
+    if (this.trx) {
+      return this.executeCommit(this.trx, kyselyTxn);
+    }
+    let resultOrdinals = [];
+    await this.db.transaction().execute(async (trx) => {
+      resultOrdinals = await this.executeCommit(trx, kyselyTxn);
+    });
+    return resultOrdinals;
+  }
+  async executeCommit(trx, kyselyTxn) {
     const collections = kyselyTxn.getCollections();
     const memberships = kyselyTxn.getCollectionMembershipRecords();
     const removals = kyselyTxn.getCollectionRemovals();
     const operations = kyselyTxn.getOperations();
-    let resultOrdinals = [];
-    await this.db.transaction().execute(async (trx) => {
-      if (collections.length > 0) {
-        const collectionRows = collections.map((collectionId) => ({
-          documentId: collectionId,
-          collectionId,
-          joinedOrdinal: BigInt(0),
+    if (collections.length > 0) {
+      const collectionRows = collections.map((collectionId) => ({
+        documentId: collectionId,
+        collectionId,
+        joinedOrdinal: BigInt(0),
+        leftOrdinal: null
+      }));
+      await trx.insertInto("document_collections").values(collectionRows).onConflict((oc) => oc.doNothing()).execute();
+    }
+    let operationOrdinals = [];
+    if (operations.length > 0) {
+      const operationRows = operations.map((op) => ({
+        opId: op.id || "",
+        documentId: op.documentId,
+        documentType: op.documentType,
+        scope: op.scope,
+        branch: op.branch,
+        timestampUtcMs: op.timestampUtcMs,
+        index: op.index,
+        skip: op.skip,
+        hash: op.hash,
+        action: op.action,
+        sourceRemote: op.sourceRemote
+      }));
+      const insertedOps = await trx.insertInto("operation_index_operations").values(operationRows).returning("ordinal").execute();
+      operationOrdinals = insertedOps.map((row) => row.ordinal);
+    }
+    if (memberships.length > 0) {
+      for (const m of memberships) {
+        const ordinal = operationOrdinals[m.operationIndex];
+        await trx.insertInto("document_collections").values({
+          documentId: m.documentId,
+          collectionId: m.collectionId,
+          joinedOrdinal: BigInt(ordinal),
           leftOrdinal: null
-        }));
-        await trx.insertInto("document_collections").values(collectionRows).onConflict((oc) => oc.doNothing()).execute();
-      }
-      let operationOrdinals = [];
-      if (operations.length > 0) {
-        const operationRows = operations.map((op) => ({
-          opId: op.id || "",
-          documentId: op.documentId,
-          documentType: op.documentType,
-          scope: op.scope,
-          branch: op.branch,
-          timestampUtcMs: op.timestampUtcMs,
-          index: op.index,
-          skip: op.skip,
-          hash: op.hash,
-          action: op.action,
-          sourceRemote: op.sourceRemote
-        }));
-        const insertedOps = await trx.insertInto("operation_index_operations").values(operationRows).returning("ordinal").execute();
-        operationOrdinals = insertedOps.map((row) => row.ordinal);
-        resultOrdinals = operationOrdinals;
-      }
-      if (memberships.length > 0) {
-        for (const m of memberships) {
-          const ordinal = operationOrdinals[m.operationIndex];
-          await trx.insertInto("document_collections").values({
-            documentId: m.documentId,
-            collectionId: m.collectionId,
-            joinedOrdinal: BigInt(ordinal),
-            leftOrdinal: null
-          }).onConflict((oc) => oc.columns(["documentId", "collectionId"]).doUpdateSet({
-            joinedOrdinal: BigInt(ordinal),
-            leftOrdinal: null
-          })).execute();
-        }
+        }).onConflict((oc) => oc.columns(["documentId", "collectionId"]).doUpdateSet({
+          joinedOrdinal: BigInt(ordinal),
+          leftOrdinal: null
+        })).execute();
       }
-      if (removals.length > 0) {
-        for (const r of removals) {
-          const ordinal = operationOrdinals[r.operationIndex];
-          await trx.updateTable("document_collections").set({
-            leftOrdinal: BigInt(ordinal)
-          }).where("collectionId", "=", r.collectionId).where("documentId", "=", r.documentId).where("leftOrdinal", "is", null).execute();
-        }
+    }
+    if (removals.length > 0) {
+      for (const r of removals) {
+        const ordinal = operationOrdinals[r.operationIndex];
+        await trx.updateTable("document_collections").set({
+          leftOrdinal: BigInt(ordinal)
+        }).where("collectionId", "=", r.collectionId).where("documentId", "=", r.documentId).where("leftOrdinal", "is", null).execute();
       }
-    });
-    return resultOrdinals;
+    }
+    return operationOrdinals;
   }
   async find(collectionId, cursor, view, paging, signal) {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.selectFrom("operation_index_operations as oi").innerJoin("document_collections as dc", "oi.documentId", "dc.documentId").selectAll("oi").select(["dc.documentId", "dc.collectionId"]).where("dc.collectionId", "=", collectionId).where(sql`(dc."leftOrdinal" IS NULL OR oi.ordinal < dc."leftOrdinal")`).orderBy("oi.ordinal", "asc");
+    let query = this.queryExecutor.selectFrom("operation_index_operations as oi").innerJoin("document_collections as dc", "oi.documentId", "dc.documentId").selectAll("oi").select(["dc.documentId", "dc.collectionId"]).where("dc.collectionId", "=", collectionId).where(sql`(dc."leftOrdinal" IS NULL OR oi.ordinal < dc."leftOrdinal")`).orderBy("oi.ordinal", "asc");
     if (cursor !== undefined) {
       query = query.where("oi.ordinal", ">", cursor);
     }
@@ -11701,7 +11727,7 @@ class KyselyOperationIndex {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.selectFrom("operation_index_operations").selectAll().where("documentId", "=", documentId).orderBy("ordinal", "asc");
+    let query = this.queryExecutor.selectFrom("operation_index_operations").selectAll().where("documentId", "=", documentId).orderBy("ordinal", "asc");
     if (view?.branch) {
       query = query.where("branch", "=", view.branch);
     }
@@ -11737,7 +11763,7 @@ class KyselyOperationIndex {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.selectFrom("operation_index_operations").selectAll().where("ordinal", ">", ordinal).orderBy("ordinal", "asc");
+    let query = this.queryExecutor.selectFrom("operation_index_operations").selectAll().where("ordinal", ">", ordinal).orderBy("ordinal", "asc");
     if (paging?.cursor) {
       const cursorOrdinal = Number.parseInt(paging.cursor, 10);
       query = query.where("ordinal", ">", cursorOrdinal);
@@ -11802,14 +11828,14 @@ class KyselyOperationIndex {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    const result = await this.db.selectFrom("operation_index_operations as oi").innerJoin("document_collections as dc", "oi.documentId", "dc.documentId").select("oi.timestampUtcMs").where("dc.collectionId", "=", collectionId).where(sql`(dc."leftOrdinal" IS NULL OR oi.ordinal < dc."leftOrdinal")`).orderBy("oi.ordinal", "desc").limit(1).executeTakeFirst();
+    const result = await this.queryExecutor.selectFrom("operation_index_operations as oi").innerJoin("document_collections as dc", "oi.documentId", "dc.documentId").select("oi.timestampUtcMs").where("dc.collectionId", "=", collectionId).where(sql`(dc."leftOrdinal" IS NULL OR oi.ordinal < dc."leftOrdinal")`).orderBy("oi.ordinal", "desc").limit(1).executeTakeFirst();
     return result?.timestampUtcMs ?? null;
   }
   async getCollectionsForDocuments(documentIds) {
     if (documentIds.length === 0) {
       return {};
     }
-    const rows = await this.db.selectFrom("document_collections").select(["documentId", "collectionId"]).where("documentId", "in", documentIds).where("leftOrdinal", "is", null).execute();
+    const rows = await this.queryExecutor.selectFrom("document_collections").select(["documentId", "collectionId"]).where("documentId", "in", documentIds).where("leftOrdinal", "is", null).execute();
     const result = {};
     for (const row of rows) {
       if (!(row.documentId in result)) {
@@ -11866,6 +11892,11 @@ class RingBuffer {
 }
 
 // src/cache/kysely-write-cache.ts
+function extractModuleVersion(doc) {
+  const v = doc.state.document.version;
+  return v === 0 ? undefined : v;
+}
+
 class KyselyWriteCache {
   streams;
   lruTracker;
@@ -11885,6 +11916,12 @@ class KyselyWriteCache {
     this.streams = new Map;
     this.lruTracker = new LRUTracker;
   }
+  withScopedStores(operationStore, keyframeStore) {
+    const scoped = new KyselyWriteCache(keyframeStore, operationStore, this.registry, this.config);
+    scoped.streams = this.streams;
+    scoped.lruTracker = this.lruTracker;
+    return scoped;
+  }
   async startup() {
     return Promise.resolve();
   }
@@ -12023,7 +12060,7 @@ class KyselyWriteCache {
         throw new Error(`Failed to rebuild document ${documentId}: CREATE_DOCUMENT action missing model in input`);
       }
       document = createDocumentFromAction(documentCreateAction);
-      const docModule = this.registry.getModule(documentType);
+      let docModule = this.registry.getModule(documentType, extractModuleVersion(document));
       const docScopeOps = await this.operationStore.getSince(documentId, "document", branch, 0, undefined, undefined, signal);
       for (const operation of docScopeOps.results) {
         if (operation.index === 0) {
@@ -12032,6 +12069,7 @@ class KyselyWriteCache {
         if (operation.action.type === "UPGRADE_DOCUMENT") {
           const upgradeAction = operation.action;
           document = applyUpgradeDocumentAction(document, upgradeAction);
+          docModule = this.registry.getModule(documentType, extractModuleVersion(document));
         } else if (operation.action.type === "DELETE_DOCUMENT") {
           applyDeleteDocumentAction(document, operation.action);
         } else {
@@ -12043,7 +12081,7 @@ class KyselyWriteCache {
         }
       }
     }
-    const module = this.registry.getModule(documentType);
+    const module = this.registry.getModule(documentType, extractModuleVersion(document));
     let cursor = undefined;
     const pageSize = 100;
     let hasMorePages;
@@ -12217,6 +12255,64 @@ class EventBus {
   }
 }
 
+// src/executor/execution-scope.ts
+class DefaultExecutionScope {
+  operationStore;
+  operationIndex;
+  writeCache;
+  documentMetaCache;
+  collectionMembershipCache;
+  constructor(operationStore, operationIndex, writeCache, documentMetaCache, collectionMembershipCache) {
+    this.operationStore = operationStore;
+    this.operationIndex = operationIndex;
+    this.writeCache = writeCache;
+    this.documentMetaCache = documentMetaCache;
+    this.collectionMembershipCache = collectionMembershipCache;
+  }
+  async run(fn) {
+    return fn({
+      operationStore: this.operationStore,
+      operationIndex: this.operationIndex,
+      writeCache: this.writeCache,
+      documentMetaCache: this.documentMetaCache,
+      collectionMembershipCache: this.collectionMembershipCache
+    });
+  }
+}
+
+class KyselyExecutionScope {
+  db;
+  operationStore;
+  operationIndex;
+  keyframeStore;
+  writeCache;
+  documentMetaCache;
+  collectionMembershipCache;
+  constructor(db, operationStore, operationIndex, keyframeStore, writeCache, documentMetaCache, collectionMembershipCache) {
+    this.db = db;
+    this.operationStore = operationStore;
+    this.operationIndex = operationIndex;
+    this.keyframeStore = keyframeStore;
+    this.writeCache = writeCache;
+    this.documentMetaCache = documentMetaCache;
+    this.collectionMembershipCache = collectionMembershipCache;
+  }
+  async run(fn) {
+    return this.db.transaction().execute(async (trx) => {
+      const scopedOperationStore = this.operationStore.withTransaction(trx);
+      const scopedOperationIndex = this.operationIndex.withTransaction(trx);
+      const scopedKeyframeStore = this.keyframeStore.withTransaction(trx);
+      return fn({
+        operationStore: scopedOperationStore,
+        operationIndex: scopedOperationIndex,
+        writeCache: this.writeCache.withScopedStores(scopedOperationStore, scopedKeyframeStore),
+        documentMetaCache: this.documentMetaCache.withScopedStore(scopedOperationStore),
+        collectionMembershipCache: this.collectionMembershipCache.withScopedIndex(scopedOperationIndex)
+      });
+    });
+  }
+}
+
 // src/queue/types.ts
 var QueueEventTypes = {
   JOB_AVAILABLE: 1e4
@@ -12766,37 +12862,29 @@ function driveCollectionId(branch, driveId) {
 
 // src/executor/document-action-handler.ts
 class DocumentActionHandler {
-  writeCache;
-  operationStore;
-  documentMetaCache;
-  collectionMembershipCache;
   registry;
   logger;
-  constructor(writeCache, operationStore, documentMetaCache, collectionMembershipCache, registry, logger) {
-    this.writeCache = writeCache;
-    this.operationStore = operationStore;
-    this.documentMetaCache = documentMetaCache;
-    this.collectionMembershipCache = collectionMembershipCache;
+  constructor(registry, logger) {
     this.registry = registry;
     this.logger = logger;
   }
-  async execute(job, action, startTime, indexTxn, skip = 0, sourceRemote = "") {
+  async execute(job, action, startTime, indexTxn, stores, skip = 0, sourceRemote = "") {
     switch (action.type) {
       case "CREATE_DOCUMENT":
-        return this.executeCreate(job, action, startTime, indexTxn, skip, sourceRemote);
+        return this.executeCreate(job, action, startTime, indexTxn, stores, skip, sourceRemote);
       case "DELETE_DOCUMENT":
-        return this.executeDelete(job, action, startTime, indexTxn, sourceRemote);
+        return this.executeDelete(job, action, startTime, indexTxn, stores, sourceRemote);
       case "UPGRADE_DOCUMENT":
-        return this.executeUpgrade(job, action, startTime, indexTxn, skip, sourceRemote);
+        return this.executeUpgrade(job, action, startTime, indexTxn, stores, skip, sourceRemote);
       case "ADD_RELATIONSHIP":
-        return this.executeAddRelationship(job, action, startTime, indexTxn, sourceRemote);
+        return this.executeAddRelationship(job, action, startTime, indexTxn, stores, sourceRemote);
       case "REMOVE_RELATIONSHIP":
-        return this.executeRemoveRelationship(job, action, startTime, indexTxn, sourceRemote);
+        return this.executeRemoveRelationship(job, action, startTime, indexTxn, stores, sourceRemote);
       default:
         return buildErrorResult(job, new Error(`Unknown document action type: ${action.type}`), startTime);
     }
   }
-  async executeCreate(job, action, startTime, indexTxn, skip = 0, sourceRemote = "") {
+  async executeCreate(job, action, startTime, indexTxn, stores, skip = 0, sourceRemote = "") {
     if (job.scope !== "document") {
       return {
         job,
@@ -12816,12 +12904,12 @@ class DocumentActionHandler {
       ...document.state
     };
     const resultingState = JSON.stringify(resultingStateObj);
-    const writeError = await this.writeOperationToStore(document.header.id, document.header.documentType, job.scope, job.branch, operation, job, startTime);
+    const writeError = await this.writeOperationToStore(document.header.id, document.header.documentType, job.scope, job.branch, operation, job, startTime, stores);
     if (writeError !== null) {
       return writeError;
     }
     updateDocumentRevision(document, job.scope, operation.index);
-    this.writeCache.putState(document.header.id, job.scope, job.branch, operation.index, document);
+    stores.writeCache.putState(document.header.id, job.scope, job.branch, operation.index, document);
     indexTxn.write([
       {
         ...operation,
@@ -12837,14 +12925,14 @@ class DocumentActionHandler {
       indexTxn.createCollection(collectionId);
       indexTxn.addToCollection(collectionId, document.header.id);
     }
-    this.documentMetaCache.putDocumentMeta(document.header.id, job.branch, {
+    stores.documentMetaCache.putDocumentMeta(document.header.id, job.branch, {
       state: document.state.document,
       documentType: document.header.documentType,
       documentScopeRevision: 1
     });
     return buildSuccessResult(job, operation, document.header.id, document.header.documentType, resultingState, startTime);
   }
-  async executeDelete(job, action, startTime, indexTxn, sourceRemote = "") {
+  async executeDelete(job, action, startTime, indexTxn, stores, sourceRemote = "") {
     const input = action.input;
     if (!input.documentId) {
       return buildErrorResult(job, new Error("DELETE_DOCUMENT action requires a documentId in input"), startTime);
@@ -12852,7 +12940,7 @@ class DocumentActionHandler {
     const documentId = input.documentId;
     let document;
     try {
-      document = await this.writeCache.getState(documentId, job.scope, job.branch);
+      document = await stores.writeCache.getState(documentId, job.scope, job.branch);
     } catch (error) {
       return buildErrorResult(job, new Error(`Failed to fetch document before deletion: ${error instanceof Error ? error.message : String(error)}`), startTime);
     }
@@ -12872,12 +12960,12 @@ class DocumentActionHandler {
       document: document.state.document
     };
     const resultingState = JSON.stringify(resultingStateObj);
-    const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime);
+    const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime, stores);
     if (writeError !== null) {
       return writeError;
     }
     updateDocumentRevision(document, job.scope, operation.index);
-    this.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
+    stores.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
     indexTxn.write([
       {
         ...operation,
@@ -12888,14 +12976,14 @@ class DocumentActionHandler {
         sourceRemote
       }
     ]);
-    this.documentMetaCache.putDocumentMeta(documentId, job.branch, {
+    stores.documentMetaCache.putDocumentMeta(documentId, job.branch, {
       state: document.state.document,
       documentType: document.header.documentType,
       documentScopeRevision: operation.index + 1
     });
     return buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
   }
-  async executeUpgrade(job, action, startTime, indexTxn, skip = 0, sourceRemote = "") {
+  async executeUpgrade(job, action, startTime, indexTxn, stores, skip = 0, sourceRemote = "") {
     const input = action.input;
     if (!input.documentId) {
       return buildErrorResult(job, new Error("UPGRADE_DOCUMENT action requires a documentId in input"), startTime);
@@ -12905,7 +12993,7 @@ class DocumentActionHandler {
     const toVersion = input.toVersion;
     let document;
     try {
-      document = await this.writeCache.getState(documentId, job.scope, job.branch);
+      document = await stores.writeCache.getState(documentId, job.scope, job.branch);
     } catch (error) {
       return buildErrorResult(job, new Error(`Failed to fetch document for upgrade: ${error instanceof Error ? error.message : String(error)}`), startTime);
     }
@@ -12946,12 +13034,12 @@ class DocumentActionHandler {
       ...document.state
     };
     const resultingState = JSON.stringify(resultingStateObj);
-    const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime);
+    const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime, stores);
     if (writeError !== null) {
       return writeError;
     }
     updateDocumentRevision(document, job.scope, operation.index);
-    this.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
+    stores.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
     indexTxn.write([
       {
         ...operation,
@@ -12962,14 +13050,14 @@ class DocumentActionHandler {
         sourceRemote
       }
     ]);
-    this.documentMetaCache.putDocumentMeta(documentId, job.branch, {
+    stores.documentMetaCache.putDocumentMeta(documentId, job.branch, {
       state: document.state.document,
       documentType: document.header.documentType,
       documentScopeRevision: operation.index + 1
     });
     return buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
   }
-  async executeAddRelationship(job, action, startTime, indexTxn, sourceRemote = "") {
+  async executeAddRelationship(job, action, startTime, indexTxn, stores, sourceRemote = "") {
     if (job.scope !== "document") {
       return buildErrorResult(job, new Error(`ADD_RELATIONSHIP must be in "document" scope, got "${job.scope}"`), startTime);
     }
@@ -12982,7 +13070,7 @@ class DocumentActionHandler {
     }
     let sourceDoc;
     try {
-      sourceDoc = await this.writeCache.getState(input.sourceId, "document", job.branch);
+      sourceDoc = await stores.writeCache.getState(input.sourceId, "document", job.branch);
     } catch (error) {
       return buildErrorResult(job, new Error(`ADD_RELATIONSHIP: source document ${input.sourceId} not found: ${error instanceof Error ? error.message : String(error)}`), startTime);
     }
@@ -12992,7 +13080,7 @@ class DocumentActionHandler {
       scope: job.scope,
       branch: job.branch
     });
-    const writeError = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime);
+    const writeError = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime, stores);
     if (writeError !== null) {
       return writeError;
     }
@@ -13008,7 +13096,7 @@ class DocumentActionHandler {
       [job.scope]: scopeState === undefined ? {} : structuredClone(scopeState)
     };
     const resultingState = JSON.stringify(resultingStateObj);
-    this.writeCache.putState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
+    stores.writeCache.putState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
     indexTxn.write([
       {
         ...operation,
@@ -13022,16 +13110,16 @@ class DocumentActionHandler {
     if (sourceDoc.header.documentType === "powerhouse/document-drive") {
       const collectionId = driveCollectionId(job.branch, input.sourceId);
       indexTxn.addToCollection(collectionId, input.targetId);
-      this.collectionMembershipCache.invalidate(input.targetId);
+      stores.collectionMembershipCache.invalidate(input.targetId);
     }
-    this.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
+    stores.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
       state: sourceDoc.state.document,
       documentType: sourceDoc.header.documentType,
       documentScopeRevision: operation.index + 1
     });
     return buildSuccessResult(job, operation, input.sourceId, sourceDoc.header.documentType, resultingState, startTime);
   }
-  async executeRemoveRelationship(job, action, startTime, indexTxn, sourceRemote = "") {
+  async executeRemoveRelationship(job, action, startTime, indexTxn, stores, sourceRemote = "") {
     if (job.scope !== "document") {
       return buildErrorResult(job, new Error(`REMOVE_RELATIONSHIP must be in "document" scope, got "${job.scope}"`), startTime);
     }
@@ -13041,7 +13129,7 @@ class DocumentActionHandler {
     }
     let sourceDoc;
     try {
-      sourceDoc = await this.writeCache.getState(input.sourceId, "document", job.branch);
+      sourceDoc = await stores.writeCache.getState(input.sourceId, "document", job.branch);
     } catch (error) {
       return buildErrorResult(job, new Error(`REMOVE_RELATIONSHIP: source document ${input.sourceId} not found: ${error instanceof Error ? error.message : String(error)}`), startTime);
     }
@@ -13051,7 +13139,7 @@ class DocumentActionHandler {
       scope: job.scope,
       branch: job.branch
     });
-    const writeError = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime);
+    const writeError = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime, stores);
     if (writeError !== null) {
       return writeError;
     }
@@ -13067,7 +13155,7 @@ class DocumentActionHandler {
       [job.scope]: scopeState === undefined ? {} : structuredClone(scopeState)
     };
     const resultingState = JSON.stringify(resultingStateObj);
-    this.writeCache.putState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
+    stores.writeCache.putState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
     indexTxn.write([
       {
         ...operation,
@@ -13081,24 +13169,24 @@ class DocumentActionHandler {
     if (sourceDoc.header.documentType === "powerhouse/document-drive") {
       const collectionId = driveCollectionId(job.branch, input.sourceId);
       indexTxn.removeFromCollection(collectionId, input.targetId);
-      this.collectionMembershipCache.invalidate(input.targetId);
+      stores.collectionMembershipCache.invalidate(input.targetId);
     }
-    this.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
+    stores.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
       state: sourceDoc.state.document,
       documentType: sourceDoc.header.documentType,
       documentScopeRevision: operation.index + 1
     });
     return buildSuccessResult(job, operation, input.sourceId, sourceDoc.header.documentType, resultingState, startTime);
   }
-  async writeOperationToStore(documentId, documentType, scope, branch, operation, job, startTime) {
+  async writeOperationToStore(documentId, documentType, scope, branch, operation, job, startTime, stores) {
     try {
-      await this.operationStore.apply(documentId, documentType, scope, branch, operation.index, (txn) => {
+      await stores.operationStore.apply(documentId, documentType, scope, branch, operation.index, (txn) => {
         txn.addOperations(operation);
       });
       return null;
     } catch (error) {
       this.logger.error("Error writing @Operation to IOperationStore: @Error", operation, error);
-      this.writeCache.invalidate(documentId, scope, branch);
+      stores.writeCache.invalidate(documentId, scope, branch);
       return {
         job,
         success: false,
@@ -13199,7 +13287,8 @@ class SimpleJobExecutor {
   config;
   signatureVerifierModule;
   documentActionHandler;
-  constructor(logger, registry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, config, signatureVerifier) {
+  executionScope;
+  constructor(logger, registry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, config, signatureVerifier, executionScope) {
     this.logger = logger;
     this.registry = registry;
     this.operationStore = operationStore;
@@ -13216,71 +13305,101 @@ class SimpleJobExecutor {
       retryMaxDelayMs: config.retryMaxDelayMs ?? 5000
     };
     this.signatureVerifierModule = new SignatureVerifier(signatureVerifier);
-    this.documentActionHandler = new DocumentActionHandler(writeCache, operationStore, documentMetaCache, collectionMembershipCache, registry, logger);
+    this.documentActionHandler = new DocumentActionHandler(registry, logger);
+    this.executionScope = executionScope ?? new DefaultExecutionScope(operationStore, operationIndex, writeCache, documentMetaCache, collectionMembershipCache);
   }
   async executeJob(job) {
     const startTime = Date.now();
-    const indexTxn = this.operationIndex.start();
-    if (job.kind === "load") {
-      const result2 = await this.executeLoadJob(job, startTime, indexTxn);
-      if (result2.success && result2.operationsWithContext) {
-        const ordinals2 = await this.operationIndex.commit(indexTxn);
-        for (let i = 0;i < result2.operationsWithContext.length; i++) {
-          result2.operationsWithContext[i].context.ordinal = ordinals2[i];
+    const touchedCacheEntries = [];
+    let pendingEvent;
+    let result;
+    try {
+      result = await this.executionScope.run(async (stores) => {
+        const indexTxn = stores.operationIndex.start();
+        if (job.kind === "load") {
+          const loadResult = await this.executeLoadJob(job, startTime, indexTxn, stores);
+          if (loadResult.success && loadResult.operationsWithContext) {
+            for (const owc of loadResult.operationsWithContext) {
+              touchedCacheEntries.push({
+                documentId: owc.context.documentId,
+                scope: owc.context.scope,
+                branch: owc.context.branch
+              });
+            }
+            const ordinals2 = await stores.operationIndex.commit(indexTxn);
+            for (let i = 0;i < loadResult.operationsWithContext.length; i++) {
+              loadResult.operationsWithContext[i].context.ordinal = ordinals2[i];
+            }
+            const collectionMemberships = loadResult.operationsWithContext.length > 0 ? await this.getCollectionMembershipsForOperations(loadResult.operationsWithContext, stores) : {};
+            pendingEvent = {
+              jobId: job.id,
+              operations: loadResult.operationsWithContext,
+              jobMeta: job.meta,
+              collectionMemberships
+            };
+          }
+          return loadResult;
         }
-        const collectionMemberships = result2.operationsWithContext.length > 0 ? await this.getCollectionMembershipsForOperations(result2.operationsWithContext) : {};
-        const event = {
-          jobId: job.id,
-          operations: result2.operationsWithContext,
-          jobMeta: job.meta,
-          collectionMemberships
+        const actionResult = await this.processActions(job, job.actions, startTime, indexTxn, stores);
+        if (!actionResult.success) {
+          return {
+            job,
+            success: false,
+            error: actionResult.error,
+            duration: Date.now() - startTime
+          };
+        }
+        if (actionResult.operationsWithContext.length > 0) {
+          for (const owc of actionResult.operationsWithContext) {
+            touchedCacheEntries.push({
+              documentId: owc.context.documentId,
+              scope: owc.context.scope,
+              branch: owc.context.branch
+            });
+          }
+        }
+        const ordinals = await stores.operationIndex.commit(indexTxn);
+        if (actionResult.operationsWithContext.length > 0) {
+          for (let i = 0;i < actionResult.operationsWithContext.length; i++) {
+            actionResult.operationsWithContext[i].context.ordinal = ordinals[i];
+          }
+          const collectionMemberships = await this.getCollectionMembershipsForOperations(actionResult.operationsWithContext, stores);
+          pendingEvent = {
+            jobId: job.id,
+            operations: actionResult.operationsWithContext,
+            jobMeta: job.meta,
+            collectionMemberships
+          };
+        }
+        return {
+          job,
+          success: true,
+          operations: actionResult.generatedOperations,
+          operationsWithContext: actionResult.operationsWithContext,
+          duration: Date.now() - startTime
         };
-        this.eventBus.emit(ReactorEventTypes.JOB_WRITE_READY, event).catch((error) => {
-          this.logger.error("Failed to emit JOB_WRITE_READY event: @Event : @Error", event, error);
-        });
+      });
+    } catch (error) {
+      for (const entry of touchedCacheEntries) {
+        this.writeCache.invalidate(entry.documentId, entry.scope, entry.branch);
+        this.documentMetaCache.invalidate(entry.documentId, entry.branch);
       }
-      return result2;
-    }
-    const result = await this.processActions(job, job.actions, startTime, indexTxn);
-    if (!result.success) {
-      return {
-        job,
-        success: false,
-        error: result.error,
-        duration: Date.now() - startTime
-      };
+      throw error;
     }
-    const ordinals = await this.operationIndex.commit(indexTxn);
-    if (result.operationsWithContext.length > 0) {
-      for (let i = 0;i < result.operationsWithContext.length; i++) {
-        result.operationsWithContext[i].context.ordinal = ordinals[i];
-      }
-      const collectionMemberships = await this.getCollectionMembershipsForOperations(result.operationsWithContext);
-      const event = {
-        jobId: job.id,
-        operations: result.operationsWithContext,
-        jobMeta: job.meta,
-        collectionMemberships
-      };
-      this.eventBus.emit(ReactorEventTypes.JOB_WRITE_READY, event).catch((error) => {
-        this.logger.error("Failed to emit JOB_WRITE_READY event: @Event : @Error", event, error);
+    if (pendingEvent) {
+      this.eventBus.emit(ReactorEventTypes.JOB_WRITE_READY, pendingEvent).catch((error) => {
+        this.logger.error("Failed to emit JOB_WRITE_READY event: @Event : @Error", pendingEvent, error);
       });
     }
-    return {
-      job,
-      success: true,
-      operations: result.generatedOperations,
-      operationsWithContext: result.operationsWithContext,
-      duration: Date.now() - startTime
-    };
+    return result;
   }
-  async getCollectionMembershipsForOperations(operations) {
+  async getCollectionMembershipsForOperations(operations, stores) {
     const documentIds = [
       ...new Set(operations.map((op) => op.context.documentId))
     ];
-    return this.collectionMembershipCache.getCollectionsForDocuments(documentIds);
+    return stores.collectionMembershipCache.getCollectionsForDocuments(documentIds);
   }
-  async processActions(job, actions2, startTime, indexTxn, skipValues, sourceOperations, sourceRemote = "") {
+  async processActions(job, actions2, startTime, indexTxn, stores, skipValues, sourceOperations, sourceRemote = "") {
     const generatedOperations = [];
     const operationsWithContext = [];
     try {
@@ -13298,7 +13417,7 @@ class SimpleJobExecutor {
       const skip = skipValues?.[actionIndex] ?? 0;
       const sourceOperation = sourceOperations?.[actionIndex];
       const isDocumentAction = documentScopeActions.includes(action.type);
-      const result = isDocumentAction ? await this.documentActionHandler.execute(job, action, startTime, indexTxn, skip, sourceRemote) : await this.executeRegularAction(job, action, startTime, indexTxn, skip, sourceOperation, sourceRemote);
+      const result = isDocumentAction ? await this.documentActionHandler.execute(job, action, startTime, indexTxn, stores, skip, sourceRemote) : await this.executeRegularAction(job, action, startTime, indexTxn, stores, skip, sourceOperation, sourceRemote);
       const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
       if (error !== null) {
         return {
@@ -13315,10 +13434,10 @@ class SimpleJobExecutor {
       operationsWithContext
     };
   }
-  async executeRegularAction(job, action, startTime, indexTxn, skip = 0, sourceOperation, sourceRemote = "") {
+  async executeRegularAction(job, action, startTime, indexTxn, stores, skip = 0, sourceOperation, sourceRemote = "") {
     let docMeta;
     try {
-      docMeta = await this.documentMetaCache.getDocumentMeta(job.documentId, job.branch);
+      docMeta = await stores.documentMetaCache.getDocumentMeta(job.documentId, job.branch);
     } catch (error) {
       return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
     }
@@ -13326,11 +13445,11 @@ class SimpleJobExecutor {
       return buildErrorResult(job, new DocumentDeletedError(job.documentId, docMeta.state.deletedAtUtcIso), startTime);
     }
     if (isUndoRedo(action) || action.type === "PRUNE" || action.type === "NOOP" && skip > 0) {
-      this.writeCache.invalidate(job.documentId, job.scope, job.branch);
+      stores.writeCache.invalidate(job.documentId, job.scope, job.branch);
     }
     let document;
     try {
-      document = await this.writeCache.getState(job.documentId, job.scope, job.branch);
+      document = await stores.writeCache.getState(job.documentId, job.scope, job.branch);
     } catch (error) {
       return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
     }
@@ -13381,12 +13500,12 @@ ${error.stack}`;
       header: updatedDocument.header
     });
     try {
-      await this.operationStore.apply(job.documentId, document.header.documentType, scope, job.branch, newOperation.index, (txn) => {
+      await stores.operationStore.apply(job.documentId, document.header.documentType, scope, job.branch, newOperation.index, (txn) => {
         txn.addOperations(newOperation);
       });
     } catch (error) {
       this.logger.error("Error writing @Operation to IOperationStore: @Error", newOperation, error);
-      this.writeCache.invalidate(job.documentId, scope, job.branch);
+      stores.writeCache.invalidate(job.documentId, scope, job.branch);
       return {
         job,
         success: false,
@@ -13398,7 +13517,7 @@ ${error.stack}`;
       ...updatedDocument.header.revision,
       [scope]: newOperation.index + 1
     };
-    this.writeCache.putState(job.documentId, scope, job.branch, newOperation.index, updatedDocument);
+    stores.writeCache.putState(job.documentId, scope, job.branch, newOperation.index, updatedDocument);
     indexTxn.write([
       {
         ...newOperation,
@@ -13429,13 +13548,13 @@ ${error.stack}`;
       duration: Date.now() - startTime
     };
   }
-  async executeLoadJob(job, startTime, indexTxn) {
+  async executeLoadJob(job, startTime, indexTxn, stores) {
     if (job.operations.length === 0) {
       return buildErrorResult(job, new Error("Load job must include at least one operation"), startTime);
     }
     let docMeta;
     try {
-      docMeta = await this.documentMetaCache.getDocumentMeta(job.documentId, job.branch);
+      docMeta = await stores.documentMetaCache.getDocumentMeta(job.documentId, job.branch);
     } catch {}
     if (docMeta?.state.isDeleted) {
       return buildErrorResult(job, new DocumentDeletedError(job.documentId, docMeta.state.deletedAtUtcIso), startTime);
@@ -13443,7 +13562,7 @@ ${error.stack}`;
     const scope = job.scope;
     let latestRevision = 0;
     try {
-      const revisions = await this.operationStore.getRevisions(job.documentId, job.branch);
+      const revisions = await stores.operationStore.getRevisions(job.documentId, job.branch);
       latestRevision = revisions.revision[scope] ?? 0;
     } catch {
       latestRevision = 0;
@@ -13459,7 +13578,7 @@ ${error.stack}`;
     }
     let conflictingOps = [];
     try {
-      const conflictingResult = await this.operationStore.getConflicting(job.documentId, scope, job.branch, minIncomingTimestamp);
+      const conflictingResult = await stores.operationStore.getConflicting(job.documentId, scope, job.branch, minIncomingTimestamp);
       conflictingOps = conflictingResult.results;
     } catch {
       conflictingOps = [];
@@ -13468,7 +13587,7 @@ ${error.stack}`;
     if (conflictingOps.length > 0) {
       const minConflictingIndex = Math.min(...conflictingOps.map((op) => op.index));
       try {
-        const allOpsResult = await this.operationStore.getSince(job.documentId, scope, job.branch, minConflictingIndex - 1);
+        const allOpsResult = await stores.operationStore.getSince(job.documentId, scope, job.branch, minConflictingIndex - 1);
         allOpsFromMinConflictingIndex = allOpsResult.results;
       } catch {
         allOpsFromMinConflictingIndex = conflictingOps;
@@ -13529,7 +13648,7 @@ ${error.stack}`;
     const actions2 = reshuffledOperations.map((operation) => operation.action);
     const skipValues = reshuffledOperations.map((operation) => operation.skip);
     const effectiveSourceRemote = skipCount > 0 ? "" : job.meta.sourceRemote || "";
-    const result = await this.processActions(job, actions2, startTime, indexTxn, skipValues, reshuffledOperations, effectiveSourceRemote);
+    const result = await this.processActions(job, actions2, startTime, indexTxn, stores, skipValues, reshuffledOperations, effectiveSourceRemote);
     if (!result.success) {
       return {
         job,
@@ -13538,9 +13657,9 @@ ${error.stack}`;
         duration: Date.now() - startTime
       };
     }
-    this.writeCache.invalidate(job.documentId, scope, job.branch);
+    stores.writeCache.invalidate(job.documentId, scope, job.branch);
     if (scope === "document") {
-      this.documentMetaCache.invalidate(job.documentId, job.branch);
+      stores.documentMetaCache.invalidate(job.documentId, job.branch);
     }
     return {
       job,
@@ -15456,14 +15575,23 @@ class KyselyDocumentIndexer extends BaseReadModel {
 // src/storage/kysely/keyframe-store.ts
 class KyselyKeyframeStore {
   db;
+  trx;
   constructor(db) {
     this.db = db;
   }
+  get queryExecutor() {
+    return this.trx ?? this.db;
+  }
+  withTransaction(trx) {
+    const instance = new KyselyKeyframeStore(this.db);
+    instance.trx = trx;
+    return instance;
+  }
   async putKeyframe(documentId, scope, branch, revision, document, signal) {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    await this.db.insertInto("Keyframe").values({
+    await this.queryExecutor.insertInto("Keyframe").values({
       documentId,
       documentType: document.header.documentType,
       scope,
@@ -15476,7 +15604,7 @@ class KyselyKeyframeStore {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    const row = await this.db.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("revision", "<=", targetRevision).orderBy("revision", "desc").limit(1).executeTakeFirst();
+    const row = await this.queryExecutor.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("revision", "<=", targetRevision).orderBy("revision", "desc").limit(1).executeTakeFirst();
     if (!row) {
       return;
     }
@@ -15485,11 +15613,30 @@ class KyselyKeyframeStore {
       document: row.document
     };
   }
+  async listKeyframes(documentId, scope, branch, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    let query = this.queryExecutor.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).orderBy("revision", "asc");
+    if (scope !== undefined) {
+      query = query.where("scope", "=", scope);
+    }
+    if (branch !== undefined) {
+      query = query.where("branch", "=", branch);
+    }
+    const rows = await query.execute();
+    return rows.map((row) => ({
+      scope: row.scope,
+      branch: row.branch,
+      revision: row.revision,
+      document: row.document
+    }));
+  }
   async deleteKeyframes(documentId, scope, branch, signal) {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.deleteFrom("Keyframe").where("documentId", "=", documentId);
+    let query = this.queryExecutor.deleteFrom("Keyframe").where("documentId", "=", documentId);
     if (scope !== undefined && branch !== undefined) {
       query = query.where("scope", "=", scope).where("branch", "=", branch);
     } else if (scope !== undefined) {
@@ -15564,48 +15711,64 @@ class AtomicTransaction {
 // src/storage/kysely/store.ts
 class KyselyOperationStore {
   db;
+  trx;
   constructor(db) {
     this.db = db;
   }
+  get queryExecutor() {
+    return this.trx ?? this.db;
+  }
+  withTransaction(trx) {
+    const instance = new KyselyOperationStore(this.db);
+    instance.trx = trx;
+    return instance;
+  }
   async apply(documentId, documentType, scope, branch, revision, fn, signal) {
-    await this.db.transaction().execute(async (trx) => {
-      if (signal?.aborted) {
-        throw new Error("Operation aborted");
+    if (this.trx) {
+      await this.executeApply(this.trx, documentId, documentType, scope, branch, revision, fn, signal);
+    } else {
+      await this.db.transaction().execute(async (trx) => {
+        await this.executeApply(trx, documentId, documentType, scope, branch, revision, fn, signal);
+      });
+    }
+  }
+  async executeApply(trx, documentId, documentType, scope, branch, revision, fn, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    const latestOp = await trx.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).orderBy("index", "desc").limit(1).executeTakeFirst();
+    const currentRevision = latestOp ? latestOp.index : -1;
+    if (currentRevision !== revision - 1) {
+      throw new RevisionMismatchError(currentRevision + 1, revision);
+    }
+    const atomicTxn = new AtomicTransaction(documentId, documentType, scope, branch, revision);
+    await fn(atomicTxn);
+    const operations = atomicTxn.getOperations();
+    if (operations.length > 0) {
+      let prevOpId = latestOp?.opId || "";
+      for (const op of operations) {
+        op.prevOpId = prevOpId;
+        prevOpId = op.opId;
       }
-      const latestOp = await trx.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).orderBy("index", "desc").limit(1).executeTakeFirst();
-      const currentRevision = latestOp ? latestOp.index : -1;
-      if (currentRevision !== revision - 1) {
-        throw new RevisionMismatchError(currentRevision + 1, revision);
-      }
-      const atomicTxn = new AtomicTransaction(documentId, documentType, scope, branch, revision);
-      await fn(atomicTxn);
-      const operations = atomicTxn.getOperations();
-      if (operations.length > 0) {
-        let prevOpId = latestOp?.opId || "";
-        for (const op of operations) {
-          op.prevOpId = prevOpId;
-          prevOpId = op.opId;
-        }
-        try {
-          await trx.insertInto("Operation").values(operations).execute();
-        } catch (error) {
-          if (error instanceof Error) {
-            if (error.message.includes("unique constraint")) {
-              const op = operations[0];
-              throw new DuplicateOperationError(`${op.opId} at index ${op.index} with skip ${op.skip}`);
-            }
-            throw error;
+      try {
+        await trx.insertInto("Operation").values(operations).execute();
+      } catch (error) {
+        if (error instanceof Error) {
+          if (error.message.includes("unique constraint")) {
+            const op = operations[0];
+            throw new DuplicateOperationError(`${op.opId} at index ${op.index} with skip ${op.skip}`);
           }
           throw error;
         }
+        throw error;
       }
-    });
+    }
   }
   async getSince(documentId, scope, branch, revision, filter, paging, signal) {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("index", ">", revision).orderBy("index", "asc");
+    let query = this.queryExecutor.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("index", ">", revision).orderBy("index", "asc");
     if (filter) {
       if (filter.actionTypes && filter.actionTypes.length > 0) {
         const actionTypesArray = filter.actionTypes.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
@@ -15652,7 +15815,7 @@ class KyselyOperationStore {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.selectFrom("Operation").selectAll().where("id", ">", id).orderBy("id", "asc");
+    let query = this.queryExecutor.selectFrom("Operation").selectAll().where("id", ">", id).orderBy("id", "asc");
     if (paging) {
       const cursorValue = Number.parseInt(paging.cursor, 10);
       if (cursorValue > 0) {
@@ -15684,7 +15847,7 @@ class KyselyOperationStore {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    let query = this.db.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("timestampUtcMs", ">=", new Date(minTimestamp)).orderBy("index", "asc");
+    let query = this.queryExecutor.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("timestampUtcMs", ">=", new Date(minTimestamp)).orderBy("index", "asc");
     if (paging) {
       const cursorValue = Number.parseInt(paging.cursor, 10);
       if (cursorValue > 0) {
@@ -15716,7 +15879,7 @@ class KyselyOperationStore {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
-    const scopeRevisions = await this.db.selectFrom("Operation as o1").select(["o1.scope", "o1.index", "o1.timestampUtcMs"]).where("o1.documentId", "=", documentId).where("o1.branch", "=", branch).where((eb) => eb("o1.index", "=", eb.selectFrom("Operation as o2").select((eb2) => eb2.fn.max("o2.index").as("maxIndex")).where("o2.documentId", "=", eb.ref("o1.documentId")).where("o2.branch", "=", eb.ref("o1.branch")).where("o2.scope", "=", eb.ref("o1.scope")))).execute();
+    const scopeRevisions = await this.queryExecutor.selectFrom("Operation as o1").select(["o1.scope", "o1.index", "o1.timestampUtcMs"]).where("o1.documentId", "=", documentId).where("o1.branch", "=", branch).where((eb) => eb("o1.index", "=", eb.selectFrom("Operation as o2").select((eb2) => eb2.fn.max("o2.index").as("maxIndex")).where("o2.documentId", "=", eb.ref("o1.documentId")).where("o2.branch", "=", eb.ref("o1.branch")).where("o2.scope", "=", eb.ref("o1.scope")))).execute();
     const revision = {};
     let latestTimestamp = new Date(0).toISOString();
     for (const row of scopeRevisions) {
@@ -19755,9 +19918,10 @@ class ReactorBuilder {
     });
     await documentMetaCache.startup();
     const collectionMembershipCache = new CollectionMembershipCache(operationIndex);
+    const executionScope = new KyselyExecutionScope(database, operationStore, operationIndex, keyframeStore, writeCache, documentMetaCache, collectionMembershipCache);
     let executorManager = this.executorManager;
     if (!executorManager) {
-      executorManager = new SimpleJobExecutorManager(() => new SimpleJobExecutor(this.logger, documentModelRegistry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, this.executorConfig, this.signatureVerifier), eventBus, queue, jobTracker, this.logger, resolver);
+      executorManager = new SimpleJobExecutorManager(() => new SimpleJobExecutor(this.logger, documentModelRegistry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, this.executorConfig, this.signatureVerifier, executionScope), eventBus, queue, jobTracker, this.logger, resolver);
     }
     await executorManager.start(this.executorConfig.maxConcurrency ?? 1);
     const readModelInstances = Array.from(new Set([...this.readModels]));
@@ -19889,6 +20053,7 @@ class ReactorClientBuilder {
   signatureVerifier;
   subscriptionManager;
   jobAwaiter;
+  documentModelLoader;
   withLogger(logger) {
     this.logger = logger;
     return this;
@@ -19927,6 +20092,10 @@ class ReactorClientBuilder {
     this.jobAwaiter = jobAwaiter;
     return this;
   }
+  withDocumentModelLoader(loader) {
+    this.documentModelLoader = loader;
+    return this;
+  }
   async build() {
     const module = await this.buildModule();
     return module.client;
@@ -19944,6 +20113,9 @@ class ReactorClientBuilder {
       if (this.signatureVerifier) {
         this.reactorBuilder.withSignatureVerifier(this.signatureVerifier);
       }
+      if (this.documentModelLoader) {
+        this.reactorBuilder.withDocumentModelLoader(this.documentModelLoader);
+      }
       reactorModule = await this.reactorBuilder.buildModule();
       reactor = reactorModule.reactor;
       eventBus = reactorModule.eventBus;
@@ -20126,6 +20298,126 @@ class RelationalDbProcessor {
     return relationalDbToQueryBuilder(this.relationalDb);
   }
 }
+// src/admin/document-integrity-service.ts
+import { hashDocumentStateForScope } from "document-model/core";
+var nullKeyframeStore = {
+  putKeyframe: () => Promise.resolve(),
+  findNearestKeyframe: () => Promise.resolve(undefined),
+  listKeyframes: () => Promise.resolve([]),
+  deleteKeyframes: () => Promise.resolve(0)
+};
+
+class DocumentIntegrityService {
+  keyframeStore;
+  operationStore;
+  writeCache;
+  documentView;
+  documentModelRegistry;
+  constructor(keyframeStore, operationStore, writeCache, documentView, documentModelRegistry) {
+    this.keyframeStore = keyframeStore;
+    this.operationStore = operationStore;
+    this.writeCache = writeCache;
+    this.documentView = documentView;
+    this.documentModelRegistry = documentModelRegistry;
+  }
+  async validateDocument(documentId, branch = "main", signal) {
+    const keyframeIssues = [];
+    const snapshotIssues = [];
+    const replayCache = new KyselyWriteCache(nullKeyframeStore, this.operationStore, this.documentModelRegistry, {
+      maxDocuments: 1,
+      ringBufferSize: 1,
+      keyframeInterval: Number.MAX_SAFE_INTEGER
+    });
+    const keyframes = await this.keyframeStore.listKeyframes(documentId, undefined, branch, signal);
+    for (const keyframe of keyframes) {
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      replayCache.invalidate(documentId, keyframe.scope, branch);
+      const replayedDoc = await replayCache.getState(documentId, keyframe.scope, branch, keyframe.revision, signal);
+      const kfHash = hashDocumentStateForScope(keyframe.document, keyframe.scope);
+      const replayHash = hashDocumentStateForScope(replayedDoc, keyframe.scope);
+      if (kfHash !== replayHash) {
+        keyframeIssues.push({
+          scope: keyframe.scope,
+          branch,
+          revision: keyframe.revision,
+          keyframeHash: kfHash,
+          replayedHash: replayHash
+        });
+      }
+    }
+    let currentDoc;
+    try {
+      currentDoc = await this.documentView.get(documentId);
+    } catch {
+      return {
+        documentId,
+        isConsistent: keyframeIssues.length === 0,
+        keyframeIssues,
+        snapshotIssues
+      };
+    }
+    const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+    const allScopes = Object.keys(revisions.revision);
+    for (const scope of allScopes) {
+      if (scope === "document")
+        continue;
+      replayCache.invalidate(documentId, scope, branch);
+      let replayedDoc;
+      try {
+        replayedDoc = await replayCache.getState(documentId, scope, branch, undefined, signal);
+      } catch {
+        if (signal?.aborted) {
+          throw new Error("Operation aborted");
+        }
+        continue;
+      }
+      const snapshotHash = hashDocumentStateForScope(currentDoc, scope);
+      const replayHash = hashDocumentStateForScope(replayedDoc, scope);
+      if (snapshotHash !== replayHash) {
+        snapshotIssues.push({
+          scope,
+          branch,
+          snapshotHash,
+          replayedHash: replayHash
+        });
+      }
+    }
+    return {
+      documentId,
+      isConsistent: keyframeIssues.length === 0 && snapshotIssues.length === 0,
+      keyframeIssues,
+      snapshotIssues
+    };
+  }
+  async rebuildKeyframes(documentId, branch = "main", signal) {
+    const deleted = await this.keyframeStore.deleteKeyframes(documentId, undefined, branch, signal);
+    return {
+      documentId,
+      keyframesDeleted: deleted,
+      scopesInvalidated: 0
+    };
+  }
+  async rebuildSnapshots(documentId, branch = "main", signal) {
+    const scopes = await this.discoverScopes(documentId, branch, signal);
+    for (const scope of scopes) {
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      this.writeCache.invalidate(documentId, scope, branch);
+    }
+    return {
+      documentId,
+      keyframesDeleted: 0,
+      scopesInvalidated: scopes.length
+    };
+  }
+  async discoverScopes(documentId, branch, signal) {
+    const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+    return Object.keys(revisions.revision);
+  }
+}
 export {
   upgradeDocumentAction,
   trimMailboxFromAckOrdinal,
@@ -20197,6 +20489,7 @@ export {
   DuplicateOperationError,
   DuplicateModuleError,
   DocumentModelRegistry,
+  DocumentIntegrityService,
   DocumentChangeType,
   DefaultSubscriptionErrorHandler,
   ConsoleLogger,