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

package/dist/modules/@powerhousedao/reactor-browser/{chunk-N5UNGAA6.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()
@@ -11915,8 +11918,18 @@ var 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();
@@ -11936,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;
@@ -11955,7 +11974,7 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
     return result.registerPullResponderListener.listenerId;
   }
   static async pullStrands(driveId, url, listenerId, options) {
-    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 {
@@ -11995,27 +12014,34 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
       `, { listenerId });
     const error = result.errors?.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) => {
       const result = await requestGraphql(url, gql`
@@ -12039,74 +12065,124 @@ var 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) {
-    this.staticLogger.verbose(`executePull(driveId: ${driveId}), trigger:`, trigger);
+    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?.([]);
-        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 = graphqlError.response?.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);
-        }
-        listenerRevisions.push({
-          branch: strand.branch,
-          documentId: strand.documentId || "",
-          driveId: strand.driveId,
-          revision: operations.pop()?.index ?? -1,
-          scope: strand.scope,
-          status: error ? error instanceof OperationError ? error.status : "ERROR" : "SUCCESS",
-          error
-        });
+          break;
+        }
       }
-      this.staticLogger.verbose("Processed strands...");
-      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);
+        onRevisions?.([]);
+      } catch (error2) {
+        staticLogger().error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+        onError(error2);
       }
-      if (success) {
-        this.staticLogger.verbose("Acknowledged strands successfully.");
-      } else {
-        this.staticLogger.error("Failed to acknowledge strands");
+      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: operations.pop()?.index ?? -1,
+        scope: strand.scope,
+        status: error2 ? error2 instanceof OperationError ? error2.status : "ERROR" : "SUCCESS",
+        error: error2
+      });
+    }
+    staticLogger().verbose("Processed strands...");
+    try {
+      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?.(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) {
@@ -12118,20 +12194,25 @@ var 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);
@@ -12139,17 +12220,20 @@ 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 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,
@@ -12276,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;
@@ -12347,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);
       });
     }
@@ -12389,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);
   }
@@ -12449,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);
             }
           }
         });
@@ -12473,14 +12558,19 @@ var BaseDocumentDriveServer = class {
   }
   async _initializeDrive(driveId) {
     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 (zodListener.callInfo?.transmitterType === "SwitchboardPush") {
+        this.logger.verbose(`[SYNC DEBUG] Setting up SwitchboardPush listener ${zodListener.listenerId} for drive ${driveId}`);
         const transmitter = new SwitchboardPushTransmitter(zodListener.callInfo?.data ?? "");
-        this.listenerManager.setListener(driveId, {
+        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,
           filter: {
@@ -12494,7 +12584,29 @@ var BaseDocumentDriveServer = class {
           system: zodListener.system,
           label: zodListener.label ?? "",
           transmitter
+        }).then(() => {
+          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 {
+        this.logger.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${zodListener.callInfo?.transmitterType || "unknown"}`);
       }
     }
   }
@@ -12593,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);
@@ -12601,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;
     }
@@ -12613,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;
     }
   }
@@ -12632,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;
   }
@@ -12692,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);
@@ -12864,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);
@@ -12920,7 +13034,7 @@ var BaseDocumentDriveServer = class {
         });
       });
     } catch (error) {
-      logger.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -12951,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;
     }
   }
@@ -12968,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;
@@ -12982,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)) {
@@ -13015,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);
@@ -13116,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;
     }
   }
@@ -13144,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));
@@ -13171,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);
@@ -13273,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);
@@ -13447,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);
@@ -13602,57 +13732,78 @@ var 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?.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?.since,
-            fromRevision: options?.fromRevision ?? 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?.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?.since,
+              fromRevision: options?.fromRevision ?? 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) {
@@ -13717,23 +13868,33 @@ var SynchronizationManager = class {
   }
   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) => ({
+    this.logger.verbose(`getSynchronizationUnitsRevision: ${JSON.stringify(revisions)}`);
+    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: [
           {
@@ -13799,14 +13960,27 @@ var SynchronizationManager = class {
     };
   }
   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,