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

package/dist/modules/@powerhousedao/reactor-browser/{chunk-64UP3MVE.js → chunk-SQ5HIKYV.js}

@@ -11898,11 +11898,14 @@ var PULL_DRIVE_INTERVAL = 1500;
 
 // ../../packages/document-drive/dist/src/server/listener/transmitter/pull-responder.js
 var MAX_REVISIONS_PER_ACK = 100;
+var _staticLogger;
+var staticLogger = () => {
+  if (!_staticLogger) {
+    _staticLogger = childLogger(["PullResponderTransmitter", "static"]);
+  }
+  return _staticLogger;
+};
 var PullResponderTransmitter = class _PullResponderTransmitter {
-  static staticLogger = childLogger([
-    "PullResponderTransmitter",
-    "static"
-  ]);
   logger = childLogger([
     "PullResponderTransmitter",
     Math.floor(Math.random() * 999).toString()
@@ -11946,15 +11949,21 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
     }
     return success;
   }
-  static async registerPullResponder(driveId, url, filter) {
-    _PullResponderTransmitter.staticLogger.verbose(`registerPullResponder(url: ${url})`, filter);
+  static async registerPullResponder(driveId, url, filter, listenerId) {
+    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 = result.errors?.at(0);
     if (error) {
       throw error;
@@ -11965,7 +11974,7 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
     return result.registerPullResponderListener.listenerId;
   }
   static async pullStrands(driveId, url, listenerId, options) {
-    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 {
@@ -12005,11 +12014,11 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
       `, { listenerId });
     const error = result.errors?.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) => ({
@@ -12019,20 +12028,20 @@ var 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) => {
       const result = await requestGraphql(url, gql`
@@ -12065,27 +12074,27 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
    * Because of this, `onError` _may be called multiple times_.
    */
   static async executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
-    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 = graphqlError.response?.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}`);
+            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;
           }
@@ -12094,21 +12103,21 @@ var 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?.([]);
       } 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) => ({
@@ -12116,7 +12125,7 @@ var 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, {
@@ -12127,7 +12136,7 @@ var 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);
       }
@@ -12141,14 +12150,14 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
         error: error2
       });
     }
-    this.staticLogger.verbose("Processed strands...");
+    staticLogger().verbose("Processed strands...");
     try {
       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) => {
@@ -12157,23 +12166,23 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
       }));
       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?.(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) {
@@ -12185,25 +12194,25 @@ var 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);
@@ -12211,7 +12220,7 @@ var 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: ["*"],
@@ -12351,6 +12360,7 @@ function isAtRevision(document, revisions) {
 
 // ../../packages/document-drive/dist/src/server/base-server.js
 var BaseDocumentDriveServer = class {
+  logger = childLogger(["BaseDocumentDriveServer"]);
   // external dependencies
   documentModelModules;
   storage;
@@ -12422,19 +12432,19 @@ var BaseDocumentDriveServer = class {
   async _initialize() {
     await this.listenerManager.initialize(this.handleListenerError);
     await this.queueManager.init(this.queueDelegate, (error) => {
-      logger.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.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.error(`Error initializing drive ${drive}`, error);
+        this.logger.error(`Error initializing drive ${drive}`, error);
         errors.push(error);
       });
     }
@@ -12464,7 +12474,7 @@ var BaseDocumentDriveServer = class {
     return source.type === "local" ? "push" : "pull";
   }
   handleListenerError(error, driveId, listener) {
-    logger.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);
   }
@@ -12524,9 +12534,9 @@ var BaseDocumentDriveServer = class {
             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.error);
+                  this.listenerManager.updateListenerRevision(pushListener.listenerId, driveId, revision.syncId, revision.revision).catch(this.logger.error);
                 }
-              }).catch(logger.error);
+              }).catch(this.logger.error);
             }
           }
         });
@@ -12548,18 +12558,18 @@ var BaseDocumentDriveServer = class {
   }
   async _initializeDrive(driveId) {
     const drive = await this.getDrive(driveId);
-    logger.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.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.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 (zodListener.callInfo?.transmitterType === "SwitchboardPush") {
-        logger.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(zodListener.callInfo?.data ?? "");
-        logger.verbose(`[SYNC DEBUG] Created SwitchboardPush transmitter with URL: ${zodListener.callInfo?.data || "none"}`);
+        this.logger.verbose(`[SYNC DEBUG] Created SwitchboardPush transmitter with URL: ${zodListener.callInfo?.data || "none"}`);
         await this.listenerManager.setListener(driveId, {
           block: zodListener.block,
           driveId: drive.state.global.id,
@@ -12575,10 +12585,28 @@ var BaseDocumentDriveServer = class {
           label: zodListener.label ?? "",
           transmitter
         }).then(() => {
-          logger.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 (zodListener.callInfo?.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.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${zodListener.callInfo?.transmitterType || "unknown"}`);
+        this.logger.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${zodListener.callInfo?.transmitterType || "unknown"}`);
       }
     }
   }
@@ -12677,7 +12705,7 @@ var BaseDocumentDriveServer = class {
         }
       }
     } catch (e) {
-      logger.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);
@@ -12685,7 +12713,7 @@ var BaseDocumentDriveServer = class {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
     } else {
       if (!options?.revisions) {
-        this.cache.setDrive(driveId, result).catch(logger.error);
+        this.cache.setDrive(driveId, result).catch(this.logger.error);
       }
       return result;
     }
@@ -12697,14 +12725,14 @@ var BaseDocumentDriveServer = class {
         return drive;
       }
     } catch (e) {
-      logger.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.error);
+      this.cache.setDriveBySlug(slug, document).catch(this.logger.error);
       return document;
     }
   }
@@ -12716,12 +12744,12 @@ var BaseDocumentDriveServer = class {
         return cachedDocument;
       }
     } catch (e) {
-      logger.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?.revisions) {
-      this.cache.setDocument(documentId, document).catch(logger.error);
+      this.cache.setDocument(documentId, document).catch(this.logger.error);
     }
     return document;
   }
@@ -12776,7 +12804,7 @@ var BaseDocumentDriveServer = class {
       }
       await this.listenerManager.removeSyncUnits(driveId, syncUnits);
     } catch (error) {
-      logger.warn("Error deleting document", error);
+      this.logger.warn("Error deleting document", error);
     }
     await this.cache.deleteDocument(documentId);
     return this.storage.deleteDocument(driveId, documentId);
@@ -12948,33 +12976,35 @@ var BaseDocumentDriveServer = class {
     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.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);
@@ -13004,7 +13034,7 @@ var BaseDocumentDriveServer = class {
         });
       });
     } catch (error) {
-      logger.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -13035,7 +13065,7 @@ var BaseDocumentDriveServer = class {
         });
       });
     } catch (error) {
-      logger.error("Error adding drive job", error);
+      this.logger.error("Error adding drive job", error);
       throw error;
     }
   }
@@ -13052,7 +13082,7 @@ var BaseDocumentDriveServer = class {
       await this._addOperations(driveId, documentId, async (documentStorage) => {
         const result2 = await this._processOperations(driveId, documentId, documentStorage, operations);
         if (!result2.document) {
-          logger.error("Invalid document");
+          this.logger.error("Invalid document");
           throw result2.error ?? new Error("Invalid document");
         }
         document = result2.document;
@@ -13066,7 +13096,7 @@ var BaseDocumentDriveServer = class {
         };
       });
       if (document) {
-        this.cache.setDocument(documentId, document).catch(logger.error);
+        this.cache.setDocument(documentId, document).catch(this.logger.error);
       }
       const { scopes, branches } = operationsApplied.reduce((acc, operation) => {
         if (!acc.scopes.includes(operation.scope)) {
@@ -13099,7 +13129,7 @@ var BaseDocumentDriveServer = class {
           });
         }
       }).catch((error2) => {
-        logger.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);
@@ -13200,7 +13230,7 @@ var BaseDocumentDriveServer = class {
         });
       });
     } catch (error) {
-      logger.error("Error adding drive job", error);
+      this.logger.error("Error adding drive job", error);
       throw error;
     }
   }
@@ -13228,7 +13258,7 @@ var BaseDocumentDriveServer = class {
       if (!document || !isDocumentDrive(document)) {
         throw error ?? new Error("Invalid Document Drive document");
       }
-      this.cache.setDrive(driveId, document).catch(logger.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));
@@ -13255,7 +13285,7 @@ var BaseDocumentDriveServer = class {
             });
           }
         }).catch((error2) => {
-          logger.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);
@@ -13357,9 +13387,26 @@ var BaseDocumentDriveServer = class {
       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);
@@ -13531,11 +13578,10 @@ var 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?.transmit) {
-          this.logger.verbose(`Transmitter not set on listener: ${listenerId}`);
           continue;
         }
         const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
@@ -13829,18 +13875,26 @@ var SynchronizationManager = class {
     const drive = await this.getDrive(driveId);
     const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
     this.logger.verbose(`getSynchronizationUnitsRevision: ${JSON.stringify(revisions)}`);
-    return syncUnitsQuery.map((s) => ({
+    const synchronizationUnits = syncUnitsQuery.map((s) => ({
       ...s,
       lastUpdated: drive.created,
-      revision: revisions.find((r) => r.documentId === s.documentId && r.scope === s.scope && r.branch === s.branch)?.revision ?? -1
+      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?.length || documentId.includes(node.id) || documentId.includes("*")) && (!documentType2?.length || documentType2.includes(node.documentType) || documentType2.includes("*")));
     if ((!documentId || documentId.includes("*") || documentId.includes("")) && (!documentType2?.length || documentType2.includes("powerhouse/document-drive") || documentType2.includes("*"))) {
       nodes.unshift({
-        id: drive.state.global.id,
+        id: driveId,
         documentType: "powerhouse/document-drive",
         synchronizationUnits: [
           {

package/dist/modules/@powerhousedao/reactor-browser/{chunk-UWJGRLW3.js → chunk-XV42KZK3.js}

@@ -1,6 +1,6 @@
 import {
   useDriveActions
-} from "./chunk-ZWFCVUBU.js";
+} from "./chunk-5QJXNK35.js";
 import {
   useDriveContext
 } from "./chunk-XBTEGV5M.js";

package/dist/modules/@powerhousedao/reactor-browser/context/index.js

@@ -3,10 +3,10 @@ import {
   ReadModeContext,
   ReadModeContextProvider,
   useReadModeContext
-} from "../chunk-YSOX63EM.js";
+} from "../chunk-3C54663M.js";
 import "../chunk-OVGOA2P5.js";
 import "../chunk-P6NJ6IAQ.js";
-import "../chunk-64UP3MVE.js";
+import "../chunk-SQ5HIKYV.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-2ESYSVXG.js";
 export {

package/dist/modules/@powerhousedao/reactor-browser/context/read-mode.js

@@ -2,10 +2,10 @@ import {
   ReadModeContext,
   ReadModeContextProvider,
   useReadModeContext
-} from "../chunk-YSOX63EM.js";
+} from "../chunk-3C54663M.js";
 import "../chunk-OVGOA2P5.js";
 import "../chunk-P6NJ6IAQ.js";
-import "../chunk-64UP3MVE.js";
+import "../chunk-SQ5HIKYV.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-2ESYSVXG.js";
 export {