@powerhousedao/connect 1.0.5-dev.0 → 1.0.6-dev.1

package/dist/assets/{app-loader-D5SWSIlq.js → app-loader-CZ0aVaYP.js}

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-D5aQi0aY.js","assets/main.DnroXr_4.js","assets/app-CcH3qGge.css"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-DzySetAh.js","assets/main.BQPIoivi.js","assets/app-CcH3qGge.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.DnroXr_4.js";
+import { _ as __vitePreload } from "./main.BQPIoivi.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect, Suspense, lazy } from "react";
 function _mergeNamespaces(n, m) {
@@ -22517,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",
@@ -22561,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;
@@ -22582,7 +22595,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
   }
   static async pullStrands(driveId, url, listenerId, options) {
     var _a2;
-    this.staticLogger.verbose(`[SYNC DEBUG] PullResponderTransmitter.pullStrands called for drive: ${driveId}, url: ${url}, listener: ${listenerId}, options: ${JSON.stringify(options || {})}`);
+    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 {
@@ -22622,11 +22635,11 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       `, { listenerId });
     const error = (_a2 = result.errors) == null ? void 0 : _a2.at(0);
     if (error) {
-      this.staticLogger.verbose(`[SYNC DEBUG] Error pulling strands for drive: ${driveId}, listener: ${listenerId}, error: ${JSON.stringify(error)}`);
+      staticLogger().verbose(`[SYNC DEBUG] Error pulling strands for drive: ${driveId}, listener: ${listenerId}, error: ${JSON.stringify(error)}`);
       throw error;
     }
     if (!result.system) {
-      this.staticLogger.verbose(`[SYNC DEBUG] No system data returned when pulling strands for drive: ${driveId}, listener: ${listenerId}`);
+      staticLogger().verbose(`[SYNC DEBUG] No system data returned when pulling strands for drive: ${driveId}, listener: ${listenerId}`);
       return [];
     }
     const strands = result.system.sync.strands.map((s) => ({
@@ -22636,20 +22649,20 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
         input: JSON.parse(o.input)
       }))
     }));
-    this.staticLogger.verbose(`[SYNC DEBUG] PullResponderTransmitter.pullStrands returning ${strands.length} strands for drive: ${driveId}, listener: ${listenerId}`);
+    staticLogger().verbose(`[SYNC DEBUG] PullResponderTransmitter.pullStrands returning ${strands.length} strands for drive: ${driveId}, listener: ${listenerId}`);
     if (strands.length > 0) {
-      this.staticLogger.verbose(`[SYNC DEBUG] Strands being returned: ${strands.map((s) => `${s.documentId}:${s.scope}`).join(", ")}`);
+      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;
@@ -22684,27 +22697,27 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
    */
   static async executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
     var _a2, _b;
-    this.staticLogger.verbose(`executePull(driveId: ${driveId}), trigger:`, trigger);
-    this.staticLogger.info(`[SYNC DEBUG] PullResponderTransmitter.executePull starting for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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 {
-      strands = await _PullResponderTransmitter.pullStrands(driveId, url, trigger.data.listenerId);
+      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") {
-          this.staticLogger.verbose(`[SYNC DEBUG] Auto-registering pull responder for drive: ${driveId}`);
-          const listenerId = await _PullResponderTransmitter.registerPullResponder(trigger.driveId, url, trigger.filter);
-          trigger.data.listenerId = listenerId;
+          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);
-            this.staticLogger.verbose(`Successfully auto-registerd and pulled strands for drive: ${driveId}, listenerId: ${listenerId}`);
+            strands = await PullResponderTransmitter.pullStrands(driveId, url, listenerId);
+            staticLogger().verbose(`Successfully auto-registered and pulled strands for drive: ${driveId}, listenerId: ${listenerId}`);
           } catch (error2) {
-            this.staticLogger.error(`Could not resolve 'Listener not found' error by registering a new pull responder for drive: ${driveId}, listenerId: ${listenerId}: ${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;
           }
@@ -22713,21 +22726,21 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       }
     }
     if (!strands) {
-      this.staticLogger.error(`Error pulling strands for drive, and could not auto-register: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
+      staticLogger().error(`Error pulling strands for drive, and could not auto-register: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
       onError(error);
       return;
     }
     if (!strands.length) {
-      this.staticLogger.verbose(`[SYNC DEBUG] No strands returned in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+      staticLogger().verbose(`[SYNC DEBUG] No strands returned in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
       try {
         onRevisions == null ? void 0 : onRevisions([]);
       } catch (error2) {
-        this.staticLogger.error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+        staticLogger().error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
         onError(error2);
       }
       return;
     }
-    this.staticLogger.verbose(`[SYNC DEBUG] Processing ${strands.length} strands in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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) => ({
@@ -22735,7 +22748,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
         scope: strand.scope,
         branch: strand.branch
       }));
-      this.staticLogger.verbose(`[SYNC DEBUG] Processing strand for drive: ${strand.driveId}, document: ${strand.documentId}, scope: ${strand.scope}, with ${operations.length} operations`);
+      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, {
@@ -22746,7 +22759,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
           throw result.error;
         }
       } catch (e) {
-        this.staticLogger.error(`Error processing strand for drive: ${strand.driveId}, document: ${strand.documentId}, scope: ${strand.scope}, with ${operations.length} operations: ${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);
       }
@@ -22760,39 +22773,39 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
         error: error2
       });
     }
-    this.staticLogger.verbose("Processed strands...");
+    staticLogger().verbose("Processed strands...");
     try {
       onRevisions == null ? void 0 : onRevisions(listenerRevisions);
     } catch (error2) {
-      this.staticLogger.error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      staticLogger().error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
       onError(error2);
     }
-    this.staticLogger.verbose(`[SYNC DEBUG] Acknowledging ${listenerRevisions.length} strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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) => {
+      await PullResponderTransmitter.acknowledgeStrands(url, trigger.data.listenerId, listenerRevisions.map((revision) => {
         const { error: error2, ...rest } = revision;
         return rest;
       }));
       success = true;
     } catch (error2) {
-      this.staticLogger.error(`Error acknowledging strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      staticLogger().error(`Error acknowledging strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
       onError(error2);
     }
     if (success) {
-      this.staticLogger.verbose(`[SYNC DEBUG] Successfully acknowledged strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+      staticLogger().verbose(`[SYNC DEBUG] Successfully acknowledged strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
     } else {
-      this.staticLogger.error("Failed to acknowledge strands");
+      staticLogger().error("Failed to acknowledge strands");
     }
     try {
       onAcknowledge == null ? void 0 : onAcknowledge(success);
     } catch (error2) {
-      this.staticLogger.error(`Error calling onAcknowledge for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${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(`[SYNC DEBUG] PullResponderTransmitter.setupPull initiated for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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) {
@@ -22804,25 +22817,25 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       } catch {
       }
     }
-    this.staticLogger.verbose(`[SYNC DEBUG] Pull interval set to ${loopInterval}ms for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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(`[SYNC DEBUG] Starting pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+        staticLogger().verbose(`[SYNC DEBUG] Starting pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
         await this.executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge);
-        this.staticLogger.verbose(`[SYNC DEBUG] Completed pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}, waiting ${loopInterval}ms for next cycle`);
+        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((error) => {
-      this.staticLogger.error(`Error in executeLoop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
+      staticLogger().error(`Error in executeLoop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
     });
     return () => {
-      this.staticLogger.verbose(`[SYNC DEBUG] Cancelling pull loop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+      staticLogger().verbose(`[SYNC DEBUG] Cancelling pull loop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
       isCancelled = true;
       if (timeout !== void 0) {
         clearTimeout(timeout);
@@ -22830,7 +22843,7 @@ 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 filter = pullFilter ?? {
       documentId: ["*"],
@@ -22838,7 +22851,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       branch: ["*"],
       scope: ["*"]
     };
-    const listenerId = await _PullResponderTransmitter.registerPullResponder(driveId, url, filter);
+    const listenerId = await PullResponderTransmitter.registerPullResponder(driveId, url, filter);
     const pullTrigger = {
       id: generateUUID(),
       type: "PullResponder",
@@ -22855,12 +22868,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() {
@@ -23077,6 +23085,7 @@ 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");
@@ -23147,19 +23156,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);
       });
     }
@@ -23189,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);
   }
@@ -23252,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);
             }
           }
         });
@@ -23275,20 +23284,20 @@ class BaseDocumentDriveServer {
     return this.triggerMap.delete(driveId);
   }
   async _initializeDrive(driveId) {
-    var _a2, _b, _c, _d, _e, _f, _g, _h;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
     const drive = await this.getDrive(driveId);
-    logger$1.verbose(`[SYNC DEBUG] Initializing drive ${driveId} with slug "${drive.state.global.slug}"`);
+    this.logger.verbose(`[SYNC DEBUG] Initializing drive ${driveId} with slug "${drive.state.global.slug}"`);
     await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
     if (this.shouldSyncRemoteDrive(drive)) {
-      logger$1.verbose(`[SYNC DEBUG] Starting sync for remote drive ${driveId}`);
+      this.logger.verbose(`[SYNC DEBUG] Starting sync for remote drive ${driveId}`);
       await this.startSyncRemoteDrive(driveId);
     }
-    logger$1.verbose(`[SYNC DEBUG] Processing ${drive.state.local.listeners.length} listeners for drive ${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") {
-        logger$1.verbose(`[SYNC DEBUG] Setting up SwitchboardPush listener ${zodListener.listenerId} for drive ${driveId}`);
+        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) ?? "");
-        logger$1.verbose(`[SYNC DEBUG] Created SwitchboardPush transmitter with URL: ${((_c = zodListener.callInfo) == null ? void 0 : _c.data) || "none"}`);
+        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,
@@ -23304,10 +23313,28 @@ class BaseDocumentDriveServer {
           label: zodListener.label ?? "",
           transmitter
         }).then(() => {
-          logger$1.verbose(`[SYNC DEBUG] Successfully set up listener ${zodListener.listenerId} for drive ${driveId}`);
+          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 {
-        logger$1.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${((_h = zodListener.callInfo) == null ? void 0 : _h.transmitterType) || "unknown"}`);
+        this.logger.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${((_i = zodListener.callInfo) == null ? void 0 : _i.transmitterType) || "unknown"}`);
       }
     }
   }
@@ -23406,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);
@@ -23414,7 +23441,7 @@ class BaseDocumentDriveServer {
       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;
     }
@@ -23426,14 +23453,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 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;
     }
   }
@@ -23445,12 +23472,12 @@ 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 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;
   }
@@ -23505,7 +23532,7 @@ 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);
@@ -23679,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);
@@ -23735,7 +23764,7 @@ class BaseDocumentDriveServer {
         });
       });
     } catch (error) {
-      logger$1.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -23766,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;
     }
   }
@@ -23783,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;
@@ -23797,7 +23826,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)) {
@@ -23830,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);
@@ -23932,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;
     }
   }
@@ -23960,7 +23989,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));
@@ -23987,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);
@@ -24089,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);
@@ -24465,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);
@@ -24765,21 +24810,26 @@ class SynchronizationManager {
     const drive = await this.getDrive(driveId);
     const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
     this.logger.verbose(`getSynchronizationUnitsRevision: ${JSON.stringify(revisions)}`);
-    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
-      };
-    });
+    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: [
           {
@@ -25740,7 +25790,7 @@ const nodeOptionsMap = {
 };
 const name = "@powerhousedao/connect";
 const productName = "Powerhouse-Connect";
-const version$1 = "1.0.5-dev.0";
+const version$1 = "1.0.6-dev.1";
 const description = "Powerhouse Connect";
 const main = "./dist/index.html";
 const type = "module";
@@ -31380,7 +31430,7 @@ if (window.__VITE_ENVS.MODE === "development") {
 } else {
   serviceWorkerManager.registerServiceWorker(false);
 }
-const App = lazy(() => __vitePreload(() => import("./app-D5aQi0aY.js").then((n) => n.aN), true ? __vite__mapDeps([0,1,2]) : void 0));
+const App = lazy(() => __vitePreload(() => import("./app-DzySetAh.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,