@powerhousedao/connect 1.0.8 → 1.0.9-dev.0

package/dist/assets/{app-loader-KTD3Q6e9.js → app-loader-BnxLpX27.js}

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-Bw1Ba-jV.js","assets/main.CzEw2R-H.js","assets/app-D3TxLTK-.css"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-Uu65do7x.js","assets/main.CpORyZoE.js","assets/app-D9QJBr8i.css"])))=>i.map(i=>d[i]);
 var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -11,7 +11,7 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 var _tags, _levelString, _errorHandler, _ConsoleLogger_instances, levelValue_get, _getDocumentModelModule, _drives, _ReadModeService_instances, parseGraphQLErrors_fn, fetchDrive_fn, _a, _ServiceWorkerManager_instances, handleServiceWorkerMessage_fn, handleServiceWorker_fn;
-import { _ as __vitePreload } from "./main.CzEw2R-H.js";
+import { _ as __vitePreload } from "./main.CpORyZoE.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect, Suspense, lazy } from "react";
 function _mergeNamespaces(n, m) {
@@ -86,34 +86,78 @@ class DocumentEditorDebugTools {
     this.document = void 0;
   }
 }
+const trimResultingState = (document) => {
+  const global2 = document.operations.global.map((e) => {
+    delete e.resultingState;
+    return e;
+  });
+  const local = document.operations.local.map((e) => {
+    delete e.resultingState;
+    return e;
+  });
+  return { ...document, operations: { global: global2, local } };
+};
 class InMemoryCache {
   constructor() {
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "idTodocument", /* @__PURE__ */ new Map());
+    __publicField(this, "idToDrive", /* @__PURE__ */ new Map());
+    __publicField(this, "slugToDriveId", /* @__PURE__ */ new Map());
   }
-  async setDocument(drive, id, document) {
-    var _a2;
-    const global2 = document.operations.global.map((e) => {
-      delete e.resultingState;
-      return e;
-    });
-    const local = document.operations.local.map((e) => {
-      delete e.resultingState;
-      return e;
-    });
-    const doc = { ...document, operations: { global: global2, local } };
-    if (!this.cache.has(drive)) {
-      this.cache.set(drive, /* @__PURE__ */ new Map());
+  clear() {
+    this.idTodocument.clear();
+    this.idToDrive.clear();
+    this.slugToDriveId.clear();
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // ICache
+  /////////////////////////////////////////////////////////////////////////////
+  async setDocument(documentId, document) {
+    const doc = trimResultingState(document);
+    this.idTodocument.set(documentId, doc);
+  }
+  async getDocument(documentId) {
+    return this.idTodocument.get(documentId);
+  }
+  async deleteDocument(documentId) {
+    return this.idTodocument.delete(documentId);
+  }
+  async setDrive(driveId, drive) {
+    const doc = trimResultingState(drive);
+    this.idToDrive.set(driveId, doc);
+  }
+  async getDrive(driveId) {
+    return this.idToDrive.get(driveId);
+  }
+  async deleteDrive(driveId) {
+    const drive = this.idToDrive.get(driveId);
+    if (!drive) {
+      return false;
     }
-    (_a2 = this.cache.get(drive)) == null ? void 0 : _a2.set(id, doc);
-    return true;
+    const slug = drive.state.global.slug;
+    if (slug) {
+      this.slugToDriveId.delete(slug);
+    }
+    return this.idToDrive.delete(driveId);
   }
-  async deleteDocument(drive, id) {
-    var _a2;
-    return ((_a2 = this.cache.get(drive)) == null ? void 0 : _a2.delete(id)) ?? false;
+  async setDriveBySlug(slug, drive) {
+    const driveId = drive.state.global.id;
+    this.slugToDriveId.set(slug, driveId);
+    this.setDrive(driveId, drive);
   }
-  async getDocument(drive, id) {
-    var _a2;
-    return (_a2 = this.cache.get(drive)) == null ? void 0 : _a2.get(id);
+  async getDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return void 0;
+    }
+    return this.getDrive(driveId);
+  }
+  async deleteDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return false;
+    }
+    this.slugToDriveId.delete(slug);
+    return this.deleteDrive(driveId);
   }
 }
 const K = [
@@ -22497,7 +22541,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
     const syncUnits = await this.manager.getListenerSyncUnitIds(driveId, listenerId);
     let success = true;
     for (const revision of revisions) {
-      const syncUnit = syncUnits.find((s) => s.scope === revision.scope && s.branch === revision.branch && s.driveId === revision.driveId && s.documentId == revision.documentId);
+      const syncUnit = syncUnits.find((s) => s.scope === revision.scope && s.branch === revision.branch && s.documentId == revision.documentId);
       if (!syncUnit) {
         this.logger.warn("Unknown sync unit was acknowledged", revision);
         success = false;
@@ -22742,6 +22786,187 @@ __publicField(_PullResponderTransmitter, "staticLogger", childLogger([
   "static"
 ]));
 let PullResponderTransmitter = _PullResponderTransmitter;
+var defaults;
+var hasRequiredDefaults;
+function requireDefaults() {
+  if (hasRequiredDefaults) return defaults;
+  hasRequiredDefaults = 1;
+  defaults = {
+    space: "",
+    cycles: false,
+    replacer: (k, v) => v,
+    stringify: JSON.stringify
+  };
+  return defaults;
+}
+var util;
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util;
+  hasRequiredUtil = 1;
+  util = {
+    isArray: Array.isArray,
+    assign: Object.assign,
+    isObject: (v) => typeof v === "object",
+    isFunction: (v) => typeof v === "function",
+    isBoolean: (v) => typeof v === "boolean",
+    isRegex: (v) => v instanceof RegExp,
+    keys: Object.keys
+  };
+  return util;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  const DEFAULTS = requireDefaults();
+  const isFunction = requireUtil().isFunction;
+  const isBoolean = requireUtil().isBoolean;
+  const isObject = requireUtil().isObject;
+  const isArray = requireUtil().isArray;
+  const isRegex = requireUtil().isRegex;
+  const assign = requireUtil().assign;
+  const keys = requireUtil().keys;
+  function serialize(obj) {
+    if (obj === null || obj === void 0) return obj;
+    if (isRegex(obj)) return obj.toString();
+    return obj.toJSON ? obj.toJSON() : obj;
+  }
+  function stringifyDeterministic(obj, opts) {
+    opts = opts || assign({}, DEFAULTS);
+    if (isFunction(opts)) opts = { compare: opts };
+    const space = opts.space || DEFAULTS.space;
+    const cycles = isBoolean(opts.cycles) ? opts.cycles : DEFAULTS.cycles;
+    const replacer = opts.replacer || DEFAULTS.replacer;
+    const stringify2 = opts.stringify || DEFAULTS.stringify;
+    const compare = opts.compare && /* @__PURE__ */ function(f) {
+      return function(node) {
+        return function(a, b) {
+          const aobj = { key: a, value: node[a] };
+          const bobj = { key: b, value: node[b] };
+          return f(aobj, bobj);
+        };
+      };
+    }(opts.compare);
+    if (!cycles) stringify2(obj);
+    const seen = [];
+    return function _deterministic(parent, key, node, level) {
+      const indent2 = space ? "\n" + new Array(level + 1).join(space) : "";
+      const colonSeparator = space ? ": " : ":";
+      node = serialize(node);
+      node = replacer.call(parent, key, node);
+      if (node === void 0) return;
+      if (!isObject(node) || node === null) return stringify2(node);
+      if (isArray(node)) {
+        const out = [];
+        for (let i = 0; i < node.length; i++) {
+          const item = _deterministic(node, i, node[i], level + 1) || stringify2(null);
+          out.push(indent2 + space + item);
+        }
+        return "[" + out.join(",") + indent2 + "]";
+      } else {
+        if (cycles) {
+          if (seen.indexOf(node) !== -1) {
+            return stringify2("[Circular]");
+          } else {
+            seen.push(node);
+          }
+        }
+        const nodeKeys = keys(node).sort(compare && compare(node));
+        const out = [];
+        for (let i = 0; i < nodeKeys.length; i++) {
+          const key2 = nodeKeys[i];
+          const value = _deterministic(node, key2, node[key2], level + 1);
+          if (!value) continue;
+          const keyValue = stringify2(key2) + colonSeparator + value;
+          out.push(indent2 + space + keyValue);
+        }
+        seen.splice(seen.indexOf(node), 1);
+        return "{" + out.join(",") + indent2 + "}";
+      }
+    }({ "": obj }, "", obj, 0);
+  }
+  lib = stringifyDeterministic;
+  return lib;
+}
+var libExports = requireLib();
+const stringify = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+const SYNC_OPS_BATCH_LIMIT = 10;
+class SwitchboardPushTransmitter {
+  constructor(targetURL) {
+    __publicField(this, "targetURL");
+    __publicField(this, "logger", childLogger([
+      "SwitchboardPushTransmitter",
+      Math.floor(Math.random() * 999).toString()
+    ]));
+    this.targetURL = targetURL;
+  }
+  async transmit(strands, source) {
+    var _a2;
+    if (source.type === "trigger" && ((_a2 = source.trigger.data) == null ? void 0 : _a2.url) === this.targetURL) {
+      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
+      return strands.map((strand) => {
+        var _a3;
+        return {
+          driveId: strand.driveId,
+          documentId: strand.documentId,
+          scope: strand.scope,
+          branch: strand.branch,
+          status: "SUCCESS",
+          revision: ((_a3 = strand.operations.at(-1)) == null ? void 0 : _a3.index) ?? -1
+        };
+      });
+    }
+    const culledStrands = [];
+    let opsCounter = 0;
+    for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
+      const currentStrand = strands.at(s);
+      if (!currentStrand) {
+        break;
+      }
+      const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
+      culledStrands.push({
+        ...currentStrand,
+        operations: currentStrand.operations.slice(0, newOps)
+      });
+      opsCounter += newOps;
+    }
+    this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
+    this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
+    try {
+      const { pushUpdates } = await requestGraphql(this.targetURL, gql`
+          mutation pushUpdates($strands: [InputStrandUpdate!]) {
+            pushUpdates(strands: $strands) {
+              driveId
+              documentId
+              scope
+              branch
+              status
+              revision
+              error
+            }
+          }
+        `, {
+        strands: culledStrands.map((strand) => ({
+          ...strand,
+          operations: strand.operations.map((op) => ({
+            ...op,
+            input: stringify(op.input)
+          }))
+        }))
+      });
+      if (!pushUpdates) {
+        throw new Error("Couldn't update listener revision");
+      }
+      return pushUpdates;
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+    return [];
+  }
+}
 var TransmitterType;
 (function(TransmitterType2) {
   TransmitterType2[TransmitterType2["Internal"] = 0] = "Internal";
@@ -22814,7 +23039,6 @@ class BaseDocumentDriveServer {
     // internal state
     __publicField(this, "triggerMap", /* @__PURE__ */ new Map());
     __publicField(this, "initializePromise");
-    var _a2, _b;
     this.documentModelModules = documentModelModules;
     this.storage = storage;
     this.documentStorage = documentStorage;
@@ -22835,17 +23059,6 @@ class BaseDocumentDriveServer {
       taskQueueMethod: (options == null ? void 0 : options.taskQueueMethod) === void 0 ? RunAsap.runAsap : options.taskQueueMethod
     };
     this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
-    (_b = (_a2 = this.storage).setStorageDelegate) == null ? void 0 : _b.call(_a2, {
-      getCachedOperations: async (drive, id) => {
-        try {
-          const document = await this.cache.getDocument(drive, id);
-          return document == null ? void 0 : document.operations;
-        } catch (error) {
-          logger$1.error(error);
-          return void 0;
-        }
-      }
-    });
     this.initializePromise = this._initialize();
   }
   // workaround for testing the ephemeral listeners -- we don't have DI in place yet
@@ -22987,11 +23200,32 @@ class BaseDocumentDriveServer {
     return this.triggerMap.delete(driveId);
   }
   async _initializeDrive(driveId) {
+    var _a2, _b, _c, _d, _e, _f;
     const drive = await this.getDrive(driveId);
     await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
     if (this.shouldSyncRemoteDrive(drive)) {
       await this.startSyncRemoteDrive(driveId);
     }
+    for (const zodListener of drive.state.local.listeners) {
+      if (((_a2 = zodListener.callInfo) == null ? void 0 : _a2.transmitterType) === "SwitchboardPush") {
+        const transmitter = new SwitchboardPushTransmitter(((_b = zodListener.callInfo) == null ? void 0 : _b.data) ?? "");
+        this.listenerManager.setListener(driveId, {
+          block: zodListener.block,
+          driveId: drive.state.global.id,
+          filter: {
+            branch: ((_c = zodListener.filter) == null ? void 0 : _c.branch) ?? [],
+            documentId: ((_d = zodListener.filter) == null ? void 0 : _d.documentId) ?? [],
+            documentType: ((_e = zodListener.filter) == null ? void 0 : _e.documentType) ?? [],
+            scope: ((_f = zodListener.filter) == null ? void 0 : _f.scope) ?? []
+          },
+          listenerId: zodListener.listenerId,
+          callInfo: zodListener.callInfo,
+          system: zodListener.system,
+          label: zodListener.label ?? "",
+          transmitter
+        });
+      }
+    }
   }
   // Delegate synchronization methods to synchronizationManager
   getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
@@ -23033,7 +23267,7 @@ class BaseDocumentDriveServer {
     };
     await this.storage.createDrive(id, document);
     if (input.global.slug) {
-      await this.cache.deleteDocument("drives-slug", input.global.slug);
+      await this.cache.deleteDriveBySlug(input.global.slug);
     }
     await this._initializeDrive(id);
     this.eventEmitter.emit("driveAdded", document);
@@ -23065,7 +23299,7 @@ class BaseDocumentDriveServer {
     const result = await Promise.allSettled([
       this.stopSyncRemoteDrive(driveId),
       this.listenerManager.removeDrive(driveId),
-      this.cache.deleteDocument("drives", driveId),
+      this.cache.deleteDrive(driveId),
       this.storage.deleteDrive(driveId)
     ]);
     result.forEach((r) => {
@@ -23080,7 +23314,7 @@ class BaseDocumentDriveServer {
   async getDrive(driveId, options) {
     let document;
     try {
-      const cachedDocument = await this.cache.getDocument("drives", driveId);
+      const cachedDocument = await this.cache.getDrive(driveId);
       if (cachedDocument && isDocumentDrive(cachedDocument)) {
         document = cachedDocument;
         if (isAtRevision(document, options == null ? void 0 : options.revisions)) {
@@ -23096,16 +23330,16 @@ class BaseDocumentDriveServer {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
     } else {
       if (!(options == null ? void 0 : options.revisions)) {
-        this.cache.setDocument("drives", driveId, result).catch(logger$1.error);
+        this.cache.setDrive(driveId, result).catch(logger$1.error);
       }
       return result;
     }
   }
   async getDriveBySlug(slug, options) {
     try {
-      const document2 = await this.cache.getDocument("drives-slug", slug);
-      if (document2 && isDocumentDrive(document2)) {
-        return document2;
+      const drive = await this.cache.getDriveBySlug(slug);
+      if (drive) {
+        return drive;
       }
     } catch (e) {
       logger$1.error("Error getting drive from cache", e);
@@ -23115,14 +23349,14 @@ class BaseDocumentDriveServer {
     if (!isDocumentDrive(document)) {
       throw new Error(`Document with slug ${slug} is not a Document Drive`);
     } else {
-      this.cache.setDocument("drives-slug", slug, document).catch(logger$1.error);
+      this.cache.setDriveBySlug(slug, document).catch(logger$1.error);
       return document;
     }
   }
   async getDocument(driveId, documentId, options) {
     let cachedDocument;
     try {
-      cachedDocument = await this.cache.getDocument(driveId, documentId);
+      cachedDocument = await this.cache.getDocument(documentId);
       if (cachedDocument && isAtRevision(cachedDocument, options == null ? void 0 : options.revisions)) {
         return cachedDocument;
       }
@@ -23132,7 +23366,7 @@ class BaseDocumentDriveServer {
     const documentStorage = cachedDocument ?? await this.storage.getDocument(driveId, documentId);
     const document = this._buildDocument(documentStorage, options);
     if (!(options == null ? void 0 : options.revisions)) {
-      this.cache.setDocument(driveId, documentId, document).catch(logger$1.error);
+      this.cache.setDocument(documentId, document).catch(logger$1.error);
     }
     return document;
   }
@@ -23189,7 +23423,7 @@ class BaseDocumentDriveServer {
     } catch (error) {
       logger$1.warn("Error deleting document", error);
     }
-    await this.cache.deleteDocument(driveId, documentId);
+    await this.cache.deleteDocument(documentId);
     return this.storage.deleteDocument(driveId, documentId);
   }
   async _processOperations(driveId, documentId, documentStorage, operations) {
@@ -23479,7 +23713,7 @@ class BaseDocumentDriveServer {
         };
       });
       if (document) {
-        this.cache.setDocument(driveId, documentId, document).catch(logger$1.error);
+        this.cache.setDocument(documentId, document).catch(logger$1.error);
       }
       const { scopes, branches } = operationsApplied.reduce((acc, operation) => {
         if (!acc.scopes.includes(operation.scope)) {
@@ -23642,7 +23876,7 @@ class BaseDocumentDriveServer {
       if (!document || !isDocumentDrive(document)) {
         throw error ?? new Error("Invalid Document Drive document");
       }
-      this.cache.setDocument("drives", driveId, document).catch(logger$1.error);
+      this.cache.setDrive(driveId, document).catch(logger$1.error);
       const lastOperation = operationsApplied.filter((op) => op.scope === "global").slice().pop();
       if (lastOperation) {
         const newOp = operationsApplied.find((appliedOp) => !operations.find((o) => o.id === appliedOp.id && o.index === appliedOp.index && o.skip === appliedOp.skip && o.hash === appliedOp.hash));
@@ -23651,7 +23885,6 @@ class BaseDocumentDriveServer {
         this.listenerManager.updateSynchronizationRevisions(driveId, [
           {
             syncId: "0",
-            driveId,
             documentId: "",
             scope: "global",
             branch: "main",
@@ -23790,18 +24023,15 @@ const DocumentDriveServer = ReadModeServer(BaseDocumentDriveServer);
 class MemoryStorage {
   constructor() {
     __publicField(this, "documents");
-    __publicField(this, "drives");
     __publicField(this, "driveManifests");
-    __publicField(this, "slugToDriveId", {});
     this.documents = {};
-    this.drives = {};
     this.driveManifests = {};
   }
   ////////////////////////////////
   // IDocumentStorage
   ////////////////////////////////
   exists(documentId) {
-    return Promise.resolve(!!this.documents[documentId]);
+    return Promise.resolve(!!this.documents[documentId] || !!this.documents[`drive/${documentId}`]);
   }
   create(documentId, document) {
     this.documents[documentId] = document;
@@ -23810,10 +24040,52 @@ class MemoryStorage {
   get(documentId) {
     const document = this.documents[documentId];
     if (!document) {
+      const drive = this.documents[`drive/${documentId}`];
+      if (drive) {
+        return Promise.resolve(drive);
+      }
       throw new Error(`Document with id ${documentId} not found`);
     }
     return Promise.resolve(document);
   }
+  async delete(documentId) {
+    const drives = await this.getDrives();
+    for (const driveId of drives) {
+      if (driveId === documentId)
+        continue;
+      await this.removeChild(driveId, documentId);
+    }
+    delete this.driveManifests[documentId];
+    if (this.documents[documentId]) {
+      delete this.documents[documentId];
+      return Promise.resolve(true);
+    }
+    return Promise.resolve(false);
+  }
+  async addChild(parentId, childId) {
+    if (parentId === childId) {
+      throw new Error("Cannot associate a document with itself");
+    }
+    const children = await this.getChildren(childId);
+    if (children.includes(parentId)) {
+      throw new Error("Cannot associate a document with its child");
+    }
+    const manifest = this.getManifest(parentId);
+    manifest.documentIds.add(childId);
+    this.updateDriveManifest(parentId, manifest);
+  }
+  async removeChild(parentId, childId) {
+    const manifest = this.getManifest(parentId);
+    if (manifest.documentIds.delete(childId)) {
+      this.updateDriveManifest(parentId, manifest);
+      return true;
+    }
+    return false;
+  }
+  async getChildren(parentId) {
+    const manifest = this.getManifest(parentId);
+    return [...manifest.documentIds];
+  }
   ////////////////////////////////
   // IDriveStorage
   ////////////////////////////////
@@ -23821,27 +24093,19 @@ class MemoryStorage {
     return this.exists(id);
   }
   getDocuments(drive) {
-    const manifest = this.getDriveManifest(drive);
+    const manifest = this.getManifest(drive);
     return Promise.resolve([...manifest.documentIds]);
   }
   getDocument(driveId, id) {
     return this.get(id);
   }
-  async saveDocument(drive, id, document) {
-    this.documents[id] = document;
-    const manifest = this.getDriveManifest(drive);
-    manifest.documentIds.add(id);
-    this.updateDriveManifest(drive, manifest);
-  }
   async clearStorage() {
     this.documents = {};
-    this.drives = {};
     this.driveManifests = {};
-    this.slugToDriveId = {};
   }
   async createDocument(drive, id, document) {
     await this.create(id, document);
-    const manifest = this.getDriveManifest(drive);
+    const manifest = this.getManifest(drive);
     manifest.documentIds.add(id);
     this.updateDriveManifest(drive, manifest);
   }
@@ -23858,59 +24122,60 @@ class MemoryStorage {
     };
   }
   async deleteDocument(drive, id) {
-    const drives = await this.getDrives();
-    for (const driveId of drives) {
-      const manifest = this.getDriveManifest(driveId);
-      if (manifest.documentIds.has(id)) {
-        manifest.documentIds.delete(id);
-        this.updateDriveManifest(driveId, manifest);
-      }
-    }
-    delete this.documents[id];
+    this.delete(id);
   }
   async getDrives() {
-    return Object.keys(this.drives);
+    return Object.keys(this.driveManifests);
   }
   async getDrive(id) {
-    const drive = this.drives[id];
+    const drive = this.documents[`drive/${id}`];
     if (!drive) {
       throw new DriveNotFoundError(id);
     }
     return drive;
   }
   async getDriveBySlug(slug) {
-    const driveId = this.slugToDriveId[slug];
-    if (!driveId) {
-      throw new Error(`Drive with slug ${slug} not found`);
+    for (const driveId of Object.keys(this.driveManifests)) {
+      const drive = this.documents[`drive/${driveId}`];
+      if (drive.initialState.state.global.slug === slug) {
+        return drive;
+      }
     }
-    return this.getDrive(driveId);
+    throw new Error(`Drive with slug ${slug} not found`);
   }
   async createDrive(id, drive) {
-    this.drives[id] = drive;
-    this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
-    const { slug } = drive.initialState.state.global;
+    const slug = drive.initialState.state.global.slug;
     if (slug) {
-      this.slugToDriveId[slug] = id;
+      let existingDrive;
+      try {
+        existingDrive = await this.getDriveBySlug(slug);
+      } catch {
+      }
+      if (existingDrive) {
+        throw new Error(`Drive with slug ${slug} already exists`);
+      }
     }
+    await this.create(`drive/${id}`, drive);
+    this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
   }
   async addDriveOperations(id, operations, header) {
     const drive = await this.getDrive(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
-    this.drives[id] = {
+    this.documents[`drive/${id}`] = {
       ...drive,
       ...header,
       operations: mergedOperations
     };
   }
   async deleteDrive(id) {
-    const manifest = this.getDriveManifest(id);
+    const manifest = this.getManifest(id);
     const drives = await this.getDrives();
     await Promise.all([...manifest.documentIds].map((docId) => {
       for (const driveId of drives) {
         if (driveId === id) {
           continue;
         }
-        const manifest2 = this.getDriveManifest(driveId);
+        const manifest2 = this.getManifest(driveId);
         if (manifest2.documentIds.has(docId)) {
           return;
         }
@@ -23918,24 +24183,18 @@ class MemoryStorage {
       delete this.documents[docId];
     }));
     delete this.driveManifests[id];
-    delete this.drives[id];
-    for (const [slug, driveId] of Object.entries(this.slugToDriveId)) {
-      if (driveId === id) {
-        delete this.slugToDriveId[slug];
-      }
-    }
+    delete this.documents[id];
   }
   async getSynchronizationUnitsRevision(units) {
     const results = await Promise.allSettled(units.map(async (unit) => {
       try {
-        const document = await (unit.documentId ? this.getDocument(unit.driveId, unit.documentId) : this.getDrive(unit.driveId));
+        const document = await this.get(unit.documentId);
         if (!document) {
           return void 0;
         }
         const operation = document.operations[unit.scope].at(-1);
         if (operation) {
           return {
-            driveId: unit.driveId,
             documentId: unit.documentId,
             scope: unit.scope,
             branch: unit.branch,
@@ -23957,7 +24216,7 @@ class MemoryStorage {
   ////////////////////////////////
   // Private
   ////////////////////////////////
-  getDriveManifest(driveId) {
+  getManifest(driveId) {
     if (!this.driveManifests[driveId]) {
       this.driveManifests[driveId] = { documentIds: /* @__PURE__ */ new Set() };
     }
@@ -24138,7 +24397,7 @@ const _ListenerManager = class _ListenerManager {
             this.logger.verbose(`Abandoning push for sync unit ${syncUnit.syncId}: already up-to-date (${unitState.listenerRev} >= ${syncUnit.revision})`);
             return;
           } else {
-            this.logger.verbose(`Listener out-of-date for sync unit (${syncUnit.driveId}, ${syncUnit.scope}, ${syncUnit.documentId}): ${unitState == null ? void 0 : unitState.listenerRev} < ${syncUnit.revision}`);
+            this.logger.verbose(`Listener out-of-date for sync unit (${syncUnit.scope}, ${syncUnit.documentId}): ${unitState == null ? void 0 : unitState.listenerRev} < ${syncUnit.revision}`);
           }
           const opData = [];
           try {
@@ -24296,11 +24555,11 @@ const _ListenerManager = class _ListenerManager {
       if (entry && entry.listenerRev >= syncUnit.revision) {
         return;
       }
-      const { documentId, driveId: driveId2, scope, branch } = syncUnit;
+      const { documentId, scope, branch } = syncUnit;
       try {
         const operations = await this.syncManager.getOperationData(
           // DEAL WITH INVALID SYNC ID ERROR
-          driveId2,
+          driveId,
           syncUnit.syncId,
           {
             since: options == null ? void 0 : options.since,
@@ -24313,7 +24572,7 @@ const _ListenerManager = class _ListenerManager {
         }
         operationsCount += operations.length;
         strands.push({
-          driveId: driveId2,
+          driveId,
           documentId,
           scope,
           branch,
@@ -24356,187 +24615,6 @@ const _ListenerManager = class _ListenerManager {
 };
 __publicField(_ListenerManager, "LISTENER_UPDATE_DELAY", 250);
 let ListenerManager = _ListenerManager;
-var defaults;
-var hasRequiredDefaults;
-function requireDefaults() {
-  if (hasRequiredDefaults) return defaults;
-  hasRequiredDefaults = 1;
-  defaults = {
-    space: "",
-    cycles: false,
-    replacer: (k, v) => v,
-    stringify: JSON.stringify
-  };
-  return defaults;
-}
-var util;
-var hasRequiredUtil;
-function requireUtil() {
-  if (hasRequiredUtil) return util;
-  hasRequiredUtil = 1;
-  util = {
-    isArray: Array.isArray,
-    assign: Object.assign,
-    isObject: (v) => typeof v === "object",
-    isFunction: (v) => typeof v === "function",
-    isBoolean: (v) => typeof v === "boolean",
-    isRegex: (v) => v instanceof RegExp,
-    keys: Object.keys
-  };
-  return util;
-}
-var lib;
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib;
-  hasRequiredLib = 1;
-  const DEFAULTS = requireDefaults();
-  const isFunction = requireUtil().isFunction;
-  const isBoolean = requireUtil().isBoolean;
-  const isObject = requireUtil().isObject;
-  const isArray = requireUtil().isArray;
-  const isRegex = requireUtil().isRegex;
-  const assign = requireUtil().assign;
-  const keys = requireUtil().keys;
-  function serialize(obj) {
-    if (obj === null || obj === void 0) return obj;
-    if (isRegex(obj)) return obj.toString();
-    return obj.toJSON ? obj.toJSON() : obj;
-  }
-  function stringifyDeterministic(obj, opts) {
-    opts = opts || assign({}, DEFAULTS);
-    if (isFunction(opts)) opts = { compare: opts };
-    const space = opts.space || DEFAULTS.space;
-    const cycles = isBoolean(opts.cycles) ? opts.cycles : DEFAULTS.cycles;
-    const replacer = opts.replacer || DEFAULTS.replacer;
-    const stringify2 = opts.stringify || DEFAULTS.stringify;
-    const compare = opts.compare && /* @__PURE__ */ function(f) {
-      return function(node) {
-        return function(a, b) {
-          const aobj = { key: a, value: node[a] };
-          const bobj = { key: b, value: node[b] };
-          return f(aobj, bobj);
-        };
-      };
-    }(opts.compare);
-    if (!cycles) stringify2(obj);
-    const seen = [];
-    return function _deterministic(parent, key, node, level) {
-      const indent2 = space ? "\n" + new Array(level + 1).join(space) : "";
-      const colonSeparator = space ? ": " : ":";
-      node = serialize(node);
-      node = replacer.call(parent, key, node);
-      if (node === void 0) return;
-      if (!isObject(node) || node === null) return stringify2(node);
-      if (isArray(node)) {
-        const out = [];
-        for (let i = 0; i < node.length; i++) {
-          const item = _deterministic(node, i, node[i], level + 1) || stringify2(null);
-          out.push(indent2 + space + item);
-        }
-        return "[" + out.join(",") + indent2 + "]";
-      } else {
-        if (cycles) {
-          if (seen.indexOf(node) !== -1) {
-            return stringify2("[Circular]");
-          } else {
-            seen.push(node);
-          }
-        }
-        const nodeKeys = keys(node).sort(compare && compare(node));
-        const out = [];
-        for (let i = 0; i < nodeKeys.length; i++) {
-          const key2 = nodeKeys[i];
-          const value = _deterministic(node, key2, node[key2], level + 1);
-          if (!value) continue;
-          const keyValue = stringify2(key2) + colonSeparator + value;
-          out.push(indent2 + space + keyValue);
-        }
-        seen.splice(seen.indexOf(node), 1);
-        return "{" + out.join(",") + indent2 + "}";
-      }
-    }({ "": obj }, "", obj, 0);
-  }
-  lib = stringifyDeterministic;
-  return lib;
-}
-var libExports = requireLib();
-const stringify = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
-const SYNC_OPS_BATCH_LIMIT = 10;
-class SwitchboardPushTransmitter {
-  constructor(targetURL) {
-    __publicField(this, "targetURL");
-    __publicField(this, "logger", childLogger([
-      "SwitchboardPushTransmitter",
-      Math.floor(Math.random() * 999).toString()
-    ]));
-    this.targetURL = targetURL;
-  }
-  async transmit(strands, source) {
-    var _a2;
-    if (source.type === "trigger" && ((_a2 = source.trigger.data) == null ? void 0 : _a2.url) === this.targetURL) {
-      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
-      return strands.map((strand) => {
-        var _a3;
-        return {
-          driveId: strand.driveId,
-          documentId: strand.documentId,
-          scope: strand.scope,
-          branch: strand.branch,
-          status: "SUCCESS",
-          revision: ((_a3 = strand.operations.at(-1)) == null ? void 0 : _a3.index) ?? -1
-        };
-      });
-    }
-    const culledStrands = [];
-    let opsCounter = 0;
-    for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
-      const currentStrand = strands.at(s);
-      if (!currentStrand) {
-        break;
-      }
-      const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
-      culledStrands.push({
-        ...currentStrand,
-        operations: currentStrand.operations.slice(0, newOps)
-      });
-      opsCounter += newOps;
-    }
-    this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
-    this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
-    try {
-      const { pushUpdates } = await requestGraphql(this.targetURL, gql`
-          mutation pushUpdates($strands: [InputStrandUpdate!]) {
-            pushUpdates(strands: $strands) {
-              driveId
-              documentId
-              scope
-              branch
-              status
-              revision
-              error
-            }
-          }
-        `, {
-        strands: culledStrands.map((strand) => ({
-          ...strand,
-          operations: strand.operations.map((op) => ({
-            ...op,
-            input: stringify(op.input)
-          }))
-        }))
-      });
-      if (!pushUpdates) {
-        throw new Error("Couldn't update listener revision");
-      }
-      return pushUpdates;
-    } catch (e) {
-      this.logger.error(e);
-      throw e;
-    }
-    return [];
-  }
-}
 class TransmitterFactory {
   constructor(listenerManager) {
     __publicField(this, "listenerManager");
@@ -24580,26 +24658,21 @@ class SynchronizationManager {
   async getSynchronizationUnitsRevision(driveId, syncUnitsQuery) {
     const drive = await this.getDrive(driveId);
     const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
-    const synchronizationUnits = syncUnitsQuery.map((s) => ({
-      ...s,
-      lastUpdated: drive.created,
-      revision: -1
-    }));
-    for (const revision of revisions) {
-      const syncUnit = synchronizationUnits.find((s) => revision.driveId === s.driveId && revision.documentId === s.documentId && revision.scope === s.scope && revision.branch === s.branch);
-      if (syncUnit) {
-        syncUnit.revision = revision.revision;
-        syncUnit.lastUpdated = revision.lastUpdated;
-      }
-    }
-    return synchronizationUnits;
+    return syncUnitsQuery.map((s) => {
+      var _a2;
+      return {
+        ...s,
+        lastUpdated: drive.created,
+        revision: ((_a2 = revisions.find((r) => r.documentId === s.documentId && r.scope === s.scope && r.branch === s.branch)) == null ? void 0 : _a2.revision) ?? -1
+      };
+    });
   }
   async getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType2) {
     const drive = await this.getDrive(driveId);
     const nodes = drive.state.global.nodes.filter((node) => isFileNode(node) && (!(documentId == null ? void 0 : documentId.length) || documentId.includes(node.id) || documentId.includes("*")) && (!(documentType2 == null ? void 0 : documentType2.length) || documentType2.includes(node.documentType) || documentType2.includes("*")));
     if ((!documentId || documentId.includes("*") || documentId.includes("")) && (!(documentType2 == null ? void 0 : documentType2.length) || documentType2.includes("powerhouse/document-drive") || documentType2.includes("*"))) {
       nodes.unshift({
-        id: "",
+        id: drive.state.global.id,
         documentType: "powerhouse/document-drive",
         synchronizationUnits: [
           {
@@ -24641,7 +24714,6 @@ class SynchronizationManager {
       syncId,
       scope: syncUnit.scope,
       branch: syncUnit.branch,
-      driveId,
       documentId: node.id,
       documentType: node.documentType
     };
@@ -24659,7 +24731,6 @@ class SynchronizationManager {
       syncId,
       scope,
       branch,
-      driveId,
       documentId,
       documentType: documentType2,
       lastUpdated: lastOperation.timestamp ?? document.lastModified,
@@ -24688,7 +24759,7 @@ class SynchronizationManager {
   }
   async getDrive(driveId) {
     try {
-      const cachedDocument = await this.cache.getDocument("drives", driveId);
+      const cachedDocument = await this.cache.getDrive(driveId);
       if (cachedDocument && isDocumentDrive(cachedDocument)) {
         return cachedDocument;
       }
@@ -24704,7 +24775,7 @@ class SynchronizationManager {
   }
   async getDocument(driveId, documentId) {
     try {
-      const cachedDocument = await this.cache.getDocument(driveId, documentId);
+      const cachedDocument = await this.cache.getDocument(documentId);
       if (cachedDocument) {
         return cachedDocument;
       }
@@ -25545,7 +25616,7 @@ const nodeOptionsMap = {
 };
 const name = "@powerhousedao/connect";
 const productName = "Powerhouse-Connect";
-const version$1 = "1.0.8";
+const version$1 = "1.0.9-dev.0";
 const description = "Powerhouse Connect";
 const main = "./dist/index.html";
 const type = "module";
@@ -28338,6 +28409,10 @@ const _BrowserStorage = class _BrowserStorage {
       name: namespace ? `${namespace}:${_BrowserStorage.DBName}` : _BrowserStorage.DBName
     }));
   }
+  async clear() {
+    const db = await this.db;
+    await db.clear();
+  }
   ////////////////////////////////
   // IDocumentStorage
   ////////////////////////////////
@@ -28358,13 +28433,57 @@ const _BrowserStorage = class _BrowserStorage {
     }
     return document;
   }
+  async delete(documentId) {
+    const db = await this.db;
+    const document = await db.getItem(this.buildDocumentKey(documentId));
+    if (!document) {
+      return false;
+    }
+    const drives = await this.getDrives();
+    for (const driveId of drives) {
+      if (driveId === documentId)
+        continue;
+      await this.removeChild(driveId, documentId);
+    }
+    await db.removeItem(this.buildManifestKey(documentId));
+    await db.removeItem(this.buildDocumentKey(documentId));
+    return true;
+  }
+  async removeChild(parentId, childId) {
+    const manifest = await this.getManifest(parentId);
+    const docIndex = manifest.documentIds.indexOf(childId);
+    if (docIndex !== -1) {
+      manifest.documentIds.splice(docIndex, 1);
+      await this.updateDriveManifest(parentId, manifest);
+      return true;
+    }
+    return false;
+  }
+  async addChild(parentId, childId) {
+    if (parentId === childId) {
+      throw new Error("Cannot associate a document with itself");
+    }
+    const children = await this.getChildren(childId);
+    if (children.includes(parentId)) {
+      throw new Error("Cannot associate a document with its child");
+    }
+    const manifest = await this.getManifest(parentId);
+    if (!manifest.documentIds.includes(childId)) {
+      manifest.documentIds.push(childId);
+      await this.updateDriveManifest(parentId, manifest);
+    }
+  }
+  async getChildren(parentId) {
+    const manifest = await this.getManifest(parentId);
+    return manifest.documentIds;
+  }
   ////////////////////////////////
   // IDriveStorage
   ////////////////////////////////
   checkDocumentExists(drive, documentId) {
     return this.exists(documentId);
   }
-  async getDriveManifest(driveId) {
+  async getManifest(driveId) {
     const db = await this.db;
     const manifest = await db.getItem(this.buildManifestKey(driveId));
     return manifest || { documentIds: [] };
@@ -28374,7 +28493,7 @@ const _BrowserStorage = class _BrowserStorage {
     await db.setItem(this.buildManifestKey(driveId), manifest);
   }
   async getDocuments(drive) {
-    const manifest = await this.getDriveManifest(drive);
+    const manifest = await this.getManifest(drive);
     return manifest.documentIds;
   }
   async getDocument(driveId, id) {
@@ -28382,7 +28501,7 @@ const _BrowserStorage = class _BrowserStorage {
   }
   async createDocument(drive, id, document) {
     await this.create(id, document);
-    const manifest = await this.getDriveManifest(drive);
+    const manifest = await this.getManifest(drive);
     if (!manifest.documentIds.includes(id)) {
       manifest.documentIds.push(id);
       await this.updateDriveManifest(drive, manifest);
@@ -28390,7 +28509,7 @@ const _BrowserStorage = class _BrowserStorage {
   }
   async deleteDocument(drive, id) {
     await (await this.db).removeItem(this.buildDocumentKey(id));
-    const manifest = await this.getDriveManifest(drive);
+    const manifest = await this.getManifest(drive);
     const docIndex = manifest.documentIds.indexOf(id);
     if (docIndex !== -1) {
       manifest.documentIds.splice(docIndex, 1);
@@ -28416,12 +28535,13 @@ const _BrowserStorage = class _BrowserStorage {
   async getDrives() {
     const db = await this.db;
     const keys = await db.keys();
-    return keys.filter((key) => key.startsWith(_BrowserStorage.DRIVES_KEY)).map((key) => key.slice(_BrowserStorage.DRIVES_KEY.length + _BrowserStorage.SEP.length));
+    return keys.filter((key) => key.startsWith(_BrowserStorage.MANIFEST_KEY)).map((key) => key.slice(_BrowserStorage.MANIFEST_KEY.length + _BrowserStorage.SEP.length));
   }
   async getDrive(id) {
-    const db = await this.db;
-    const drive = await db.getItem(this.buildDriveKey(id));
-    if (!drive) {
+    let drive;
+    try {
+      drive = await this.get(id);
+    } catch {
       throw new DriveNotFoundError(id);
     }
     return drive;
@@ -28437,8 +28557,18 @@ const _BrowserStorage = class _BrowserStorage {
     throw new Error(`Drive with slug ${slug} not found`);
   }
   async createDrive(id, drive) {
-    const db = await this.db;
-    await db.setItem(this.buildDriveKey(id), drive);
+    const slug = drive.initialState.state.global.slug;
+    if (slug) {
+      let existingDrive;
+      try {
+        existingDrive = await this.getDriveBySlug(slug);
+      } catch {
+      }
+      if (existingDrive) {
+        throw new Error(`Drive with slug ${slug} already exists`);
+      }
+    }
+    await this.create(id, drive);
     await this.updateDriveManifest(id, { documentIds: [] });
   }
   async deleteDrive(id) {
@@ -28446,13 +28576,13 @@ const _BrowserStorage = class _BrowserStorage {
     await Promise.all(documents.map((doc) => this.deleteDocument(id, doc)));
     const db = await this.db;
     await db.removeItem(this.buildManifestKey(id));
-    return db.removeItem(this.buildDriveKey(id));
+    return db.removeItem(this.buildDocumentKey(id));
   }
   async addDriveOperations(id, operations, header) {
     const drive = await this.getDrive(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
     const db = await this.db;
-    await db.setItem(this.buildDriveKey(id), {
+    await db.setItem(this.buildDocumentKey(id), {
       ...drive,
       ...header,
       operations: mergedOperations
@@ -28461,14 +28591,13 @@ const _BrowserStorage = class _BrowserStorage {
   async getSynchronizationUnitsRevision(units) {
     const results = await Promise.allSettled(units.map(async (unit) => {
       try {
-        const document = await (unit.documentId ? this.getDocument(unit.driveId, unit.documentId) : this.getDrive(unit.driveId));
+        const document = await this.get(unit.documentId);
         if (!document) {
           return void 0;
         }
         const operation = document.operations[unit.scope].at(-1);
         if (operation) {
           return {
-            driveId: unit.driveId,
             documentId: unit.documentId,
             scope: unit.scope,
             branch: unit.branch,
@@ -28500,7 +28629,7 @@ const _BrowserStorage = class _BrowserStorage {
     const drive = await this.getDrive(driveId);
     const migratedDrive = migrateDocumentOperationSignatures(drive);
     if (migratedDrive !== drive) {
-      return (await this.db).setItem(this.buildDriveKey(driveId), migratedDrive);
+      return (await this.db).setItem(this.buildDocumentKey(driveId), migratedDrive);
     }
   }
   async migrateDocument(drive, id) {
@@ -28513,9 +28642,6 @@ const _BrowserStorage = class _BrowserStorage {
   ////////////////////////////////
   // Private methods
   ////////////////////////////////
-  buildDriveKey(driveId) {
-    return `${_BrowserStorage.DRIVES_KEY}${_BrowserStorage.SEP}${driveId}`;
-  }
   buildDocumentKey(documentId) {
     return `${_BrowserStorage.DOCUMENT_KEY}${_BrowserStorage.SEP}${documentId}`;
   }
@@ -28525,7 +28651,6 @@ const _BrowserStorage = class _BrowserStorage {
 };
 __publicField(_BrowserStorage, "DBName", "DOCUMENT_DRIVES");
 __publicField(_BrowserStorage, "SEP", ":");
-__publicField(_BrowserStorage, "DRIVES_KEY", "DRIVES");
 __publicField(_BrowserStorage, "DOCUMENT_KEY", "DOCUMENT");
 __publicField(_BrowserStorage, "MANIFEST_KEY", "MANIFEST");
 let BrowserStorage = _BrowserStorage;
@@ -31131,7 +31256,7 @@ if (window.__VITE_ENVS.MODE === "development") {
 } else {
   serviceWorkerManager.registerServiceWorker(false);
 }
-const App = lazy(() => __vitePreload(() => import("./app-Bw1Ba-jV.js").then((n) => n.aN), true ? __vite__mapDeps([0,1,2]) : void 0));
+const App = lazy(() => __vitePreload(() => import("./app-Uu65do7x.js").then((n) => n.aN), true ? __vite__mapDeps([0,1,2]) : void 0));
 const AppLoader = /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(App, {}) });
 const appLoader = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,