@powerhousedao/connect 6.0.0-dev.88 → 6.0.0-dev.89

package/dist/src/utils/index.js

@@ -4499,7 +4499,7 @@ var init_package = __esm(() => {
   package_default = {
     name: "@powerhousedao/connect",
     productName: "Powerhouse-Connect",
-    version: "6.0.0-dev.87",
+    version: "6.0.0-dev.88",
     description: "Powerhouse Connect",
     main: "dist/index.html",
     type: "module",
@@ -4638,6 +4638,7 @@ import { isUndoRedo } from "document-model/core";
 import { deriveOperationId as deriveOperationId2 } from "document-model/core";
 import { ConsoleLogger } from "document-model/core";
 import { AbortError } from "document-drive/utils/errors";
+import { hashDocumentStateForScope } from "document-model/core";
 function createDocumentAction(input) {
   return {
     id: generateId(),
@@ -11932,6 +11933,10 @@ class RingBuffer {
     return this.size;
   }
 }
+function extractModuleVersion(doc) {
+  const v = doc.state.document.version;
+  return v === 0 ? undefined : v;
+}
 
 class KyselyWriteCache {
   streams;
@@ -12096,7 +12101,7 @@ class KyselyWriteCache {
         throw new Error(`Failed to rebuild document ${documentId}: CREATE_DOCUMENT action missing model in input`);
       }
       document2 = createDocumentFromAction(documentCreateAction);
-      const docModule = this.registry.getModule(documentType);
+      let docModule = this.registry.getModule(documentType, extractModuleVersion(document2));
       const docScopeOps = await this.operationStore.getSince(documentId, "document", branch, 0, undefined, undefined, signal);
       for (const operation of docScopeOps.results) {
         if (operation.index === 0) {
@@ -12105,6 +12110,7 @@ class KyselyWriteCache {
         if (operation.action.type === "UPGRADE_DOCUMENT") {
           const upgradeAction = operation.action;
           document2 = applyUpgradeDocumentAction(document2, upgradeAction);
+          docModule = this.registry.getModule(documentType, extractModuleVersion(document2));
         } else if (operation.action.type === "DELETE_DOCUMENT") {
           applyDeleteDocumentAction(document2, operation.action);
         } else {
@@ -12116,7 +12122,7 @@ class KyselyWriteCache {
         }
       }
     }
-    const module = this.registry.getModule(documentType);
+    const module = this.registry.getModule(documentType, extractModuleVersion(document2));
     let cursor = undefined;
     const pageSize = 100;
     let hasMorePages;
@@ -14554,6 +14560,25 @@ 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");
@@ -18817,6 +18842,118 @@ function relationalDbToQueryBuilder(query) {
     withSchema: (schema) => relationalDbToQueryBuilder(query.withSchema(schema))
   };
 }
+
+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);
+  }
+}
 var __defProp2, __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
@@ -18959,7 +19096,7 @@ var __defProp2, __export2 = (target, all) => {
     }
   }
   return maxOrdinal;
-}, SyncStatus, cachedEncoder, LOG2_26, IS_RELATIONAL_DB_PROCESSOR, RelationalDbProcessor;
+}, SyncStatus, cachedEncoder, LOG2_26, IS_RELATIONAL_DB_PROCESSOR, RelationalDbProcessor, nullKeyframeStore;
 var init_src = __esm(() => {
   __defProp2 = Object.defineProperty;
   byteToHex = [];
@@ -24219,6 +24356,12 @@ var init_src = __esm(() => {
       return relationalDbToQueryBuilder(this.relationalDb);
     }
   };
+  nullKeyframeStore = {
+    putKeyframe: () => Promise.resolve(),
+    findNearestKeyframe: () => Promise.resolve(undefined),
+    listKeyframes: () => Promise.resolve([]),
+    deleteKeyframes: () => Promise.resolve(0)
+  };
 });
 
 // ../../packages/reactor-browser/dist/src/index.js
@@ -24433,6 +24576,7 @@ __export(exports_src, {
   InMemoryQueue: () => InMemoryQueue,
   ISSUER_TYPE: () => ISSUER_TYPE,
   GqlRequestChannel: () => GqlRequestChannel,
+  DocumentIntegrityService: () => DocumentIntegrityService,
   DocumentChangeType: () => DocumentChangeType,
   DocumentCache: () => DocumentCache,
   DisconnectIcon: () => DisconnectIcon,

package/dist/style.css

@@ -2882,6 +2882,9 @@
   .border-black {
     border-color: var(--color-black);
   }
+  .border-blue-300 {
+    border-color: var(--color-blue-300);
+  }
   .border-blue-500 {
     border-color: var(--color-blue-500);
   }
@@ -2942,6 +2945,9 @@
   .border-yellow-300 {
     border-color: var(--color-yellow-300);
   }
+  .border-yellow-400 {
+    border-color: var(--color-yellow-400);
+  }
   .border-zinc-200 {
     border-color: var(--color-zinc-200);
   }
@@ -3098,6 +3104,9 @@
   .bg-yellow-500 {
     background-color: var(--color-yellow-500);
   }
+  .bg-yellow-600 {
+    background-color: var(--color-yellow-600);
+  }
   .bg-zinc-50 {
     background-color: var(--color-zinc-50);
   }
@@ -4280,6 +4289,13 @@
       }
     }
   }
+  .hover\:bg-yellow-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-yellow-700);
+      }
+    }
+  }
   .hover\:text-\[\#9896FF\] {
     &:hover {
       @media (hover: hover) {
@@ -4365,6 +4381,11 @@
       }
     }
   }
+  .focus\:border-blue-400 {
+    &:focus {
+      border-color: var(--color-blue-400);
+    }
+  }
   .focus\:bg-gray-50 {
     &:focus {
       background-color: var(--color-gray-50);