@powerhousedao/connect 1.0.8 → 1.0.10-dev.0

package/dist/assets/{app-loader-KTD3Q6e9.js → app-loader-C7A2YjX4.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-CsiwsM42.js","assets/main.BmcV9296.js","assets/app-BIIVKAZr.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.BmcV9296.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 = [
@@ -22473,7 +22517,14 @@ class DefaultDrivesManager {
 }
 const PULL_DRIVE_INTERVAL = 1500;
 const MAX_REVISIONS_PER_ACK = 100;
-const _PullResponderTransmitter = class _PullResponderTransmitter {
+let _staticLogger;
+const staticLogger = () => {
+  if (!_staticLogger) {
+    _staticLogger = childLogger(["PullResponderTransmitter", "static"]);
+  }
+  return _staticLogger;
+};
+class PullResponderTransmitter {
   constructor(listener, manager) {
     __publicField(this, "logger", childLogger([
       "PullResponderTransmitter",
@@ -22486,8 +22537,18 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
     this.logger.verbose(`constructor(listener: ${listener.listenerId})`);
   }
   getStrands(options) {
-    this.logger.verbose(`getStrands(drive: ${this.listener.driveId}, listener: ${this.listener.listenerId})`);
-    return this.manager.getStrands(this.listener.driveId, this.listener.listenerId, options);
+    this.logger.verbose(`[SYNC DEBUG] PullResponderTransmitter.getStrands called for drive: ${this.listener.driveId}, listener: ${this.listener.listenerId}, options: ${JSON.stringify(options || {})}`);
+    return this.manager.getStrands(this.listener.driveId, this.listener.listenerId, options).then((strands) => {
+      this.logger.verbose(`[SYNC DEBUG] PullResponderTransmitter.getStrands returning ${strands.length} strands for drive: ${this.listener.driveId}, listener: ${this.listener.listenerId}`);
+      if (strands.length === 0) {
+        this.logger.verbose(`[SYNC DEBUG] No strands returned for drive: ${this.listener.driveId}, listener: ${this.listener.listenerId}`);
+      } else {
+        for (const strand of strands) {
+          this.logger.verbose(`[SYNC DEBUG] Strand for drive: ${strand.driveId}, document: ${strand.documentId}, scope: ${strand.scope}, operations: ${strand.operations.length}`);
+        }
+      }
+      return strands;
+    });
   }
   disconnect() {
     return Promise.resolve();
@@ -22497,7 +22558,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;
@@ -22507,16 +22568,22 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
     }
     return success;
   }
-  static async registerPullResponder(driveId, url, filter) {
+  static async registerPullResponder(driveId, url, filter, listenerId) {
     var _a2;
-    _PullResponderTransmitter.staticLogger.verbose(`registerPullResponder(url: ${url})`, filter);
+    staticLogger().verbose(`registerPullResponder(url: ${url})`, filter);
     const result = await requestGraphql(url, gql`
-        mutation registerPullResponderListener($filter: InputListenerFilter!) {
-          registerPullResponderListener(filter: $filter) {
+        mutation registerPullResponderListener(
+          $filter: InputListenerFilter!
+          $listenerId: String
+        ) {
+          registerPullResponderListener(
+            filter: $filter
+            listenerId: $listenerId
+          ) {
             listenerId
           }
         }
-      `, { filter });
+      `, { filter, listenerId });
     const error = (_a2 = result.errors) == null ? void 0 : _a2.at(0);
     if (error) {
       throw error;
@@ -22528,7 +22595,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
   }
   static async pullStrands(driveId, url, listenerId, options) {
     var _a2;
-    this.staticLogger.verbose(`pullStrands(url: ${url}, listener: ${listenerId})`);
+    staticLogger().verbose(`[SYNC DEBUG] PullResponderTransmitter.pullStrands called for drive: ${driveId}, url: ${url}, listener: ${listenerId}, options: ${JSON.stringify(options || {})}`);
     const result = await requestGraphql(url, gql`
         query strands($listenerId: ID!) {
           system {
@@ -22568,27 +22635,34 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       `, { listenerId });
     const error = (_a2 = result.errors) == null ? void 0 : _a2.at(0);
     if (error) {
+      staticLogger().verbose(`[SYNC DEBUG] Error pulling strands for drive: ${driveId}, listener: ${listenerId}, error: ${JSON.stringify(error)}`);
       throw error;
     }
     if (!result.system) {
+      staticLogger().verbose(`[SYNC DEBUG] No system data returned when pulling strands for drive: ${driveId}, listener: ${listenerId}`);
       return [];
     }
-    return result.system.sync.strands.map((s) => ({
+    const strands = result.system.sync.strands.map((s) => ({
       ...s,
       operations: s.operations.map((o) => ({
         ...o,
         input: JSON.parse(o.input)
       }))
     }));
+    staticLogger().verbose(`[SYNC DEBUG] PullResponderTransmitter.pullStrands returning ${strands.length} strands for drive: ${driveId}, listener: ${listenerId}`);
+    if (strands.length > 0) {
+      staticLogger().verbose(`[SYNC DEBUG] Strands being returned: ${strands.map((s) => `${s.documentId}:${s.scope}`).join(", ")}`);
+    }
+    return strands;
   }
   static async acknowledgeStrands(url, listenerId, revisions) {
-    this.staticLogger.verbose(`acknowledgeStrands(url: ${url}, listener: ${listenerId})`, revisions);
+    staticLogger().verbose(`acknowledgeStrands(url: ${url}, listener: ${listenerId})`, revisions);
     const chunks = [];
     for (let i = 0; i < revisions.length; i += MAX_REVISIONS_PER_ACK) {
       chunks.push(revisions.slice(i, i + MAX_REVISIONS_PER_ACK));
     }
     if (chunks.length > 1) {
-      this.staticLogger.verbose(`Breaking strand acknowledgement into ${chunks.length} chunks...`);
+      staticLogger().verbose(`Breaking strand acknowledgement into ${chunks.length} chunks...`);
     }
     const results = await Promise.allSettled(chunks.map(async (chunk) => {
       var _a2;
@@ -22613,75 +22687,125 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       throw new Error("Error acknowledging strands");
     }
   }
+  /**
+   * This function will only throw if `onError` throws an error (or there is
+   * an unintentionally unhandled error in the pull loop).
+   *
+   * All other errors are caught, logged, and passed to `onError`.
+   *
+   * Because of this, `onError` _may be called multiple times_.
+   */
   static async executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
-    var _a2;
-    this.staticLogger.verbose(`executePull(driveId: ${driveId}), trigger:`, trigger);
+    var _a2, _b;
+    staticLogger().verbose(`executePull(driveId: ${driveId}), trigger:`, trigger);
+    staticLogger().info(`[SYNC DEBUG] PullResponderTransmitter.executePull starting for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    const { url } = trigger.data;
+    let strands;
+    let error;
+    const listenerId = trigger.data.listenerId;
     try {
-      const { url, listenerId } = trigger.data;
-      const strands = await _PullResponderTransmitter.pullStrands(driveId, url, listenerId);
-      this.staticLogger.verbose("Pulled strands...");
-      if (!strands.length) {
-        onRevisions == null ? void 0 : onRevisions([]);
-        this.staticLogger.verbose("No new strands, skipping...");
-        return;
-      }
-      const listenerRevisions = [];
-      for (const strand of strands) {
-        const operations = strand.operations.map((op) => ({
-          ...op,
-          scope: strand.scope,
-          branch: strand.branch
-        }));
-        this.staticLogger.verbose("Processing strand...");
-        let error = void 0;
-        try {
-          const result = await onStrandUpdate(strand, {
-            type: "trigger",
-            trigger
-          });
-          if (result.error) {
-            throw result.error;
+      strands = await PullResponderTransmitter.pullStrands(driveId, url, listenerId);
+    } catch (e) {
+      error = e;
+      const graphqlError = error;
+      const errors = ((_a2 = graphqlError.response) == null ? void 0 : _a2.errors) ?? [];
+      for (const err of errors) {
+        if (err.message === "Listener not found") {
+          staticLogger().verbose(`[SYNC DEBUG] Auto-registering pull responder for drive: ${driveId}`);
+          await PullResponderTransmitter.registerPullResponder(trigger.driveId, url, trigger.filter, listenerId);
+          try {
+            strands = await PullResponderTransmitter.pullStrands(driveId, url, listenerId);
+            staticLogger().verbose(`Successfully auto-registered and pulled strands for drive: ${driveId}, listenerId: ${listenerId}`);
+          } catch (error2) {
+            staticLogger().error(`Could not resolve 'Listener not found' error by registering a new pull responder for drive: ${driveId}, listenerId: ${listenerId}: ${error2}`);
+            onError(error2);
+            return;
           }
-        } catch (e) {
-          error = e;
-          onError(error);
+          break;
         }
-        listenerRevisions.push({
-          branch: strand.branch,
-          documentId: strand.documentId || "",
-          driveId: strand.driveId,
-          revision: ((_a2 = operations.pop()) == null ? void 0 : _a2.index) ?? -1,
-          scope: strand.scope,
-          status: error ? error instanceof OperationError ? error.status : "ERROR" : "SUCCESS",
-          error
-        });
       }
-      this.staticLogger.verbose("Processed strands...");
-      onRevisions == null ? void 0 : onRevisions(listenerRevisions);
-      this.staticLogger.verbose("Acknowledging strands...");
-      let success = false;
+    }
+    if (!strands) {
+      staticLogger().error(`Error pulling strands for drive, and could not auto-register: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
+      onError(error);
+      return;
+    }
+    if (!strands.length) {
+      staticLogger().verbose(`[SYNC DEBUG] No strands returned in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
       try {
-        await _PullResponderTransmitter.acknowledgeStrands(url, listenerId, listenerRevisions.map((revision) => {
-          const { error, ...rest } = revision;
-          return rest;
-        }));
-        success = true;
-      } catch (error) {
-        this.staticLogger.error("ACK error", error);
-      }
-      if (success) {
-        this.staticLogger.verbose("Acknowledged strands successfully.");
-      } else {
-        this.staticLogger.error("Failed to acknowledge strands");
+        onRevisions == null ? void 0 : onRevisions([]);
+      } catch (error2) {
+        staticLogger().error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+        onError(error2);
       }
+      return;
+    }
+    staticLogger().verbose(`[SYNC DEBUG] Processing ${strands.length} strands in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    const listenerRevisions = [];
+    for (const strand of strands) {
+      const operations = strand.operations.map((op) => ({
+        ...op,
+        scope: strand.scope,
+        branch: strand.branch
+      }));
+      staticLogger().verbose(`[SYNC DEBUG] Processing strand for drive: ${strand.driveId}, document: ${strand.documentId}, scope: ${strand.scope}, with ${operations.length} operations`);
+      let error2 = void 0;
+      try {
+        const result = await onStrandUpdate(strand, {
+          type: "trigger",
+          trigger
+        });
+        if (result.error) {
+          throw result.error;
+        }
+      } catch (e) {
+        staticLogger().error(`Error processing strand for drive: ${strand.driveId}, document: ${strand.documentId}, scope: ${strand.scope}, with ${operations.length} operations: ${e}`);
+        error2 = e;
+        onError(error2);
+      }
+      listenerRevisions.push({
+        branch: strand.branch,
+        documentId: strand.documentId || "",
+        driveId: strand.driveId,
+        revision: ((_b = operations.pop()) == null ? void 0 : _b.index) ?? -1,
+        scope: strand.scope,
+        status: error2 ? error2 instanceof OperationError ? error2.status : "ERROR" : "SUCCESS",
+        error: error2
+      });
+    }
+    staticLogger().verbose("Processed strands...");
+    try {
+      onRevisions == null ? void 0 : onRevisions(listenerRevisions);
+    } catch (error2) {
+      staticLogger().error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      onError(error2);
+    }
+    staticLogger().verbose(`[SYNC DEBUG] Acknowledging ${listenerRevisions.length} strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    let success = false;
+    try {
+      await PullResponderTransmitter.acknowledgeStrands(url, trigger.data.listenerId, listenerRevisions.map((revision) => {
+        const { error: error2, ...rest } = revision;
+        return rest;
+      }));
+      success = true;
+    } catch (error2) {
+      staticLogger().error(`Error acknowledging strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      onError(error2);
+    }
+    if (success) {
+      staticLogger().verbose(`[SYNC DEBUG] Successfully acknowledged strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    } else {
+      staticLogger().error("Failed to acknowledge strands");
+    }
+    try {
       onAcknowledge == null ? void 0 : onAcknowledge(success);
-    } catch (error) {
-      this.staticLogger.error("Pull error", error);
-      onError(error);
+    } catch (error2) {
+      staticLogger().error(`Error calling onAcknowledge for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      onError(error2);
     }
   }
   static setupPull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
-    this.staticLogger.verbose(`setupPull(drive: ${driveId}), trigger:`, trigger);
+    staticLogger().verbose(`[SYNC DEBUG] PullResponderTransmitter.setupPull initiated for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
     const { interval } = trigger.data;
     let loopInterval = PULL_DRIVE_INTERVAL;
     if (interval) {
@@ -22693,20 +22817,25 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       } catch {
       }
     }
+    staticLogger().verbose(`[SYNC DEBUG] Pull interval set to ${loopInterval}ms for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
     let isCancelled = false;
     let timeout;
     const executeLoop = async () => {
       while (!isCancelled) {
-        this.staticLogger.verbose("Execute loop...");
+        staticLogger().verbose(`[SYNC DEBUG] Starting pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
         await this.executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge);
+        staticLogger().verbose(`[SYNC DEBUG] Completed pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}, waiting ${loopInterval}ms for next cycle`);
         await new Promise((resolve) => {
-          this.staticLogger.verbose(`Scheduling next pull in ${loopInterval} ms`);
+          staticLogger().verbose(`Scheduling next pull in ${loopInterval} ms`);
           timeout = setTimeout(resolve, loopInterval);
         });
       }
     };
-    executeLoop().catch(this.staticLogger.error);
+    executeLoop().catch((error) => {
+      staticLogger().error(`Error in executeLoop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
+    });
     return () => {
+      staticLogger().verbose(`[SYNC DEBUG] Cancelling pull loop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
       isCancelled = true;
       if (timeout !== void 0) {
         clearTimeout(timeout);
@@ -22714,17 +22843,20 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
     };
   }
   static async createPullResponderTrigger(driveId, url, options) {
-    this.staticLogger.verbose(`createPullResponderTrigger(drive: ${driveId}, url: ${url})`);
+    staticLogger().verbose(`createPullResponderTrigger(drive: ${driveId}, url: ${url})`);
     const { pullFilter, pullInterval } = options;
-    const listenerId = await _PullResponderTransmitter.registerPullResponder(driveId, url, pullFilter ?? {
+    const filter = pullFilter ?? {
       documentId: ["*"],
       documentType: ["*"],
       branch: ["*"],
       scope: ["*"]
-    });
+    };
+    const listenerId = await PullResponderTransmitter.registerPullResponder(driveId, url, filter);
     const pullTrigger = {
       id: generateUUID(),
       type: "PullResponder",
+      driveId,
+      filter,
       data: {
         url,
         listenerId,
@@ -22736,142 +22868,307 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
   static isPullResponderTrigger(trigger) {
     return trigger.type === "PullResponder";
   }
-};
-__publicField(_PullResponderTransmitter, "staticLogger", childLogger([
-  "PullResponderTransmitter",
-  "static"
-]));
-let PullResponderTransmitter = _PullResponderTransmitter;
-var TransmitterType;
-(function(TransmitterType2) {
-  TransmitterType2[TransmitterType2["Internal"] = 0] = "Internal";
-  TransmitterType2[TransmitterType2["SwitchboardPush"] = 1] = "SwitchboardPush";
-  TransmitterType2[TransmitterType2["PullResponder"] = 2] = "PullResponder";
-  TransmitterType2[TransmitterType2["SecureConnect"] = 3] = "SecureConnect";
-  TransmitterType2[TransmitterType2["MatrixConnect"] = 4] = "MatrixConnect";
-  TransmitterType2[TransmitterType2["RESTWebhook"] = 5] = "RESTWebhook";
-})(TransmitterType || (TransmitterType = {}));
-const DefaultListenerManagerOptions = {
-  sequentialUpdates: true
-};
-function filterOperationsByRevision(operations, revisions) {
-  if (!revisions) {
-    return operations;
-  }
-  return Object.keys(operations).reduce((acc, scope) => {
-    const revision = revisions[scope];
-    if (revision !== void 0) {
-      acc[scope] = operations[scope].filter((op) => op.index <= revision);
-    }
-    return acc;
-  }, { global: [], local: [] });
 }
-function isAtRevision(document, revisions) {
-  return !revisions || Object.entries(revisions).find(([scope, revision]) => {
-    const operation = document.operations[scope].at(-1);
-    if (revision === -1) {
-      return operation !== void 0;
-    }
-    return (operation == null ? void 0 : operation.index) !== revision;
-  }) === void 0;
+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;
 }
-class BaseDocumentDriveServer {
-  constructor(documentModelModules, storage, documentStorage, cache, queueManager, eventEmitter, synchronizationManager, listenerManager, options) {
-    // external dependencies
-    __publicField(this, "documentModelModules");
-    __publicField(this, "storage");
-    __publicField(this, "documentStorage");
-    __publicField(this, "cache");
-    __publicField(this, "queueManager");
-    __publicField(this, "eventEmitter");
-    __publicField(this, "options");
-    __publicField(this, "listenerManager");
-    __publicField(this, "synchronizationManager");
-    // internal dependencies
-    __publicField(this, "defaultDrivesManager");
-    __publicField(this, "defaultDrivesManagerDelegate", {
-      detachDrive: this.detachDrive.bind(this),
-      emit: (...args) => this.eventEmitter.emit("defaultRemoteDrive", ...args)
-    });
-    __publicField(this, "queueDelegate", {
-      checkDocumentExists: (documentId) => this.documentStorage.exists(documentId),
-      processOperationJob: async ({ driveId, documentId, operations, options }) => {
-        return documentId ? this.addOperations(driveId, documentId, operations, options) : this.addDriveOperations(driveId, operations, options);
-      },
-      processActionJob: async ({ driveId, documentId, actions: actions2, options }) => {
-        return documentId ? this.addActions(driveId, documentId, actions2, options) : this.addDriveActions(driveId, actions2, options);
-      },
-      processJob: async (job) => {
-        if (isOperationJob(job)) {
-          return this.queueDelegate.processOperationJob(job);
-        } else if (isActionJob(job)) {
-          return this.queueDelegate.processActionJob(job);
-        } else {
-          throw new Error("Unknown job type", job);
-        }
-      }
-    });
-    // internal state
-    __publicField(this, "triggerMap", /* @__PURE__ */ new Map());
-    __publicField(this, "initializePromise");
-    var _a2, _b;
-    this.documentModelModules = documentModelModules;
-    this.storage = storage;
-    this.documentStorage = documentStorage;
-    this.cache = cache;
-    this.queueManager = queueManager;
-    this.eventEmitter = eventEmitter;
-    this.synchronizationManager = synchronizationManager;
-    this.listenerManager = listenerManager;
-    this.options = {
-      ...options,
-      defaultDrives: {
-        ...options == null ? void 0 : options.defaultDrives
-      },
-      listenerManager: {
-        ...DefaultListenerManagerOptions,
-        ...options == null ? void 0 : options.listenerManager
-      },
-      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
-  // todo: remove this once we have DI
-  get listeners() {
-    return this.listenerManager;
-  }
-  initialize() {
-    return this.initializePromise;
+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;
   }
-  async _initialize() {
-    await this.listenerManager.initialize(this.handleListenerError);
-    await this.queueManager.init(this.queueDelegate, (error) => {
-      logger$1.error(`Error initializing queue manager`, error);
-      errors.push(error);
-    });
+  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";
+  TransmitterType2[TransmitterType2["SwitchboardPush"] = 1] = "SwitchboardPush";
+  TransmitterType2[TransmitterType2["PullResponder"] = 2] = "PullResponder";
+  TransmitterType2[TransmitterType2["SecureConnect"] = 3] = "SecureConnect";
+  TransmitterType2[TransmitterType2["MatrixConnect"] = 4] = "MatrixConnect";
+  TransmitterType2[TransmitterType2["RESTWebhook"] = 5] = "RESTWebhook";
+})(TransmitterType || (TransmitterType = {}));
+const DefaultListenerManagerOptions = {
+  sequentialUpdates: true
+};
+function filterOperationsByRevision(operations, revisions) {
+  if (!revisions) {
+    return operations;
+  }
+  return Object.keys(operations).reduce((acc, scope) => {
+    const revision = revisions[scope];
+    if (revision !== void 0) {
+      acc[scope] = operations[scope].filter((op) => op.index <= revision);
+    }
+    return acc;
+  }, { global: [], local: [] });
+}
+function isAtRevision(document, revisions) {
+  return !revisions || Object.entries(revisions).find(([scope, revision]) => {
+    const operation = document.operations[scope].at(-1);
+    if (revision === -1) {
+      return operation !== void 0;
+    }
+    return (operation == null ? void 0 : operation.index) !== revision;
+  }) === void 0;
+}
+class BaseDocumentDriveServer {
+  constructor(documentModelModules, storage, documentStorage, cache, queueManager, eventEmitter, synchronizationManager, listenerManager, options) {
+    __publicField(this, "logger", childLogger(["BaseDocumentDriveServer"]));
+    // external dependencies
+    __publicField(this, "documentModelModules");
+    __publicField(this, "storage");
+    __publicField(this, "documentStorage");
+    __publicField(this, "cache");
+    __publicField(this, "queueManager");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "options");
+    __publicField(this, "listenerManager");
+    __publicField(this, "synchronizationManager");
+    // internal dependencies
+    __publicField(this, "defaultDrivesManager");
+    __publicField(this, "defaultDrivesManagerDelegate", {
+      detachDrive: this.detachDrive.bind(this),
+      emit: (...args) => this.eventEmitter.emit("defaultRemoteDrive", ...args)
+    });
+    __publicField(this, "queueDelegate", {
+      checkDocumentExists: (documentId) => this.documentStorage.exists(documentId),
+      processOperationJob: async ({ driveId, documentId, operations, options }) => {
+        return documentId ? this.addOperations(driveId, documentId, operations, options) : this.addDriveOperations(driveId, operations, options);
+      },
+      processActionJob: async ({ driveId, documentId, actions: actions2, options }) => {
+        return documentId ? this.addActions(driveId, documentId, actions2, options) : this.addDriveActions(driveId, actions2, options);
+      },
+      processJob: async (job) => {
+        if (isOperationJob(job)) {
+          return this.queueDelegate.processOperationJob(job);
+        } else if (isActionJob(job)) {
+          return this.queueDelegate.processActionJob(job);
+        } else {
+          throw new Error("Unknown job type", job);
+        }
+      }
+    });
+    // internal state
+    __publicField(this, "triggerMap", /* @__PURE__ */ new Map());
+    __publicField(this, "initializePromise");
+    this.documentModelModules = documentModelModules;
+    this.storage = storage;
+    this.documentStorage = documentStorage;
+    this.cache = cache;
+    this.queueManager = queueManager;
+    this.eventEmitter = eventEmitter;
+    this.synchronizationManager = synchronizationManager;
+    this.listenerManager = listenerManager;
+    this.options = {
+      ...options,
+      defaultDrives: {
+        ...options == null ? void 0 : options.defaultDrives
+      },
+      listenerManager: {
+        ...DefaultListenerManagerOptions,
+        ...options == null ? void 0 : options.listenerManager
+      },
+      taskQueueMethod: (options == null ? void 0 : options.taskQueueMethod) === void 0 ? RunAsap.runAsap : options.taskQueueMethod
+    };
+    this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
+    this.initializePromise = this._initialize();
+  }
+  // workaround for testing the ephemeral listeners -- we don't have DI in place yet
+  // todo: remove this once we have DI
+  get listeners() {
+    return this.listenerManager;
+  }
+  initialize() {
+    return this.initializePromise;
+  }
+  async _initialize() {
+    await this.listenerManager.initialize(this.handleListenerError);
+    await this.queueManager.init(this.queueDelegate, (error) => {
+      this.logger.error(`Error initializing queue manager`, error);
+      errors.push(error);
+    });
     try {
       await this.defaultDrivesManager.removeOldremoteDrives();
     } catch (error) {
-      logger$1.error(error);
+      this.logger.error(error);
     }
     const errors = [];
     const drives = await this.getDrives();
     for (const drive of drives) {
       await this._initializeDrive(drive).catch((error) => {
-        logger$1.error(`Error initializing drive ${drive}`, error);
+        this.logger.error(`Error initializing drive ${drive}`, error);
         errors.push(error);
       });
     }
@@ -22901,7 +23198,7 @@ class BaseDocumentDriveServer {
     return source.type === "local" ? "push" : "pull";
   }
   handleListenerError(error, driveId, listener) {
-    logger$1.error(`Listener ${listener.listener.label ?? listener.listener.listenerId} error:`, error);
+    this.logger.error(`Listener ${listener.listener.label ?? listener.listener.listenerId} error:`, error);
     const status = error instanceof OperationError ? error.status : "ERROR";
     this.synchronizationManager.updateSyncStatus(driveId, { push: status }, error);
   }
@@ -22964,9 +23261,9 @@ class BaseDocumentDriveServer {
             if (pushListener) {
               this.getSynchronizationUnitsRevision(driveId, syncUnits).then((syncUnitRevisions) => {
                 for (const revision of syncUnitRevisions) {
-                  this.listenerManager.updateListenerRevision(pushListener.listenerId, driveId, revision.syncId, revision.revision).catch(logger$1.error);
+                  this.listenerManager.updateListenerRevision(pushListener.listenerId, driveId, revision.syncId, revision.revision).catch(this.logger.error);
                 }
-              }).catch(logger$1.error);
+              }).catch(this.logger.error);
             }
           }
         });
@@ -22987,11 +23284,59 @@ class BaseDocumentDriveServer {
     return this.triggerMap.delete(driveId);
   }
   async _initializeDrive(driveId) {
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
     const drive = await this.getDrive(driveId);
+    this.logger.verbose(`[SYNC DEBUG] Initializing drive ${driveId} with slug "${drive.state.global.slug}"`);
     await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
     if (this.shouldSyncRemoteDrive(drive)) {
+      this.logger.verbose(`[SYNC DEBUG] Starting sync for remote drive ${driveId}`);
       await this.startSyncRemoteDrive(driveId);
     }
+    this.logger.verbose(`[SYNC DEBUG] Processing ${drive.state.local.listeners.length} listeners for drive ${driveId}`);
+    for (const zodListener of drive.state.local.listeners) {
+      if (((_a2 = zodListener.callInfo) == null ? void 0 : _a2.transmitterType) === "SwitchboardPush") {
+        this.logger.verbose(`[SYNC DEBUG] Setting up SwitchboardPush listener ${zodListener.listenerId} for drive ${driveId}`);
+        const transmitter = new SwitchboardPushTransmitter(((_b = zodListener.callInfo) == null ? void 0 : _b.data) ?? "");
+        this.logger.verbose(`[SYNC DEBUG] Created SwitchboardPush transmitter with URL: ${((_c = zodListener.callInfo) == null ? void 0 : _c.data) || "none"}`);
+        await this.listenerManager.setListener(driveId, {
+          block: zodListener.block,
+          driveId: drive.state.global.id,
+          filter: {
+            branch: ((_d = zodListener.filter) == null ? void 0 : _d.branch) ?? [],
+            documentId: ((_e = zodListener.filter) == null ? void 0 : _e.documentId) ?? [],
+            documentType: ((_f = zodListener.filter) == null ? void 0 : _f.documentType) ?? [],
+            scope: ((_g = zodListener.filter) == null ? void 0 : _g.scope) ?? []
+          },
+          listenerId: zodListener.listenerId,
+          callInfo: zodListener.callInfo,
+          system: zodListener.system,
+          label: zodListener.label ?? "",
+          transmitter
+        }).then(() => {
+          this.logger.verbose(`[SYNC DEBUG] Successfully set up listener ${zodListener.listenerId} for drive ${driveId}`);
+        });
+      } else if (((_h = zodListener.callInfo) == null ? void 0 : _h.transmitterType) === "PullResponder") {
+        this.logger.verbose(`[SYNC DEBUG] Setting up PullResponder listener ${zodListener.listenerId} for drive ${driveId}`);
+        const pullResponderListener = {
+          driveId,
+          listenerId: zodListener.listenerId,
+          block: false,
+          filter: zodListener.filter,
+          system: false,
+          label: `PullResponder #${zodListener.listenerId}`,
+          callInfo: {
+            data: "",
+            name: "PullResponder",
+            transmitterType: "PullResponder"
+          }
+        };
+        const pullResponder = new PullResponderTransmitter(pullResponderListener, this.listenerManager);
+        pullResponderListener.transmitter = pullResponder;
+        await this.listenerManager.setListener(driveId, pullResponderListener);
+      } else {
+        this.logger.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${((_i = zodListener.callInfo) == null ? void 0 : _i.transmitterType) || "unknown"}`);
+      }
+    }
   }
   // Delegate synchronization methods to synchronizationManager
   getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
@@ -23033,7 +23378,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 +23410,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 +23425,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)) {
@@ -23088,7 +23433,7 @@ class BaseDocumentDriveServer {
         }
       }
     } catch (e) {
-      logger$1.error("Error getting drive from cache", e);
+      this.logger.error("Error getting drive from cache", e);
     }
     const driveStorage = document ?? await this.storage.getDrive(driveId);
     const result = this._buildDocument(driveStorage, options);
@@ -23096,43 +23441,43 @@ 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(this.logger.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);
+      this.logger.error("Error getting drive from cache", e);
     }
     const driveStorage = await this.storage.getDriveBySlug(slug);
     const document = this._buildDocument(driveStorage, options);
     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(this.logger.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;
       }
     } catch (e) {
-      logger$1.error("Error getting document from cache", e);
+      this.logger.error("Error getting document from cache", e);
     }
     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(this.logger.error);
     }
     return document;
   }
@@ -23187,9 +23532,9 @@ class BaseDocumentDriveServer {
       }
       await this.listenerManager.removeSyncUnits(driveId, syncUnits);
     } catch (error) {
-      logger$1.warn("Error deleting document", error);
+      this.logger.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) {
@@ -23361,33 +23706,35 @@ class BaseDocumentDriveServer {
     if (result) {
       return result;
     }
+    let jobId;
+    const promise = new Promise((resolve, reject) => {
+      const unsubscribe = this.queueManager.on("jobCompleted", (job, result2) => {
+        if (job.jobId === jobId) {
+          unsubscribe();
+          unsubscribeError();
+          resolve(result2);
+        }
+      });
+      const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
+        if (job.jobId === jobId) {
+          unsubscribe();
+          unsubscribeError();
+          reject(error);
+        }
+      });
+    });
     try {
-      const jobId = await this.queueManager.addJob({
+      jobId = await this.queueManager.addJob({
         driveId,
         documentId,
         operations,
         options
       });
-      return new Promise((resolve, reject) => {
-        const unsubscribe = this.queueManager.on("jobCompleted", (job, result2) => {
-          if (job.jobId === jobId) {
-            unsubscribe();
-            unsubscribeError();
-            resolve(result2);
-          }
-        });
-        const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
-          if (job.jobId === jobId) {
-            unsubscribe();
-            unsubscribeError();
-            reject(error);
-          }
-        });
-      });
     } catch (error) {
-      logger$1.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
+    return promise;
   }
   async queueAction(driveId, documentId, action, options) {
     return this.queueActions(driveId, documentId, [action], options);
@@ -23417,7 +23764,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -23448,7 +23795,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding drive job", error);
+      this.logger.error("Error adding drive job", error);
       throw error;
     }
   }
@@ -23465,7 +23812,7 @@ class BaseDocumentDriveServer {
       await this._addOperations(driveId, documentId, async (documentStorage) => {
         const result2 = await this._processOperations(driveId, documentId, documentStorage, operations);
         if (!result2.document) {
-          logger$1.error("Invalid document");
+          this.logger.error("Invalid document");
           throw result2.error ?? new Error("Invalid document");
         }
         document = result2.document;
@@ -23479,7 +23826,7 @@ class BaseDocumentDriveServer {
         };
       });
       if (document) {
-        this.cache.setDocument(driveId, documentId, document).catch(logger$1.error);
+        this.cache.setDocument(documentId, document).catch(this.logger.error);
       }
       const { scopes, branches } = operationsApplied.reduce((acc, operation) => {
         if (!acc.scopes.includes(operation.scope)) {
@@ -23512,7 +23859,7 @@ class BaseDocumentDriveServer {
           });
         }
       }).catch((error2) => {
-        logger$1.error("Non handled error updating sync revision", error2);
+        this.logger.error("Non handled error updating sync revision", error2);
         this.synchronizationManager.updateSyncStatus(driveId, {
           [operationSource]: "ERROR"
         }, error2);
@@ -23614,7 +23961,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding drive job", error);
+      this.logger.error("Error adding drive job", error);
       throw error;
     }
   }
@@ -23642,7 +23989,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(this.logger.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 +23998,6 @@ class BaseDocumentDriveServer {
         this.listenerManager.updateSynchronizationRevisions(driveId, [
           {
             syncId: "0",
-            driveId,
             documentId: "",
             scope: "global",
             branch: "main",
@@ -23670,7 +24016,7 @@ class BaseDocumentDriveServer {
             });
           }
         }).catch((error2) => {
-          logger$1.error("Non handled error updating sync revision", error2);
+          this.logger.error("Non handled error updating sync revision", error2);
           this.synchronizationManager.updateSyncStatus(driveId, {
             [operationSource]: "ERROR"
           }, error2);
@@ -23772,9 +24118,26 @@ class BaseDocumentDriveServer {
       scope: strand.scope,
       branch: strand.branch
     }));
-    const result = await (!strand.documentId ? this.queueDriveOperations(strand.driveId, operations, { source }) : this.queueOperations(strand.driveId, strand.documentId, operations, {
-      source
-    }));
+    let result;
+    if (strand.documentId) {
+      try {
+        result = await this.queueOperations(strand.driveId, strand.documentId, operations, {
+          source
+        });
+      } catch (error) {
+        this.logger.error("Error queueing operations", error);
+        throw error;
+      }
+    } else {
+      try {
+        result = await this.queueDriveOperations(strand.driveId, operations, {
+          source
+        });
+      } catch (error) {
+        this.logger.error("Error queueing operations", error);
+        throw error;
+      }
+    }
     if (result.status === "ERROR") {
       const syncUnits = strand.documentId !== "" ? (await this.getSynchronizationUnitsIds(strand.driveId, [strand.documentId], [strand.scope], [strand.branch])).map((s) => s.syncId) : [strand.driveId];
       const operationSource = this.getOperationSource(source);
@@ -23790,18 +24153,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 +24170,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 +24223,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 +24252,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 +24313,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 +24346,7 @@ class MemoryStorage {
   ////////////////////////////////
   // Private
   ////////////////////////////////
-  getDriveManifest(driveId) {
+  getManifest(driveId) {
     if (!this.driveManifests[driveId]) {
       this.driveManifests[driveId] = { documentIds: /* @__PURE__ */ new Set() };
     }
@@ -24122,11 +24511,10 @@ const _ListenerManager = class _ListenerManager {
       throw new Error("Maximum retries exhausted.");
     }
     const listenerUpdates = [];
-    for (const [driveId, drive] of this.listenerStateByDriveId) {
-      for (const [listenerId, listenerState] of drive) {
+    for (const [driveId, listenerStateById] of this.listenerStateByDriveId) {
+      for (const [listenerId, listenerState] of listenerStateById) {
         const transmitter = listenerState.listener.transmitter;
         if (!(transmitter == null ? void 0 : transmitter.transmit)) {
-          this.logger.verbose(`Transmitter not set on listener: ${listenerId}`);
           continue;
         }
         const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
@@ -24138,7 +24526,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 {
@@ -24280,57 +24668,78 @@ const _ListenerManager = class _ListenerManager {
     }
   }
   async getStrands(driveId, listenerId, options) {
-    const listenerState = this.getListenerState(driveId, listenerId);
-    const strands = [];
-    const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
-    const limit = options == null ? void 0 : options.limit;
-    let operationsCount = 0;
-    const tasks = syncUnits.map((syncUnit) => async () => {
-      if (limit && operationsCount >= limit) {
-        return;
-      }
-      if (syncUnit.revision < 0) {
-        return;
-      }
-      const entry = listenerState.syncUnits.get(syncUnit.syncId);
-      if (entry && entry.listenerRev >= syncUnit.revision) {
-        return;
-      }
-      const { documentId, driveId: driveId2, scope, branch } = syncUnit;
-      try {
-        const operations = await this.syncManager.getOperationData(
-          // DEAL WITH INVALID SYNC ID ERROR
-          driveId2,
-          syncUnit.syncId,
-          {
-            since: options == null ? void 0 : options.since,
-            fromRevision: (options == null ? void 0 : options.fromRevision) ?? (entry == null ? void 0 : entry.listenerRev),
-            limit: limit ? limit - operationsCount : void 0
+    this.logger.verbose(`[SYNC DEBUG] ListenerManager.getStrands called for drive: ${driveId}, listener: ${listenerId}, options: ${JSON.stringify(options || {})}`);
+    let listenerState;
+    try {
+      listenerState = this.getListenerState(driveId, listenerId);
+      this.logger.verbose(`[SYNC DEBUG] Found listener state for drive: ${driveId}, listener: ${listenerId}, status: ${listenerState.listenerStatus}`);
+    } catch (error) {
+      this.logger.error(`[SYNC DEBUG] Failed to find listener state for drive: ${driveId}, listener: ${listenerId}. Error: ${error}`);
+      throw error;
+    }
+    const strands = [];
+    try {
+      const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
+      this.logger.verbose(`[SYNC DEBUG] Retrieved ${syncUnits.length} sync units for drive: ${driveId}, listener: ${listenerId}`);
+      const limit = options == null ? void 0 : options.limit;
+      let operationsCount = 0;
+      const tasks = syncUnits.map((syncUnit) => async () => {
+        if (limit && operationsCount >= limit) {
+          return;
+        }
+        if (syncUnit.revision < 0) {
+          this.logger.verbose(`[SYNC DEBUG] Skipping sync unit with negative revision: ${syncUnit.syncId}, revision: ${syncUnit.revision}`);
+          return;
+        }
+        const entry = listenerState.syncUnits.get(syncUnit.syncId);
+        if (entry && entry.listenerRev >= syncUnit.revision) {
+          this.logger.verbose(`[SYNC DEBUG] Skipping sync unit - listener already up to date: ${syncUnit.syncId}, listenerRev: ${entry.listenerRev}, revision: ${syncUnit.revision}`);
+          return;
+        }
+        const { documentId, scope, branch } = syncUnit;
+        try {
+          this.logger.verbose(`[SYNC DEBUG] Getting operations for syncUnit: ${syncUnit.syncId}, documentId: ${documentId}, scope: ${scope}, branch: ${branch}`);
+          const operations = await this.syncManager.getOperationData(
+            // DEAL WITH INVALID SYNC ID ERROR
+            driveId,
+            syncUnit.syncId,
+            {
+              since: options == null ? void 0 : options.since,
+              fromRevision: (options == null ? void 0 : options.fromRevision) ?? (entry == null ? void 0 : entry.listenerRev),
+              limit: limit ? limit - operationsCount : void 0
+            }
+          );
+          this.logger.verbose(`[SYNC DEBUG] Retrieved ${operations.length} operations for syncUnit: ${syncUnit.syncId}`);
+          if (!operations.length) {
+            return;
           }
-        );
-        if (!operations.length) {
+          operationsCount += operations.length;
+          strands.push({
+            driveId,
+            documentId,
+            scope,
+            branch,
+            operations
+          });
+          this.logger.verbose(`[SYNC DEBUG] Added strand with ${operations.length} operations for syncUnit: ${syncUnit.syncId}`);
+        } catch (error) {
+          this.logger.error(`Error getting operations for syncUnit: ${syncUnit.syncId}, error: ${error}`);
           return;
         }
-        operationsCount += operations.length;
-        strands.push({
-          driveId: driveId2,
-          documentId,
-          scope,
-          branch,
-          operations
-        });
-      } catch (error) {
-        this.logger.error(error);
-        return;
-      }
-    });
-    if (this.options.sequentialUpdates) {
-      for (const task of tasks) {
-        await task();
+      });
+      if (this.options.sequentialUpdates) {
+        this.logger.verbose(`[SYNC DEBUG] Processing ${tasks.length} sync units sequentially`);
+        for (const task of tasks) {
+          await task();
+        }
+      } else {
+        this.logger.verbose(`[SYNC DEBUG] Processing ${tasks.length} sync units in parallel`);
+        await Promise.all(tasks.map((task) => task()));
       }
-    } else {
-      await Promise.all(tasks.map((task) => task()));
+    } catch (error) {
+      this.logger.error(`Error in getStrands: ${error}`);
     }
+    this.logger.verbose(`ListenerManager.getStrands returning ${strands.length} strands for drive: ${driveId}, listener: ${listenerId}`);
     return strands;
   }
   getListenerState(driveId, listenerId) {
@@ -24356,187 +24765,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");
@@ -24575,18 +24803,20 @@ class SynchronizationManager {
   }
   async getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
     const synchronizationUnitsQuery = await this.getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType2);
+    this.logger.verbose(`getSynchronizationUnits query: ${JSON.stringify(synchronizationUnitsQuery)}`);
     return this.getSynchronizationUnitsRevision(driveId, synchronizationUnitsQuery);
   }
   async getSynchronizationUnitsRevision(driveId, syncUnitsQuery) {
     const drive = await this.getDrive(driveId);
     const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
+    this.logger.verbose(`getSynchronizationUnitsRevision: ${JSON.stringify(revisions)}`);
     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);
+      const syncUnit = synchronizationUnits.find((s) => revision.documentId === s.documentId && revision.scope === s.scope && revision.branch === s.branch);
       if (syncUnit) {
         syncUnit.revision = revision.revision;
         syncUnit.lastUpdated = revision.lastUpdated;
@@ -24599,7 +24829,7 @@ class SynchronizationManager {
     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: driveId,
         documentType: "powerhouse/document-drive",
         synchronizationUnits: [
           {
@@ -24641,7 +24871,6 @@ class SynchronizationManager {
       syncId,
       scope: syncUnit.scope,
       branch: syncUnit.branch,
-      driveId,
       documentId: node.id,
       documentType: node.documentType
     };
@@ -24659,7 +24888,6 @@ class SynchronizationManager {
       syncId,
       scope,
       branch,
-      driveId,
       documentId,
       documentType: documentType2,
       lastUpdated: lastOperation.timestamp ?? document.lastModified,
@@ -24667,14 +24895,27 @@ class SynchronizationManager {
     };
   }
   async getOperationData(driveId, syncId, filter) {
+    this.logger.verbose(`[SYNC DEBUG] SynchronizationManager.getOperationData called for drive: ${driveId}, syncId: ${syncId}, filter: ${JSON.stringify(filter)}`);
     const syncUnit = syncId === "0" ? { documentId: "", scope: "global" } : await this.getSynchronizationUnitIdInfo(driveId, syncId);
     if (!syncUnit) {
+      this.logger.error(`SYNC DEBUG] Invalid Sync Id ${syncId} in drive ${driveId}`);
       throw new Error(`Invalid Sync Id ${syncId} in drive ${driveId}`);
     }
+    this.logger.verbose(`[SYNC DEBUG] Found sync unit: documentId: ${syncUnit.documentId}, scope: ${syncUnit.scope}`);
     const document = syncId === "0" ? await this.getDrive(driveId) : await this.getDocument(driveId, syncUnit.documentId);
+    this.logger.verbose(`[SYNC DEBUG] Retrieved document ${syncUnit.documentId} with type: ${document.documentType}`);
     const operations = document.operations[syncUnit.scope] ?? [];
+    this.logger.verbose(`[SYNC DEBUG] Found ${operations.length} total operations in scope ${syncUnit.scope}`);
     const filteredOperations = operations.filter((operation) => Object.keys(filter).length === 0 || (filter.since === void 0 || isBefore(filter.since, operation.timestamp)) && (filter.fromRevision === void 0 || operation.index > filter.fromRevision));
+    this.logger.verbose(`[SYNC DEBUG] Filtered to ${filteredOperations.length} operations based on filter criteria` + (filter.fromRevision !== void 0 ? ` (fromRevision: ${filter.fromRevision})` : ""));
     const limitedOperations = filter.limit ? filteredOperations.slice(0, filter.limit) : filteredOperations;
+    this.logger.verbose(`[SYNC DEBUG] Returning ${limitedOperations.length} operations after applying limit`);
+    if (limitedOperations.length > 0) {
+      const firstOp = limitedOperations[0];
+      const lastOp = limitedOperations[limitedOperations.length - 1];
+      this.logger.verbose(`[SYNC DEBUG] First operation: index=${firstOp.index}, type=${firstOp.type}`);
+      this.logger.verbose(`[SYNC DEBUG] Last operation: index=${lastOp.index}, type=${lastOp.type}`);
+    }
     return limitedOperations.map((operation) => ({
       hash: operation.hash,
       index: operation.index,
@@ -24688,7 +24929,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 +24945,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;
       }
@@ -25180,6 +25421,9 @@ function Modified(props) {
 function Moved(props) {
   return jsxs("svg", { ...props, width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("path", { d: "M7.07143 1.96429C7.07143 2.2207 6.86356 2.42857 6.60714 2.42857H5.21429C3.67578 2.42857 2.42857 3.67578 2.42857 5.21429V10.7857C2.42857 12.3242 3.67578 13.5714 5.21429 13.5714H10.7857C12.3242 13.5714 13.5714 12.3242 13.5714 10.7857V9.39286C13.5714 9.13644 13.7793 8.92857 14.0357 8.92857C14.2921 8.92857 14.5 9.13644 14.5 9.39286V10.7857C14.5 12.8371 12.8371 14.5 10.7857 14.5H5.21429C3.16294 14.5 1.5 12.8371 1.5 10.7857V5.21429C1.5 3.16294 3.16294 1.5 5.21429 1.5H6.60714C6.86356 1.5 7.07143 1.70787 7.07143 1.96429Z", fill: "currentcolor" }), jsx("path", { d: "M14 6.5V2.5C14 2.22386 13.7761 2 13.5 2H9.5", stroke: "currentcolor", strokeLinecap: "round" }), jsx("path", { d: "M7 10L7.28346 9.29136C8.39378 6.51556 10.4269 4.20728 13.0403 2.75539L13.5 2.5", stroke: "currentcolor", strokeLinecap: "round" })] });
 }
+function Npm(props) {
+  return jsx("svg", { ...props, xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 128 128", children: jsx("path", { fill: "#cb3837", d: "M2 38.5h124v43.71H64v7.29H36.44v-7.29H2zm6.89 36.43h13.78V53.07h6.89v21.86h6.89V45.79H8.89zm34.44-29.14v36.42h13.78v-7.28h13.78V45.79zm13.78 7.29H64v14.56h-6.89zm20.67-7.29v29.14h13.78V53.07h6.89v21.86h6.89V53.07h6.89v21.86h6.89V45.79z" }) });
+}
 function PackageManager(props) {
   return jsx("svg", { ...props, width: "12", height: "12", viewBox: "0 0 12 12", fill: "currentcolor", children: jsx("path", { d: "M1.22323 -0.00109863C0.549226 -0.00109863 -0.00610352 0.533576 -0.00610352 1.20691V2.79089C-0.00610352 3.46423 0.549226 3.9989 1.22323 3.9989H4.0979C4.7719 3.9989 5.32723 3.46423 5.32723 2.79089V1.20691C5.32723 0.533576 4.7719 -0.00109863 4.0979 -0.00109863H1.22323ZM7.9939 -0.00109863C7.25723 -0.00109863 6.66056 0.595568 6.66056 1.33223V5.33223C6.66056 6.0689 7.25723 6.66557 7.9939 6.66557H10.6606C11.3972 6.66557 11.9939 6.0689 11.9939 5.33223V1.33223C11.9939 0.595568 11.3972 -0.00109863 10.6606 -0.00109863H7.9939ZM1.32723 5.33223C0.590563 5.33223 -0.00610352 5.9289 -0.00610352 6.66557V10.6656C-0.00610352 11.4022 0.590563 11.9989 1.32723 11.9989H3.9939C4.73056 11.9989 5.32723 11.4022 5.32723 10.6656V6.66557C5.32723 5.9289 4.73056 5.33223 3.9939 5.33223H1.32723ZM7.88989 7.9989C7.21589 7.9989 6.66056 8.53358 6.66056 9.20691V10.7909C6.66056 11.4642 7.21589 11.9989 7.88989 11.9989H10.7646C11.4386 11.9989 11.9939 11.4642 11.9939 10.7909V9.20691C11.9939 8.53358 11.4386 7.9989 10.7646 7.9989H7.88989Z" }) });
 }
@@ -25368,6 +25612,7 @@ const iconComponents = {
   M,
   Modified,
   Moved,
+  Npm,
   PackageManager,
   Pencil,
   PeopleFill,
@@ -25545,7 +25790,7 @@ const nodeOptionsMap = {
 };
 const name = "@powerhousedao/connect";
 const productName = "Powerhouse-Connect";
-const version$1 = "1.0.8";
+const version$1 = "1.0.10-dev.0";
 const description = "Powerhouse Connect";
 const main = "./dist/index.html";
 const type = "module";
@@ -28338,6 +28583,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 +28607,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 +28667,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 +28675,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 +28683,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 +28709,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 +28731,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 +28750,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 +28765,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 +28803,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 +28816,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 +28825,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 +31430,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-CsiwsM42.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,