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

package/dist/modules/@powerhousedao/reactor-browser/{chunk-N5UNGAA6.js → chunk-HYN4HC4N.js}

@@ -1271,13 +1271,6 @@ var DriveAlreadyExistsError = class extends Error {
     this.driveId = driveId;
   }
 };
-var DriveNotFoundError = class extends Error {
-  driveId;
-  constructor(driveId) {
-    super(`Drive with id ${driveId} not found`);
-    this.driveId = driveId;
-  }
-};
 var SynchronizationUnitNotFoundError = class extends Error {
   syncUnitId;
   constructor(message, syncUnitId) {
@@ -1710,7 +1703,7 @@ var MemoryStorage = class {
   // IDocumentStorage
   ////////////////////////////////
   exists(documentId) {
-    return Promise.resolve(!!this.documents[documentId] || !!this.documents[`drive/${documentId}`]);
+    return Promise.resolve(!!this.documents[documentId]);
   }
   create(documentId, document) {
     this.documents[documentId] = document;
@@ -1719,10 +1712,6 @@ var MemoryStorage = class {
   get(documentId) {
     const document = this.documents[documentId];
     if (!document) {
-      const drive = this.documents[`drive/${documentId}`];
-      if (drive) {
-        return Promise.resolve(drive);
-      }
       throw new Error(`Document with id ${documentId} not found`);
     }
     return Promise.resolve(document);
@@ -1775,9 +1764,6 @@ var MemoryStorage = class {
     const manifest = this.getManifest(drive);
     return Promise.resolve([...manifest.documentIds]);
   }
-  getDocument(driveId, id) {
-    return this.get(id);
-  }
   async clearStorage() {
     this.documents = {};
     this.driveManifests = {};
@@ -1789,7 +1775,7 @@ var MemoryStorage = class {
     this.updateDriveManifest(drive, manifest);
   }
   async addDocumentOperations(drive, id, operations, header) {
-    const document = await this.getDocument(drive, id);
+    const document = await this.get(id);
     if (!document) {
       throw new Error(`Document with id ${id} not found`);
     }
@@ -1806,16 +1792,9 @@ var MemoryStorage = class {
   async getDrives() {
     return Object.keys(this.driveManifests);
   }
-  async getDrive(id) {
-    const drive = this.documents[`drive/${id}`];
-    if (!drive) {
-      throw new DriveNotFoundError(id);
-    }
-    return drive;
-  }
   async getDriveBySlug(slug) {
     for (const driveId of Object.keys(this.driveManifests)) {
-      const drive = this.documents[`drive/${driveId}`];
+      const drive = this.documents[driveId];
       if (drive.initialState.state.global.slug === slug) {
         return drive;
       }
@@ -1834,13 +1813,13 @@ var MemoryStorage = class {
         throw new Error(`Drive with slug ${slug} already exists`);
       }
     }
-    await this.create(`drive/${id}`, drive);
+    await this.create(id, drive);
     this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
   }
   async addDriveOperations(id, operations, header) {
-    const drive = await this.getDrive(id);
+    const drive = await this.get(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
-    this.documents[`drive/${id}`] = {
+    this.documents[id] = {
       ...drive,
       ...header,
       operations: mergedOperations
@@ -11745,9 +11724,7 @@ var DefaultDrivesManager = class {
     try {
       await this.server.deleteDrive(driveId);
     } catch (error) {
-      if (!(error instanceof DriveNotFoundError)) {
-        logger.error(error);
-      }
+      logger.error(error);
     }
   }
   async preserveDrivesById(driveIdsToPreserve, drives, removeStrategy = "detach") {
@@ -11898,11 +11875,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 +11895,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 +11926,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 +11951,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 +11991,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 +12042,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 +12171,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 +12197,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,9 +12337,10 @@ function isAtRevision(document, revisions) {
 
 // ../../packages/document-drive/dist/src/server/base-server.js
 var BaseDocumentDriveServer = class {
+  logger = childLogger(["BaseDocumentDriveServer"]);
   // external dependencies
   documentModelModules;
-  storage;
+  legacyStorage;
   documentStorage;
   cache;
   queueManager;
@@ -12315,7 +12377,7 @@ var BaseDocumentDriveServer = class {
   initializePromise;
   constructor(documentModelModules, storage, documentStorage, cache, queueManager, eventEmitter, synchronizationManager, listenerManager, options) {
     this.documentModelModules = documentModelModules;
-    this.storage = storage;
+    this.legacyStorage = storage;
     this.documentStorage = documentStorage;
     this.cache = cache;
     this.queueManager = queueManager;
@@ -12347,19 +12409,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 +12451,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 +12511,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 +12535,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 +12561,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"}`);
       }
     }
   }
@@ -12526,7 +12615,7 @@ var BaseDocumentDriveServer = class {
     if (!id) {
       throw new Error("Invalid Drive Id");
     }
-    const drives = await this.storage.getDrives();
+    const drives = await this.legacyStorage.getDrives();
     if (drives.includes(id)) {
       throw new DriveAlreadyExistsError(id);
     }
@@ -12536,7 +12625,7 @@ var BaseDocumentDriveServer = class {
     document.meta = {
       preferredEditor
     };
-    await this.storage.createDrive(id, document);
+    await this.legacyStorage.createDrive(id, document);
     if (input.global.slug) {
       await this.cache.deleteDriveBySlug(input.global.slug);
     }
@@ -12571,7 +12660,7 @@ var BaseDocumentDriveServer = class {
       this.stopSyncRemoteDrive(driveId),
       this.listenerManager.removeDrive(driveId),
       this.cache.deleteDrive(driveId),
-      this.storage.deleteDrive(driveId)
+      this.legacyStorage.deleteDrive(driveId)
     ]);
     result.forEach((r) => {
       if (r.status === "rejected") {
@@ -12580,7 +12669,7 @@ var BaseDocumentDriveServer = class {
     });
   }
   getDrives() {
-    return this.storage.getDrives();
+    return this.legacyStorage.getDrives();
   }
   async getDrive(driveId, options) {
     let document;
@@ -12593,15 +12682,15 @@ 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 driveStorage = document ?? await this.documentStorage.get(driveId);
     const result = this._buildDocument(driveStorage, options);
     if (!isDocumentDrive(result)) {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
     } else {
       if (!options?.revisions) {
-        this.cache.setDrive(driveId, result).catch(logger.error);
+        this.cache.setDrive(driveId, result).catch(this.logger.error);
       }
       return result;
     }
@@ -12613,14 +12702,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 driveStorage = await this.legacyStorage.getDriveBySlug(slug);
     const document = this._buildDocument(driveStorage, options);
     if (!isDocumentDrive(document)) {
       throw new Error(`Document with slug ${slug} is not a Document Drive`);
     } else {
-      this.cache.setDriveBySlug(slug, document).catch(logger.error);
+      this.cache.setDriveBySlug(slug, document).catch(this.logger.error);
       return document;
     }
   }
@@ -12632,17 +12721,17 @@ 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 documentStorage = cachedDocument ?? await this.documentStorage.get(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;
   }
   getDocuments(driveId) {
-    return this.storage.getDocuments(driveId);
+    return this.legacyStorage.getDocuments(driveId);
   }
   async createDocument(driveId, input) {
     let state = void 0;
@@ -12665,7 +12754,7 @@ var BaseDocumentDriveServer = class {
       clipboard: [],
       state: state ?? document.state
     };
-    await this.storage.createDocument(driveId, input.id, documentStorage);
+    await this.legacyStorage.createDocument(driveId, input.id, documentStorage);
     for (const syncUnit of input.synchronizationUnits) {
       this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
         pull: this.triggerMap.get(driveId) ? "INITIAL_SYNC" : void 0,
@@ -12675,9 +12764,9 @@ var BaseDocumentDriveServer = class {
     const operations = Object.values(document.operations).flat();
     if (operations.length) {
       if (isDocumentDrive(document)) {
-        await this.storage.addDriveOperations(driveId, operations, document);
+        await this.legacyStorage.addDriveOperations(driveId, operations, document);
       } else {
-        await this.storage.addDocumentOperations(driveId, input.id, operations, document);
+        await this.legacyStorage.addDocumentOperations(driveId, input.id, operations, document);
       }
     }
     return document;
@@ -12692,10 +12781,10 @@ 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);
+    return this.legacyStorage.deleteDocument(driveId, documentId);
   }
   async _processOperations(driveId, documentId, documentStorage, operations) {
     const operationsApplied = [];
@@ -12746,7 +12835,7 @@ var BaseDocumentDriveServer = class {
     for (const scope of Object.keys(documentOperations)) {
       const lastRemainingOperation = documentOperations[scope].at(-1);
       if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-        lastRemainingOperation.resultingState = await (documentId ? this.storage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : this.storage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+        lastRemainingOperation.resultingState = await (documentId ? this.legacyStorage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : this.legacyStorage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
       }
     }
     return {
@@ -12778,7 +12867,7 @@ var BaseDocumentDriveServer = class {
     });
     const lastRemainingOperation = documentOperations[scope].at(-1);
     if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-      lastRemainingOperation.resultingState = await (documentId ? this.storage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : this.storage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+      lastRemainingOperation.resultingState = await (documentId ? this.legacyStorage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main") : this.legacyStorage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
     }
     const operationSignals = [];
     newDocument = documentModelModule.reducer(newDocument, operation, (signal) => {
@@ -12825,14 +12914,14 @@ var BaseDocumentDriveServer = class {
     return this.addOperations(driveId, documentId, [operation], options);
   }
   async _addOperations(driveId, documentId, callback) {
-    if (!this.storage.addDocumentOperationsWithTransaction) {
-      const documentStorage = await this.storage.getDocument(driveId, documentId);
+    if (!this.legacyStorage.addDocumentOperationsWithTransaction) {
+      const documentStorage = await this.documentStorage.get(documentId);
       const result = await callback(documentStorage);
       if (result.operations.length > 0) {
-        await this.storage.addDocumentOperations(driveId, documentId, result.operations, result.header);
+        await this.legacyStorage.addDocumentOperations(driveId, documentId, result.operations, result.header);
       }
     } else {
-      await this.storage.addDocumentOperationsWithTransaction(driveId, documentId, callback);
+      await this.legacyStorage.addDocumentOperationsWithTransaction(driveId, documentId, callback);
     }
   }
   queueOperation(driveId, documentId, operation, options) {
@@ -12864,33 +12953,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 +13011,7 @@ var BaseDocumentDriveServer = class {
         });
       });
     } catch (error) {
-      logger.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -12951,7 +13042,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 +13059,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 +13073,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 +13106,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);
@@ -13052,18 +13143,18 @@ var BaseDocumentDriveServer = class {
     for (const drive of await this.getDrives()) {
       await this.deleteDrive(drive);
     }
-    await this.storage.clearStorage?.();
+    await this.legacyStorage.clearStorage?.();
   }
   async _addDriveOperations(driveId, callback) {
-    if (!this.storage.addDriveOperationsWithTransaction) {
-      const documentStorage = await this.storage.getDrive(driveId);
+    if (!this.legacyStorage.addDriveOperationsWithTransaction) {
+      const documentStorage = await this.documentStorage.get(driveId);
       const result = await callback(documentStorage);
       if (result.operations.length > 0) {
-        await this.storage.addDriveOperations(driveId, result.operations, result.header);
+        await this.legacyStorage.addDriveOperations(driveId, result.operations, result.header);
       }
       return result;
     } else {
-      return this.storage.addDriveOperationsWithTransaction(driveId, callback);
+      return this.legacyStorage.addDriveOperationsWithTransaction(driveId, callback);
     }
   }
   queueDriveOperation(driveId, operation, options) {
@@ -13116,7 +13207,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 +13235,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 +13262,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 +13364,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 +13555,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 +13709,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) {
@@ -13704,36 +13832,48 @@ var TransmitterFactory = class {
 // ../../packages/document-drive/dist/src/server/sync-manager.js
 var SynchronizationManager = class {
   storage;
+  documentStorage;
   cache;
   documentModelModules;
   eventEmitter;
   syncStatus = /* @__PURE__ */ new Map();
   logger = childLogger(["SynchronizationManager"]);
-  constructor(storage, cache, documentModelModules, eventEmitter) {
+  constructor(storage, documentStorage, cache, documentModelModules, eventEmitter) {
     this.storage = storage;
+    this.documentStorage = documentStorage;
     this.cache = cache;
     this.documentModelModules = documentModelModules;
     this.eventEmitter = eventEmitter;
   }
   async getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
     const synchronizationUnitsQuery = await this.getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType2);
+    this.logger.verbose(`getSynchronizationUnits query: ${JSON.stringify(synchronizationUnitsQuery)}`);
     return this.getSynchronizationUnitsRevision(driveId, synchronizationUnitsQuery);
   }
   async getSynchronizationUnitsRevision(driveId, syncUnitsQuery) {
     const drive = await this.getDrive(driveId);
     const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
-    return syncUnitsQuery.map((s) => ({
+    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 +13939,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,
@@ -13827,7 +13980,7 @@ var SynchronizationManager = class {
     } catch (e) {
       this.logger.error("Error getting drive from cache", e);
     }
-    const driveStorage = await this.storage.getDrive(driveId);
+    const driveStorage = await this.documentStorage.get(driveId);
     const result = this._buildDocument(driveStorage);
     if (!isDocumentDrive(result)) {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
@@ -13843,7 +13996,7 @@ var SynchronizationManager = class {
     } catch (e) {
       this.logger.error("Error getting document from cache", e);
     }
-    const documentStorage = await this.storage.getDocument(driveId, documentId);
+    const documentStorage = await this.documentStorage.get(documentId);
     return this._buildDocument(documentStorage);
   }
   _buildDocument(documentStorage) {
@@ -14005,7 +14158,14 @@ var ReactorBuilder = class {
       this.eventEmitter = new DefaultEventEmitter();
     }
     if (!this.synchronizationManager) {
-      this.synchronizationManager = new SynchronizationManager(this.storage, this.cache, this.documentModelModules, this.eventEmitter);
+      this.synchronizationManager = new SynchronizationManager(
+        this.storage,
+        // as we refactor, we're secretly making all the IStorage implementations also implement IDocumentStorage
+        this.storage,
+        this.cache,
+        this.documentModelModules,
+        this.eventEmitter
+      );
     }
     if (!this.listenerManager) {
       const config = {
@@ -14043,7 +14203,6 @@ export {
   isFolderNode,
   generateNodesCopy,
   generateAddNodeAction,
-  DriveNotFoundError,
   mergeOperations,
   BaseQueueManager,
   ReadDriveNotFoundError,