@powerhousedao/connect 1.0.19-staging.0 → 1.0.20-dev.0

package/dist/assets/router-CvCplkfB.js

@@ -0,0 +1,2178 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/content-CwQswwKt.js","assets/app-DULISSV9.js","assets/main.uPY9aYSk.js","assets/app-loader-CS6aHo9m.js","assets/app-loader-B74nopv_.css","assets/app-b1jkE5Vo.css"])))=>i.map(i=>d[i]);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+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 _client, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_fn, notify_fn, _a;
+import { _ as __vitePreload } from "./main.uPY9aYSk.js";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { $ as Icon, _ as logger, a1 as LOCAL, aB as FILE, aR as DRIVE, aY as gql, aZ as request, ah as connectConfig } from "./app-loader-CS6aHo9m.js";
+import * as React from "react";
+import React__default, { useRef, useState, useEffect, useCallback, useContext, useSyncExternalStore, useMemo, Component, createElement, createContext, Suspense } from "react";
+import * as ReactDOM from "react-dom";
+import { P as Popover, a as PopoverTrigger, b as PopoverContent, t as twMerge, B as Button, g as getEnsAvatar$1, c as getEnsName$1, d as BaseError$1, W as WagmiContext, S as Subscribable, p as pendingThenable, r as resolveEnabled, s as shallowEqualObjects, e as resolveStaleTime, n as noop$1, i as isServer, f as isValidTimeout, h as timeUntilStale, j as focusManager, k as fetchState, l as replaceData, m as notifyManager, u as useQueryClient, o as useDocumentDriveServer, q as createRouter$1, v as createBrowserHistory, w as logV6DeprecationWarnings, D as DataRouterContext, x as DataRouterStateContext, R as Router, E as ErrorResponseImpl, y as useRoutesImpl, z as mapRouteProperties, A as useLocation, C as useNavigate, F as useTranslation, G as useUiNodes, H as useDocumentDrives, I as useReadModeContext, J as useAsyncReactor, K as useConnectConfig, L as SUCCESS, M as toast, N as CONFLICT, O as ERROR, Q as isLatestVersion, T as useParams, U as useUiNodesContext, V as useUnwrappedReactor, X as useModal, Y as useLogin, Z as ModalManager, _ as isElectron, $ as isMac, a0 as Outlet, a1 as useGetAppNameForEditorId, a2 as createMemoryRouter } from "./app-DULISSV9.js";
+const AccountPopover = ({ children, content }) => {
+  return jsxs(Popover, { children: [jsx(PopoverTrigger, { asChild: true, children: jsx("div", { className: "cursor-pointer", children }) }), jsx(PopoverContent, { className: "w-52 p-0", align: "start", children: content })] });
+};
+function SidebarHeader({ className, ...props }) {
+  return jsx("div", { className: twMerge("shrink-0", className), ...props });
+}
+function SidebarFooter({ className, ...props }) {
+  return jsx("div", { className: twMerge("shrink-0", className), ...props });
+}
+const Sidebar$1 = ({ maxWidth = "304px", minWidth = "80px", className, children, ...props }) => {
+  const ref = useRef(null);
+  return jsx("div", { ...props, className: twMerge(`group flex h-full flex-col bg-slate-50`, className), ref, style: {
+    width: minWidth
+  }, children });
+};
+function SidebarPanel({ className, children, ...props }) {
+  const [hasScroll, setHasScroll] = useState(false);
+  function checkContentScroll(target) {
+    setHasScroll(target.scrollHeight - target.scrollTop - target.clientHeight > 1);
+  }
+  const containerRef = useRef(null);
+  useEffect(() => {
+    if (!containerRef.current) {
+      return;
+    }
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries.pop();
+      if (!entry) {
+        return;
+      }
+      const { target } = entry;
+      checkContentScroll(target);
+    });
+    observer.observe(containerRef.current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [containerRef.current]);
+  return jsxs(Fragment, { children: [jsx("div", { className: twMerge("no-scrollbar flex-1 overflow-auto text-gray-900 transition-shadow", className), onScroll: (e) => checkContentScroll(e.currentTarget), ref: containerRef, ...props, children }), hasScroll ? jsx("div", { className: "pointer-events-none z-10 -mt-12 h-12 w-full", style: {
+    boxShadow: "inset 0px -33px 32px -16px rgba(0,0,0,0.1)"
+  } }) : null] });
+}
+const AccountPopoverLogin = ({ onLogin }) => {
+  const [loading, setLoading] = useState(false);
+  const content = loading ? jsx(Icon, { name: "Reload", size: 14, className: "animate-spin" }) : jsx("span", { children: "Connect" });
+  const handleLogin = () => {
+    setLoading(true);
+    onLogin();
+  };
+  return jsxs("div", { className: "p-4", children: [jsx("div", { className: "mb-4 flex justify-center", children: jsx("div", { className: "flex h-[22px] w-[83px] items-center justify-center overflow-hidden", children: jsx(Icon, { name: "RenownLight", size: 83 }) }) }), jsx("button", { onClick: handleLogin, className: "mt-4 flex h-7 w-full cursor-pointer items-center justify-center rounded-lg border border-gray-300 bg-transparent text-sm active:opacity-70", type: "button", children: content })] });
+};
+const shortAddress = (address) => `${address.slice(0, 7)}...${address.slice(-5)}`;
+const AccountPopoverUser = ({ address, onDisconnect, etherscanUrl, username = "" }) => {
+  const [isCopied, setIsCopied] = useState(false);
+  const copyToClipboard = useCallback(async (text) => {
+    try {
+      await navigator.clipboard.writeText(text);
+      setIsCopied(true);
+      setTimeout(() => setIsCopied(false), 2e3);
+    } catch (err) {
+      console.error("Failed to copy address:", err);
+    }
+  }, []);
+  return jsxs("div", { className: "flex flex-col divide-y divide-gray-200 text-gray-900", children: [jsxs("div", { className: "px-3 py-2", children: [username && jsx("div", { className: "text-sm font-medium", children: username }), jsx("div", { className: "mt-1 flex items-center gap-2", children: jsx(Button, { size: "small", color: "light", onClick: copyToClipboard.bind(null, address), className: "w-full cursor-pointer bg-transparent p-0 active:opacity-70", type: "button", children: jsxs("div", { className: "relative flex w-full items-center gap-1", children: [jsxs("div", { className: `flex items-center gap-1 transition-opacity duration-150 ${isCopied ? "opacity-0" : "opacity-100"}`, children: [jsx("span", { className: "text-xs", children: shortAddress(address) }), jsx(Icon, { name: "FilesEarmark", color: "#9EA0A1", size: 14 })] }), jsx("div", { className: `absolute left-0 text-xs transition-opacity duration-150 ${isCopied ? "opacity-100" : "opacity-0"}`, children: "Copied to clipboard!" })] }) }) })] }), etherscanUrl && jsx("div", { className: "px-3 py-2", children: jsxs("a", { href: etherscanUrl, target: "_blank", rel: "noopener noreferrer", className: "flex items-center gap-2 text-sm text-gray-900 hover:text-gray-600", children: [jsx(Icon, { name: "Ethscan", size: 14 }), "View on Etherscan"] }) }), jsx("div", { className: "px-3 py-2", children: jsxs("button", { onClick: onDisconnect, className: "flex w-full cursor-pointer items-center gap-2 text-sm text-red-900 hover:text-red-700", type: "button", children: [jsx(Icon, { name: "Disconnect", size: 14, color: "#EA4335" }), "Disconnect"] }) })] });
+};
+const ImgPowerhouse = "/assets/powerhouse-rounded-CeKGGUG4.png";
+function getAction(client, actionFn, name) {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit;
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit;
+  return (params) => actionFn(client, params);
+}
+function getChainId(config) {
+  return config.state.chainId;
+}
+function getEnsAvatar(config, parameters) {
+  const { chainId, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, getEnsAvatar$1, "getEnsAvatar");
+  return action(rest);
+}
+function getEnsName(config, parameters) {
+  const { chainId, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, getEnsName$1, "getEnsName");
+  return action(rest);
+}
+function watchChainId(config, parameters) {
+  const { onChange } = parameters;
+  return config.subscribe((state) => state.chainId, onChange);
+}
+const version = "2.14.15";
+const getVersion = () => `wagmi@${version}`;
+class BaseError extends BaseError$1 {
+  constructor() {
+    super(...arguments);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "WagmiError"
+    });
+  }
+  get docsBaseUrl() {
+    return "https://wagmi.sh/react";
+  }
+  get version() {
+    return getVersion();
+  }
+}
+class WagmiProviderNotFoundError extends BaseError {
+  constructor() {
+    super("`useConfig` must be used within `WagmiProvider`.", {
+      docsPath: "/api/WagmiProvider"
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "WagmiProviderNotFoundError"
+    });
+  }
+}
+function useConfig(parameters = {}) {
+  const config = parameters.config ?? useContext(WagmiContext);
+  if (!config)
+    throw new WagmiProviderNotFoundError();
+  return config;
+}
+var QueryObserver = (_a = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _QueryObserver_instances);
+    __privateAdd(this, _client);
+    __privateAdd(this, _currentQuery);
+    __privateAdd(this, _currentQueryInitialState);
+    __privateAdd(this, _currentResult);
+    __privateAdd(this, _currentResultState);
+    __privateAdd(this, _currentResultOptions);
+    __privateAdd(this, _currentThenable);
+    __privateAdd(this, _selectError);
+    __privateAdd(this, _selectFn);
+    __privateAdd(this, _selectResult);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    __privateAdd(this, _lastQueryWithDefinedData);
+    __privateAdd(this, _staleTimeoutId);
+    __privateAdd(this, _refetchIntervalId);
+    __privateAdd(this, _currentRefetchInterval);
+    __privateAdd(this, _trackedProps, /* @__PURE__ */ new Set());
+    this.options = options;
+    __privateSet(this, _client, client);
+    __privateSet(this, _selectError, null);
+    __privateSet(this, _currentThenable, pendingThenable());
+    if (!this.options.experimental_prefetchInRender) {
+      __privateGet(this, _currentThenable).reject(
+        new Error("experimental_prefetchInRender feature flag is not enabled")
+      );
+    }
+    this.bindMethods();
+    this.setOptions(options);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      __privateGet(this, _currentQuery).addObserver(this);
+      if (shouldFetchOnMount(__privateGet(this, _currentQuery), this.options)) {
+        __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+      } else {
+        this.updateResult();
+      }
+      __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(
+      __privateGet(this, _currentQuery),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(
+      __privateGet(this, _currentQuery),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set();
+    __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+    __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+    __privateGet(this, _currentQuery).removeObserver(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    const prevQuery = __privateGet(this, _currentQuery);
+    this.options = __privateGet(this, _client).defaultQueryOptions(options);
+    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== "boolean") {
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    }
+    __privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
+    __privateGet(this, _currentQuery).setOptions(this.options);
+    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client).getQueryCache().notify({
+        type: "observerOptionsUpdated",
+        query: __privateGet(this, _currentQuery),
+        observer: this
+      });
+    }
+    const mounted = this.hasListeners();
+    if (mounted && shouldFetchOptionally(
+      __privateGet(this, _currentQuery),
+      prevQuery,
+      this.options,
+      prevOptions
+    )) {
+      __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+    }
+    this.updateResult();
+    if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveEnabled(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveStaleTime(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveStaleTime(prevOptions.staleTime, __privateGet(this, _currentQuery)))) {
+      __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+    }
+    const nextRefetchInterval = __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this);
+    if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveEnabled(prevOptions.enabled, __privateGet(this, _currentQuery)) || nextRefetchInterval !== __privateGet(this, _currentRefetchInterval))) {
+      __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, nextRefetchInterval);
+    }
+  }
+  getOptimisticResult(options) {
+    const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), options);
+    const result = this.createResult(query, options);
+    if (shouldAssignObserverCurrentProperties(this, result)) {
+      __privateSet(this, _currentResult, result);
+      __privateSet(this, _currentResultOptions, this.options);
+      __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+    }
+    return result;
+  }
+  getCurrentResult() {
+    return __privateGet(this, _currentResult);
+  }
+  trackResult(result, onPropTracked) {
+    const trackedResult = {};
+    Object.keys(result).forEach((key) => {
+      Object.defineProperty(trackedResult, key, {
+        configurable: false,
+        enumerable: true,
+        get: () => {
+          this.trackProp(key);
+          onPropTracked == null ? void 0 : onPropTracked(key);
+          return result[key];
+        }
+      });
+    });
+    return trackedResult;
+  }
+  trackProp(key) {
+    __privateGet(this, _trackedProps).add(key);
+  }
+  getCurrentQuery() {
+    return __privateGet(this, _currentQuery);
+  }
+  refetch({ ...options } = {}) {
+    return this.fetch({
+      ...options
+    });
+  }
+  fetchOptimistic(options) {
+    const defaultedOptions = __privateGet(this, _client).defaultQueryOptions(options);
+    const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), defaultedOptions);
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+  fetch(fetchOptions) {
+    return __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this, {
+      ...fetchOptions,
+      cancelRefetch: fetchOptions.cancelRefetch ?? true
+    }).then(() => {
+      this.updateResult();
+      return __privateGet(this, _currentResult);
+    });
+  }
+  createResult(query, options) {
+    var _a2;
+    const prevQuery = __privateGet(this, _currentQuery);
+    const prevOptions = this.options;
+    const prevResult = __privateGet(this, _currentResult);
+    const prevResultState = __privateGet(this, _currentResultState);
+    const prevResultOptions = __privateGet(this, _currentResultOptions);
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : __privateGet(this, _currentQueryInitialState);
+    const { state } = query;
+    let newState = { ...state };
+    let isPlaceholderData = false;
+    let data;
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+      if (fetchOnMount || fetchOptionally) {
+        newState = {
+          ...newState,
+          ...fetchState(state.data, query.options)
+        };
+      }
+      if (options._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let { error, errorUpdatedAt, status } = newState;
+    if (options.select && newState.data !== void 0) {
+      if (prevResult && newState.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === __privateGet(this, _selectFn)) {
+        data = __privateGet(this, _selectResult);
+      } else {
+        try {
+          __privateSet(this, _selectFn, options.select);
+          data = options.select(newState.data);
+          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
+          __privateSet(this, _selectResult, data);
+          __privateSet(this, _selectError, null);
+        } catch (selectError) {
+          __privateSet(this, _selectError, selectError);
+        }
+      }
+    } else {
+      data = newState.data;
+    }
+    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+      let placeholderData;
+      if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
+        placeholderData = prevResult.data;
+      } else {
+        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
+          (_a2 = __privateGet(this, _lastQueryWithDefinedData)) == null ? void 0 : _a2.state.data,
+          __privateGet(this, _lastQueryWithDefinedData)
+        ) : options.placeholderData;
+        if (options.select && placeholderData !== void 0) {
+          try {
+            placeholderData = options.select(placeholderData);
+            __privateSet(this, _selectError, null);
+          } catch (selectError) {
+            __privateSet(this, _selectError, selectError);
+          }
+        }
+      }
+      if (placeholderData !== void 0) {
+        status = "success";
+        data = replaceData(
+          prevResult == null ? void 0 : prevResult.data,
+          placeholderData,
+          options
+        );
+        isPlaceholderData = true;
+      }
+    }
+    if (__privateGet(this, _selectError)) {
+      error = __privateGet(this, _selectError);
+      data = __privateGet(this, _selectResult);
+      errorUpdatedAt = Date.now();
+      status = "error";
+    }
+    const isFetching = newState.fetchStatus === "fetching";
+    const isPending = status === "pending";
+    const isError = status === "error";
+    const isLoading = isPending && isFetching;
+    const hasData = data !== void 0;
+    const result = {
+      status,
+      fetchStatus: newState.fetchStatus,
+      isPending,
+      isSuccess: status === "success",
+      isError,
+      isInitialLoading: isLoading,
+      isLoading,
+      data,
+      dataUpdatedAt: newState.dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: newState.fetchFailureCount,
+      failureReason: newState.fetchFailureReason,
+      errorUpdateCount: newState.errorUpdateCount,
+      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
+      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isPending,
+      isLoadingError: isError && !hasData,
+      isPaused: newState.fetchStatus === "paused",
+      isPlaceholderData,
+      isRefetchError: isError && hasData,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      promise: __privateGet(this, _currentThenable)
+    };
+    const nextResult = result;
+    if (this.options.experimental_prefetchInRender) {
+      const finalizeThenableIfPossible = (thenable) => {
+        if (nextResult.status === "error") {
+          thenable.reject(nextResult.error);
+        } else if (nextResult.data !== void 0) {
+          thenable.resolve(nextResult.data);
+        }
+      };
+      const recreateThenable = () => {
+        const pending = __privateSet(this, _currentThenable, nextResult.promise = pendingThenable());
+        finalizeThenableIfPossible(pending);
+      };
+      const prevThenable = __privateGet(this, _currentThenable);
+      switch (prevThenable.status) {
+        case "pending":
+          if (query.queryHash === prevQuery.queryHash) {
+            finalizeThenableIfPossible(prevThenable);
+          }
+          break;
+        case "fulfilled":
+          if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
+            recreateThenable();
+          }
+          break;
+        case "rejected":
+          if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
+            recreateThenable();
+          }
+          break;
+      }
+    }
+    return nextResult;
+  }
+  updateResult() {
+    const prevResult = __privateGet(this, _currentResult);
+    const nextResult = this.createResult(__privateGet(this, _currentQuery), this.options);
+    __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+    __privateSet(this, _currentResultOptions, this.options);
+    if (__privateGet(this, _currentResultState).data !== void 0) {
+      __privateSet(this, _lastQueryWithDefinedData, __privateGet(this, _currentQuery));
+    }
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+    __privateSet(this, _currentResult, nextResult);
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+      const { notifyOnChangeProps } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !__privateGet(this, _trackedProps).size) {
+        return true;
+      }
+      const includedProps = new Set(
+        notifyOnChangePropsValue ?? __privateGet(this, _trackedProps)
+      );
+      if (this.options.throwOnError) {
+        includedProps.add("error");
+      }
+      return Object.keys(__privateGet(this, _currentResult)).some((key) => {
+        const typedKey = key;
+        const changed = __privateGet(this, _currentResult)[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+    __privateMethod(this, _QueryObserver_instances, notify_fn).call(this, { listeners: shouldNotifyListeners() });
+  }
+  onQueryUpdate() {
+    this.updateResult();
+    if (this.hasListeners()) {
+      __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+    }
+  }
+}, _client = new WeakMap(), _currentQuery = new WeakMap(), _currentQueryInitialState = new WeakMap(), _currentResult = new WeakMap(), _currentResultState = new WeakMap(), _currentResultOptions = new WeakMap(), _currentThenable = new WeakMap(), _selectError = new WeakMap(), _selectFn = new WeakMap(), _selectResult = new WeakMap(), _lastQueryWithDefinedData = new WeakMap(), _staleTimeoutId = new WeakMap(), _refetchIntervalId = new WeakMap(), _currentRefetchInterval = new WeakMap(), _trackedProps = new WeakMap(), _QueryObserver_instances = new WeakSet(), executeFetch_fn = function(fetchOptions) {
+  __privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
+  let promise = __privateGet(this, _currentQuery).fetch(
+    this.options,
+    fetchOptions
+  );
+  if (!(fetchOptions == null ? void 0 : fetchOptions.throwOnError)) {
+    promise = promise.catch(noop$1);
+  }
+  return promise;
+}, updateStaleTimeout_fn = function() {
+  __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+  const staleTime = resolveStaleTime(
+    this.options.staleTime,
+    __privateGet(this, _currentQuery)
+  );
+  if (isServer || __privateGet(this, _currentResult).isStale || !isValidTimeout(staleTime)) {
+    return;
+  }
+  const time = timeUntilStale(__privateGet(this, _currentResult).dataUpdatedAt, staleTime);
+  const timeout = time + 1;
+  __privateSet(this, _staleTimeoutId, setTimeout(() => {
+    if (!__privateGet(this, _currentResult).isStale) {
+      this.updateResult();
+    }
+  }, timeout));
+}, computeRefetchInterval_fn = function() {
+  return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(__privateGet(this, _currentQuery)) : this.options.refetchInterval) ?? false;
+}, updateRefetchInterval_fn = function(nextInterval) {
+  __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+  __privateSet(this, _currentRefetchInterval, nextInterval);
+  if (isServer || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) === false || !isValidTimeout(__privateGet(this, _currentRefetchInterval)) || __privateGet(this, _currentRefetchInterval) === 0) {
+    return;
+  }
+  __privateSet(this, _refetchIntervalId, setInterval(() => {
+    if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+      __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+    }
+  }, __privateGet(this, _currentRefetchInterval)));
+}, updateTimers_fn = function() {
+  __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+  __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this));
+}, clearStaleTimeout_fn = function() {
+  if (__privateGet(this, _staleTimeoutId)) {
+    clearTimeout(__privateGet(this, _staleTimeoutId));
+    __privateSet(this, _staleTimeoutId, void 0);
+  }
+}, clearRefetchInterval_fn = function() {
+  if (__privateGet(this, _refetchIntervalId)) {
+    clearInterval(__privateGet(this, _refetchIntervalId));
+    __privateSet(this, _refetchIntervalId, void 0);
+  }
+}, updateQuery_fn = function() {
+  const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), this.options);
+  if (query === __privateGet(this, _currentQuery)) {
+    return;
+  }
+  const prevQuery = __privateGet(this, _currentQuery);
+  __privateSet(this, _currentQuery, query);
+  __privateSet(this, _currentQueryInitialState, query.state);
+  if (this.hasListeners()) {
+    prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+    query.addObserver(this);
+  }
+}, notify_fn = function(notifyOptions) {
+  notifyManager.batch(() => {
+    if (notifyOptions.listeners) {
+      this.listeners.forEach((listener) => {
+        listener(__privateGet(this, _currentResult));
+      });
+    }
+    __privateGet(this, _client).getQueryCache().notify({
+      query: __privateGet(this, _currentQuery),
+      type: "observerResultsUpdated"
+    });
+  });
+}, _a);
+function shouldLoadOnMount(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
+}
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+function shouldFetchOn(query, options, field) {
+  if (resolveEnabled(options.enabled, query) !== false) {
+    const value = typeof field === "function" ? field(query) : field;
+    return value === "always" || value !== false && isStale(query, options);
+  }
+  return false;
+}
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}
+function hashFn(queryKey) {
+  return JSON.stringify(queryKey, (_, value) => {
+    if (isPlainObject(value))
+      return Object.keys(value).sort().reduce((result, key) => {
+        result[key] = value[key];
+        return result;
+      }, {});
+    if (typeof value === "bigint")
+      return value.toString();
+    return value;
+  });
+}
+function isPlainObject(value) {
+  if (!hasObjectPrototype(value)) {
+    return false;
+  }
+  const ctor = value.constructor;
+  if (typeof ctor === "undefined")
+    return true;
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot))
+    return false;
+  if (!prot.hasOwnProperty("isPrototypeOf"))
+    return false;
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function filterQueryOptions(options) {
+  const {
+    // import('@tanstack/query-core').QueryOptions
+    _defaulted,
+    behavior,
+    gcTime,
+    initialData,
+    initialDataUpdatedAt,
+    maxPages,
+    meta,
+    networkMode,
+    queryFn,
+    queryHash,
+    queryKey,
+    queryKeyHashFn,
+    retry,
+    retryDelay,
+    structuralSharing,
+    // import('@tanstack/query-core').InfiniteQueryObserverOptions
+    getPreviousPageParam,
+    getNextPageParam,
+    initialPageParam,
+    // import('@tanstack/react-query').UseQueryOptions
+    _optimisticResults,
+    enabled,
+    notifyOnChangeProps,
+    placeholderData,
+    refetchInterval,
+    refetchIntervalInBackground,
+    refetchOnMount,
+    refetchOnReconnect,
+    refetchOnWindowFocus,
+    retryOnMount,
+    select,
+    staleTime,
+    suspense,
+    throwOnError,
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // wagmi
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    config,
+    connector,
+    query,
+    ...rest
+  } = options;
+  return rest;
+}
+function getEnsAvatarQueryOptions(config, options = {}) {
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1];
+      if (!name)
+        throw new Error("name is required");
+      return getEnsAvatar(config, { ...parameters, name });
+    },
+    queryKey: getEnsAvatarQueryKey(options)
+  };
+}
+function getEnsAvatarQueryKey(options = {}) {
+  return ["ensAvatar", filterQueryOptions(options)];
+}
+function getEnsNameQueryOptions(config, options = {}) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1];
+      if (!address)
+        throw new Error("address is required");
+      return getEnsName(config, { ...parameters, address });
+    },
+    queryKey: getEnsNameQueryKey(options)
+  };
+}
+function getEnsNameQueryKey(options = {}) {
+  return ["ensName", filterQueryOptions(options)];
+}
+var IsRestoringContext = React.createContext(false);
+var useIsRestoring = () => React.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+var QueryErrorResetBoundaryContext = React.createContext(createValue());
+var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
+function shouldThrowError(throwError, params) {
+  if (typeof throwError === "function") {
+    return throwError(...params);
+  }
+  return !!throwError;
+}
+function noop() {
+}
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+  if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+var useClearResetErrorBoundary = (errorResetBoundary) => {
+  React.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+var getHasError = ({
+  result,
+  errorResetBoundary,
+  throwOnError,
+  query,
+  suspense
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+};
+var ensureSuspenseTimers = (defaultedOptions) => {
+  const originalStaleTime = defaultedOptions.staleTime;
+  if (defaultedOptions.suspense) {
+    defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => Math.max(originalStaleTime(...args), 1e3) : Math.max(originalStaleTime ?? 1e3, 1e3);
+    if (typeof defaultedOptions.gcTime === "number") {
+      defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, 1e3);
+    }
+  }
+};
+var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+var shouldSuspend = (defaultedOptions, result) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+  errorResetBoundary.clearReset();
+});
+function useBaseQuery(options, Observer, queryClient) {
+  var _a2, _b, _c, _d, _e;
+  const client = useQueryClient();
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const defaultedOptions = client.defaultQueryOptions(options);
+  (_b = (_a2 = client.getDefaultOptions().queries) == null ? void 0 : _a2._experimental_beforeQuery) == null ? void 0 : _b.call(
+    _a2,
+    defaultedOptions
+  );
+  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+  ensureSuspenseTimers(defaultedOptions);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  useClearResetErrorBoundary(errorResetBoundary);
+  const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+  const [observer] = React.useState(
+    () => new Observer(
+      client,
+      defaultedOptions
+    )
+  );
+  const result = observer.getOptimisticResult(defaultedOptions);
+  const shouldSubscribe = !isRestoring && options.subscribed !== false;
+  React.useSyncExternalStore(
+    React.useCallback(
+      (onStoreChange) => {
+        const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+        observer.updateResult();
+        return unsubscribe;
+      },
+      [observer, shouldSubscribe]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  React.useEffect(() => {
+    observer.setOptions(defaultedOptions);
+  }, [defaultedOptions, observer]);
+  if (shouldSuspend(defaultedOptions, result)) {
+    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  }
+  if (getHasError({
+    result,
+    errorResetBoundary,
+    throwOnError: defaultedOptions.throwOnError,
+    query: client.getQueryCache().get(defaultedOptions.queryHash),
+    suspense: defaultedOptions.suspense
+  })) {
+    throw result.error;
+  }
+  (_d = (_c = client.getDefaultOptions().queries) == null ? void 0 : _c._experimental_afterQuery) == null ? void 0 : _d.call(
+    _c,
+    defaultedOptions,
+    result
+  );
+  if (defaultedOptions.experimental_prefetchInRender && !isServer && willFetch(result, isRestoring)) {
+    const promise = isNewCacheEntry ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      (_e = client.getQueryCache().get(defaultedOptions.queryHash)) == null ? void 0 : _e.promise
+    );
+    promise == null ? void 0 : promise.catch(noop).finally(() => {
+      observer.updateResult();
+    });
+  }
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+function useQuery$1(options, queryClient) {
+  return useBaseQuery(options, QueryObserver);
+}
+function useQuery(parameters) {
+  const result = useQuery$1({
+    ...parameters,
+    queryKeyHashFn: hashFn
+    // for bigint support
+  });
+  result.queryKey = parameters.queryKey;
+  return result;
+}
+function useChainId(parameters = {}) {
+  const config = useConfig(parameters);
+  return useSyncExternalStore((onChange) => watchChainId(config, { onChange }), () => getChainId(config), () => getChainId(config));
+}
+function useEnsAvatar(parameters = {}) {
+  const { name, query = {} } = parameters;
+  const config = useConfig(parameters);
+  const chainId = useChainId({ config });
+  const options = getEnsAvatarQueryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId
+  });
+  const enabled = Boolean(name && (query.enabled ?? true));
+  return useQuery({ ...query, ...options, enabled });
+}
+function useEnsName(parameters = {}) {
+  const { address, query = {} } = parameters;
+  const config = useConfig(parameters);
+  const chainId = useChainId({ config });
+  const options = getEnsNameQueryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId
+  });
+  const enabled = Boolean(address && (query.enabled ?? true));
+  return useQuery({ ...query, ...options, enabled });
+}
+function ENSAvatar(props) {
+  const { address, chainId = 1, size = "14px" } = props;
+  const style = {
+    width: size,
+    height: size
+  };
+  const ensNameResult = useEnsName({ address, chainId });
+  const name = ensNameResult.data ?? void 0;
+  const ensAvatarResult = useEnsAvatar({ name });
+  const avatarUrl = ensAvatarResult.data ?? ImgPowerhouse;
+  const isLoading = ensNameResult.isLoading || ensAvatarResult.isLoading;
+  if (isLoading)
+    return jsx("div", { className: "fade-out flex-none animate-pulse rounded-full bg-gray-400", style });
+  return jsx("img", { alt: "ENS Avatar", className: "flex-none rounded-full object-contain", src: avatarUrl, style });
+}
+const HomeBg = "/assets/home-bg-BEhF9NuW.png";
+const HomeScreen = function HomeScreen2(props) {
+  const { children, containerClassName } = props;
+  return jsx("div", { className: twMerge("container relative mx-auto flex h-full flex-col", containerClassName), children: jsxs("div", { className: "m-8 flex flex-wrap justify-center gap-4 pt-12", children: [jsx("img", { src: HomeBg, alt: "background", className: "pointer-events-none absolute inset-8 z-0 size-[calc(100%-32px)] object-contain" }), children] }) });
+};
+const HomeScreenItem = function HomeScreenItem2(props) {
+  const { icon, title, description, containerClassName, shareable, onClick } = props;
+  return jsxs("div", { className: twMerge("relative flex h-24 cursor-pointer flex-col items-center justify-center text-center text-sm text-black", containerClassName, onClick && "cursor-pointer"), onClick, children: [jsx("div", { className: "mx-auto pb-2", children: icon || jsx("div", { className: "size-8 items-center justify-center rounded-lg bg-black pt-1", children: jsx("span", { className: "text-6 w-6 text-white", children: title.slice(0, 1).toUpperCase() }) }) }), jsxs("div", { children: [jsx("h3", { children: title }), description && jsx("p", { className: "text-gray-500", children: description })] }), shareable && jsx("div", { className: "absolute left-2 top-0 mb-2", children: jsx(Icon, { name: "PeopleFill", width: 12, height: 12 }) })] });
+};
+const HomeScreenAddDriveItem = function HomeScreenAddDriveItem2(props) {
+  const { containerClassName, onClick } = props;
+  return jsx(HomeScreenItem, { title: "Create New Drive", icon: jsx(Icon, { name: "PlusSquare", size: 32 }), onClick, containerClassName });
+};
+const renownShortHover = "/assets/renown-short-hover-BiSLBV7L.png";
+const renownShort = "data:image/png;base64,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";
+const SidebarLogin = ({ onLogin }) => {
+  const content = jsx(AccountPopoverLogin, { onLogin });
+  return jsx(AccountPopover, { content, children: jsxs("div", { className: "group/sidebar-footer flex w-full cursor-pointer items-baseline justify-start text-sm font-semibold leading-10 text-gray-600", children: [jsx("img", { className: "group-hover/sidebar-footer:hidden", src: renownShort }), jsx("img", { className: "hidden group-hover/sidebar-footer:block", src: renownShortHover })] }) });
+};
+const SidebarUser = ({ address, etherscanUrl, onDisconnect }) => {
+  const { data } = useEnsName({ address });
+  const ensName = data;
+  const content = jsx(AccountPopoverUser, { address, username: ensName, onDisconnect, etherscanUrl });
+  return jsx(AccountPopover, { content, children: jsx("div", { className: "flex items-center justify-center rounded-sm", children: jsx(ENSAvatar, { address, size: "40px" }) }) });
+};
+const ConnectSidebarFooter = ({ address, className, onLogin, onClickSettings, onDisconnect, etherscanUrl = "", ...props }) => {
+  return jsxs(SidebarFooter, { ...props, className: twMerge("flex flex-col gap-2 border-t border-gray-300 px-2 py-4", className), children: [jsx("div", { className: "", children: address ? jsx(SidebarUser, { address, onDisconnect, etherscanUrl }) : jsx(SidebarLogin, { onLogin }) }), jsxs("button", { type: "button", className: "mt-3 flex w-full cursor-pointer items-center justify-center outline-none", onClick: onClickSettings, children: [jsx(Icon, { className: "text-gray-600", name: "Settings" }), jsx("span", { className: "hidden text-sm font-semibold leading-6 text-gray-800", children: "Settings" })] })] });
+};
+const ConnectSidebarHeader = ({ onClick, className, children, ...props }) => {
+  return jsx(SidebarHeader, { ...props, className: twMerge("flex justify-center gap-4 border-b border-gray-300 py-4", className), children: jsx("button", { className: "", onClick, type: "button", children: jsx(Icon, { className: "text-gray-600", name: "ConnectSmall", size: 24 }) }) });
+};
+const ConnectSidebar = ({ onClick, address, headerContent, onClickSettings, maxWidth = "304px", minWidth = "58px", onLogin, onDisconnect, etherscanUrl, ...props }) => {
+  return jsxs(Sidebar$1, { ...props, maxWidth, minWidth, children: [jsxs(SidebarPanel, { children: [jsx(ConnectSidebarHeader, { onClick, children: headerContent }), jsx("div", { className: "flex flex-col", children: props.children })] }), jsx(ConnectSidebarFooter, { address, onClickSettings, onLogin, onDisconnect, etherscanUrl })] });
+};
+const SidebarItem = function SidebarItem2(props) {
+  const { icon, title, description, containerClassName, active, onClick } = props;
+  return jsx("div", { className: twMerge("relative flex cursor-pointer flex-col items-center justify-center text-center text-sm text-black", containerClassName, active && "bg-white", onClick && "cursor-pointer"), onClick, children: jsx("div", { className: "mx-auto py-4", children: icon || jsx("div", { className: "size-8 items-center justify-center rounded-lg bg-black pt-1", children: jsx("span", { className: "text-6 w-6 text-white", children: title.slice(0, 1).toUpperCase() }) }) }) });
+};
+const SidebarAddDriveItem = function SidebarAddDriveItem2(props) {
+  const { containerClassName, onClick } = props;
+  return jsx(SidebarItem, { title: "Create New Drive", icon: jsx(Icon, { name: "PlusSquare", size: 32 }), onClick, containerClassName });
+};
+function useSwitchboard() {
+  return {
+    getDriveIdBySlug: async (driveUrl, slug) => {
+      if (!driveUrl) {
+        return;
+      }
+      const urlParts = driveUrl.split("/");
+      urlParts.pop();
+      urlParts.pop();
+      urlParts.push("drives");
+      const drivesUrl = urlParts.join("/");
+      const result = await fetch(drivesUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query: `
+                        query getDriveIdBySlug($slug: String!) {
+                            driveIdBySlug(slug: $slug)
+                        }
+                    `,
+          variables: {
+            slug
+          }
+        })
+      });
+      const data = await result.json();
+      return data.data.driveIdBySlug;
+    }
+  };
+}
+const DELAY_LIMIT = 1e5;
+const isListenerIdNotFound = (errorMessage, listenerId) => {
+  if (!listenerId) return false;
+  return errorMessage.toLocaleLowerCase().includes(`transmitter ${listenerId} not found`);
+};
+const useClientErrorHandler = () => {
+  const [handlingInProgress, setHandlingInProgress] = useState([]);
+  const [pullResponderTriggerMap, setPullResponderTriggerMap] = useState(/* @__PURE__ */ new Map());
+  const {
+    addTrigger,
+    removeTrigger,
+    registerNewPullResponderTrigger,
+    renameDrive,
+    addRemoteDrive,
+    documentDrives,
+    setDriveSharingType
+  } = useDocumentDriveServer();
+  const { getDriveIdBySlug } = useSwitchboard();
+  const pullResponderRegisterDelay = useRef(/* @__PURE__ */ new Map());
+  const handleStrands400 = useCallback(
+    async (driveId, trigger, handlerCode) => {
+      setHandlingInProgress((state) => [...state, handlerCode]);
+      const triggerData = trigger.data;
+      try {
+        let pullResponderTrigger = pullResponderTriggerMap.get(handlerCode);
+        if (!pullResponderTrigger) {
+          pullResponderTrigger = await registerNewPullResponderTrigger(
+            driveId,
+            triggerData.url,
+            {
+              pullInterval: Number(triggerData.interval) || 3e3
+            }
+          );
+          pullResponderTriggerMap.set(
+            handlerCode,
+            pullResponderTrigger
+          );
+          setPullResponderTriggerMap(pullResponderTriggerMap);
+        }
+        await removeTrigger(driveId, trigger.id);
+        await addTrigger(driveId, pullResponderTrigger);
+        pullResponderRegisterDelay.current.delete(handlerCode);
+      } catch (error) {
+        const delay = pullResponderRegisterDelay.current.get(handlerCode) || 1;
+        pullResponderRegisterDelay.current.set(
+          handlerCode,
+          delay === DELAY_LIMIT ? delay : delay * 10
+        );
+        logger.error(error);
+      } finally {
+        setHandlingInProgress(
+          (state) => state.filter((code) => code !== handlerCode)
+        );
+      }
+    },
+    [
+      pullResponderTriggerMap,
+      removeTrigger,
+      addTrigger,
+      pullResponderRegisterDelay,
+      registerNewPullResponderTrigger
+    ]
+  );
+  const handleDriveNotFound = useCallback(
+    async (driveId, trigger, handlerCode) => {
+      var _a2;
+      setHandlingInProgress((state) => [...state, handlerCode]);
+      try {
+        const drive = documentDrives.find(
+          (drive2) => drive2.state.global.id === driveId
+        );
+        if (!drive) return;
+        await removeTrigger(driveId, trigger.id);
+        await renameDrive(
+          driveId,
+          drive.state.global.name + ` (${drive.state.global.id})`
+        );
+        await setDriveSharingType(driveId, LOCAL);
+        if (((_a2 = trigger.data) == null ? void 0 : _a2.url) && drive.state.global.slug) {
+          const newId = await getDriveIdBySlug(
+            trigger.data.url,
+            drive.state.global.slug
+          );
+          if (newId) {
+            const urlParts = trigger.data.url.split("/");
+            urlParts[urlParts.length - 1] = newId;
+            const newUrl = urlParts.join("/");
+            await addRemoteDrive(newUrl, {
+              availableOffline: true,
+              sharingType: "PUBLIC",
+              listeners: [],
+              triggers: []
+            });
+          }
+        }
+      } catch (e) {
+        logger.error(e);
+      } finally {
+        setHandlingInProgress(
+          (state) => state.filter((code) => code !== handlerCode)
+        );
+      }
+    },
+    [
+      documentDrives,
+      removeTrigger,
+      renameDrive,
+      setDriveSharingType,
+      getDriveIdBySlug,
+      addRemoteDrive
+    ]
+  );
+  const strandsErrorHandler = useCallback(
+    async (driveId, trigger, status, errorMessage) => {
+      var _a2;
+      switch (status) {
+        case 400: {
+          if (isListenerIdNotFound(
+            errorMessage,
+            (_a2 = trigger.data) == null ? void 0 : _a2.listenerId
+          )) {
+            const autoRegisterPullResponder = localStorage.getItem(
+              "AUTO_REGISTER_PULL_RESPONDER"
+            ) !== "false";
+            if (!autoRegisterPullResponder) return;
+            const handlerCode = `strands:${driveId}:${status}`;
+            if (handlingInProgress.includes(handlerCode))
+              return;
+            if (!trigger.data) return;
+            const delay = pullResponderRegisterDelay.current.get(
+              handlerCode
+            ) || 0;
+            setTimeout(
+              () => handleStrands400(
+                driveId,
+                trigger,
+                handlerCode
+              ),
+              delay
+            );
+          }
+          break;
+        }
+        case 404: {
+          const handlerCode = `strands:${driveId}:${status}`;
+          if (handlingInProgress.includes(handlerCode)) return;
+          setTimeout(
+            () => handleDriveNotFound(
+              driveId,
+              trigger,
+              handlerCode
+            ),
+            0
+          );
+          break;
+        }
+      }
+    },
+    [handleDriveNotFound, handleStrands400, handlingInProgress]
+  );
+  return useMemo(() => ({ strandsErrorHandler }), [strandsErrorHandler]);
+};
+/**
+ * React Router DOM v6.30.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function createSearchParams(init) {
+  if (init === void 0) {
+    init = "";
+  }
+  return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
+    let value = init[key];
+    return memo.concat(Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]);
+  }, []));
+}
+function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
+  let searchParams = createSearchParams(locationSearch);
+  if (defaultSearchParams) {
+    defaultSearchParams.forEach((_, key) => {
+      if (!searchParams.has(key)) {
+        defaultSearchParams.getAll(key).forEach((value) => {
+          searchParams.append(key, value);
+        });
+      }
+    });
+  }
+  return searchParams;
+}
+const REACT_ROUTER_VERSION = "6";
+try {
+  window.__reactRouterVersion = REACT_ROUTER_VERSION;
+} catch (e) {
+}
+function createBrowserRouter(routes2, opts) {
+  return createRouter$1({
+    basename: opts == null ? void 0 : opts.basename,
+    future: _extends({}, opts == null ? void 0 : opts.future, {
+      v7_prependBasename: true
+    }),
+    history: createBrowserHistory({
+      window: opts == null ? void 0 : opts.window
+    }),
+    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),
+    routes: routes2,
+    mapRouteProperties,
+    dataStrategy: opts == null ? void 0 : opts.dataStrategy,
+    patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation,
+    window: opts == null ? void 0 : opts.window
+  }).initialize();
+}
+function parseHydrationData() {
+  var _window;
+  let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;
+  if (state && state.errors) {
+    state = _extends({}, state, {
+      errors: deserializeErrors(state.errors)
+    });
+  }
+  return state;
+}
+function deserializeErrors(errors) {
+  if (!errors) return null;
+  let entries = Object.entries(errors);
+  let serialized = {};
+  for (let [key, val] of entries) {
+    if (val && val.__type === "RouteErrorResponse") {
+      serialized[key] = new ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);
+    } else if (val && val.__type === "Error") {
+      if (val.__subType) {
+        let ErrorConstructor = window[val.__subType];
+        if (typeof ErrorConstructor === "function") {
+          try {
+            let error = new ErrorConstructor(val.message);
+            error.stack = "";
+            serialized[key] = error;
+          } catch (e) {
+          }
+        }
+      }
+      if (serialized[key] == null) {
+        let error = new Error(val.message);
+        error.stack = "";
+        serialized[key] = error;
+      }
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
+}
+const ViewTransitionContext = /* @__PURE__ */ React.createContext({
+  isTransitioning: false
+});
+const FetchersContext = /* @__PURE__ */ React.createContext(/* @__PURE__ */ new Map());
+const START_TRANSITION = "startTransition";
+const startTransitionImpl = React[START_TRANSITION];
+const FLUSH_SYNC = "flushSync";
+const flushSyncImpl = ReactDOM[FLUSH_SYNC];
+function startTransitionSafe(cb) {
+  if (startTransitionImpl) {
+    startTransitionImpl(cb);
+  } else {
+    cb();
+  }
+}
+function flushSyncSafe(cb) {
+  if (flushSyncImpl) {
+    flushSyncImpl(cb);
+  } else {
+    cb();
+  }
+}
+class Deferred {
+  constructor() {
+    this.status = "pending";
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = (value) => {
+        if (this.status === "pending") {
+          this.status = "resolved";
+          resolve(value);
+        }
+      };
+      this.reject = (reason) => {
+        if (this.status === "pending") {
+          this.status = "rejected";
+          reject(reason);
+        }
+      };
+    });
+  }
+}
+function RouterProvider(_ref) {
+  let {
+    fallbackElement,
+    router: router2,
+    future
+  } = _ref;
+  let [state, setStateImpl] = React.useState(router2.state);
+  let [pendingState, setPendingState] = React.useState();
+  let [vtContext, setVtContext] = React.useState({
+    isTransitioning: false
+  });
+  let [renderDfd, setRenderDfd] = React.useState();
+  let [transition, setTransition] = React.useState();
+  let [interruption, setInterruption] = React.useState();
+  let fetcherData = React.useRef(/* @__PURE__ */ new Map());
+  let {
+    v7_startTransition
+  } = future || {};
+  let optInStartTransition = React.useCallback((cb) => {
+    if (v7_startTransition) {
+      startTransitionSafe(cb);
+    } else {
+      cb();
+    }
+  }, [v7_startTransition]);
+  let setState = React.useCallback((newState, _ref2) => {
+    let {
+      deletedFetchers,
+      flushSync,
+      viewTransitionOpts
+    } = _ref2;
+    newState.fetchers.forEach((fetcher, key) => {
+      if (fetcher.data !== void 0) {
+        fetcherData.current.set(key, fetcher.data);
+      }
+    });
+    deletedFetchers.forEach((key) => fetcherData.current.delete(key));
+    let isViewTransitionUnavailable = router2.window == null || router2.window.document == null || typeof router2.window.document.startViewTransition !== "function";
+    if (!viewTransitionOpts || isViewTransitionUnavailable) {
+      if (flushSync) {
+        flushSyncSafe(() => setStateImpl(newState));
+      } else {
+        optInStartTransition(() => setStateImpl(newState));
+      }
+      return;
+    }
+    if (flushSync) {
+      flushSyncSafe(() => {
+        if (transition) {
+          renderDfd && renderDfd.resolve();
+          transition.skipTransition();
+        }
+        setVtContext({
+          isTransitioning: true,
+          flushSync: true,
+          currentLocation: viewTransitionOpts.currentLocation,
+          nextLocation: viewTransitionOpts.nextLocation
+        });
+      });
+      let t = router2.window.document.startViewTransition(() => {
+        flushSyncSafe(() => setStateImpl(newState));
+      });
+      t.finished.finally(() => {
+        flushSyncSafe(() => {
+          setRenderDfd(void 0);
+          setTransition(void 0);
+          setPendingState(void 0);
+          setVtContext({
+            isTransitioning: false
+          });
+        });
+      });
+      flushSyncSafe(() => setTransition(t));
+      return;
+    }
+    if (transition) {
+      renderDfd && renderDfd.resolve();
+      transition.skipTransition();
+      setInterruption({
+        state: newState,
+        currentLocation: viewTransitionOpts.currentLocation,
+        nextLocation: viewTransitionOpts.nextLocation
+      });
+    } else {
+      setPendingState(newState);
+      setVtContext({
+        isTransitioning: true,
+        flushSync: false,
+        currentLocation: viewTransitionOpts.currentLocation,
+        nextLocation: viewTransitionOpts.nextLocation
+      });
+    }
+  }, [router2.window, transition, renderDfd, fetcherData, optInStartTransition]);
+  React.useLayoutEffect(() => router2.subscribe(setState), [router2, setState]);
+  React.useEffect(() => {
+    if (vtContext.isTransitioning && !vtContext.flushSync) {
+      setRenderDfd(new Deferred());
+    }
+  }, [vtContext]);
+  React.useEffect(() => {
+    if (renderDfd && pendingState && router2.window) {
+      let newState = pendingState;
+      let renderPromise = renderDfd.promise;
+      let transition2 = router2.window.document.startViewTransition(async () => {
+        optInStartTransition(() => setStateImpl(newState));
+        await renderPromise;
+      });
+      transition2.finished.finally(() => {
+        setRenderDfd(void 0);
+        setTransition(void 0);
+        setPendingState(void 0);
+        setVtContext({
+          isTransitioning: false
+        });
+      });
+      setTransition(transition2);
+    }
+  }, [optInStartTransition, pendingState, renderDfd, router2.window]);
+  React.useEffect(() => {
+    if (renderDfd && pendingState && state.location.key === pendingState.location.key) {
+      renderDfd.resolve();
+    }
+  }, [renderDfd, transition, state.location, pendingState]);
+  React.useEffect(() => {
+    if (!vtContext.isTransitioning && interruption) {
+      setPendingState(interruption.state);
+      setVtContext({
+        isTransitioning: true,
+        flushSync: false,
+        currentLocation: interruption.currentLocation,
+        nextLocation: interruption.nextLocation
+      });
+      setInterruption(void 0);
+    }
+  }, [vtContext.isTransitioning, interruption]);
+  React.useEffect(() => {
+  }, []);
+  let navigator2 = React.useMemo(() => {
+    return {
+      createHref: router2.createHref,
+      encodeLocation: router2.encodeLocation,
+      go: (n) => router2.navigate(n),
+      push: (to, state2, opts) => router2.navigate(to, {
+        state: state2,
+        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset
+      }),
+      replace: (to, state2, opts) => router2.navigate(to, {
+        replace: true,
+        state: state2,
+        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset
+      })
+    };
+  }, [router2]);
+  let basename = router2.basename || "/";
+  let dataRouterContext = React.useMemo(() => ({
+    router: router2,
+    navigator: navigator2,
+    static: false,
+    basename
+  }), [router2, navigator2, basename]);
+  let routerFuture = React.useMemo(() => ({
+    v7_relativeSplatPath: router2.future.v7_relativeSplatPath
+  }), [router2.future.v7_relativeSplatPath]);
+  React.useEffect(() => logV6DeprecationWarnings(future, router2.future), [future, router2.future]);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(DataRouterContext.Provider, {
+    value: dataRouterContext
+  }, /* @__PURE__ */ React.createElement(DataRouterStateContext.Provider, {
+    value: state
+  }, /* @__PURE__ */ React.createElement(FetchersContext.Provider, {
+    value: fetcherData.current
+  }, /* @__PURE__ */ React.createElement(ViewTransitionContext.Provider, {
+    value: vtContext
+  }, /* @__PURE__ */ React.createElement(Router, {
+    basename,
+    location: state.location,
+    navigationType: state.historyAction,
+    navigator: navigator2,
+    future: routerFuture
+  }, state.initialized || router2.future.v7_partialHydration ? /* @__PURE__ */ React.createElement(MemoizedDataRoutes, {
+    routes: router2.routes,
+    future: router2.future,
+    state
+  }) : fallbackElement))))), null);
+}
+const MemoizedDataRoutes = /* @__PURE__ */ React.memo(DataRoutes);
+function DataRoutes(_ref3) {
+  let {
+    routes: routes2,
+    future,
+    state
+  } = _ref3;
+  return useRoutesImpl(routes2, void 0, state, future);
+}
+var DataRouterHook;
+(function(DataRouterHook2) {
+  DataRouterHook2["UseScrollRestoration"] = "useScrollRestoration";
+  DataRouterHook2["UseSubmit"] = "useSubmit";
+  DataRouterHook2["UseSubmitFetcher"] = "useSubmitFetcher";
+  DataRouterHook2["UseFetcher"] = "useFetcher";
+  DataRouterHook2["useViewTransitionState"] = "useViewTransitionState";
+})(DataRouterHook || (DataRouterHook = {}));
+var DataRouterStateHook;
+(function(DataRouterStateHook2) {
+  DataRouterStateHook2["UseFetcher"] = "useFetcher";
+  DataRouterStateHook2["UseFetchers"] = "useFetchers";
+  DataRouterStateHook2["UseScrollRestoration"] = "useScrollRestoration";
+})(DataRouterStateHook || (DataRouterStateHook = {}));
+function useSearchParams(defaultInit) {
+  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));
+  let hasSetSearchParamsRef = React.useRef(false);
+  let location2 = useLocation();
+  let searchParams = React.useMemo(() => (
+    // Only merge in the defaults if we haven't yet called setSearchParams.
+    // Once we call that we want those to take precedence, otherwise you can't
+    // remove a param with setSearchParams({}) if it has an initial value
+    getSearchParamsForLocation(location2.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current)
+  ), [location2.search]);
+  let navigate = useNavigate();
+  let setSearchParams = React.useCallback((nextInit, navigateOptions) => {
+    const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit);
+    hasSetSearchParamsRef.current = true;
+    navigate("?" + newSearchParams, navigateOptions);
+  }, [navigate, searchParams]);
+  return [searchParams, setSearchParams];
+}
+const useLoadInitialData = () => {
+  const { t } = useTranslation();
+  const {
+    documentDrives,
+    driveNodes,
+    setDriveNodes,
+    makeUiDriveNodes,
+    onSyncStatus
+  } = useUiNodes();
+  const prevDrivesState = useRef([...driveNodes]);
+  const drivesWithError = useRef([]);
+  const [, , serverSubscribeUpdates] = useDocumentDrives();
+  const { readDrives } = useReadModeContext();
+  const clientErrorHandler = useClientErrorHandler();
+  const reactor = useAsyncReactor();
+  const [connectConfig2] = useConnectConfig();
+  async function checkLatestVersion() {
+    const result = await isLatestVersion();
+    if (result === null) return;
+    if (result.isLatest) {
+      return true;
+    }
+    if (window.__VITE_ENVS.MODE === "development" || connectConfig2.studioMode || !connectConfig2.warnOutdatedApp) {
+      console.warn(
+        `Connect is outdated: 
+Current: ${result.currentVersion}
+Latest: ${result.latestVersion}`
+      );
+    } else {
+      toast(/* @__PURE__ */ jsx(ReloadConnectToast, {}), {
+        type: "connect-warning",
+        toastId: "outdated-app",
+        autoClose: false
+      });
+    }
+  }
+  useEffect(() => {
+    checkLatestVersion().catch(console.error);
+  }, []);
+  useEffect(() => {
+    const unsubscribe = serverSubscribeUpdates(clientErrorHandler);
+    return unsubscribe;
+  }, [serverSubscribeUpdates, documentDrives, clientErrorHandler]);
+  const checkDrivesErrors = useCallback(
+    async (driveNodes2, t2) => {
+      driveNodes2.forEach((drive) => {
+        const prevDrive = prevDrivesState.current.find(
+          (prevDrive2) => prevDrive2.id === drive.id
+        );
+        if (!prevDrive) return;
+        if (drive.sharingType !== LOCAL && drive.syncStatus === SUCCESS && drivesWithError.current.includes(drive)) {
+          drivesWithError.current = drivesWithError.current.filter(
+            (d) => d.id !== drive.id
+          );
+          return toast(t2("notifications.driveSyncSuccess"), {
+            type: "connect-success"
+          });
+        }
+        if ((drive.syncStatus === CONFLICT || drive.syncStatus === ERROR) && drive.syncStatus !== prevDrive.syncStatus) {
+          drivesWithError.current.push(drive);
+        }
+      });
+      prevDrivesState.current = [...driveNodes2];
+      if (drivesWithError.current.length > 0) {
+        const isCurrent = await checkLatestVersion();
+        if (isCurrent) {
+          drivesWithError.current.forEach((drive) => {
+            toast(
+              t2(
+                `notifications.${drive.syncStatus === CONFLICT ? "driveSyncConflict" : "driveSyncError"}`,
+                { drive: drive.name }
+              ),
+              {
+                type: "connect-warning",
+                toastId: `${drive.syncStatus === CONFLICT ? "driveSyncConflict" : "driveSyncError"}-${drive.id}`
+              }
+            );
+          });
+        }
+      }
+    },
+    []
+  );
+  useEffect(() => {
+    checkDrivesErrors(driveNodes, t).catch(console.error);
+  }, [driveNodes, t, checkDrivesErrors]);
+  const updateUiDriveNodes = useCallback(
+    async (documentDrives2) => {
+      const uiDriveNodes = await makeUiDriveNodes(documentDrives2);
+      setDriveNodes(uiDriveNodes);
+    },
+    [makeUiDriveNodes, setDriveNodes]
+  );
+  useEffect(() => {
+    const drives = [
+      ...readDrives,
+      ...documentDrives
+    ];
+    updateUiDriveNodes(drives).catch(console.error);
+  }, [documentDrives, readDrives, updateUiDriveNodes]);
+  useEffect(() => {
+    if (!reactor) {
+      return;
+    }
+    const unsub = onSyncStatus(() => updateUiDriveNodes(documentDrives));
+    return unsub;
+  }, [reactor, documentDrives, onSyncStatus, updateUiDriveNodes]);
+};
+function buildPathname(selectedNodePath) {
+  const driveNode = selectedNodePath[0];
+  if (!driveNode) {
+    return;
+  }
+  if (driveNode.kind !== DRIVE) {
+    throw new Error(
+      "Node path is invalid, first node is not a drive node."
+    );
+  }
+  const driveNodeComponent = makeDriveNodeUrlComponent(driveNode);
+  const nodePathComponents = selectedNodePath.slice(1).map((node) => encodeURIComponent(node.slug || node.name));
+  const pathname = [driveNodeComponent, ...nodePathComponents].join("/");
+  return pathname;
+}
+function makeDriveNodeUrlComponent(driveNode) {
+  const component = driveNode.slug || driveNode.name || driveNode.id;
+  return `/d/${encodeURIComponent(component)}`;
+}
+function getSelectedNodeFromPathname(driveNodes, driveIdFromPathname, nodeNamesFromPathname) {
+  if (!driveIdFromPathname) {
+    return null;
+  }
+  const driveId = decodeURIComponent(driveIdFromPathname);
+  const driveNode = driveNodes.find(
+    (node) => (node == null ? void 0 : node.id) === driveId || (node == null ? void 0 : node.slug) === driveId || (node == null ? void 0 : node.name) === driveId
+  );
+  if (!driveNode) return null;
+  if (!nodeNamesFromPathname) return driveNode;
+  const nodeNames = nodeNamesFromPathname.split("/").filter(Boolean).map(decodeURIComponent);
+  let selectedNode = driveNode;
+  for (const nodeName of nodeNames) {
+    if (selectedNode.kind === FILE) break;
+    const nextNode = selectedNode.children.find(
+      (node) => node.slug === nodeName || node.name === nodeName
+    );
+    if (!nextNode) {
+      console.error("Node not found:", nodeName);
+      break;
+    }
+    selectedNode = nextNode;
+  }
+  return selectedNode;
+}
+const useNodeNavigation = () => {
+  const navigate = useNavigate();
+  const location2 = useLocation();
+  const { search, pathname } = location2;
+  const params = useParams();
+  const { driveNodes, selectedNode, selectedNodePath, setSelectedNode } = useUiNodesContext();
+  const driveIdFromPathname = params.driveId;
+  const nodeNamesFromPathname = params["*"];
+  const selectedNodeFromPathname = getSelectedNodeFromPathname(
+    driveNodes,
+    driveIdFromPathname,
+    nodeNamesFromPathname
+  );
+  const selectedNodePathname = buildPathname(selectedNodePath);
+  useEffect(() => {
+    if (!selectedNodePathname || selectedNodePathname === pathname) return;
+    navigate({ pathname: selectedNodePathname, search });
+  }, [search, navigate, selectedNodePathname]);
+  useEffect(() => {
+    if (selectedNode || !selectedNodeFromPathname) return;
+    setSelectedNode(selectedNodeFromPathname);
+  }, [selectedNode, selectedNodeFromPathname, setSelectedNode]);
+  useEffect(() => {
+    const selectedNodeFromPathname2 = getSelectedNodeFromPathname(
+      driveNodes,
+      driveIdFromPathname,
+      nodeNamesFromPathname
+    );
+    if (!selectedNodeFromPathname2) return;
+    setSelectedNode(selectedNodeFromPathname2);
+  }, [
+    driveNodes,
+    driveIdFromPathname,
+    nodeNamesFromPathname,
+    setSelectedNode
+  ]);
+};
+const SvgAtlasLogomark = (props) => /* @__PURE__ */ React.createElement("svg", { width: 28, height: 32, viewBox: "0 0 28 32", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M0.05092 23.7286L0.000163347 23.9993L0 23.9995L0.207853 24.067L27.6823 24.067L27.9995 23.9995L27.9161 23.6913L14.2182 0.209032L13.9998 0L13.749 0.246353L0.05092 23.7286ZM20.9994 11.9999L7.0003 11.9999L13.9998 23.999L20.9994 11.9999Z", fill: "url(#paint0_radial_319_20865)" }), /* @__PURE__ */ React.createElement("path", { d: "M14 0L0 23.9998V7.99993L14 0Z", fill: "url(#paint1_linear_319_20865)" }), /* @__PURE__ */ React.createElement("path", { d: "M28 24L7.82013e-05 24L14 31.9999L28 24Z", fill: "url(#paint2_linear_319_20865)" }), /* @__PURE__ */ React.createElement("path", { d: "M14 0L28 23.9998V7.99993L14 0Z", fill: "url(#paint3_linear_319_20865)" }), /* @__PURE__ */ React.createElement("defs", null, /* @__PURE__ */ React.createElement("radialGradient", { id: "paint0_radial_319_20865", cx: 0, cy: 0, r: 1, gradientUnits: "userSpaceOnUse", gradientTransform: "translate(13.9994 16.0344) rotate(-89.9988) scale(16.0344 16.201)" }, /* @__PURE__ */ React.createElement("stop", { offset: 0.181008, stopColor: "#FFCD6B" }), /* @__PURE__ */ React.createElement("stop", { offset: 1, stopColor: "#EB5EDF" })), /* @__PURE__ */ React.createElement("linearGradient", { id: "paint1_linear_319_20865", x1: -0.031454, y1: 24.041, x2: 13.801, y2: -0.142908, gradientUnits: "userSpaceOnUse" }, /* @__PURE__ */ React.createElement("stop", { stopColor: "#4331E9" }), /* @__PURE__ */ React.createElement("stop", { offset: 1, stopColor: "#A273FF" })), /* @__PURE__ */ React.createElement("linearGradient", { id: "paint2_linear_319_20865", x1: -0.0310093, y1: 24, x2: 28.0444, y2: 24, gradientUnits: "userSpaceOnUse" }, /* @__PURE__ */ React.createElement("stop", { stopColor: "#A273FF" }), /* @__PURE__ */ React.createElement("stop", { offset: 1, stopColor: "#4331E9" })), /* @__PURE__ */ React.createElement("linearGradient", { id: "paint3_linear_319_20865", x1: 28.0315, y1: 24.041, x2: 14.199, y2: -0.142908, gradientUnits: "userSpaceOnUse" }, /* @__PURE__ */ React.createElement("stop", { stopColor: "#A273FF" }), /* @__PURE__ */ React.createElement("stop", { offset: 1, stopColor: "#4331E9" }))));
+const SvgRefresh = (props) => /* @__PURE__ */ React.createElement("svg", { width: 16, height: 16, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("path", { d: "M15.6867 8.03333C15.4933 7.83999 15.1733 7.83999 14.98 8.03333L14.6733 8.34001V8C14.6733 4.32 11.68 1.32666 7.99999 1.32666C5.96666 1.32666 4.06666 2.23999 2.79333 3.82666C2.61999 4.03999 2.65332 4.35999 2.87332 4.52665C3.08666 4.69999 3.40666 4.66666 3.57332 4.44666C4.65999 3.09332 6.27332 2.31999 7.99999 2.31999C11.1267 2.31999 13.6733 4.86666 13.6733 7.99333V8.32666L13.3667 8.02002C13.1733 7.82669 12.8533 7.82669 12.66 8.02002C12.4667 8.21335 12.4667 8.53335 12.66 8.72668L13.82 9.88668C13.8667 9.93334 13.92 9.96666 13.98 9.99333C14.04 10.02 14.1067 10.0333 14.1733 10.0333C14.24 10.0333 14.3 10.02 14.3667 9.99333C14.4267 9.96666 14.48 9.93334 14.5267 9.88668L15.6867 8.72668C15.88 8.54668 15.88 8.22666 15.6867 8.03333Z", fill: "#6C7275" }), /* @__PURE__ */ React.createElement("path", { d: "M13.1267 11.4666C12.9133 11.2933 12.5933 11.3266 12.4267 11.5466C11.34 12.9 9.72665 13.6733 7.99998 13.6733C4.87332 13.6733 2.32665 11.1266 2.32665 7.99996V7.66663L2.63332 7.97331C2.73332 8.07331 2.85999 8.11996 2.98665 8.11996C3.11332 8.11996 3.23999 8.07331 3.33999 7.97331C3.53332 7.77998 3.53332 7.45998 3.33999 7.26664L2.17998 6.10661C2.13332 6.05994 2.07998 6.02663 2.01998 5.99996C1.89998 5.94663 1.75998 5.94663 1.63998 5.99996C1.57998 6.02663 1.52665 6.05994 1.47999 6.10661L0.319988 7.26664C0.126654 7.45998 0.126654 7.77998 0.319988 7.97331C0.513321 8.16664 0.833319 8.16664 1.02665 7.97331L1.33332 7.66663V7.99996C1.33332 11.68 4.32665 14.6733 8.00665 14.6733C10.04 14.6733 11.94 13.76 13.2133 12.1733C13.38 11.96 13.3467 11.64 13.1267 11.4666Z", fill: "#6C7275" }));
+const REACTOR_URL = "https://apps.powerhouse.io/sky-atlas/staging/switchboard";
+const MIN_LOADING_TIME = 2e3;
+function useReactorUrl() {
+  const { search } = useLocation();
+  return useMemo(() => {
+    const params = new URLSearchParams(search);
+    const url = params.get("reactorUrl") ?? REACTOR_URL;
+    return url.endsWith("/") ? url : `${url}/`;
+  }, [search]);
+}
+async function forkAtlas(docId, reactorUrl) {
+  const document = gql`
+        mutation ForkAtlas($docId: PHID) {
+            ForkAtlas(docId: $docId)
+        }
+    `;
+  return await request(`${reactorUrl}graphql`, document, { docId });
+}
+function AtlasImport() {
+  const status = useRef("initial");
+  const reactor = useUnwrappedReactor();
+  const { documentId } = useParams();
+  const reactorUrl = useReactorUrl();
+  const navigate = useNavigate();
+  const { addRemoteDrive } = useDocumentDriveServer();
+  const [driveId, setDriveId] = useState(void 0);
+  const [error, setError] = useState(void 0);
+  const [loading, setLoading] = useState(true);
+  const hasError = status.current === "error";
+  useEffect(() => {
+    if (error) {
+      console.error("Error forking Atlas:", error);
+      toast("Error forking Atlas", { type: "error" });
+    }
+  }, [error]);
+  async function forkAtlasDocument(documentId2) {
+    const result = await forkAtlas(documentId2, reactorUrl);
+    const driveId2 = result.ForkAtlas;
+    status.current = "forked";
+    setDriveId(driveId2);
+  }
+  const redirectToDrive = useCallback(() => {
+    if (driveId && !loading) {
+      navigate(`/d/${driveId}`, { replace: true });
+    }
+  }, [driveId, navigate, loading]);
+  const addForkDrive = useCallback(
+    async (driveId2) => {
+      console.log("Adding remote drive:", driveId2);
+      const driveUrl = `${reactorUrl}d/${driveId2}`;
+      try {
+        const addedDrive = await addRemoteDrive(driveUrl, {
+          sharingType: "PUBLIC",
+          availableOffline: true,
+          listeners: [
+            {
+              block: true,
+              callInfo: {
+                data: driveUrl,
+                name: "switchboard-push",
+                transmitterType: "SwitchboardPush"
+              },
+              filter: {
+                branch: ["main"],
+                documentId: ["*"],
+                documentType: ["*"],
+                scope: ["global"]
+              },
+              label: "Switchboard Sync",
+              listenerId: "1",
+              system: true
+            }
+          ],
+          triggers: []
+        });
+        status.current = "done";
+        console.log("Added remote drive:", addedDrive);
+        setTimeout(() => {
+          setLoading(false);
+        }, MIN_LOADING_TIME);
+      } catch (error2) {
+        status.current = "error";
+        setLoading(false);
+        setError(error2);
+      }
+    },
+    [addRemoteDrive, navigate, reactorUrl]
+  );
+  useEffect(() => {
+    if (!documentId || status.current !== "initial") return;
+    status.current = "forking";
+    forkAtlasDocument(documentId).catch((error2) => {
+      status.current = "error";
+      setError(error2);
+    });
+  }, [documentId, status]);
+  useEffect(() => {
+    if (!driveId || !reactor || status.current !== "forked") return;
+    status.current = "addingDrive";
+    new Promise((resolve) => {
+      setTimeout(resolve, 500);
+    }).then(() => addForkDrive(driveId)).catch((error2) => {
+      status.current = "error";
+      setError(error2);
+    });
+  }, [driveId, reactor, status]);
+  return /* @__PURE__ */ jsx("div", { className: "bg-gray-50 size-full flex justify-center gap-x-4", children: /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-2xl w-full max-w-[850px] drop-shadow-sm p-6", children: [
+    /* @__PURE__ */ jsx("h1", { className: "text-lg text-gray-900 font-medium", children: "Welcome to the Atlas Explorer" }),
+    /* @__PURE__ */ jsx("div", { className: "mt-4 bg-gray-50 border border-gray-200 rounded-xl p-6", children: /* @__PURE__ */ jsxs("div", { className: "bg-slate-50 rounded-2xl min-h-80 flex flex-col justify-center items-center", children: [
+      /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(SvgAtlasLogomark, {}) }),
+      hasError ? /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-800 mt-3", children: "Error forking Atlas scope. Please try again." }) : /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500 mt-3", children: "Forking Atlas scope..." }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          onClick: hasError ? window.location.reload.bind(
+            window.location
+          ) : redirectToDrive,
+          size: "small",
+          color: "light",
+          className: "bg-white border border-gray-200 h-9 px-3 mt-4 text-gray-600",
+          children: hasError ? "Retry" : loading ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(SvgRefresh, { className: "animate-spin" }),
+            "Loading"
+          ] }) : "Continue"
+        }
+      )
+    ] }) })
+  ] }) });
+}
+const ErrorBoundaryContext = createContext(null);
+const initialState = {
+  didCatch: false,
+  error: null
+};
+class ErrorBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.resetErrorBoundary = this.resetErrorBoundary.bind(this);
+    this.state = initialState;
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      didCatch: true,
+      error
+    };
+  }
+  resetErrorBoundary() {
+    const {
+      error
+    } = this.state;
+    if (error !== null) {
+      var _this$props$onReset, _this$props;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      (_this$props$onReset = (_this$props = this.props).onReset) === null || _this$props$onReset === void 0 ? void 0 : _this$props$onReset.call(_this$props, {
+        args,
+        reason: "imperative-api"
+      });
+      this.setState(initialState);
+    }
+  }
+  componentDidCatch(error, info) {
+    var _this$props$onError, _this$props2;
+    (_this$props$onError = (_this$props2 = this.props).onError) === null || _this$props$onError === void 0 ? void 0 : _this$props$onError.call(_this$props2, error, info);
+  }
+  componentDidUpdate(prevProps, prevState) {
+    const {
+      didCatch
+    } = this.state;
+    const {
+      resetKeys
+    } = this.props;
+    if (didCatch && prevState.error !== null && hasArrayChanged(prevProps.resetKeys, resetKeys)) {
+      var _this$props$onReset2, _this$props3;
+      (_this$props$onReset2 = (_this$props3 = this.props).onReset) === null || _this$props$onReset2 === void 0 ? void 0 : _this$props$onReset2.call(_this$props3, {
+        next: resetKeys,
+        prev: prevProps.resetKeys,
+        reason: "keys"
+      });
+      this.setState(initialState);
+    }
+  }
+  render() {
+    const {
+      children,
+      fallbackRender,
+      FallbackComponent,
+      fallback
+    } = this.props;
+    const {
+      didCatch,
+      error
+    } = this.state;
+    let childToRender = children;
+    if (didCatch) {
+      const props = {
+        error,
+        resetErrorBoundary: this.resetErrorBoundary
+      };
+      if (typeof fallbackRender === "function") {
+        childToRender = fallbackRender(props);
+      } else if (FallbackComponent) {
+        childToRender = createElement(FallbackComponent, props);
+      } else if (fallback !== void 0) {
+        childToRender = fallback;
+      } else {
+        throw error;
+      }
+    }
+    return createElement(ErrorBoundaryContext.Provider, {
+      value: {
+        didCatch,
+        error,
+        resetErrorBoundary: this.resetErrorBoundary
+      }
+    }, childToRender);
+  }
+}
+function hasArrayChanged() {
+  let a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+  let b = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return a.length !== b.length || a.some((item, index) => !Object.is(item, b[index]));
+}
+const SvgConnect = (props) => /* @__PURE__ */ React.createElement("svg", { width: 107, height: 20, viewBox: "0 0 107 20", fill: "currentColor", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("path", { d: "M0.666504 10.1087C0.666504 8.30419 1.056 6.69918 1.83499 5.29371C2.61398 3.8709 3.6959 2.76908 5.08077 1.98827C6.48295 1.1901 8.0669 0.791016 9.83261 0.791016C11.9965 0.791016 13.8487 1.36361 15.3894 2.50881C16.9301 3.654 17.9601 5.21563 18.4794 7.1937H13.5977C13.2342 6.43023 12.7149 5.84896 12.0397 5.44988C11.3819 5.05079 10.6289 4.85125 9.78067 4.85125C8.41311 4.85125 7.30522 5.32842 6.45699 6.28275C5.60876 7.23708 5.18464 8.51241 5.18464 10.1087C5.18464 11.7051 5.60876 12.9804 6.45699 13.9347C7.30522 14.8891 8.41311 15.3662 9.78067 15.3662C10.6289 15.3662 11.3819 15.1667 12.0397 14.7676C12.7149 14.3685 13.2342 13.7872 13.5977 13.0238H18.4794C17.9601 15.0018 16.9301 16.5635 15.3894 17.7087C13.8487 18.8365 11.9965 19.4004 9.83261 19.4004C8.0669 19.4004 6.48295 19.01 5.08077 18.2292C3.6959 17.431 2.61398 16.3292 1.83499 14.9238C1.056 13.5183 0.666504 11.9133 0.666504 10.1087Z" }), /* @__PURE__ */ React.createElement("path", { d: "M26.7553 19.4785C25.3358 19.4785 24.0548 19.1749 22.9123 18.5676C21.7871 17.9603 20.8956 17.0927 20.2378 15.9648C19.5973 14.837 19.277 13.5183 19.277 12.0087C19.277 10.5165 19.6059 9.20646 20.2638 8.07862C20.9216 6.93343 21.8217 6.05718 22.9642 5.44988C24.1068 4.84258 25.3878 4.53893 26.8073 4.53893C28.2267 4.53893 29.5078 4.84258 30.6503 5.44988C31.7928 6.05718 32.693 6.93343 33.3508 8.07862C34.0086 9.20646 34.3375 10.5165 34.3375 12.0087C34.3375 13.5009 33.9999 14.8197 33.3248 15.9648C32.667 17.0927 31.7582 17.9603 30.5983 18.5676C29.4558 19.1749 28.1748 19.4785 26.7553 19.4785ZM26.7553 15.6265C27.6036 15.6265 28.322 15.3142 28.9105 14.6895C29.5164 14.0649 29.8193 13.1713 29.8193 12.0087C29.8193 10.8462 29.5251 9.95257 28.9365 9.32792C28.3652 8.70327 27.6555 8.39095 26.8073 8.39095C25.9417 8.39095 25.2233 8.70327 24.6521 9.32792C24.0808 9.93522 23.7952 10.8288 23.7952 12.0087C23.7952 13.1713 24.0721 14.0649 24.6261 14.6895C25.1973 15.3142 25.9071 15.6265 26.7553 15.6265Z" }), /* @__PURE__ */ React.createElement("path", { d: "M44.483 4.59098C46.1795 4.59098 47.5297 5.14623 48.5337 6.25672C49.5551 7.34986 50.0658 8.85944 50.0658 10.7854V19.2703H45.6515V11.3841C45.6515 10.4124 45.4005 9.6576 44.8985 9.11971C44.3964 8.58181 43.7213 8.31286 42.8731 8.31286C42.0249 8.31286 41.3497 8.58181 40.8477 9.11971C40.3457 9.6576 40.0947 10.4124 40.0947 11.3841V19.2703H35.6545V4.74714H40.0947V6.67315C40.5448 6.03115 41.1507 5.52796 41.9123 5.16358C42.674 4.78185 43.5309 4.59098 44.483 4.59098Z" }), /* @__PURE__ */ React.createElement("path", { d: "M60.9412 4.59098C62.6376 4.59098 63.9879 5.14623 64.9919 6.25672C66.0133 7.34986 66.5239 8.85944 66.5239 10.7854V19.2703H62.1096V11.3841C62.1096 10.4124 61.8586 9.6576 61.3566 9.11971C60.8546 8.58181 60.1795 8.31286 59.3313 8.31286C58.483 8.31286 57.8079 8.58181 57.3059 9.11971C56.8039 9.6576 56.5529 10.4124 56.5529 11.3841V19.2703H52.1126V4.74714H56.5529V6.67315C57.0029 6.03115 57.6088 5.52796 58.3705 5.16358C59.1322 4.78185 59.9891 4.59098 60.9412 4.59098Z" }), /* @__PURE__ */ React.createElement("path", { d: "M82.2291 11.7745C82.2291 12.1909 82.2031 12.6247 82.1512 13.0758H72.1022C72.1715 13.9781 72.4571 14.6722 72.9591 15.158C73.4784 15.6265 74.1103 15.8607 74.8546 15.8607C75.9625 15.8607 76.7329 15.3923 77.1656 14.4553H81.8915C81.6491 15.4096 81.2077 16.2685 80.5672 17.032C79.944 17.7954 79.1564 18.3941 78.2043 18.8278C77.2522 19.2616 76.1876 19.4785 75.0104 19.4785C73.5909 19.4785 72.3272 19.1749 71.2194 18.5676C70.1115 17.9603 69.2459 17.0927 68.6227 15.9648C67.9995 14.837 67.6879 13.5183 67.6879 12.0087C67.6879 10.4991 67.9909 9.18044 68.5968 8.05259C69.2199 6.92475 70.0855 6.05718 71.1934 5.44988C72.3013 4.84258 73.5736 4.53893 75.0104 4.53893C76.4126 4.53893 77.659 4.8339 78.7496 5.42385C79.8402 6.0138 80.6884 6.85534 81.2943 7.94848C81.9175 9.04163 82.2291 10.317 82.2291 11.7745ZM77.685 10.6033C77.685 9.83979 77.4253 9.23249 76.906 8.78135C76.3866 8.33022 75.7375 8.10465 74.9585 8.10465C74.2141 8.10465 73.5823 8.32154 73.063 8.75533C72.561 9.18911 72.2494 9.80509 72.1282 10.6033H77.685Z" }), /* @__PURE__ */ React.createElement("path", { d: "M82.65 12.0087C82.65 10.4991 82.9529 9.18044 83.5588 8.05259C84.182 6.92475 85.0389 6.05718 86.1295 5.44988C87.2374 4.84258 88.5011 4.53893 89.9206 4.53893C91.7382 4.53893 93.2529 5.01609 94.4647 5.97042C95.6937 6.92475 96.4987 8.26949 96.8795 10.0046H92.1537C91.7555 8.89414 90.9852 8.33889 89.8427 8.33889C89.0291 8.33889 88.3799 8.65989 87.8952 9.3019C87.4105 9.92655 87.1681 10.8288 87.1681 12.0087C87.1681 13.1886 87.4105 14.0996 87.8952 14.7416C88.3799 15.3662 89.0291 15.6786 89.8427 15.6786C90.9852 15.6786 91.7555 15.1233 92.1537 14.0128H96.8795C96.4987 15.7133 95.6937 17.0493 94.4647 18.021C93.2356 18.9927 91.7209 19.4785 89.9206 19.4785C88.5011 19.4785 87.2374 19.1749 86.1295 18.5676C85.0389 17.9603 84.182 17.0927 83.5588 15.9648C82.9529 14.837 82.65 13.5183 82.65 12.0087Z" }), /* @__PURE__ */ React.createElement("path", { d: "M106.291 15.4964V19.2703H104.032C102.423 19.2703 101.167 18.8799 100.267 18.0991C99.3672 17.3009 98.9171 16.0082 98.9171 14.221V8.443H97.1514V4.74714H98.9171V1.20745H103.357V4.74714H106.266V8.443H103.357V14.2731C103.357 14.7069 103.461 15.0192 103.669 15.2101C103.877 15.4009 104.223 15.4964 104.708 15.4964H106.291Z" }));
+const SvgLogo = (props) => /* @__PURE__ */ React.createElement("svg", { width: 26, height: 26, viewBox: "0 0 26 26", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("path", { d: "M20.105 7.37978C19.9097 7.18452 19.9097 6.86795 20.105 6.67269L22.5725 4.20504C24.9229 6.75889 26.0649 10.0248 25.9972 13.2723L20.105 7.37978ZM16.1222 10.6556C15.927 10.8509 15.927 11.1674 16.1222 11.3627L24.2614 19.5023C25.125 18.0079 25.667 16.378 25.8875 14.7149L19.3289 8.15595C19.1336 7.96068 18.817 7.96068 18.6218 8.15595L16.1222 10.6556ZM0.00284613 12.729C-0.0649083 15.9752 1.07706 19.2411 3.42753 21.7962L5.89504 19.3285C6.09029 19.1333 6.09029 18.8167 5.89504 18.6214L0.00284613 12.729ZM4.20485 22.5723C6.75858 24.9229 10.0256 26.0649 13.2716 25.9972L7.37946 20.1047C7.1842 19.9094 6.8676 19.9094 6.67234 20.1047L4.20485 22.5723ZM13.0519 18.5174C13.2472 18.3222 13.2472 18.0056 13.0519 17.8103L1.73982 6.49772C0.87626 7.99209 0.334223 9.62072 0.113713 11.2851L9.84523 21.0171C10.0405 21.2124 10.3571 21.2124 10.5524 21.0171L13.0519 18.5174ZM9.60276 7.08454C9.78969 6.88798 9.7858 6.57823 9.594 6.38642L5.55009 2.34233C4.93783 2.77105 4.35391 3.25889 3.80695 3.80588C3.25998 4.35287 2.77216 4.93684 2.34346 5.54912L6.3864 9.59111C6.57859 9.78325 6.88907 9.7867 7.08548 9.59887L8.47817 8.26702L9.60276 7.08454ZM11.2072 21.6733C11.012 21.8685 11.012 22.1851 11.2072 22.3804L14.7142 25.8875C16.3785 25.667 18.0071 25.1249 19.5013 24.2613L14.4139 19.1736C14.2186 18.9783 13.902 18.9783 13.7067 19.1736L11.2072 21.6733ZM23.6565 20.4496L11.0843 7.87683C10.8891 7.68156 10.5725 7.68156 10.3772 7.87683L7.87766 10.3765C7.68241 10.5718 7.68241 10.8883 7.87766 11.0836L20.4499 23.6564C21.0622 23.2277 21.6461 22.7398 22.193 22.1929C22.74 21.6459 23.2278 21.0619 23.6565 20.4496ZM17.8445 7.37855C18.0397 7.18329 18.0397 6.86672 17.8445 6.67146L11.2858 0.112477C9.62151 0.332998 7.99294 0.875053 6.49865 1.73866L14.6378 9.87821C14.8331 10.0735 15.1497 10.0735 15.3449 9.87821L17.8445 7.37855ZM21.7951 3.42769C19.2414 1.07712 15.9744 -0.0649114 12.7284 0.00284625L18.6205 5.89529C18.8158 6.09056 19.1324 6.09056 19.3277 5.89529L21.7951 3.42769Z", fill: "url(#paint0_linear_526_12008)" }), /* @__PURE__ */ React.createElement("defs", null, /* @__PURE__ */ React.createElement("linearGradient", { id: "paint0_linear_526_12008", x1: 13, y1: 0, x2: 13, y2: 26, gradientUnits: "userSpaceOnUse" }, /* @__PURE__ */ React.createElement("stop", { stopColor: "currentColor" }), /* @__PURE__ */ React.createElement("stop", { offset: 1, stopColor: "currentColor" }))));
+function Sidebar() {
+  const { showModal } = useModal();
+  const navigate = useNavigate();
+  const { user, openRenown, logout } = useLogin();
+  const { driveNodes, setSelectedNode, selectedNode, showAddDriveModal } = useUiNodes();
+  const connectDebug = localStorage.getItem("CONNECT_DEBUG") === "true";
+  const onClickSettings = () => {
+    showModal("settingsModal", { onRefresh: () => navigate(0) });
+  };
+  const onRootClick = useCallback(() => {
+    setSelectedNode(null);
+    navigate("/");
+  }, [navigate, setSelectedNode]);
+  const onAddDriveClick = useCallback(() => {
+    showAddDriveModal();
+  }, [showAddDriveModal]);
+  const headerContent = /* @__PURE__ */ jsxs("div", { className: "flex h-full items-center", children: [
+    /* @__PURE__ */ jsx(
+      Icon,
+      {
+        name: "Connect",
+        className: "!h-[30px] !w-[100px] cursor-pointer",
+        onClick: onRootClick
+      }
+    ),
+    connectDebug && /* @__PURE__ */ jsx(
+      "button",
+      {
+        id: "connect-debug-button",
+        className: "ml-6",
+        onClick: () => showModal("debugSettingsModal", {}),
+        children: /* @__PURE__ */ jsx("img", { src: "settings.png", className: "h-5 text-gray-600" })
+      }
+    )
+  ] });
+  const handleDriveClick = useCallback(
+    (driveNode) => {
+      setSelectedNode(driveNode);
+    },
+    [setSelectedNode]
+  );
+  const etherscanUrl = (user == null ? void 0 : user.address) ? `https://etherscan.io/address/${user.address}` : "";
+  return /* @__PURE__ */ jsx(
+    ConnectSidebar,
+    {
+      id: "sidebar",
+      onClick: () => onRootClick(),
+      onClickSettings,
+      headerContent,
+      address: user == null ? void 0 : user.address,
+      onLogin: openRenown,
+      onDisconnect: logout,
+      etherscanUrl,
+      children: /* @__PURE__ */ jsxs(
+        ErrorBoundary,
+        {
+          fallback: /* @__PURE__ */ jsx("div", { className: "text-center", children: "There was an error loading drives" }),
+          onError: logger.error,
+          children: [
+            driveNodes.map((node, index) => /* @__PURE__ */ jsx(
+              SidebarItem,
+              {
+                title: node.name,
+                onClick: () => handleDriveClick(node),
+                active: (selectedNode == null ? void 0 : selectedNode.id) === node.id,
+                icon: node.icon ? /* @__PURE__ */ jsx(
+                  "img",
+                  {
+                    src: node.icon,
+                    alt: node.name,
+                    width: 32,
+                    height: 32
+                  }
+                ) : void 0
+              },
+              index
+            )),
+            /* @__PURE__ */ jsx(SidebarAddDriveItem, { onClick: onAddDriveClick })
+          ]
+        }
+      )
+    }
+  );
+}
+function Root() {
+  useLoadInitialData();
+  useNodeNavigation();
+  const navigate = useNavigate();
+  const { login } = useLogin();
+  useEffect(() => {
+    var _a2;
+    (_a2 = window.electronAPI) == null ? void 0 : _a2.ready();
+  }, []);
+  const [searchParams, setSearchParams] = useSearchParams();
+  useEffect(() => {
+    const userStr = searchParams.get("user");
+    if (userStr && login) {
+      const userDid = decodeURIComponent(userStr);
+      searchParams.delete("user");
+      setSearchParams(searchParams);
+      login(userDid).catch(logger.error);
+    }
+  }, [login, searchParams, setSearchParams]);
+  useEffect(() => {
+    var _a2;
+    const unsubscribe = (_a2 = window.electronAPI) == null ? void 0 : _a2.handleURL((_e, url) => {
+      navigate(`/${url}`);
+    });
+    return unsubscribe;
+  }, [navigate]);
+  return /* @__PURE__ */ jsx(ModalManager, { children: /* @__PURE__ */ jsxs("div", { className: "h-screen", children: [
+    isElectron && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: `h-8 w-full
+                    ${isMac && "justify-center"}
+                    flex items-center bg-gray-50`,
+        children: [
+          /* @__PURE__ */ jsx(SvgLogo, { className: "ml-1 mr-0.5 p-1.5" }),
+          /* @__PURE__ */ jsx(SvgConnect, { className: "h-3 w-fit" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `flex items-stretch overflow-auto
+                        ${isElectron ? "h-app-height" : "h-screen"}
+                    `,
+        role: "presentation",
+        tabIndex: 0,
+        children: /* @__PURE__ */ jsxs(Suspense, { children: [
+          /* @__PURE__ */ jsx(Sidebar, {}),
+          /* @__PURE__ */ jsx("div", { className: "relative flex-1 overflow-auto", children: /* @__PURE__ */ jsx(Outlet, {}) })
+        ] })
+      }
+    )
+  ] }) });
+}
+const ReloadConnectToast = () => {
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx("p", { className: "font-medium", children: t("notifications.reloadApp") }),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: () => location.reload(),
+        className: "underline decoration-solid underline-offset-2",
+        children: [
+          t("common.reloadConnect"),
+          " 🔄"
+        ]
+      }
+    )
+  ] });
+};
+function getDriveIcon(driveNode) {
+  if (driveNode.icon) {
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: driveNode.icon,
+        alt: driveNode.name,
+        height: 32,
+        width: 32
+      }
+    );
+  }
+  if (driveNode.sharingType === "LOCAL") {
+    return /* @__PURE__ */ jsx(Icon, { name: "Hdd", size: 32 });
+  } else {
+    return /* @__PURE__ */ jsx(Icon, { name: "Server", size: 32 });
+  }
+}
+function Home() {
+  const getAppDescriptionForEditorId = useGetAppNameForEditorId();
+  const { showAddDriveModal, driveNodes, setSelectedNode } = useUiNodes();
+  const { documentDrives } = useDocumentDriveServer();
+  const handleDriveClick = useCallback(
+    (driveNode) => {
+      setSelectedNode(driveNode);
+    },
+    [setSelectedNode]
+  );
+  const onAddDriveClick = useCallback(() => {
+    showAddDriveModal();
+  }, [showAddDriveModal]);
+  return /* @__PURE__ */ jsxs(HomeScreen, { children: [
+    driveNodes.map((driveNode) => {
+      var _a2;
+      const drive = documentDrives.find(
+        (d) => d.state.global.id === driveNode.id
+      );
+      const editorId = (_a2 = drive == null ? void 0 : drive.meta) == null ? void 0 : _a2.preferredEditor;
+      const appName = editorId ? getAppDescriptionForEditorId(editorId) : void 0;
+      return /* @__PURE__ */ jsx(
+        HomeScreenItem,
+        {
+          title: driveNode.name,
+          description: appName || "Drive Explorer App",
+          icon: getDriveIcon(driveNode),
+          onClick: () => handleDriveClick(driveNode)
+        },
+        driveNode.id
+      );
+    }),
+    /* @__PURE__ */ jsx(HomeScreenAddDriveItem, { onClick: onAddDriveClick })
+  ] });
+}
+const Content = React__default.lazy(() => __vitePreload(() => import("./content-CwQswwKt.js"), true ? __vite__mapDeps([0,1,2,3,4,5]) : void 0));
+async function createRouter(routes2) {
+  var _a2;
+  const isPackaged = await ((_a2 = window.electronAPI) == null ? void 0 : _a2.isPackaged());
+  const createRouter2 = isPackaged ? createMemoryRouter : createBrowserRouter;
+  return createRouter2(routes2, {
+    basename: connectConfig.routerBasename,
+    future: {
+      v7_fetcherPersist: true,
+      v7_relativeSplatPath: true
+    }
+  });
+}
+function createRoutes() {
+  const routes2 = [
+    {
+      path: "/",
+      element: /* @__PURE__ */ jsx(Home, {})
+    },
+    {
+      path: "d?/:driveId?/*?",
+      element: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(Content, {}) })
+    },
+    {
+      path: "import/:documentId",
+      element: /* @__PURE__ */ jsx(AtlasImport, {})
+    }
+  ];
+  return [
+    {
+      path: "/",
+      element: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(Root, {}) }),
+      children: routes2
+    },
+    {
+      element: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(Root, {}) })
+    }
+  ];
+}
+const routes = createRoutes();
+const RouterAsync = async () => {
+  const router2 = await createRouter(routes);
+  const Router2 = () => /* @__PURE__ */ jsx(RouterProvider, { router: router2 });
+  return Router2;
+};
+const router = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: RouterAsync
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ENSAvatar as E,
+  ErrorBoundary as a,
+  router as r,
+  useQuery$1 as u
+};
+//# sourceMappingURL=router-CvCplkfB.js.map