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

package/dist/src/main.js

@@ -7982,7 +7982,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",
@@ -8121,6 +8121,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(),
@@ -15415,6 +15416,10 @@ class RingBuffer {
     return this.size;
   }
 }
+function extractModuleVersion(doc) {
+  const v = doc.state.document.version;
+  return v === 0 ? undefined : v;
+}
 
 class KyselyWriteCache {
   streams;
@@ -15579,7 +15584,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) {
@@ -15588,6 +15593,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 {
@@ -15599,7 +15605,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;
@@ -18037,6 +18043,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");
@@ -22300,6 +22325,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, {
@@ -22442,7 +22579,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 = [];
@@ -27702,6 +27839,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
@@ -27916,6 +28059,7 @@ __export(exports_src, {
   InMemoryQueue: () => InMemoryQueue,
   ISSUER_TYPE: () => ISSUER_TYPE,
   GqlRequestChannel: () => GqlRequestChannel,
+  DocumentIntegrityService: () => DocumentIntegrityService,
   DocumentChangeType: () => DocumentChangeType,
   DocumentCache: () => DocumentCache,
   DisconnectIcon: () => DisconnectIcon,
@@ -263718,13 +263862,55 @@ var init_useDbExplorer = __esm(() => {
   ];
 });
 
-// src/components/modal/modals/InspectorModal/useProcessorsInspector.ts
+// src/components/modal/modals/InspectorModal/useIntegrityInspector.ts
 import { useCallback as useCallback38, useMemo as useMemo18 } from "react";
+function useIntegrityInspector() {
+  const reactorClientModule = useReactorClientModule2();
+  const reactorModule = reactorClientModule?.reactorModule;
+  const service = useMemo18(() => {
+    if (!reactorModule)
+      return;
+    return new DocumentIntegrityService(reactorModule.keyframeStore, reactorModule.operationStore, reactorModule.writeCache, reactorModule.documentView, reactorModule.documentModelRegistry);
+  }, [reactorModule]);
+  const onValidate = useCallback38(async (documentId, branch) => {
+    if (!service) {
+      throw new Error("Reactor module not available");
+    }
+    return service.validateDocument(documentId, branch);
+  }, [service]);
+  const onRebuildKeyframes = useCallback38(async (documentId, branch) => {
+    if (!service) {
+      throw new Error("Reactor module not available");
+    }
+    return service.rebuildKeyframes(documentId, branch);
+  }, [service]);
+  const onRebuildSnapshots = useCallback38(async (documentId, branch) => {
+    if (!service) {
+      throw new Error("Reactor module not available");
+    }
+    return service.rebuildSnapshots(documentId, branch);
+  }, [service]);
+  if (!service) {
+    return;
+  }
+  return {
+    onValidate,
+    onRebuildKeyframes,
+    onRebuildSnapshots
+  };
+}
+var init_useIntegrityInspector = __esm(() => {
+  init_src2();
+  init_connect2();
+});
+
+// src/components/modal/modals/InspectorModal/useProcessorsInspector.ts
+import { useCallback as useCallback39, useMemo as useMemo19 } from "react";
 function useProcessorsInspector() {
   const reactorClientModule = useReactorClientModule2();
   const processorManager = reactorClientModule?.reactorModule?.processorManager;
-  const hasProcessorManager = useMemo18(() => processorManager != null, [processorManager]);
-  const getProcessors = useCallback38(async () => {
+  const hasProcessorManager = useMemo19(() => processorManager != null, [processorManager]);
+  const getProcessors = useCallback39(async () => {
     if (!processorManager) {
       return [];
     }
@@ -263739,7 +263925,7 @@ function useProcessorsInspector() {
       lastErrorTimestamp: tracked.lastErrorTimestamp
     }));
   }, [processorManager]);
-  const onRetry = useCallback38(async (processorId) => {
+  const onRetry = useCallback39(async (processorId) => {
     if (!processorManager)
       return;
     const tracked = processorManager.get(processorId);
@@ -263760,17 +263946,17 @@ var init_useProcessorsInspector = __esm(() => {
 });
 
 // src/components/modal/modals/InspectorModal/useQueueInspector.ts
-import { useCallback as useCallback39, useMemo as useMemo19 } from "react";
+import { useCallback as useCallback40, useMemo as useMemo20 } from "react";
 function useQueueInspector() {
   const reactorClientModule = useReactorClientModule2();
   const queue = reactorClientModule?.reactorModule?.queue;
-  const inMemoryQueue = useMemo19(() => {
+  const inMemoryQueue = useMemo20(() => {
     if (queue instanceof InMemoryQueue) {
       return queue;
     }
     return;
   }, [queue]);
-  const getQueueState = useCallback39(async () => {
+  const getQueueState = useCallback40(async () => {
     if (!inMemoryQueue) {
       return {
         isPaused: false,
@@ -263799,12 +263985,12 @@ function useQueueInspector() {
       totalExecuting: executingJobs.length
     };
   }, [inMemoryQueue]);
-  const onPause = useCallback39(async () => {
+  const onPause = useCallback40(async () => {
     if (inMemoryQueue) {
       inMemoryQueue.pause();
     }
   }, [inMemoryQueue]);
-  const onResume = useCallback39(async () => {
+  const onResume = useCallback40(async () => {
     if (inMemoryQueue) {
       await inMemoryQueue.resume();
     }
@@ -263824,17 +264010,17 @@ var init_useQueueInspector = __esm(() => {
 });
 
 // src/components/modal/modals/InspectorModal/useRemotesInspector.ts
-import { useCallback as useCallback40 } from "react";
+import { useCallback as useCallback41 } from "react";
 function useRemotesInspector() {
   const syncManager = useSync2();
   if (!syncManager) {
     throw new Error("Sync manager not found");
   }
   const connectionStates = useConnectionStates2();
-  const getRemotes = useCallback40(() => {
+  const getRemotes = useCallback41(() => {
     return Promise.resolve(syncManager.list());
   }, [syncManager]);
-  const removeRemote = useCallback40((name6) => syncManager.remove(name6), [syncManager]);
+  const removeRemote = useCallback41((name6) => syncManager.remove(name6), [syncManager]);
   return {
     getRemotes,
     removeRemote,
@@ -263855,6 +264041,7 @@ var DEFAULT_PAGE_SIZE = 25, InspectorModal = () => {
   const { getRemotes, removeRemote, connectionStates } = useRemotesInspector();
   const queueInspectorProps = useQueueInspector();
   const processorsInspectorProps = useProcessorsInspector();
+  const integrityInspectorProps = useIntegrityInspector();
   return /* @__PURE__ */ jsxDEV27(ConnectInspectorModal, {
     open,
     onOpenChange: (status) => {
@@ -263876,13 +264063,15 @@ var DEFAULT_PAGE_SIZE = 25, InspectorModal = () => {
       connectionStates
     },
     queueInspectorProps,
-    processorsInspectorProps
+    processorsInspectorProps,
+    integrityInspectorProps
   }, undefined, false, undefined, this);
 };
 var init_InspectorModal = __esm(() => {
   init_src2();
   init_src2();
   init_useDbExplorer();
+  init_useIntegrityInspector();
   init_useProcessorsInspector();
   init_useQueueInspector();
   init_useRemotesInspector();
@@ -264441,12 +264630,12 @@ var CookieBanner = () => {
 // src/components/document-editor-container.tsx
 init_services();
 init_src2();
-import { useCallback as useCallback41, useMemo as useMemo20 } from "react";
+import { useCallback as useCallback42, useMemo as useMemo21 } from "react";
 import { jsxDEV as jsxDEV32 } from "react/jsx-dev-runtime";
 function DocumentEditorContainer() {
   const [selectedDocument] = useSelectedDocument();
   const parentFolder = useNodeParentFolderById(selectedDocument.header.id);
-  const onExport = useCallback41(() => {
+  const onExport = useCallback42(() => {
     const validationErrors = validateDocument(selectedDocument);
     if (validationErrors.length) {
       showPHModal({
@@ -264461,10 +264650,10 @@ function DocumentEditorContainer() {
       });
     }
   }, [selectedDocument]);
-  const onOpenSwitchboardLink = useMemo20(() => {
+  const onOpenSwitchboardLink = useMemo21(() => {
     return async () => {};
   }, []);
-  const onClose = useCallback41(() => {
+  const onClose = useCallback42(() => {
     setSelectedNode(parentFolder);
   }, [parentFolder, setSelectedNode]);
   return /* @__PURE__ */ jsxDEV32("div", {
@@ -264555,13 +264744,13 @@ function DriveEditorContainer() {
 init_src2();
 init_connect2();
 import { Icon as Icon3 } from "@powerhousedao/design-system";
-import { useMemo as useMemo21 } from "react";
+import { useMemo as useMemo23 } from "react";
 import { jsxDEV as jsxDEV36 } from "react/jsx-dev-runtime";
 function DriveIcon({
   drive
 }) {
   const remotes = useSyncList2();
-  const isRemoteDrive = useMemo21(() => {
+  const isRemoteDrive = useMemo23(() => {
     if (!drive)
       return false;
     return remotes.some((remote) => remote.collectionId === driveCollectionId("main", drive.header.id));
@@ -264590,12 +264779,12 @@ function DriveIcon({
 init_src2();
 init_toast();
 import { PackageInstallModal } from "@powerhousedao/design-system/connect";
-import { useCallback as useCallback42 } from "react";
+import { useCallback as useCallback43 } from "react";
 import { jsxDEV as jsxDEV37 } from "react/jsx-dev-runtime";
 var PackageInstallPrompt = () => {
   const packageManager = useVetraPackageManager();
   const pending = usePendingInstallations();
-  const handleInstall = useCallback42(async (packageName) => {
+  const handleInstall = useCallback43(async (packageName) => {
     if (!packageManager)
       return;
     try {
@@ -264610,7 +264799,7 @@ var PackageInstallPrompt = () => {
       });
     }
   }, [packageManager]);
-  const handleDismiss = useCallback42((packageName) => {
+  const handleDismiss = useCallback43((packageName) => {
     if (!packageManager)
       return;
     packageManager.rejectInstallation(packageName);
@@ -265674,13 +265863,13 @@ var gql = (chunks, ...variables) => {
 };
 // src/pages/demo/atlas-import.tsx
 init_dist4();
-import { useCallback as useCallback43, useEffect as useEffect53, useMemo as useMemo23, useRef as useRef32, useState as useState44 } from "react";
+import { useCallback as useCallback44, useEffect as useEffect53, useMemo as useMemo25, useRef as useRef32, useState as useState44 } from "react";
 import { jsxDEV as jsxDEV45, Fragment as Fragment9 } from "react/jsx-dev-runtime";
 var REACTOR_URL = "https://apps.powerhouse.io/sky-atlas/staging/switchboard";
 var MIN_LOADING_TIME = 2000;
 function useReactorUrl() {
   const { search } = useLocation();
-  return useMemo23(() => {
+  return useMemo25(() => {
     const params = new URLSearchParams(search);
     const url2 = params.get("reactorUrl") ?? REACTOR_URL;
     return url2.endsWith("/") ? url2 : `${url2}/`;
@@ -265716,12 +265905,12 @@ function AtlasImport() {
     status.current = "forked";
     setDriveId(driveId2);
   }
-  const redirectToDrive = useCallback43(() => {
+  const redirectToDrive = useCallback44(() => {
     if (driveId && !loading2) {
       navigate(`/d/${driveId}`, { replace: true });
     }
   }, [driveId, navigate, loading2]);
-  const addForkDrive = useCallback43(async (driveId2) => {
+  const addForkDrive = useCallback44(async (driveId2) => {
     console.log("Adding remote drive:", driveId2);
     const driveUrl = `${reactorUrl}d/${driveId2}`;
     try {