@powerhousedao/connect 1.0.4-dev.0 → 1.0.4-dev.1

package/dist/modules/@powerhousedao/reactor-browser/{chunk-6MBHOHAA.js → chunk-4GNNWOQN.js}

@@ -4,7 +4,7 @@ import {
   ReactorBuilder,
   memory_default,
   mergeOperations
-} from "./chunk-N5UNGAA6.js";
+} from "./chunk-ZZIQ3KGW.js";
 import {
   __commonJS,
   __require,

package/dist/modules/@powerhousedao/reactor-browser/{chunk-UDKYG6I4.js → chunk-AEE452AO.js}

@@ -8,7 +8,7 @@ import {
   isFolderNode,
   moveNode,
   updateNode
-} from "./chunk-N5UNGAA6.js";
+} from "./chunk-ZZIQ3KGW.js";
 import {
   generateId
 } from "./chunk-FQF4YAVC.js";

package/dist/modules/@powerhousedao/reactor-browser/{chunk-IC6B3767.js → chunk-N7NRLUYA.js}

@@ -1,6 +1,6 @@
 import {
   useDriveActions
-} from "./chunk-UDKYG6I4.js";
+} from "./chunk-AEE452AO.js";
 import {
   useDriveContext
 } from "./chunk-XBTEGV5M.js";

package/dist/modules/@powerhousedao/reactor-browser/{chunk-OYYVE7RP.js → chunk-Q5MVFG2N.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-P6NJ6IAQ.js";
 import {
   ReadDriveNotFoundError
-} from "./chunk-N5UNGAA6.js";
+} from "./chunk-ZZIQ3KGW.js";
 
 // ../../packages/reactor-browser/dist/src/context/read-mode.js
 import { jsx as _jsx } from "react/jsx-runtime";

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

@@ -11915,8 +11915,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();
@@ -11955,7 +11965,7 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
     return result.registerPullResponderListener.listenerId;
   }
   static async pullStrands(driveId, url, listenerId, options) {
-    this.staticLogger.verbose(`pullStrands(url: ${url}, listener: ${listenerId})`);
+    this.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,18 +12005,25 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
       `, { listenerId });
     const error = result.errors?.at(0);
     if (error) {
+      this.staticLogger.verbose(`[SYNC DEBUG] Error pulling strands for drive: ${driveId}, listener: ${listenerId}, error: ${JSON.stringify(error)}`);
       throw error;
     }
     if (!result.system) {
+      this.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)
       }))
     }));
+    this.staticLogger.verbose(`[SYNC DEBUG] PullResponderTransmitter.pullStrands returning ${strands.length} strands for drive: ${driveId}, listener: ${listenerId}`);
+    if (strands.length > 0) {
+      this.staticLogger.verbose(`[SYNC DEBUG] Strands being returned: ${strands.map((s) => `${s.documentId}:${s.scope}`).join(", ")}`);
+    }
+    return strands;
   }
   static async acknowledgeStrands(url, listenerId, revisions) {
     this.staticLogger.verbose(`acknowledgeStrands(url: ${url}, listener: ${listenerId})`, revisions);
@@ -12039,74 +12056,123 @@ 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);
+    this.staticLogger.info(`[SYNC DEBUG] PullResponderTransmitter.executePull starting for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    const { url } = trigger.data;
+    let strands;
+    let error;
     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, trigger.data.listenerId);
+    } catch (e) {
+      error = e;
+      const errors = error.response.errors;
+      for (const error2 of errors) {
+        if (error2.message === "Listener not found") {
+          this.staticLogger.verbose(`[SYNC DEBUG] Auto-registering pull responder for drive: ${driveId}`);
+          const listenerId = await _PullResponderTransmitter.registerPullResponder(trigger.driveId, url, trigger.filter);
+          trigger.data.listenerId = listenerId;
+          try {
+            strands = await _PullResponderTransmitter.pullStrands(driveId, url, listenerId);
+            this.staticLogger.verbose(`Successfully auto-registerd and pulled strands for drive: ${driveId}, listenerId: ${listenerId}`);
+          } catch (error3) {
+            this.staticLogger.error(`Could not resolve 'Listener not found' error by registering a new pull responder for drive: ${driveId}, listenerId: ${listenerId}: ${error3}`);
+            onError(error3);
+            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) {
+      this.staticLogger.error(`Error pulling strands for drive, and could not auto-register: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
+      onError(error);
+      return;
+    }
+    if (!strands.length) {
+      this.staticLogger.verbose(`[SYNC DEBUG] No strands returned in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
       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) {
+        this.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;
+    }
+    this.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
+      }));
+      this.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) {
+        this.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
+      });
+    }
+    this.staticLogger.verbose("Processed strands...");
+    try {
+      onRevisions?.(listenerRevisions);
+    } catch (error2) {
+      this.staticLogger.error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      onError(error2);
+    }
+    this.staticLogger.verbose(`[SYNC DEBUG] Acknowledging ${listenerRevisions.length} strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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) {
+      this.staticLogger.error(`Error acknowledging strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+      onError(error2);
+    }
+    if (success) {
+      this.staticLogger.verbose(`[SYNC DEBUG] Successfully acknowledged strands for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    } else {
+      this.staticLogger.error("Failed to acknowledge strands");
+    }
+    try {
       onAcknowledge?.(success);
-    } catch (error) {
-      this.staticLogger.error("Pull error", error);
-      onError(error);
+    } catch (error2) {
+      this.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);
+    this.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 +12184,25 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
       } catch {
       }
     }
+    this.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...");
+        this.staticLogger.verbose(`[SYNC DEBUG] Starting pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
         await this.executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge);
+        this.staticLogger.verbose(`[SYNC DEBUG] Completed pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}, waiting ${loopInterval}ms for next cycle`);
         await new Promise((resolve) => {
           this.staticLogger.verbose(`Scheduling next pull in ${loopInterval} ms`);
           timeout = setTimeout(resolve, loopInterval);
         });
       }
     };
-    executeLoop().catch(this.staticLogger.error);
+    executeLoop().catch((error) => {
+      this.staticLogger.error(`Error in executeLoop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error}`);
+    });
     return () => {
+      this.staticLogger.verbose(`[SYNC DEBUG] Cancelling pull loop for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
       isCancelled = true;
       if (timeout !== void 0) {
         clearTimeout(timeout);
@@ -12141,15 +12212,18 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
   static async createPullResponderTrigger(driveId, url, options) {
     this.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,
@@ -12473,14 +12547,19 @@ var BaseDocumentDriveServer = class {
   }
   async _initializeDrive(driveId) {
     const drive = await this.getDrive(driveId);
+    logger.verbose(`[SYNC DEBUG] Initializing drive ${driveId} with slug "${drive.state.global.slug}"`);
     await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
     if (this.shouldSyncRemoteDrive(drive)) {
+      logger.verbose(`[SYNC DEBUG] Starting sync for remote drive ${driveId}`);
       await this.startSyncRemoteDrive(driveId);
     }
+    logger.verbose(`[SYNC DEBUG] Processing ${drive.state.local.listeners.length} listeners for drive ${driveId}`);
     for (const zodListener of drive.state.local.listeners) {
       if (zodListener.callInfo?.transmitterType === "SwitchboardPush") {
+        logger.verbose(`[SYNC DEBUG] Setting up SwitchboardPush listener ${zodListener.listenerId} for drive ${driveId}`);
         const transmitter = new SwitchboardPushTransmitter(zodListener.callInfo?.data ?? "");
-        this.listenerManager.setListener(driveId, {
+        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 +12573,11 @@ var BaseDocumentDriveServer = class {
           system: zodListener.system,
           label: zodListener.label ?? "",
           transmitter
+        }).then(() => {
+          logger.verbose(`[SYNC DEBUG] Successfully set up listener ${zodListener.listenerId} for drive ${driveId}`);
         });
+      } else {
+        logger.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${zodListener.callInfo?.transmitterType || "unknown"}`);
       }
     }
   }
@@ -13602,57 +13685,78 @@ var ListenerManager = class _ListenerManager {
     }
   }
   async getStrands(driveId, listenerId, options) {
-    const listenerState = this.getListenerState(driveId, listenerId);
+    this.logger.verbose(`[SYNC DEBUG] ListenerManager.getStrands called for drive: ${driveId}, listener: ${listenerId}, options: ${JSON.stringify(options || {})}`);
+    let listenerState;
+    try {
+      listenerState = this.getListenerState(driveId, listenerId);
+      this.logger.verbose(`[SYNC DEBUG] Found listener state for drive: ${driveId}, listener: ${listenerId}, status: ${listenerState.listenerStatus}`);
+    } catch (error) {
+      this.logger.error(`[SYNC DEBUG] Failed to find listener state for drive: ${driveId}, listener: ${listenerId}. Error: ${error}`);
+      throw error;
+    }
     const strands = [];
-    const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
-    const limit = options?.limit;
-    let operationsCount = 0;
-    const tasks = syncUnits.map((syncUnit) => async () => {
-      if (limit && operationsCount >= limit) {
-        return;
-      }
-      if (syncUnit.revision < 0) {
-        return;
-      }
-      const entry = listenerState.syncUnits.get(syncUnit.syncId);
-      if (entry && entry.listenerRev >= syncUnit.revision) {
-        return;
-      }
-      const { documentId, scope, branch } = syncUnit;
-      try {
-        const operations = await this.syncManager.getOperationData(
-          // DEAL WITH INVALID SYNC ID ERROR
-          driveId,
-          syncUnit.syncId,
-          {
-            since: options?.since,
-            fromRevision: options?.fromRevision ?? entry?.listenerRev,
-            limit: limit ? limit - operationsCount : void 0
+    try {
+      const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
+      this.logger.verbose(`[SYNC DEBUG] Retrieved ${syncUnits.length} sync units for drive: ${driveId}, listener: ${listenerId}`);
+      const limit = options?.limit;
+      let operationsCount = 0;
+      const tasks = syncUnits.map((syncUnit) => async () => {
+        if (limit && operationsCount >= limit) {
+          return;
+        }
+        if (syncUnit.revision < 0) {
+          this.logger.verbose(`[SYNC DEBUG] Skipping sync unit with negative revision: ${syncUnit.syncId}, revision: ${syncUnit.revision}`);
+          return;
+        }
+        const entry = listenerState.syncUnits.get(syncUnit.syncId);
+        if (entry && entry.listenerRev >= syncUnit.revision) {
+          this.logger.verbose(`[SYNC DEBUG] Skipping sync unit - listener already up to date: ${syncUnit.syncId}, listenerRev: ${entry.listenerRev}, revision: ${syncUnit.revision}`);
+          return;
+        }
+        const { documentId, scope, branch } = syncUnit;
+        try {
+          this.logger.verbose(`[SYNC DEBUG] Getting operations for syncUnit: ${syncUnit.syncId}, documentId: ${documentId}, scope: ${scope}, branch: ${branch}`);
+          const operations = await this.syncManager.getOperationData(
+            // DEAL WITH INVALID SYNC ID ERROR
+            driveId,
+            syncUnit.syncId,
+            {
+              since: options?.since,
+              fromRevision: options?.fromRevision ?? entry?.listenerRev,
+              limit: limit ? limit - operationsCount : void 0
+            }
+          );
+          this.logger.verbose(`[SYNC DEBUG] Retrieved ${operations.length} operations for syncUnit: ${syncUnit.syncId}`);
+          if (!operations.length) {
+            return;
           }
-        );
-        if (!operations.length) {
+          operationsCount += operations.length;
+          strands.push({
+            driveId,
+            documentId,
+            scope,
+            branch,
+            operations
+          });
+          this.logger.verbose(`[SYNC DEBUG] Added strand with ${operations.length} operations for syncUnit: ${syncUnit.syncId}`);
+        } catch (error) {
+          this.logger.error(`Error getting operations for syncUnit: ${syncUnit.syncId}, error: ${error}`);
           return;
         }
-        operationsCount += operations.length;
-        strands.push({
-          driveId,
-          documentId,
-          scope,
-          branch,
-          operations
-        });
-      } catch (error) {
-        this.logger.error(error);
-        return;
-      }
-    });
-    if (this.options.sequentialUpdates) {
-      for (const task of tasks) {
-        await task();
+      });
+      if (this.options.sequentialUpdates) {
+        this.logger.verbose(`[SYNC DEBUG] Processing ${tasks.length} sync units sequentially`);
+        for (const task of tasks) {
+          await task();
+        }
+      } else {
+        this.logger.verbose(`[SYNC DEBUG] Processing ${tasks.length} sync units in parallel`);
+        await Promise.all(tasks.map((task) => task()));
       }
-    } else {
-      await Promise.all(tasks.map((task) => task()));
+    } catch (error) {
+      this.logger.error(`Error in getStrands: ${error}`);
     }
+    this.logger.verbose(`ListenerManager.getStrands returning ${strands.length} strands for drive: ${driveId}, listener: ${listenerId}`);
     return strands;
   }
   getListenerState(driveId, listenerId) {
@@ -13717,11 +13821,13 @@ 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)}`);
     return syncUnitsQuery.map((s) => ({
       ...s,
       lastUpdated: drive.created,
@@ -13799,14 +13905,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,

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

@@ -3,10 +3,10 @@ import {
   ReadModeContext,
   ReadModeContextProvider,
   useReadModeContext
-} from "../chunk-OYYVE7RP.js";
+} from "../chunk-Q5MVFG2N.js";
 import "../chunk-OVGOA2P5.js";
 import "../chunk-P6NJ6IAQ.js";
-import "../chunk-N5UNGAA6.js";
+import "../chunk-ZZIQ3KGW.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-2ESYSVXG.js";
 export {

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

@@ -2,10 +2,10 @@ import {
   ReadModeContext,
   ReadModeContextProvider,
   useReadModeContext
-} from "../chunk-OYYVE7RP.js";
+} from "../chunk-Q5MVFG2N.js";
 import "../chunk-OVGOA2P5.js";
 import "../chunk-P6NJ6IAQ.js";
-import "../chunk-N5UNGAA6.js";
+import "../chunk-ZZIQ3KGW.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-2ESYSVXG.js";
 export {

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

@@ -1,10 +1,10 @@
 import "../chunk-DKDARAJS.js";
 import {
   useDriveActionsWithUiNodes
-} from "../chunk-IC6B3767.js";
+} from "../chunk-N7NRLUYA.js";
 import {
   useDriveActions
-} from "../chunk-UDKYG6I4.js";
+} from "../chunk-AEE452AO.js";
 import {
   DriveContextProvider,
   useDriveContext
@@ -57,7 +57,7 @@ import {
   useUserPermissions
 } from "../chunk-OVGOA2P5.js";
 import "../chunk-P6NJ6IAQ.js";
-import "../chunk-N5UNGAA6.js";
+import "../chunk-ZZIQ3KGW.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-YWKVPJNL.js";
 import "../chunk-2X2M6BYG.js";

package/dist/modules/@powerhousedao/reactor-browser/hooks/useDriveActions.js

@@ -1,7 +1,7 @@
 import {
   useDriveActions
-} from "../chunk-UDKYG6I4.js";
-import "../chunk-N5UNGAA6.js";
+} from "../chunk-AEE452AO.js";
+import "../chunk-ZZIQ3KGW.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-2ESYSVXG.js";
 export {

package/dist/modules/@powerhousedao/reactor-browser/hooks/useDriveActionsWithUiNodes.js

@@ -1,12 +1,12 @@
 import {
   useDriveActionsWithUiNodes
-} from "../chunk-IC6B3767.js";
-import "../chunk-UDKYG6I4.js";
+} from "../chunk-N7NRLUYA.js";
+import "../chunk-AEE452AO.js";
 import "../chunk-XBTEGV5M.js";
 import "../chunk-RGIB4DD4.js";
 import "../chunk-7OQWVUC5.js";
 import "../chunk-ZL5IPB6D.js";
-import "../chunk-N5UNGAA6.js";
+import "../chunk-ZZIQ3KGW.js";
 import "../chunk-FQF4YAVC.js";
 import "../chunk-2ESYSVXG.js";
 export {

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

@@ -6,10 +6,10 @@ import "./chunk-LH2T6NLN.js";
 import "./chunk-DKDARAJS.js";
 import {
   useDriveActionsWithUiNodes
-} from "./chunk-IC6B3767.js";
+} from "./chunk-N7NRLUYA.js";
 import {
   useDriveActions
-} from "./chunk-UDKYG6I4.js";
+} from "./chunk-AEE452AO.js";
 import {
   DriveContextProvider,
   useDriveContext
@@ -65,18 +65,18 @@ import {
 import {
   createBrowserDocumentDriveServer,
   getReactorDefaultDrivesConfig
-} from "./chunk-6MBHOHAA.js";
+} from "./chunk-4GNNWOQN.js";
 import "./chunk-U36SV333.js";
 import {
   ReadModeContext,
   ReadModeContextProvider,
   useReadModeContext
-} from "./chunk-OYYVE7RP.js";
+} from "./chunk-Q5MVFG2N.js";
 import {
   useUserPermissions
 } from "./chunk-OVGOA2P5.js";
 import "./chunk-P6NJ6IAQ.js";
-import "./chunk-N5UNGAA6.js";
+import "./chunk-ZZIQ3KGW.js";
 import "./chunk-FQF4YAVC.js";
 import "./chunk-YWKVPJNL.js";
 import "./chunk-2X2M6BYG.js";

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

@@ -1,8 +1,8 @@
 import {
   createBrowserDocumentDriveServer,
   getReactorDefaultDrivesConfig
-} from "./chunk-6MBHOHAA.js";
-import "./chunk-N5UNGAA6.js";
+} from "./chunk-4GNNWOQN.js";
+import "./chunk-ZZIQ3KGW.js";
 import "./chunk-FQF4YAVC.js";
 import "./chunk-2ESYSVXG.js";
 export {