@powerhousedao/connect 1.0.8 → 1.0.10-dev.0

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

@@ -688,30 +688,79 @@ var require_lib = __commonJS({
   }
 });
 
+// ../../packages/document-drive/dist/src/cache/util.js
+var trimResultingState = (document) => {
+  const global2 = document.operations.global.map((e) => {
+    delete e.resultingState;
+    return e;
+  });
+  const local = document.operations.local.map((e) => {
+    delete e.resultingState;
+    return e;
+  });
+  return { ...document, operations: { global: global2, local } };
+};
+
 // ../../packages/document-drive/dist/src/cache/memory.js
 var InMemoryCache = class {
-  cache = /* @__PURE__ */ new Map();
-  async setDocument(drive, id, document) {
-    const global2 = document.operations.global.map((e) => {
-      delete e.resultingState;
-      return e;
-    });
-    const local = document.operations.local.map((e) => {
-      delete e.resultingState;
-      return e;
-    });
-    const doc = { ...document, operations: { global: global2, local } };
-    if (!this.cache.has(drive)) {
-      this.cache.set(drive, /* @__PURE__ */ new Map());
+  idTodocument = /* @__PURE__ */ new Map();
+  idToDrive = /* @__PURE__ */ new Map();
+  slugToDriveId = /* @__PURE__ */ new Map();
+  clear() {
+    this.idTodocument.clear();
+    this.idToDrive.clear();
+    this.slugToDriveId.clear();
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // ICache
+  /////////////////////////////////////////////////////////////////////////////
+  async setDocument(documentId, document) {
+    const doc = trimResultingState(document);
+    this.idTodocument.set(documentId, doc);
+  }
+  async getDocument(documentId) {
+    return this.idTodocument.get(documentId);
+  }
+  async deleteDocument(documentId) {
+    return this.idTodocument.delete(documentId);
+  }
+  async setDrive(driveId, drive) {
+    const doc = trimResultingState(drive);
+    this.idToDrive.set(driveId, doc);
+  }
+  async getDrive(driveId) {
+    return this.idToDrive.get(driveId);
+  }
+  async deleteDrive(driveId) {
+    const drive = this.idToDrive.get(driveId);
+    if (!drive) {
+      return false;
     }
-    this.cache.get(drive)?.set(id, doc);
-    return true;
+    const slug = drive.state.global.slug;
+    if (slug) {
+      this.slugToDriveId.delete(slug);
+    }
+    return this.idToDrive.delete(driveId);
   }
-  async deleteDocument(drive, id) {
-    return this.cache.get(drive)?.delete(id) ?? false;
+  async setDriveBySlug(slug, drive) {
+    const driveId = drive.state.global.id;
+    this.slugToDriveId.set(slug, driveId);
+    this.setDrive(driveId, drive);
   }
-  async getDocument(drive, id) {
-    return this.cache.get(drive)?.get(id);
+  async getDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return void 0;
+    }
+    return this.getDrive(driveId);
+  }
+  async deleteDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return false;
+    }
+    this.slugToDriveId.delete(slug);
+    return this.deleteDrive(driveId);
   }
 };
 var memory_default = InMemoryCache;
@@ -1652,19 +1701,16 @@ var ReadDocumentNotFoundError = class extends ReadDriveError {
 // ../../packages/document-drive/dist/src/storage/memory.js
 var MemoryStorage = class {
   documents;
-  drives;
   driveManifests;
-  slugToDriveId = {};
   constructor() {
     this.documents = {};
-    this.drives = {};
     this.driveManifests = {};
   }
   ////////////////////////////////
   // IDocumentStorage
   ////////////////////////////////
   exists(documentId) {
-    return Promise.resolve(!!this.documents[documentId]);
+    return Promise.resolve(!!this.documents[documentId] || !!this.documents[`drive/${documentId}`]);
   }
   create(documentId, document) {
     this.documents[documentId] = document;
@@ -1673,10 +1719,52 @@ 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);
   }
+  async delete(documentId) {
+    const drives = await this.getDrives();
+    for (const driveId of drives) {
+      if (driveId === documentId)
+        continue;
+      await this.removeChild(driveId, documentId);
+    }
+    delete this.driveManifests[documentId];
+    if (this.documents[documentId]) {
+      delete this.documents[documentId];
+      return Promise.resolve(true);
+    }
+    return Promise.resolve(false);
+  }
+  async addChild(parentId, childId) {
+    if (parentId === childId) {
+      throw new Error("Cannot associate a document with itself");
+    }
+    const children = await this.getChildren(childId);
+    if (children.includes(parentId)) {
+      throw new Error("Cannot associate a document with its child");
+    }
+    const manifest = this.getManifest(parentId);
+    manifest.documentIds.add(childId);
+    this.updateDriveManifest(parentId, manifest);
+  }
+  async removeChild(parentId, childId) {
+    const manifest = this.getManifest(parentId);
+    if (manifest.documentIds.delete(childId)) {
+      this.updateDriveManifest(parentId, manifest);
+      return true;
+    }
+    return false;
+  }
+  async getChildren(parentId) {
+    const manifest = this.getManifest(parentId);
+    return [...manifest.documentIds];
+  }
   ////////////////////////////////
   // IDriveStorage
   ////////////////////////////////
@@ -1684,27 +1772,19 @@ var MemoryStorage = class {
     return this.exists(id);
   }
   getDocuments(drive) {
-    const manifest = this.getDriveManifest(drive);
+    const manifest = this.getManifest(drive);
     return Promise.resolve([...manifest.documentIds]);
   }
   getDocument(driveId, id) {
     return this.get(id);
   }
-  async saveDocument(drive, id, document) {
-    this.documents[id] = document;
-    const manifest = this.getDriveManifest(drive);
-    manifest.documentIds.add(id);
-    this.updateDriveManifest(drive, manifest);
-  }
   async clearStorage() {
     this.documents = {};
-    this.drives = {};
     this.driveManifests = {};
-    this.slugToDriveId = {};
   }
   async createDocument(drive, id, document) {
     await this.create(id, document);
-    const manifest = this.getDriveManifest(drive);
+    const manifest = this.getManifest(drive);
     manifest.documentIds.add(id);
     this.updateDriveManifest(drive, manifest);
   }
@@ -1721,59 +1801,60 @@ var MemoryStorage = class {
     };
   }
   async deleteDocument(drive, id) {
-    const drives = await this.getDrives();
-    for (const driveId of drives) {
-      const manifest = this.getDriveManifest(driveId);
-      if (manifest.documentIds.has(id)) {
-        manifest.documentIds.delete(id);
-        this.updateDriveManifest(driveId, manifest);
-      }
-    }
-    delete this.documents[id];
+    this.delete(id);
   }
   async getDrives() {
-    return Object.keys(this.drives);
+    return Object.keys(this.driveManifests);
   }
   async getDrive(id) {
-    const drive = this.drives[id];
+    const drive = this.documents[`drive/${id}`];
     if (!drive) {
       throw new DriveNotFoundError(id);
     }
     return drive;
   }
   async getDriveBySlug(slug) {
-    const driveId = this.slugToDriveId[slug];
-    if (!driveId) {
-      throw new Error(`Drive with slug ${slug} not found`);
+    for (const driveId of Object.keys(this.driveManifests)) {
+      const drive = this.documents[`drive/${driveId}`];
+      if (drive.initialState.state.global.slug === slug) {
+        return drive;
+      }
     }
-    return this.getDrive(driveId);
+    throw new Error(`Drive with slug ${slug} not found`);
   }
   async createDrive(id, drive) {
-    this.drives[id] = drive;
-    this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
-    const { slug } = drive.initialState.state.global;
+    const slug = drive.initialState.state.global.slug;
     if (slug) {
-      this.slugToDriveId[slug] = id;
+      let existingDrive;
+      try {
+        existingDrive = await this.getDriveBySlug(slug);
+      } catch {
+      }
+      if (existingDrive) {
+        throw new Error(`Drive with slug ${slug} already exists`);
+      }
     }
+    await this.create(`drive/${id}`, drive);
+    this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
   }
   async addDriveOperations(id, operations, header) {
     const drive = await this.getDrive(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
-    this.drives[id] = {
+    this.documents[`drive/${id}`] = {
       ...drive,
       ...header,
       operations: mergedOperations
     };
   }
   async deleteDrive(id) {
-    const manifest = this.getDriveManifest(id);
+    const manifest = this.getManifest(id);
     const drives = await this.getDrives();
     await Promise.all([...manifest.documentIds].map((docId) => {
       for (const driveId of drives) {
         if (driveId === id) {
           continue;
         }
-        const manifest2 = this.getDriveManifest(driveId);
+        const manifest2 = this.getManifest(driveId);
         if (manifest2.documentIds.has(docId)) {
           return;
         }
@@ -1781,24 +1862,18 @@ var MemoryStorage = class {
       delete this.documents[docId];
     }));
     delete this.driveManifests[id];
-    delete this.drives[id];
-    for (const [slug, driveId] of Object.entries(this.slugToDriveId)) {
-      if (driveId === id) {
-        delete this.slugToDriveId[slug];
-      }
-    }
+    delete this.documents[id];
   }
   async getSynchronizationUnitsRevision(units) {
     const results = await Promise.allSettled(units.map(async (unit) => {
       try {
-        const document = await (unit.documentId ? this.getDocument(unit.driveId, unit.documentId) : this.getDrive(unit.driveId));
+        const document = await this.get(unit.documentId);
         if (!document) {
           return void 0;
         }
         const operation = document.operations[unit.scope].at(-1);
         if (operation) {
           return {
-            driveId: unit.driveId,
             documentId: unit.documentId,
             scope: unit.scope,
             branch: unit.branch,
@@ -1820,7 +1895,7 @@ var MemoryStorage = class {
   ////////////////////////////////
   // Private
   ////////////////////////////////
-  getDriveManifest(driveId) {
+  getManifest(driveId) {
     if (!this.driveManifests[driveId]) {
       this.driveManifests[driveId] = { documentIds: /* @__PURE__ */ new Set() };
     }
@@ -11823,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()
@@ -11840,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();
@@ -11851,7 +11939,7 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
     const syncUnits = await this.manager.getListenerSyncUnitIds(driveId, listenerId);
     let success = true;
     for (const revision of revisions) {
-      const syncUnit = syncUnits.find((s) => s.scope === revision.scope && s.branch === revision.branch && s.driveId === revision.driveId && s.documentId == revision.documentId);
+      const syncUnit = syncUnits.find((s) => s.scope === revision.scope && s.branch === revision.branch && s.documentId == revision.documentId);
       if (!syncUnit) {
         this.logger.warn("Unknown sync unit was acknowledged", revision);
         success = false;
@@ -11861,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;
@@ -11880,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 {
@@ -11920,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`
@@ -11964,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) {
@@ -12043,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);
@@ -12064,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,
@@ -12088,6 +12247,80 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
   }
 };
 
+// ../../packages/document-drive/dist/src/server/listener/transmitter/switchboard-push.js
+var import_json_stringify_deterministic = __toESM(require_lib(), 1);
+var SYNC_OPS_BATCH_LIMIT = 10;
+var SwitchboardPushTransmitter = class {
+  targetURL;
+  logger = childLogger([
+    "SwitchboardPushTransmitter",
+    Math.floor(Math.random() * 999).toString()
+  ]);
+  constructor(targetURL) {
+    this.targetURL = targetURL;
+  }
+  async transmit(strands, source) {
+    if (source.type === "trigger" && source.trigger.data?.url === this.targetURL) {
+      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
+      return strands.map((strand) => ({
+        driveId: strand.driveId,
+        documentId: strand.documentId,
+        scope: strand.scope,
+        branch: strand.branch,
+        status: "SUCCESS",
+        revision: strand.operations.at(-1)?.index ?? -1
+      }));
+    }
+    const culledStrands = [];
+    let opsCounter = 0;
+    for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
+      const currentStrand = strands.at(s);
+      if (!currentStrand) {
+        break;
+      }
+      const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
+      culledStrands.push({
+        ...currentStrand,
+        operations: currentStrand.operations.slice(0, newOps)
+      });
+      opsCounter += newOps;
+    }
+    this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
+    this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
+    try {
+      const { pushUpdates } = await requestGraphql(this.targetURL, gql`
+          mutation pushUpdates($strands: [InputStrandUpdate!]) {
+            pushUpdates(strands: $strands) {
+              driveId
+              documentId
+              scope
+              branch
+              status
+              revision
+              error
+            }
+          }
+        `, {
+        strands: culledStrands.map((strand) => ({
+          ...strand,
+          operations: strand.operations.map((op) => ({
+            ...op,
+            input: (0, import_json_stringify_deterministic.default)(op.input)
+          }))
+        }))
+      });
+      if (!pushUpdates) {
+        throw new Error("Couldn't update listener revision");
+      }
+      return pushUpdates;
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+    return [];
+  }
+};
+
 // ../../packages/document-drive/dist/src/server/types.js
 var TransmitterType;
 (function(TransmitterType2) {
@@ -12127,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;
@@ -12185,17 +12419,6 @@ var BaseDocumentDriveServer = class {
       taskQueueMethod: options?.taskQueueMethod === void 0 ? RunAsap.runAsap : options.taskQueueMethod
     };
     this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
-    this.storage.setStorageDelegate?.({
-      getCachedOperations: async (drive, id) => {
-        try {
-          const document = await this.cache.getDocument(drive, id);
-          return document?.operations;
-        } catch (error) {
-          logger.error(error);
-          return void 0;
-        }
-      }
-    });
     this.initializePromise = this._initialize();
   }
   // workaround for testing the ephemeral listeners -- we don't have DI in place yet
@@ -12209,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);
       });
     }
@@ -12251,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);
   }
@@ -12311,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);
             }
           }
         });
@@ -12335,10 +12558,57 @@ 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.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: {
+            branch: zodListener.filter?.branch ?? [],
+            documentId: zodListener.filter?.documentId ?? [],
+            documentType: zodListener.filter?.documentType ?? [],
+            scope: zodListener.filter?.scope ?? []
+          },
+          listenerId: zodListener.listenerId,
+          callInfo: zodListener.callInfo,
+          system: zodListener.system,
+          label: zodListener.label ?? "",
+          transmitter
+        }).then(() => {
+          this.logger.verbose(`[SYNC DEBUG] Successfully set up listener ${zodListener.listenerId} for drive ${driveId}`);
+        });
+      } else if (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"}`);
+      }
+    }
   }
   // Delegate synchronization methods to synchronizationManager
   getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
@@ -12380,7 +12650,7 @@ var BaseDocumentDriveServer = class {
     };
     await this.storage.createDrive(id, document);
     if (input.global.slug) {
-      await this.cache.deleteDocument("drives-slug", input.global.slug);
+      await this.cache.deleteDriveBySlug(input.global.slug);
     }
     await this._initializeDrive(id);
     this.eventEmitter.emit("driveAdded", document);
@@ -12412,7 +12682,7 @@ var BaseDocumentDriveServer = class {
     const result = await Promise.allSettled([
       this.stopSyncRemoteDrive(driveId),
       this.listenerManager.removeDrive(driveId),
-      this.cache.deleteDocument("drives", driveId),
+      this.cache.deleteDrive(driveId),
       this.storage.deleteDrive(driveId)
     ]);
     result.forEach((r) => {
@@ -12427,7 +12697,7 @@ var BaseDocumentDriveServer = class {
   async getDrive(driveId, options) {
     let document;
     try {
-      const cachedDocument = await this.cache.getDocument("drives", driveId);
+      const cachedDocument = await this.cache.getDrive(driveId);
       if (cachedDocument && isDocumentDrive(cachedDocument)) {
         document = cachedDocument;
         if (isAtRevision(document, options?.revisions)) {
@@ -12435,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);
@@ -12443,43 +12713,43 @@ var BaseDocumentDriveServer = class {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
     } else {
       if (!options?.revisions) {
-        this.cache.setDocument("drives", driveId, result).catch(logger.error);
+        this.cache.setDrive(driveId, result).catch(this.logger.error);
       }
       return result;
     }
   }
   async getDriveBySlug(slug, options) {
     try {
-      const document2 = await this.cache.getDocument("drives-slug", slug);
-      if (document2 && isDocumentDrive(document2)) {
-        return document2;
+      const drive = await this.cache.getDriveBySlug(slug);
+      if (drive) {
+        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.setDocument("drives-slug", slug, document).catch(logger.error);
+      this.cache.setDriveBySlug(slug, document).catch(this.logger.error);
       return document;
     }
   }
   async getDocument(driveId, documentId, options) {
     let cachedDocument;
     try {
-      cachedDocument = await this.cache.getDocument(driveId, documentId);
+      cachedDocument = await this.cache.getDocument(documentId);
       if (cachedDocument && isAtRevision(cachedDocument, options?.revisions)) {
         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(driveId, documentId, document).catch(logger.error);
+      this.cache.setDocument(documentId, document).catch(this.logger.error);
     }
     return document;
   }
@@ -12534,9 +12804,9 @@ 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(driveId, documentId);
+    await this.cache.deleteDocument(documentId);
     return this.storage.deleteDocument(driveId, documentId);
   }
   async _processOperations(driveId, documentId, documentStorage, operations) {
@@ -12706,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);
@@ -12762,7 +13034,7 @@ var BaseDocumentDriveServer = class {
         });
       });
     } catch (error) {
-      logger.error("Error adding job", error);
+      this.logger.error("Error adding job", error);
       throw error;
     }
   }
@@ -12793,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;
     }
   }
@@ -12810,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;
@@ -12824,7 +13096,7 @@ var BaseDocumentDriveServer = class {
         };
       });
       if (document) {
-        this.cache.setDocument(driveId, 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)) {
@@ -12857,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);
@@ -12958,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;
     }
   }
@@ -12986,7 +13258,7 @@ var BaseDocumentDriveServer = class {
       if (!document || !isDocumentDrive(document)) {
         throw error ?? new Error("Invalid Document Drive document");
       }
-      this.cache.setDocument("drives", 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));
@@ -12995,7 +13267,6 @@ var BaseDocumentDriveServer = class {
         this.listenerManager.updateSynchronizationRevisions(driveId, [
           {
             syncId: "0",
-            driveId,
             documentId: "",
             scope: "global",
             branch: "main",
@@ -13014,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);
@@ -13116,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);
@@ -13290,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);
@@ -13306,7 +13593,7 @@ var ListenerManager = class _ListenerManager {
             this.logger.verbose(`Abandoning push for sync unit ${syncUnit.syncId}: already up-to-date (${unitState.listenerRev} >= ${syncUnit.revision})`);
             return;
           } else {
-            this.logger.verbose(`Listener out-of-date for sync unit (${syncUnit.driveId}, ${syncUnit.scope}, ${syncUnit.documentId}): ${unitState?.listenerRev} < ${syncUnit.revision}`);
+            this.logger.verbose(`Listener out-of-date for sync unit (${syncUnit.scope}, ${syncUnit.documentId}): ${unitState?.listenerRev} < ${syncUnit.revision}`);
           }
           const opData = [];
           try {
@@ -13445,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, driveId: driveId2, scope, branch } = syncUnit;
-      try {
-        const operations = await this.syncManager.getOperationData(
-          // DEAL WITH INVALID SYNC ID ERROR
-          driveId2,
-          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: driveId2,
-          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) {
@@ -13520,80 +13828,6 @@ var ListenerManager = class _ListenerManager {
   }
 };
 
-// ../../packages/document-drive/dist/src/server/listener/transmitter/switchboard-push.js
-var import_json_stringify_deterministic = __toESM(require_lib(), 1);
-var SYNC_OPS_BATCH_LIMIT = 10;
-var SwitchboardPushTransmitter = class {
-  targetURL;
-  logger = childLogger([
-    "SwitchboardPushTransmitter",
-    Math.floor(Math.random() * 999).toString()
-  ]);
-  constructor(targetURL) {
-    this.targetURL = targetURL;
-  }
-  async transmit(strands, source) {
-    if (source.type === "trigger" && source.trigger.data?.url === this.targetURL) {
-      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
-      return strands.map((strand) => ({
-        driveId: strand.driveId,
-        documentId: strand.documentId,
-        scope: strand.scope,
-        branch: strand.branch,
-        status: "SUCCESS",
-        revision: strand.operations.at(-1)?.index ?? -1
-      }));
-    }
-    const culledStrands = [];
-    let opsCounter = 0;
-    for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
-      const currentStrand = strands.at(s);
-      if (!currentStrand) {
-        break;
-      }
-      const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
-      culledStrands.push({
-        ...currentStrand,
-        operations: currentStrand.operations.slice(0, newOps)
-      });
-      opsCounter += newOps;
-    }
-    this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
-    this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
-    try {
-      const { pushUpdates } = await requestGraphql(this.targetURL, gql`
-          mutation pushUpdates($strands: [InputStrandUpdate!]) {
-            pushUpdates(strands: $strands) {
-              driveId
-              documentId
-              scope
-              branch
-              status
-              revision
-              error
-            }
-          }
-        `, {
-        strands: culledStrands.map((strand) => ({
-          ...strand,
-          operations: strand.operations.map((op) => ({
-            ...op,
-            input: (0, import_json_stringify_deterministic.default)(op.input)
-          }))
-        }))
-      });
-      if (!pushUpdates) {
-        throw new Error("Couldn't update listener revision");
-      }
-      return pushUpdates;
-    } catch (e) {
-      this.logger.error(e);
-      throw e;
-    }
-    return [];
-  }
-};
-
 // ../../packages/document-drive/dist/src/server/listener/transmitter/factory.js
 var TransmitterFactory = class {
   listenerManager;
@@ -13634,18 +13868,20 @@ 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);
+    this.logger.verbose(`getSynchronizationUnitsRevision: ${JSON.stringify(revisions)}`);
     const synchronizationUnits = syncUnitsQuery.map((s) => ({
       ...s,
       lastUpdated: drive.created,
       revision: -1
     }));
     for (const revision of revisions) {
-      const syncUnit = synchronizationUnits.find((s) => revision.driveId === s.driveId && revision.documentId === s.documentId && revision.scope === s.scope && revision.branch === s.branch);
+      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;
@@ -13658,7 +13894,7 @@ var SynchronizationManager = class {
     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: "",
+        id: driveId,
         documentType: "powerhouse/document-drive",
         synchronizationUnits: [
           {
@@ -13700,7 +13936,6 @@ var SynchronizationManager = class {
       syncId,
       scope: syncUnit.scope,
       branch: syncUnit.branch,
-      driveId,
       documentId: node.id,
       documentType: node.documentType
     };
@@ -13718,7 +13953,6 @@ var SynchronizationManager = class {
       syncId,
       scope,
       branch,
-      driveId,
       documentId,
       documentType: documentType2,
       lastUpdated: lastOperation.timestamp ?? document.lastModified,
@@ -13726,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,
@@ -13747,7 +13994,7 @@ var SynchronizationManager = class {
   }
   async getDrive(driveId) {
     try {
-      const cachedDocument = await this.cache.getDocument("drives", driveId);
+      const cachedDocument = await this.cache.getDrive(driveId);
       if (cachedDocument && isDocumentDrive(cachedDocument)) {
         return cachedDocument;
       }
@@ -13763,7 +14010,7 @@ var SynchronizationManager = class {
   }
   async getDocument(driveId, documentId) {
     try {
-      const cachedDocument = await this.cache.getDocument(driveId, documentId);
+      const cachedDocument = await this.cache.getDocument(documentId);
       if (cachedDocument) {
         return cachedDocument;
       }