@powerhousedao/connect 1.0.9-dev.0 → 1.0.11-dev.0

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

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-Uu65do7x.js","assets/main.CpORyZoE.js","assets/app-D9QJBr8i.css"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-CSB8ljfZ.js","assets/main.Biy01WIR.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.CpORyZoE.js";
+import { _ as __vitePreload } from "./main.Biy01WIR.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect, Suspense, lazy } from "react";
 function _mergeNamespaces(n, m) {
@@ -11554,13 +11554,6 @@ class DriveAlreadyExistsError extends Error {
     this.driveId = driveId;
   }
 }
-class DriveNotFoundError extends Error {
-  constructor(driveId) {
-    super(`Drive with id ${driveId} not found`);
-    __publicField(this, "driveId");
-    this.driveId = driveId;
-  }
-}
 class SynchronizationUnitNotFoundError extends Error {
   constructor(message, syncUnitId) {
     super(message);
@@ -22368,9 +22361,7 @@ class DefaultDrivesManager {
     try {
       await this.server.deleteDrive(driveId);
     } catch (error) {
-      if (!(error instanceof DriveNotFoundError)) {
-        logger$1.error(error);
-      }
+      logger$1.error(error);
     }
   }
   async preserveDrivesById(driveIdsToPreserve, drives, removeStrategy = "detach") {
@@ -22517,7 +22508,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",
@@ -22530,8 +22528,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();
@@ -22551,16 +22559,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;
@@ -22572,7 +22586,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 {
@@ -22612,27 +22626,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;
@@ -22657,75 +22678,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) {
@@ -22737,20 +22808,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);
@@ -22758,17 +22834,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,
@@ -22780,12 +22859,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
   static isPullResponderTrigger(trigger) {
     return trigger.type === "PullResponder";
   }
-};
-__publicField(_PullResponderTransmitter, "staticLogger", childLogger([
-  "PullResponderTransmitter",
-  "static"
-]));
-let PullResponderTransmitter = _PullResponderTransmitter;
+}
 var defaults;
 var hasRequiredDefaults;
 function requireDefaults() {
@@ -23002,9 +23076,10 @@ function isAtRevision(document, revisions) {
 }
 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, "legacyStorage");
     __publicField(this, "documentStorage");
     __publicField(this, "cache");
     __publicField(this, "queueManager");
@@ -23040,7 +23115,7 @@ class BaseDocumentDriveServer {
     __publicField(this, "triggerMap", /* @__PURE__ */ new Map());
     __publicField(this, "initializePromise");
     this.documentModelModules = documentModelModules;
-    this.storage = storage;
+    this.legacyStorage = storage;
     this.documentStorage = documentStorage;
     this.cache = cache;
     this.queueManager = queueManager;
@@ -23072,19 +23147,19 @@ class BaseDocumentDriveServer {
   async _initialize() {
     await this.listenerManager.initialize(this.handleListenerError);
     await this.queueManager.init(this.queueDelegate, (error) => {
-      logger$1.error(`Error initializing queue manager`, 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);
       });
     }
@@ -23114,7 +23189,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);
   }
@@ -23177,9 +23252,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);
             }
           }
         });
@@ -23200,30 +23275,57 @@ class BaseDocumentDriveServer {
     return this.triggerMap.delete(driveId);
   }
   async _initializeDrive(driveId) {
-    var _a2, _b, _c, _d, _e, _f;
+    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.listenerManager.setListener(driveId, {
+        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: ((_c = zodListener.filter) == null ? void 0 : _c.branch) ?? [],
-            documentId: ((_d = zodListener.filter) == null ? void 0 : _d.documentId) ?? [],
-            documentType: ((_e = zodListener.filter) == null ? void 0 : _e.documentType) ?? [],
-            scope: ((_f = zodListener.filter) == null ? void 0 : _f.scope) ?? []
+            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"}`);
       }
     }
   }
@@ -23255,7 +23357,7 @@ class BaseDocumentDriveServer {
     if (!id) {
       throw new Error("Invalid Drive Id");
     }
-    const drives = await this.storage.getDrives();
+    const drives = await this.legacyStorage.getDrives();
     if (drives.includes(id)) {
       throw new DriveAlreadyExistsError(id);
     }
@@ -23265,7 +23367,7 @@ class BaseDocumentDriveServer {
     document.meta = {
       preferredEditor
     };
-    await this.storage.createDrive(id, document);
+    await this.legacyStorage.createDrive(id, document);
     if (input.global.slug) {
       await this.cache.deleteDriveBySlug(input.global.slug);
     }
@@ -23300,7 +23402,7 @@ class BaseDocumentDriveServer {
       this.stopSyncRemoteDrive(driveId),
       this.listenerManager.removeDrive(driveId),
       this.cache.deleteDrive(driveId),
-      this.storage.deleteDrive(driveId)
+      this.legacyStorage.deleteDrive(driveId)
     ]);
     result.forEach((r) => {
       if (r.status === "rejected") {
@@ -23309,7 +23411,7 @@ class BaseDocumentDriveServer {
     });
   }
   getDrives() {
-    return this.storage.getDrives();
+    return this.legacyStorage.getDrives();
   }
   async getDrive(driveId, options) {
     let document;
@@ -23322,15 +23424,15 @@ 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 driveStorage = document ?? await this.documentStorage.get(driveId);
     const result = this._buildDocument(driveStorage, options);
     if (!isDocumentDrive(result)) {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
     } else {
       if (!(options == null ? void 0 : options.revisions)) {
-        this.cache.setDrive(driveId, result).catch(logger$1.error);
+        this.cache.setDrive(driveId, result).catch(this.logger.error);
       }
       return result;
     }
@@ -23342,14 +23444,14 @@ class BaseDocumentDriveServer {
         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 driveStorage = await this.legacyStorage.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.setDriveBySlug(slug, document).catch(logger$1.error);
+      this.cache.setDriveBySlug(slug, document).catch(this.logger.error);
       return document;
     }
   }
@@ -23361,17 +23463,17 @@ class BaseDocumentDriveServer {
         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 documentStorage = cachedDocument ?? await this.documentStorage.get(documentId);
     const document = this._buildDocument(documentStorage, options);
     if (!(options == null ? void 0 : options.revisions)) {
-      this.cache.setDocument(documentId, document).catch(logger$1.error);
+      this.cache.setDocument(documentId, document).catch(this.logger.error);
     }
     return document;
   }
   getDocuments(driveId) {
-    return this.storage.getDocuments(driveId);
+    return this.legacyStorage.getDocuments(driveId);
   }
   async createDocument(driveId, input) {
     let state = void 0;
@@ -23394,7 +23496,7 @@ class BaseDocumentDriveServer {
       clipboard: [],
       state: state ?? document.state
     };
-    await this.storage.createDocument(driveId, input.id, documentStorage);
+    await this.legacyStorage.createDocument(driveId, input.id, documentStorage);
     for (const syncUnit of input.synchronizationUnits) {
       this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
         pull: this.triggerMap.get(driveId) ? "INITIAL_SYNC" : void 0,
@@ -23404,9 +23506,9 @@ class BaseDocumentDriveServer {
     const operations = Object.values(document.operations).flat();
     if (operations.length) {
       if (isDocumentDrive(document)) {
-        await this.storage.addDriveOperations(driveId, operations, document);
+        await this.legacyStorage.addDriveOperations(driveId, operations, document);
       } else {
-        await this.storage.addDocumentOperations(driveId, input.id, operations, document);
+        await this.legacyStorage.addDocumentOperations(driveId, input.id, operations, document);
       }
     }
     return document;
@@ -23421,10 +23523,10 @@ 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(documentId);
-    return this.storage.deleteDocument(driveId, documentId);
+    return this.legacyStorage.deleteDocument(driveId, documentId);
   }
   async _processOperations(driveId, documentId, documentStorage, operations) {
     const operationsApplied = [];
@@ -23476,7 +23578,7 @@ class BaseDocumentDriveServer {
     for (const scope of Object.keys(documentOperations)) {
       const lastRemainingOperation = documentOperations[scope].at(-1);
       if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-        lastRemainingOperation.resultingState = await (documentId ? (_b = (_a2 = this.storage).getOperationResultingState) == null ? void 0 : _b.call(_a2, driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : (_d = (_c = this.storage).getDriveOperationResultingState) == null ? void 0 : _d.call(_c, driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+        lastRemainingOperation.resultingState = await (documentId ? (_b = (_a2 = this.legacyStorage).getOperationResultingState) == null ? void 0 : _b.call(_a2, driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : (_d = (_c = this.legacyStorage).getDriveOperationResultingState) == null ? void 0 : _d.call(_c, driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
       }
     }
     return {
@@ -23509,7 +23611,7 @@ class BaseDocumentDriveServer {
     });
     const lastRemainingOperation = documentOperations[scope].at(-1);
     if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-      lastRemainingOperation.resultingState = await (documentId ? (_b = (_a2 = this.storage).getOperationResultingState) == null ? void 0 : _b.call(_a2, driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : (_d = (_c = this.storage).getDriveOperationResultingState) == null ? void 0 : _d.call(_c, driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+      lastRemainingOperation.resultingState = await (documentId ? (_b = (_a2 = this.legacyStorage).getOperationResultingState) == null ? void 0 : _b.call(_a2, driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : (_d = (_c = this.legacyStorage).getDriveOperationResultingState) == null ? void 0 : _d.call(_c, driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
     }
     const operationSignals = [];
     newDocument = documentModelModule.reducer(newDocument, operation, (signal) => {
@@ -23556,14 +23658,14 @@ class BaseDocumentDriveServer {
     return this.addOperations(driveId, documentId, [operation], options);
   }
   async _addOperations(driveId, documentId, callback) {
-    if (!this.storage.addDocumentOperationsWithTransaction) {
-      const documentStorage = await this.storage.getDocument(driveId, documentId);
+    if (!this.legacyStorage.addDocumentOperationsWithTransaction) {
+      const documentStorage = await this.documentStorage.get(documentId);
       const result = await callback(documentStorage);
       if (result.operations.length > 0) {
-        await this.storage.addDocumentOperations(driveId, documentId, result.operations, result.header);
+        await this.legacyStorage.addDocumentOperations(driveId, documentId, result.operations, result.header);
       }
     } else {
-      await this.storage.addDocumentOperationsWithTransaction(driveId, documentId, callback);
+      await this.legacyStorage.addDocumentOperationsWithTransaction(driveId, documentId, callback);
     }
   }
   queueOperation(driveId, documentId, operation, options) {
@@ -23595,33 +23697,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);
@@ -23651,7 +23755,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -23682,7 +23786,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding drive job", error);
+      this.logger.error("Error adding drive job", error);
       throw error;
     }
   }
@@ -23699,7 +23803,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;
@@ -23713,7 +23817,7 @@ class BaseDocumentDriveServer {
         };
       });
       if (document) {
-        this.cache.setDocument(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)) {
@@ -23746,7 +23850,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);
@@ -23784,18 +23888,18 @@ class BaseDocumentDriveServer {
     for (const drive of await this.getDrives()) {
       await this.deleteDrive(drive);
     }
-    await ((_b = (_a2 = this.storage).clearStorage) == null ? void 0 : _b.call(_a2));
+    await ((_b = (_a2 = this.legacyStorage).clearStorage) == null ? void 0 : _b.call(_a2));
   }
   async _addDriveOperations(driveId, callback) {
-    if (!this.storage.addDriveOperationsWithTransaction) {
-      const documentStorage = await this.storage.getDrive(driveId);
+    if (!this.legacyStorage.addDriveOperationsWithTransaction) {
+      const documentStorage = await this.documentStorage.get(driveId);
       const result = await callback(documentStorage);
       if (result.operations.length > 0) {
-        await this.storage.addDriveOperations(driveId, result.operations, result.header);
+        await this.legacyStorage.addDriveOperations(driveId, result.operations, result.header);
       }
       return result;
     } else {
-      return this.storage.addDriveOperationsWithTransaction(driveId, callback);
+      return this.legacyStorage.addDriveOperationsWithTransaction(driveId, callback);
     }
   }
   queueDriveOperation(driveId, operation, options) {
@@ -23848,7 +23952,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding drive job", error);
+      this.logger.error("Error adding drive job", error);
       throw error;
     }
   }
@@ -23876,7 +23980,7 @@ class BaseDocumentDriveServer {
       if (!document || !isDocumentDrive(document)) {
         throw error ?? new Error("Invalid Document Drive document");
       }
-      this.cache.setDrive(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));
@@ -23903,7 +24007,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);
@@ -24005,9 +24109,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);
@@ -24031,7 +24152,7 @@ class MemoryStorage {
   // IDocumentStorage
   ////////////////////////////////
   exists(documentId) {
-    return Promise.resolve(!!this.documents[documentId] || !!this.documents[`drive/${documentId}`]);
+    return Promise.resolve(!!this.documents[documentId]);
   }
   create(documentId, document) {
     this.documents[documentId] = document;
@@ -24040,10 +24161,6 @@ 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);
@@ -24096,9 +24213,6 @@ class MemoryStorage {
     const manifest = this.getManifest(drive);
     return Promise.resolve([...manifest.documentIds]);
   }
-  getDocument(driveId, id) {
-    return this.get(id);
-  }
   async clearStorage() {
     this.documents = {};
     this.driveManifests = {};
@@ -24110,7 +24224,7 @@ class MemoryStorage {
     this.updateDriveManifest(drive, manifest);
   }
   async addDocumentOperations(drive, id, operations, header) {
-    const document = await this.getDocument(drive, id);
+    const document = await this.get(id);
     if (!document) {
       throw new Error(`Document with id ${id} not found`);
     }
@@ -24127,16 +24241,9 @@ class MemoryStorage {
   async getDrives() {
     return Object.keys(this.driveManifests);
   }
-  async getDrive(id) {
-    const drive = this.documents[`drive/${id}`];
-    if (!drive) {
-      throw new DriveNotFoundError(id);
-    }
-    return drive;
-  }
   async getDriveBySlug(slug) {
     for (const driveId of Object.keys(this.driveManifests)) {
-      const drive = this.documents[`drive/${driveId}`];
+      const drive = this.documents[driveId];
       if (drive.initialState.state.global.slug === slug) {
         return drive;
       }
@@ -24155,13 +24262,13 @@ class MemoryStorage {
         throw new Error(`Drive with slug ${slug} already exists`);
       }
     }
-    await this.create(`drive/${id}`, drive);
+    await this.create(id, drive);
     this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
   }
   async addDriveOperations(id, operations, header) {
-    const drive = await this.getDrive(id);
+    const drive = await this.get(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
-    this.documents[`drive/${id}`] = {
+    this.documents[id] = {
       ...drive,
       ...header,
       operations: mergedOperations
@@ -24381,11 +24488,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);
@@ -24539,57 +24645,78 @@ const _ListenerManager = class _ListenerManager {
     }
   }
   async getStrands(driveId, listenerId, options) {
-    const listenerState = this.getListenerState(driveId, listenerId);
+    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 = [];
-    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, scope, branch } = syncUnit;
-      try {
-        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
+    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,
-          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) {
@@ -24639,40 +24766,49 @@ class TransmitterFactory {
   }
 }
 class SynchronizationManager {
-  constructor(storage, cache, documentModelModules, eventEmitter) {
+  constructor(storage, documentStorage, cache, documentModelModules, eventEmitter) {
     __publicField(this, "storage");
+    __publicField(this, "documentStorage");
     __publicField(this, "cache");
     __publicField(this, "documentModelModules");
     __publicField(this, "eventEmitter");
     __publicField(this, "syncStatus", /* @__PURE__ */ new Map());
     __publicField(this, "logger", childLogger(["SynchronizationManager"]));
     this.storage = storage;
+    this.documentStorage = documentStorage;
     this.cache = cache;
     this.documentModelModules = documentModelModules;
     this.eventEmitter = eventEmitter;
   }
   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);
-    return syncUnitsQuery.map((s) => {
-      var _a2;
-      return {
-        ...s,
-        lastUpdated: drive.created,
-        revision: ((_a2 = revisions.find((r) => r.documentId === s.documentId && r.scope === s.scope && r.branch === s.branch)) == null ? void 0 : _a2.revision) ?? -1
-      };
-    });
+    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.documentId === s.documentId && revision.scope === s.scope && revision.branch === s.branch);
+      if (syncUnit) {
+        syncUnit.revision = revision.revision;
+        syncUnit.lastUpdated = revision.lastUpdated;
+      }
+    }
+    return synchronizationUnits;
   }
   async getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType2) {
     const drive = await this.getDrive(driveId);
     const nodes = drive.state.global.nodes.filter((node) => isFileNode(node) && (!(documentId == null ? void 0 : documentId.length) || documentId.includes(node.id) || documentId.includes("*")) && (!(documentType2 == null ? void 0 : documentType2.length) || documentType2.includes(node.documentType) || documentType2.includes("*")));
     if ((!documentId || documentId.includes("*") || documentId.includes("")) && (!(documentType2 == null ? void 0 : documentType2.length) || documentType2.includes("powerhouse/document-drive") || documentType2.includes("*"))) {
       nodes.unshift({
-        id: drive.state.global.id,
+        id: driveId,
         documentType: "powerhouse/document-drive",
         synchronizationUnits: [
           {
@@ -24738,14 +24874,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,
@@ -24766,7 +24915,7 @@ class SynchronizationManager {
     } catch (e) {
       this.logger.error("Error getting drive from cache", e);
     }
-    const driveStorage = await this.storage.getDrive(driveId);
+    const driveStorage = await this.documentStorage.get(driveId);
     const result = this._buildDocument(driveStorage);
     if (!isDocumentDrive(result)) {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
@@ -24782,7 +24931,7 @@ class SynchronizationManager {
     } catch (e) {
       this.logger.error("Error getting document from cache", e);
     }
-    const documentStorage = await this.storage.getDocument(driveId, documentId);
+    const documentStorage = await this.documentStorage.get(documentId);
     return this._buildDocument(documentStorage);
   }
   _buildDocument(documentStorage) {
@@ -24943,7 +25092,14 @@ class ReactorBuilder {
       this.eventEmitter = new DefaultEventEmitter();
     }
     if (!this.synchronizationManager) {
-      this.synchronizationManager = new SynchronizationManager(this.storage, this.cache, this.documentModelModules, this.eventEmitter);
+      this.synchronizationManager = new SynchronizationManager(
+        this.storage,
+        // as we refactor, we're secretly making all the IStorage implementations also implement IDocumentStorage
+        this.storage,
+        this.cache,
+        this.documentModelModules,
+        this.eventEmitter
+      );
     }
     if (!this.listenerManager) {
       const config = {
@@ -25251,6 +25407,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" }) });
 }
@@ -25439,6 +25598,7 @@ const iconComponents = {
   M,
   Modified,
   Moved,
+  Npm,
   PackageManager,
   Pencil,
   PeopleFill,
@@ -25616,7 +25776,7 @@ const nodeOptionsMap = {
 };
 const name = "@powerhousedao/connect";
 const productName = "Powerhouse-Connect";
-const version$1 = "1.0.9-dev.0";
+const version$1 = "1.0.11-dev.0";
 const description = "Powerhouse Connect";
 const main = "./dist/index.html";
 const type = "module";
@@ -28496,9 +28656,6 @@ const _BrowserStorage = class _BrowserStorage {
     const manifest = await this.getManifest(drive);
     return manifest.documentIds;
   }
-  async getDocument(driveId, id) {
-    return this.get(id);
-  }
   async createDocument(drive, id, document) {
     await this.create(id, document);
     const manifest = await this.getManifest(drive);
@@ -28520,7 +28677,7 @@ const _BrowserStorage = class _BrowserStorage {
     return (await this.db).clear();
   }
   async addDocumentOperations(drive, id, operations, header) {
-    const document = await this.getDocument(drive, id);
+    const document = await this.get(id);
     if (!document) {
       throw new Error(`Document with id ${id} not found`);
     }
@@ -28537,21 +28694,12 @@ const _BrowserStorage = class _BrowserStorage {
     const keys = await db.keys();
     return keys.filter((key) => key.startsWith(_BrowserStorage.MANIFEST_KEY)).map((key) => key.slice(_BrowserStorage.MANIFEST_KEY.length + _BrowserStorage.SEP.length));
   }
-  async getDrive(id) {
-    let drive;
-    try {
-      drive = await this.get(id);
-    } catch {
-      throw new DriveNotFoundError(id);
-    }
-    return drive;
-  }
   async getDriveBySlug(slug) {
     const drives = (await this.getDrives()).reverse();
     for (const drive of drives) {
-      const driveData = await this.getDrive(drive);
+      const driveData = await this.get(drive);
       if (driveData.initialState.state.global.slug === slug) {
-        return this.getDrive(drive);
+        return driveData;
       }
     }
     throw new Error(`Drive with slug ${slug} not found`);
@@ -28579,7 +28727,7 @@ const _BrowserStorage = class _BrowserStorage {
     return db.removeItem(this.buildDocumentKey(id));
   }
   async addDriveOperations(id, operations, header) {
-    const drive = await this.getDrive(id);
+    const drive = await this.get(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
     const db = await this.db;
     await db.setItem(this.buildDocumentKey(id), {
@@ -28626,14 +28774,14 @@ const _BrowserStorage = class _BrowserStorage {
     }
   }
   async migrateDrive(driveId) {
-    const drive = await this.getDrive(driveId);
+    const drive = await this.get(driveId);
     const migratedDrive = migrateDocumentOperationSignatures(drive);
     if (migratedDrive !== drive) {
       return (await this.db).setItem(this.buildDocumentKey(driveId), migratedDrive);
     }
   }
   async migrateDocument(drive, id) {
-    const document = await this.getDocument(drive, id);
+    const document = await this.get(id);
     const migratedDocument = migrateDocumentOperationSignatures(document);
     if (migratedDocument !== document) {
       return (await this.db).setItem(this.buildDocumentKey(id), migratedDocument);
@@ -31256,7 +31404,7 @@ if (window.__VITE_ENVS.MODE === "development") {
 } else {
   serviceWorkerManager.registerServiceWorker(false);
 }
-const App = lazy(() => __vitePreload(() => import("./app-Uu65do7x.js").then((n) => n.aN), true ? __vite__mapDeps([0,1,2]) : void 0));
+const App = lazy(() => __vitePreload(() => import("./app-CSB8ljfZ.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,