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

package/dist/assets/{app-loader-Bkg_WUos.js → app-loader-UcJ4Us8H.js}

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-BYkaiTES.js","assets/main.CgKmK6gL.js","assets/app-D9QJBr8i.css"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-CrkKw3iM.js","assets/main.b7W0Jdwz.js","assets/app-CcH3qGge.css"])))=>i.map(i=>d[i]);
 var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -11,7 +11,7 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 var _tags, _levelString, _errorHandler, _ConsoleLogger_instances, levelValue_get, _getDocumentModelModule, _drives, _ReadModeService_instances, parseGraphQLErrors_fn, fetchDrive_fn, _a, _ServiceWorkerManager_instances, handleServiceWorkerMessage_fn, handleServiceWorker_fn;
-import { _ as __vitePreload } from "./main.CgKmK6gL.js";
+import { _ as __vitePreload } from "./main.b7W0Jdwz.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect, Suspense, lazy } from "react";
 function _mergeNamespaces(n, m) {
@@ -22530,8 +22530,18 @@ const _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();
@@ -22572,7 +22582,7 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
   }
   static async pullStrands(driveId, url, listenerId, options) {
     var _a2;
-    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 {
@@ -22612,18 +22622,25 @@ const _PullResponderTransmitter = class _PullResponderTransmitter {
       `, { listenerId });
     const error = (_a2 = result.errors) == null ? void 0 : _a2.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);
@@ -22657,75 +22674,124 @@ const _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) {
     var _a2;
     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 == null ? void 0 : 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);
+          break;
         }
-        listenerRevisions.push({
-          branch: strand.branch,
-          documentId: strand.documentId || "",
-          driveId: strand.driveId,
-          revision: ((_a2 = operations.pop()) == null ? void 0 : _a2.index) ?? -1,
-          scope: strand.scope,
-          status: error ? error instanceof OperationError ? error.status : "ERROR" : "SUCCESS",
-          error
-        });
       }
-      this.staticLogger.verbose("Processed strands...");
-      onRevisions == null ? void 0 : 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);
-      }
-      if (success) {
-        this.staticLogger.verbose("Acknowledged strands successfully.");
-      } else {
-        this.staticLogger.error("Failed to acknowledge strands");
+        onRevisions == null ? void 0 : onRevisions([]);
+      } catch (error2) {
+        this.staticLogger.error(`Error calling onRevisions for drive: ${driveId}, listenerId: ${trigger.data.listenerId}: ${error2}`);
+        onError(error2);
       }
+      return;
+    }
+    this.staticLogger.verbose(`[SYNC DEBUG] Processing ${strands.length} strands in pull cycle for drive: ${driveId}, listenerId: ${trigger.data.listenerId}`);
+    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: ((_a2 = operations.pop()) == null ? void 0 : _a2.index) ?? -1,
+        scope: strand.scope,
+        status: error2 ? error2 instanceof OperationError ? error2.status : "ERROR" : "SUCCESS",
+        error: error2
+      });
+    }
+    this.staticLogger.verbose("Processed strands...");
+    try {
+      onRevisions == null ? void 0 : 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 == null ? void 0 : 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) {
@@ -22737,20 +22803,25 @@ const _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);
@@ -22760,15 +22831,18 @@ const _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,
@@ -22786,6 +22860,187 @@ __publicField(_PullResponderTransmitter, "staticLogger", childLogger([
   "static"
 ]));
 let PullResponderTransmitter = _PullResponderTransmitter;
+var defaults;
+var hasRequiredDefaults;
+function requireDefaults() {
+  if (hasRequiredDefaults) return defaults;
+  hasRequiredDefaults = 1;
+  defaults = {
+    space: "",
+    cycles: false,
+    replacer: (k, v) => v,
+    stringify: JSON.stringify
+  };
+  return defaults;
+}
+var util;
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util;
+  hasRequiredUtil = 1;
+  util = {
+    isArray: Array.isArray,
+    assign: Object.assign,
+    isObject: (v) => typeof v === "object",
+    isFunction: (v) => typeof v === "function",
+    isBoolean: (v) => typeof v === "boolean",
+    isRegex: (v) => v instanceof RegExp,
+    keys: Object.keys
+  };
+  return util;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  const DEFAULTS = requireDefaults();
+  const isFunction = requireUtil().isFunction;
+  const isBoolean = requireUtil().isBoolean;
+  const isObject = requireUtil().isObject;
+  const isArray = requireUtil().isArray;
+  const isRegex = requireUtil().isRegex;
+  const assign = requireUtil().assign;
+  const keys = requireUtil().keys;
+  function serialize(obj) {
+    if (obj === null || obj === void 0) return obj;
+    if (isRegex(obj)) return obj.toString();
+    return obj.toJSON ? obj.toJSON() : obj;
+  }
+  function stringifyDeterministic(obj, opts) {
+    opts = opts || assign({}, DEFAULTS);
+    if (isFunction(opts)) opts = { compare: opts };
+    const space = opts.space || DEFAULTS.space;
+    const cycles = isBoolean(opts.cycles) ? opts.cycles : DEFAULTS.cycles;
+    const replacer = opts.replacer || DEFAULTS.replacer;
+    const stringify2 = opts.stringify || DEFAULTS.stringify;
+    const compare = opts.compare && /* @__PURE__ */ function(f) {
+      return function(node) {
+        return function(a, b) {
+          const aobj = { key: a, value: node[a] };
+          const bobj = { key: b, value: node[b] };
+          return f(aobj, bobj);
+        };
+      };
+    }(opts.compare);
+    if (!cycles) stringify2(obj);
+    const seen = [];
+    return function _deterministic(parent, key, node, level) {
+      const indent2 = space ? "\n" + new Array(level + 1).join(space) : "";
+      const colonSeparator = space ? ": " : ":";
+      node = serialize(node);
+      node = replacer.call(parent, key, node);
+      if (node === void 0) return;
+      if (!isObject(node) || node === null) return stringify2(node);
+      if (isArray(node)) {
+        const out = [];
+        for (let i = 0; i < node.length; i++) {
+          const item = _deterministic(node, i, node[i], level + 1) || stringify2(null);
+          out.push(indent2 + space + item);
+        }
+        return "[" + out.join(",") + indent2 + "]";
+      } else {
+        if (cycles) {
+          if (seen.indexOf(node) !== -1) {
+            return stringify2("[Circular]");
+          } else {
+            seen.push(node);
+          }
+        }
+        const nodeKeys = keys(node).sort(compare && compare(node));
+        const out = [];
+        for (let i = 0; i < nodeKeys.length; i++) {
+          const key2 = nodeKeys[i];
+          const value = _deterministic(node, key2, node[key2], level + 1);
+          if (!value) continue;
+          const keyValue = stringify2(key2) + colonSeparator + value;
+          out.push(indent2 + space + keyValue);
+        }
+        seen.splice(seen.indexOf(node), 1);
+        return "{" + out.join(",") + indent2 + "}";
+      }
+    }({ "": obj }, "", obj, 0);
+  }
+  lib = stringifyDeterministic;
+  return lib;
+}
+var libExports = requireLib();
+const stringify = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+const SYNC_OPS_BATCH_LIMIT = 10;
+class SwitchboardPushTransmitter {
+  constructor(targetURL) {
+    __publicField(this, "targetURL");
+    __publicField(this, "logger", childLogger([
+      "SwitchboardPushTransmitter",
+      Math.floor(Math.random() * 999).toString()
+    ]));
+    this.targetURL = targetURL;
+  }
+  async transmit(strands, source) {
+    var _a2;
+    if (source.type === "trigger" && ((_a2 = source.trigger.data) == null ? void 0 : _a2.url) === this.targetURL) {
+      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
+      return strands.map((strand) => {
+        var _a3;
+        return {
+          driveId: strand.driveId,
+          documentId: strand.documentId,
+          scope: strand.scope,
+          branch: strand.branch,
+          status: "SUCCESS",
+          revision: ((_a3 = strand.operations.at(-1)) == null ? void 0 : _a3.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: stringify(op.input)
+          }))
+        }))
+      });
+      if (!pushUpdates) {
+        throw new Error("Couldn't update listener revision");
+      }
+      return pushUpdates;
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+    return [];
+  }
+}
 var TransmitterType;
 (function(TransmitterType2) {
   TransmitterType2[TransmitterType2["Internal"] = 0] = "Internal";
@@ -23019,11 +23274,41 @@ class BaseDocumentDriveServer {
     return this.triggerMap.delete(driveId);
   }
   async _initializeDrive(driveId) {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
     const drive = await this.getDrive(driveId);
+    logger$1.verbose(`[SYNC DEBUG] Initializing drive ${driveId} with slug "${drive.state.global.slug}"`);
     await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
     if (this.shouldSyncRemoteDrive(drive)) {
+      logger$1.verbose(`[SYNC DEBUG] Starting sync for remote drive ${driveId}`);
       await this.startSyncRemoteDrive(driveId);
     }
+    logger$1.verbose(`[SYNC DEBUG] Processing ${drive.state.local.listeners.length} listeners for drive ${driveId}`);
+    for (const zodListener of drive.state.local.listeners) {
+      if (((_a2 = zodListener.callInfo) == null ? void 0 : _a2.transmitterType) === "SwitchboardPush") {
+        logger$1.verbose(`[SYNC DEBUG] Setting up SwitchboardPush listener ${zodListener.listenerId} for drive ${driveId}`);
+        const transmitter = new SwitchboardPushTransmitter(((_b = zodListener.callInfo) == null ? void 0 : _b.data) ?? "");
+        logger$1.verbose(`[SYNC DEBUG] Created SwitchboardPush transmitter with URL: ${((_c = zodListener.callInfo) == null ? void 0 : _c.data) || "none"}`);
+        await this.listenerManager.setListener(driveId, {
+          block: zodListener.block,
+          driveId: drive.state.global.id,
+          filter: {
+            branch: ((_d = zodListener.filter) == null ? void 0 : _d.branch) ?? [],
+            documentId: ((_e = zodListener.filter) == null ? void 0 : _e.documentId) ?? [],
+            documentType: ((_f = zodListener.filter) == null ? void 0 : _f.documentType) ?? [],
+            scope: ((_g = zodListener.filter) == null ? void 0 : _g.scope) ?? []
+          },
+          listenerId: zodListener.listenerId,
+          callInfo: zodListener.callInfo,
+          system: zodListener.system,
+          label: zodListener.label ?? "",
+          transmitter
+        }).then(() => {
+          logger$1.verbose(`[SYNC DEBUG] Successfully set up listener ${zodListener.listenerId} for drive ${driveId}`);
+        });
+      } else {
+        logger$1.error(`Skipping listener ${zodListener.listenerId} with unsupported type ${((_h = zodListener.callInfo) == null ? void 0 : _h.transmitterType) || "unknown"}`);
+      }
+    }
   }
   // Delegate synchronization methods to synchronizationManager
   getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
@@ -24337,57 +24622,78 @@ const _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 == null ? void 0 : 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 == null ? void 0 : options.since,
-            fromRevision: (options == null ? void 0 : options.fromRevision) ?? (entry == null ? void 0 : 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 == null ? void 0 : 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 == null ? void 0 : options.since,
+              fromRevision: (options == null ? void 0 : options.fromRevision) ?? (entry == null ? void 0 : 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) {
@@ -24413,187 +24719,6 @@ const _ListenerManager = class _ListenerManager {
 };
 __publicField(_ListenerManager, "LISTENER_UPDATE_DELAY", 250);
 let ListenerManager = _ListenerManager;
-var defaults;
-var hasRequiredDefaults;
-function requireDefaults() {
-  if (hasRequiredDefaults) return defaults;
-  hasRequiredDefaults = 1;
-  defaults = {
-    space: "",
-    cycles: false,
-    replacer: (k, v) => v,
-    stringify: JSON.stringify
-  };
-  return defaults;
-}
-var util;
-var hasRequiredUtil;
-function requireUtil() {
-  if (hasRequiredUtil) return util;
-  hasRequiredUtil = 1;
-  util = {
-    isArray: Array.isArray,
-    assign: Object.assign,
-    isObject: (v) => typeof v === "object",
-    isFunction: (v) => typeof v === "function",
-    isBoolean: (v) => typeof v === "boolean",
-    isRegex: (v) => v instanceof RegExp,
-    keys: Object.keys
-  };
-  return util;
-}
-var lib;
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib;
-  hasRequiredLib = 1;
-  const DEFAULTS = requireDefaults();
-  const isFunction = requireUtil().isFunction;
-  const isBoolean = requireUtil().isBoolean;
-  const isObject = requireUtil().isObject;
-  const isArray = requireUtil().isArray;
-  const isRegex = requireUtil().isRegex;
-  const assign = requireUtil().assign;
-  const keys = requireUtil().keys;
-  function serialize(obj) {
-    if (obj === null || obj === void 0) return obj;
-    if (isRegex(obj)) return obj.toString();
-    return obj.toJSON ? obj.toJSON() : obj;
-  }
-  function stringifyDeterministic(obj, opts) {
-    opts = opts || assign({}, DEFAULTS);
-    if (isFunction(opts)) opts = { compare: opts };
-    const space = opts.space || DEFAULTS.space;
-    const cycles = isBoolean(opts.cycles) ? opts.cycles : DEFAULTS.cycles;
-    const replacer = opts.replacer || DEFAULTS.replacer;
-    const stringify2 = opts.stringify || DEFAULTS.stringify;
-    const compare = opts.compare && /* @__PURE__ */ function(f) {
-      return function(node) {
-        return function(a, b) {
-          const aobj = { key: a, value: node[a] };
-          const bobj = { key: b, value: node[b] };
-          return f(aobj, bobj);
-        };
-      };
-    }(opts.compare);
-    if (!cycles) stringify2(obj);
-    const seen = [];
-    return function _deterministic(parent, key, node, level) {
-      const indent2 = space ? "\n" + new Array(level + 1).join(space) : "";
-      const colonSeparator = space ? ": " : ":";
-      node = serialize(node);
-      node = replacer.call(parent, key, node);
-      if (node === void 0) return;
-      if (!isObject(node) || node === null) return stringify2(node);
-      if (isArray(node)) {
-        const out = [];
-        for (let i = 0; i < node.length; i++) {
-          const item = _deterministic(node, i, node[i], level + 1) || stringify2(null);
-          out.push(indent2 + space + item);
-        }
-        return "[" + out.join(",") + indent2 + "]";
-      } else {
-        if (cycles) {
-          if (seen.indexOf(node) !== -1) {
-            return stringify2("[Circular]");
-          } else {
-            seen.push(node);
-          }
-        }
-        const nodeKeys = keys(node).sort(compare && compare(node));
-        const out = [];
-        for (let i = 0; i < nodeKeys.length; i++) {
-          const key2 = nodeKeys[i];
-          const value = _deterministic(node, key2, node[key2], level + 1);
-          if (!value) continue;
-          const keyValue = stringify2(key2) + colonSeparator + value;
-          out.push(indent2 + space + keyValue);
-        }
-        seen.splice(seen.indexOf(node), 1);
-        return "{" + out.join(",") + indent2 + "}";
-      }
-    }({ "": obj }, "", obj, 0);
-  }
-  lib = stringifyDeterministic;
-  return lib;
-}
-var libExports = requireLib();
-const stringify = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
-const SYNC_OPS_BATCH_LIMIT = 10;
-class SwitchboardPushTransmitter {
-  constructor(targetURL) {
-    __publicField(this, "targetURL");
-    __publicField(this, "logger", childLogger([
-      "SwitchboardPushTransmitter",
-      Math.floor(Math.random() * 999).toString()
-    ]));
-    this.targetURL = targetURL;
-  }
-  async transmit(strands, source) {
-    var _a2;
-    if (source.type === "trigger" && ((_a2 = source.trigger.data) == null ? void 0 : _a2.url) === this.targetURL) {
-      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
-      return strands.map((strand) => {
-        var _a3;
-        return {
-          driveId: strand.driveId,
-          documentId: strand.documentId,
-          scope: strand.scope,
-          branch: strand.branch,
-          status: "SUCCESS",
-          revision: ((_a3 = strand.operations.at(-1)) == null ? void 0 : _a3.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: stringify(op.input)
-          }))
-        }))
-      });
-      if (!pushUpdates) {
-        throw new Error("Couldn't update listener revision");
-      }
-      return pushUpdates;
-    } catch (e) {
-      this.logger.error(e);
-      throw e;
-    }
-    return [];
-  }
-}
 class TransmitterFactory {
   constructor(listenerManager) {
     __publicField(this, "listenerManager");
@@ -24632,11 +24757,13 @@ class SynchronizationManager {
   }
   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) => {
       var _a2;
       return {
@@ -24717,14 +24844,27 @@ class SynchronizationManager {
     };
   }
   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,
@@ -25230,6 +25370,9 @@ function Modified(props) {
 function Moved(props) {
   return jsxs("svg", { ...props, width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("path", { d: "M7.07143 1.96429C7.07143 2.2207 6.86356 2.42857 6.60714 2.42857H5.21429C3.67578 2.42857 2.42857 3.67578 2.42857 5.21429V10.7857C2.42857 12.3242 3.67578 13.5714 5.21429 13.5714H10.7857C12.3242 13.5714 13.5714 12.3242 13.5714 10.7857V9.39286C13.5714 9.13644 13.7793 8.92857 14.0357 8.92857C14.2921 8.92857 14.5 9.13644 14.5 9.39286V10.7857C14.5 12.8371 12.8371 14.5 10.7857 14.5H5.21429C3.16294 14.5 1.5 12.8371 1.5 10.7857V5.21429C1.5 3.16294 3.16294 1.5 5.21429 1.5H6.60714C6.86356 1.5 7.07143 1.70787 7.07143 1.96429Z", fill: "currentcolor" }), jsx("path", { d: "M14 6.5V2.5C14 2.22386 13.7761 2 13.5 2H9.5", stroke: "currentcolor", strokeLinecap: "round" }), jsx("path", { d: "M7 10L7.28346 9.29136C8.39378 6.51556 10.4269 4.20728 13.0403 2.75539L13.5 2.5", stroke: "currentcolor", strokeLinecap: "round" })] });
 }
+function Npm(props) {
+  return jsx("svg", { ...props, xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 128 128", children: jsx("path", { fill: "#cb3837", d: "M2 38.5h124v43.71H64v7.29H36.44v-7.29H2zm6.89 36.43h13.78V53.07h6.89v21.86h6.89V45.79H8.89zm34.44-29.14v36.42h13.78v-7.28h13.78V45.79zm13.78 7.29H64v14.56h-6.89zm20.67-7.29v29.14h13.78V53.07h6.89v21.86h6.89V53.07h6.89v21.86h6.89V45.79z" }) });
+}
 function PackageManager(props) {
   return jsx("svg", { ...props, width: "12", height: "12", viewBox: "0 0 12 12", fill: "currentcolor", children: jsx("path", { d: "M1.22323 -0.00109863C0.549226 -0.00109863 -0.00610352 0.533576 -0.00610352 1.20691V2.79089C-0.00610352 3.46423 0.549226 3.9989 1.22323 3.9989H4.0979C4.7719 3.9989 5.32723 3.46423 5.32723 2.79089V1.20691C5.32723 0.533576 4.7719 -0.00109863 4.0979 -0.00109863H1.22323ZM7.9939 -0.00109863C7.25723 -0.00109863 6.66056 0.595568 6.66056 1.33223V5.33223C6.66056 6.0689 7.25723 6.66557 7.9939 6.66557H10.6606C11.3972 6.66557 11.9939 6.0689 11.9939 5.33223V1.33223C11.9939 0.595568 11.3972 -0.00109863 10.6606 -0.00109863H7.9939ZM1.32723 5.33223C0.590563 5.33223 -0.00610352 5.9289 -0.00610352 6.66557V10.6656C-0.00610352 11.4022 0.590563 11.9989 1.32723 11.9989H3.9939C4.73056 11.9989 5.32723 11.4022 5.32723 10.6656V6.66557C5.32723 5.9289 4.73056 5.33223 3.9939 5.33223H1.32723ZM7.88989 7.9989C7.21589 7.9989 6.66056 8.53358 6.66056 9.20691V10.7909C6.66056 11.4642 7.21589 11.9989 7.88989 11.9989H10.7646C11.4386 11.9989 11.9939 11.4642 11.9939 10.7909V9.20691C11.9939 8.53358 11.4386 7.9989 10.7646 7.9989H7.88989Z" }) });
 }
@@ -25418,6 +25561,7 @@ const iconComponents = {
   M,
   Modified,
   Moved,
+  Npm,
   PackageManager,
   Pencil,
   PeopleFill,
@@ -25595,7 +25739,7 @@ const nodeOptionsMap = {
 };
 const name = "@powerhousedao/connect";
 const productName = "Powerhouse-Connect";
-const version$1 = "1.0.3-dev.0";
+const version$1 = "1.0.4-dev.1";
 const description = "Powerhouse Connect";
 const main = "./dist/index.html";
 const type = "module";
@@ -31235,7 +31379,7 @@ if (window.__VITE_ENVS.MODE === "development") {
 } else {
   serviceWorkerManager.registerServiceWorker(false);
 }
-const App = lazy(() => __vitePreload(() => import("./app-BYkaiTES.js").then((n) => n.aN), true ? __vite__mapDeps([0,1,2]) : void 0));
+const App = lazy(() => __vitePreload(() => import("./app-CrkKw3iM.js").then((n) => n.aN), true ? __vite__mapDeps([0,1,2]) : void 0));
 const AppLoader = /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(App, {}) });
 const appLoader = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,