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

package/dist/assets/{app-DULISSV9.js → app-BRmEr17M.js}

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/ccip-HqktEv5j.js","assets/main.uPY9aYSk.js","assets/app-loader-CS6aHo9m.js","assets/app-loader-B74nopv_.css","assets/index-DzXmrci3.js","assets/style-Ce3V83BE.css","assets/index-q1LnGFn2.js","assets/browser-ClaMQmoS.js","assets/router-CvCplkfB.js","assets/reactor-analytics-C3XNgGME.js"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/ccip-oTEe2poK.js","assets/main.CUjcRUhx.js","assets/app-loader-_6yU4PFI.js","assets/app-loader-DaCxVT0x.css","assets/index-DSo3d6TG.js","assets/style-BPUyhu8E.css","assets/index-C47jzF-n.js","assets/browser--PdVaTAw.js","assets/router-B-9X40Vx.js","assets/reactor-analytics-C7JH8QS3.js"])))=>i.map(i=>d[i]);
 var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -18,10 +18,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return __privateGet(obj, member, getter);
   }
 });
-var _InternalTransmitter_instances, buildInternalOperationUpdate_fn, _focused, _cleanup, _setup, _a, _online, _cleanup2, _setup2, _b, _gcTimeout, _c, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, dispatch_fn, _d, _queries, _e2, _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _f, _mutations, _scopes, _mutationId, _g, _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _h, _subtleCrypto, _keyPair, _keyPairStorage, _did, _ConnectCrypto_instances, initCrypto_fn, initialize_fn, parseDid_fn, generateECDSAKeyPair_fn, exportKeyPair_fn, importKeyPair_fn, _sign, _verify, _DB_NAME, _STORE_NAME, _KEY, _db, _BrowserKeyStorage_instances, useStore_fn;
-import { _ as __vitePreload } from "./main.uPY9aYSk.js";
+var _InternalTransmitter_instances, buildInternalOperationUpdate_fn, _focused, _cleanup, _setup, _a, _online, _cleanup2, _setup2, _b, _gcTimeout, _c, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, dispatch_fn, _d, _queries, _e2, _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _f, _mutations, _scopes, _mutationId, _g, _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _h, _client2, _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, _i, _subtleCrypto, _keyPair, _keyPairStorage, _did, _ConnectCrypto_instances, initCrypto_fn, initialize_fn, parseDid_fn, generateECDSAKeyPair_fn, exportKeyPair_fn, importKeyPair_fn, _sign, _verify, _DB_NAME, _STORE_NAME, _KEY, _db, _BrowserKeyStorage_instances, useStore_fn;
+import { _ as __vitePreload } from "./main.CUjcRUhx.js";
 import { jsx as jsx$1, Fragment, jsxs } from "react/jsx-runtime";
-import { c as createAction, a as createReducer, i as isDocumentAction, R as ReorderStateExamplesInputSchema, D as DeleteStateExampleInputSchema, U as UpdateStateExampleInputSchema, A as AddStateExampleInputSchema, S as SetInitialStateInputSchema, b as SetStateSchemaInputSchema, d as ReorderModuleOperationsInputSchema, e as DeleteOperationInputSchema, M as MoveOperationInputSchema, f as SetOperationReducerInputSchema, g as SetOperationTemplateInputSchema, h as SetOperationDescriptionInputSchema, j as SetOperationSchemaInputSchema, k as SetOperationScopeInputSchema, l as SetOperationNameInputSchema, m as AddOperationInputSchema, n as ReorderOperationExamplesInputSchema, o as DeleteOperationExampleInputSchema, p as UpdateOperationExampleInputSchema, q as AddOperationExampleInputSchema, r as ReorderOperationErrorsInputSchema, s as DeleteOperationErrorInputSchema, t as SetOperationErrorTemplateInputSchema, u as SetOperationErrorDescriptionInputSchema, v as SetOperationErrorNameInputSchema, w as SetOperationErrorCodeInputSchema, x as AddOperationErrorInputSchema, y as ReorderModulesInputSchema, z as DeleteModuleInputSchema, B as SetModuleDescriptionInputSchema, C as SetModuleNameInputSchema, E as AddModuleInputSchema, F as ReorderChangeLogItemsInputSchema, G as DeleteChangeLogItemInputSchema, H as UpdateChangeLogItemInputSchema, I as AddChangeLogItemInputSchema, J as SetAuthorWebsiteInputSchema, K as SetAuthorNameInputSchema, L as SetModelDescriptionInputSchema, N as SetModelExtensionInputSchema, O as SetModelIdInputSchema, P as SetModelNameInputSchema, Q as baseCreateExtendedState, T as baseCreateDocument, V as baseSaveToFile, W as baseSaveToFileHandle, X as baseLoadFromFile, Y as baseLoadFromInput, Z as pascalCase, _ as logger$1, $ as Icon, a0 as getDefaultExportFromCjs, a1 as LOCAL, a2 as commonjsGlobal, a3 as PUBLIC, a4 as SWITCHBOARD, a5 as locationInfoByLocation, a6 as sharingTypeOptions, a7 as objectType, a8 as recordType, a9 as stringType, aa as capitalCase, ab as CLOUD, ac as createZip, ad as LZString, ae as buildSignedOperation, af as getI18n, ag as getDefaults, ah as connectConfig, ai as hashDocumentStateForScope, aj as getAugmentedNamespace, ak as process, al as setErrorHandler, am as driveDocumentModelModule, an as createBrowserStorage, ao as createBrowserDocumentDriveServer, ap as hashKey$1, aq as childLogger, ar as reducer$8, as as isDocumentDrive, at as generateAddNodeAction, au as isFileNode, av as uploadDocumentOperations, aw as updateFile, ax as addFolder, ay as isFolderNode, az as deleteNode, aA as updateNode, aB as FILE$1, aC as moveNode, aD as generateNodesCopy, aE as copyNode, aF as createState$1, aG as setDriveName, aH as setAvailableOffline, aI as setSharingType, aJ as SynchronizationUnitNotFoundError, aK as removeTrigger, aL as generateUUID, aM as PullResponderTransmitter, aN as addTrigger, aO as ReadDriveNotFoundError, aP as openUrl, aQ as getNodeOptions, aR as DRIVE$1, aS as FOLDER, aT as requestPublicDrive, aU as serviceWorkerManager, aV as packageJson, aW as t$1, aX as generateId } from "./app-loader-CS6aHo9m.js";
+import { c as createAction, a as createReducer, i as isDocumentAction, R as ReorderStateExamplesInputSchema, D as DeleteStateExampleInputSchema, U as UpdateStateExampleInputSchema, A as AddStateExampleInputSchema, S as SetInitialStateInputSchema, b as SetStateSchemaInputSchema, d as ReorderModuleOperationsInputSchema, e as DeleteOperationInputSchema, M as MoveOperationInputSchema, f as SetOperationReducerInputSchema, g as SetOperationTemplateInputSchema, h as SetOperationDescriptionInputSchema, j as SetOperationSchemaInputSchema, k as SetOperationScopeInputSchema, l as SetOperationNameInputSchema, m as AddOperationInputSchema, n as ReorderOperationExamplesInputSchema, o as DeleteOperationExampleInputSchema, p as UpdateOperationExampleInputSchema, q as AddOperationExampleInputSchema, r as ReorderOperationErrorsInputSchema, s as DeleteOperationErrorInputSchema, t as SetOperationErrorTemplateInputSchema, u as SetOperationErrorDescriptionInputSchema, v as SetOperationErrorNameInputSchema, w as SetOperationErrorCodeInputSchema, x as AddOperationErrorInputSchema, y as ReorderModulesInputSchema, z as DeleteModuleInputSchema, B as SetModuleDescriptionInputSchema, C as SetModuleNameInputSchema, E as AddModuleInputSchema, F as ReorderChangeLogItemsInputSchema, G as DeleteChangeLogItemInputSchema, H as UpdateChangeLogItemInputSchema, I as AddChangeLogItemInputSchema, J as SetAuthorWebsiteInputSchema, K as SetAuthorNameInputSchema, L as SetModelDescriptionInputSchema, N as SetModelExtensionInputSchema, O as SetModelIdInputSchema, P as SetModelNameInputSchema, Q as baseCreateExtendedState, T as baseCreateDocument, V as baseSaveToFile, W as baseSaveToFileHandle, X as baseLoadFromFile, Y as baseLoadFromInput, Z as pascalCase, _ as logger$2, $ as Icon, a0 as getDefaultExportFromCjs, a1 as LOCAL, a2 as commonjsGlobal, a3 as PUBLIC, a4 as SWITCHBOARD, a5 as locationInfoByLocation, a6 as sharingTypeOptions, a7 as objectType, a8 as recordType, a9 as stringType, aa as capitalCase, ab as CLOUD, ac as createZip, ad as LZString, ae as buildSignedOperation, af as getI18n, ag as getDefaults, ah as connectConfig, ai as hashDocumentStateForScope, aj as getAugmentedNamespace, ak as process, al as setErrorHandler, am as driveDocumentModelModule, an as createBrowserStorage, ao as createBrowserDocumentDriveServer, ap as generateId, aq as childLogger, ar as reducer$8, as as isDocumentDrive, at as generateAddNodeAction, au as isFileNode, av as uploadDocumentOperations, aw as updateFile, ax as addFolder, ay as isFolderNode, az as deleteNode, aA as updateNode, aB as FILE$1, aC as moveNode, aD as generateNodesCopy, aE as copyNode, aF as createState$1, aG as setDriveName, aH as setAvailableOffline, aI as setSharingType, aJ as SynchronizationUnitNotFoundError, aK as removeTrigger, aL as generateUUID, aM as PullResponderTransmitter, aN as addTrigger, aO as ReadDriveNotFoundError, aP as openUrl, aQ as getNodeOptions, aR as DRIVE$1, aS as FOLDER, aT as requestPublicDrive, aU as serviceWorkerManager, aV as packageJson, aW as t$1 } from "./app-loader-_6yU4PFI.js";
 import * as React from "react";
 import React__default, { useLayoutEffect, useEffect, useState, forwardRef, useCallback, useContext, useRef, useMemo, createContext, Component, Fragment as Fragment$1, createElement, useId as useId$1, useSyncExternalStore, isValidElement, cloneElement, Children, useReducer, useDebugValue, Suspense, lazy } from "react";
 import * as ReactDOM from "react-dom";
@@ -1489,7 +1489,7 @@ class InternalTransmitter {
         };
       });
     } catch (error) {
-      logger$1.error(error);
+      logger$2.error(error);
       return strands.map(({ operations, ...s2 }) => {
         var _a3;
         return {
@@ -11446,9 +11446,9 @@ function createStringFromObject(mergedProps, registered, obj) {
         }
       } else {
         if (Array.isArray(value) && typeof value[0] === "string" && registered == null) {
-          for (var _i = 0; _i < value.length; _i++) {
-            if (isProcessableValue(value[_i])) {
-              string2 += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
+          for (var _i2 = 0; _i2 < value.length; _i2++) {
+            if (isProcessableValue(value[_i2])) {
+              string2 += processStyleName(key) + ":" + processStyleValue(key, value[_i2]) + ";";
             }
           }
         } else {
@@ -11628,7 +11628,7 @@ function _taggedTemplateLiteral(e2, t2) {
 }
 var index$2 = useLayoutEffect;
 var _excluded$4 = ["className", "clearValue", "cx", "getStyles", "getClassNames", "getValue", "hasValue", "isMulti", "isRtl", "options", "selectOption", "selectProps", "setValue", "theme"];
-var noop$1 = function noop2() {
+var noop$2 = function noop2() {
 };
 function applyPrefixToName(prefix2, name2) {
   if (!name2) {
@@ -11730,7 +11730,7 @@ function easeOutCubic(t2, b2, c2, d2) {
 }
 function animatedScrollTo(element, to) {
   var duration = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 200;
-  var callback = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : noop$1;
+  var callback = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : noop$2;
   var start = getScrollTop(element);
   var change = to - start;
   var increment = 10;
@@ -11791,8 +11791,8 @@ var options = {
 };
 var w$1 = typeof window !== "undefined" ? window : {};
 if (w$1.addEventListener && w$1.removeEventListener) {
-  w$1.addEventListener("p", noop$1, options);
-  w$1.removeEventListener("p", noop$1, false);
+  w$1.addEventListener("p", noop$2, options);
+  w$1.removeEventListener("p", noop$2, false);
 }
 var supportsPassiveEvents = passiveOptionAccessed;
 function notNullish(item) {
@@ -12668,8 +12668,8 @@ function memoizeOne(resultFn, isEqual2) {
   var cache = null;
   function memoized2() {
     var newArgs = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      newArgs[_i] = arguments[_i];
+    for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+      newArgs[_i2] = arguments[_i2];
     }
     if (cache && cache.lastThis === this && isEqual2(newArgs, cache.lastArgs)) {
       return cache.lastResult;
@@ -14533,7 +14533,7 @@ var Select$1 = /* @__PURE__ */ function(_Component) {
             id,
             innerRef: this.getInputRef,
             onBlur: this.onInputBlur,
-            onChange: noop$1,
+            onChange: noop$2,
             onFocus: this.onInputFocus,
             disabled: isDisabled,
             tabIndex,
@@ -20580,7 +20580,7 @@ async function call(client2, args) {
   } catch (err) {
     const data2 = getRevertErrorData(err);
     const { offchainLookup, offchainLookupSignature } = await __vitePreload(async () => {
-      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import("./ccip-HqktEv5j.js");
+      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import("./ccip-oTEe2poK.js");
       return { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 };
     }, true ? __vite__mapDeps([0,1,2,3]) : void 0);
     if (client2.ccipRead !== false && (data2 == null ? void 0 : data2.slice(0, 10)) === offchainLookupSignature && to)
@@ -21729,7 +21729,7 @@ async function getFeeHistory(client2, { blockCount, blockNumber, blockTag = "lat
   }, { dedupe: Boolean(blockNumberHex) });
   return formatFeeHistory(feeHistory);
 }
-async function getFilterChanges(_client2, { filter }) {
+async function getFilterChanges(_client3, { filter }) {
   const strict = "strict" in filter && filter.strict;
   const logs = await filter.request({
     method: "eth_getFilterChanges",
@@ -21746,7 +21746,7 @@ async function getFilterChanges(_client2, { filter }) {
     strict
   });
 }
-async function getFilterLogs(_client2, { filter }) {
+async function getFilterLogs(_client3, { filter }) {
   const strict = filter.strict ?? false;
   const logs = await filter.request({
     method: "eth_getFilterLogs",
@@ -24813,7 +24813,7 @@ function watchBlockNumber(client2, { emitOnBegin = false, emitMissed = false, on
   };
   return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
 }
-async function uninstallFilter(_client2, { filter }) {
+async function uninstallFilter(_client3, { filter }) {
   return filter.request({
     method: "eth_uninstallFilter",
     params: [filter.id]
@@ -28960,7 +28960,7 @@ var Subscribable = class {
   }
 };
 var isServer = typeof window === "undefined" || "Deno" in globalThis;
-function noop() {
+function noop$1() {
 }
 function functionalUpdate(updater, input) {
   return typeof updater === "function" ? updater(input) : updater;
@@ -29594,7 +29594,7 @@ var Query = (_d = class extends Removable {
     var _a2, _b2;
     const promise = (_a2 = __privateGet(this, _retryer)) == null ? void 0 : _a2.promise;
     (_b2 = __privateGet(this, _retryer)) == null ? void 0 : _b2.cancel(options2);
-    return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+    return promise ? promise.then(noop$1).catch(noop$1) : Promise.resolve();
   }
   destroy() {
     super.destroy();
@@ -30050,7 +30050,7 @@ var Mutation = (_f = class extends Removable {
     this.execute(this.state.variables);
   }
   async execute(variables) {
-    var _a2, _b2, _c2, _d2, _e3, _f2, _g2, _h2, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+    var _a2, _b2, _c2, _d2, _e3, _f2, _g2, _h2, _i2, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
     __privateSet(this, _retryer2, createRetryer({
       fn: () => {
         if (!this.options.mutationFn) {
@@ -30101,8 +30101,8 @@ var Mutation = (_f = class extends Removable {
         this
       ));
       await ((_h2 = (_g2 = this.options).onSuccess) == null ? void 0 : _h2.call(_g2, data, variables, this.state.context));
-      await ((_j = (_i = __privateGet(this, _mutationCache).config).onSettled) == null ? void 0 : _j.call(
-        _i,
+      await ((_j = (_i2 = __privateGet(this, _mutationCache).config).onSettled) == null ? void 0 : _j.call(
+        _i2,
         data,
         null,
         this.state.variables,
@@ -30336,7 +30336,7 @@ var MutationCache = (_g = class extends Subscribable {
     const pausedMutations = this.getAll().filter((x2) => x2.state.isPaused);
     return notifyManager.batch(
       () => Promise.all(
-        pausedMutations.map((mutation) => mutation.continue().catch(noop))
+        pausedMutations.map((mutation) => mutation.continue().catch(noop$1))
       )
     );
   }
@@ -30582,7 +30582,7 @@ var QueryClient = (_h = class {
     const promises = notifyManager.batch(
       () => __privateGet(this, _queryCache).findAll(filters).map((query) => query.cancel(defaultedCancelOptions))
     );
-    return Promise.all(promises).then(noop).catch(noop);
+    return Promise.all(promises).then(noop$1).catch(noop$1);
   }
   invalidateQueries(filters, options2 = {}) {
     return notifyManager.batch(() => {
@@ -30610,12 +30610,12 @@ var QueryClient = (_h = class {
       () => __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled()).map((query) => {
         let promise = query.fetch(void 0, fetchOptions);
         if (!fetchOptions.throwOnError) {
-          promise = promise.catch(noop);
+          promise = promise.catch(noop$1);
         }
         return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
       })
     );
-    return Promise.all(promises).then(noop);
+    return Promise.all(promises).then(noop$1);
   }
   fetchQuery(options2) {
     const defaultedOptions = this.defaultQueryOptions(options2);
@@ -30628,14 +30628,14 @@ var QueryClient = (_h = class {
     ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
   }
   prefetchQuery(options2) {
-    return this.fetchQuery(options2).then(noop).catch(noop);
+    return this.fetchQuery(options2).then(noop$1).catch(noop$1);
   }
   fetchInfiniteQuery(options2) {
     options2.behavior = infiniteQueryBehavior(options2.pages);
     return this.fetchQuery(options2);
   }
   prefetchInfiniteQuery(options2) {
-    return this.fetchInfiniteQuery(options2).then(noop).catch(noop);
+    return this.fetchInfiniteQuery(options2).then(noop$1).catch(noop$1);
   }
   ensureInfiniteQueryData(options2) {
     options2.behavior = infiniteQueryBehavior(options2.pages);
@@ -30737,6 +30737,455 @@ var QueryClient = (_h = class {
     __privateGet(this, _mutationCache2).clear();
   }
 }, _queryCache = new WeakMap(), _mutationCache2 = new WeakMap(), _defaultOptions2 = new WeakMap(), _queryDefaults = new WeakMap(), _mutationDefaults = new WeakMap(), _mountCount = new WeakMap(), _unsubscribeFocus = new WeakMap(), _unsubscribeOnline = new WeakMap(), _h);
+var QueryObserver = (_i = class extends Subscribable {
+  constructor(client2, options2) {
+    super();
+    __privateAdd(this, _QueryObserver_instances);
+    __privateAdd(this, _client2);
+    __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 = options2;
+    __privateSet(this, _client2, client2);
+    __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(options2);
+  }
+  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(options2) {
+    const prevOptions = this.options;
+    const prevQuery = __privateGet(this, _currentQuery);
+    this.options = __privateGet(this, _client2).defaultQueryOptions(options2);
+    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, _client2).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(options2) {
+    const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), options2);
+    const result = this.createResult(query, options2);
+    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({ ...options2 } = {}) {
+    return this.fetch({
+      ...options2
+    });
+  }
+  fetchOptimistic(options2) {
+    const defaultedOptions = __privateGet(this, _client2).defaultQueryOptions(options2);
+    const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), 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, options2) {
+    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 (options2._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options2);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options2, prevOptions);
+      if (fetchOnMount || fetchOptionally) {
+        newState = {
+          ...newState,
+          ...fetchState(state.data, query.options)
+        };
+      }
+      if (options2._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let { error, errorUpdatedAt, status } = newState;
+    if (options2.select && newState.data !== void 0) {
+      if (prevResult && newState.data === (prevResultState == null ? void 0 : prevResultState.data) && options2.select === __privateGet(this, _selectFn)) {
+        data = __privateGet(this, _selectResult);
+      } else {
+        try {
+          __privateSet(this, _selectFn, options2.select);
+          data = options2.select(newState.data);
+          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options2);
+          __privateSet(this, _selectResult, data);
+          __privateSet(this, _selectError, null);
+        } catch (selectError) {
+          __privateSet(this, _selectError, selectError);
+        }
+      }
+    } else {
+      data = newState.data;
+    }
+    if (options2.placeholderData !== void 0 && data === void 0 && status === "pending") {
+      let placeholderData;
+      if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options2.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
+        placeholderData = prevResult.data;
+      } else {
+        placeholderData = typeof options2.placeholderData === "function" ? options2.placeholderData(
+          (_a2 = __privateGet(this, _lastQueryWithDefinedData)) == null ? void 0 : _a2.state.data,
+          __privateGet(this, _lastQueryWithDefinedData)
+        ) : options2.placeholderData;
+        if (options2.select && placeholderData !== void 0) {
+          try {
+            placeholderData = options2.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,
+          options2
+        );
+        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 isError2 = status === "error";
+    const isLoading = isPending && isFetching;
+    const hasData = data !== void 0;
+    const result = {
+      status,
+      fetchStatus: newState.fetchStatus,
+      isPending,
+      isSuccess: status === "success",
+      isError: isError2,
+      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: isError2 && !hasData,
+      isPaused: newState.fetchStatus === "paused",
+      isPlaceholderData,
+      isRefetchError: isError2 && hasData,
+      isStale: isStale(query, options2),
+      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);
+    }
+  }
+}, _client2 = 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, _client2).getQueryCache().build(__privateGet(this, _client2), 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, _client2).getQueryCache().notify({
+      query: __privateGet(this, _currentQuery),
+      type: "observerResultsUpdated"
+    });
+  });
+}, _i);
+function shouldLoadOnMount(query, options2) {
+  return resolveEnabled(options2.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options2.retryOnMount === false);
+}
+function shouldFetchOnMount(query, options2) {
+  return shouldLoadOnMount(query, options2) || query.state.data !== void 0 && shouldFetchOn(query, options2, options2.refetchOnMount);
+}
+function shouldFetchOn(query, options2, field) {
+  if (resolveEnabled(options2.enabled, query) !== false) {
+    const value = typeof field === "function" ? field(query) : field;
+    return value === "always" || value !== false && isStale(query, options2);
+  }
+  return false;
+}
+function shouldFetchOptionally(query, prevQuery, options2, prevOptions) {
+  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options2.suspense || query.state.status !== "error") && isStale(query, options2);
+}
+function isStale(query, options2) {
+  return resolveEnabled(options2.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options2.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}
 var QueryClientContext = React.createContext(
   void 0
 );
@@ -30759,6 +31208,140 @@ var QueryClientProvider = ({
   }, [client2]);
   return /* @__PURE__ */ jsx$1(QueryClientContext.Provider, { value: client2, children });
 };
+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 = (options2, errorResetBoundary) => {
+  if (options2.suspense || options2.throwOnError || options2.experimental_prefetchInRender) {
+    if (!errorResetBoundary.isReset()) {
+      options2.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(options2, Observer, queryClient) {
+  var _a2, _b2, _c2, _d2, _e3;
+  const client2 = useQueryClient();
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const defaultedOptions = client2.defaultQueryOptions(options2);
+  (_b2 = (_a2 = client2.getDefaultOptions().queries) == null ? void 0 : _a2._experimental_beforeQuery) == null ? void 0 : _b2.call(
+    _a2,
+    defaultedOptions
+  );
+  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+  ensureSuspenseTimers(defaultedOptions);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  useClearResetErrorBoundary(errorResetBoundary);
+  const isNewCacheEntry = !client2.getQueryCache().get(defaultedOptions.queryHash);
+  const [observer] = React.useState(
+    () => new Observer(
+      client2,
+      defaultedOptions
+    )
+  );
+  const result = observer.getOptimisticResult(defaultedOptions);
+  const shouldSubscribe = !isRestoring && options2.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: client2.getQueryCache().get(defaultedOptions.queryHash),
+    suspense: defaultedOptions.suspense
+  })) {
+    throw result.error;
+  }
+  (_d2 = (_c2 = client2.getDefaultOptions().queries) == null ? void 0 : _c2._experimental_afterQuery) == null ? void 0 : _d2.call(
+    _c2,
+    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
+      (_e3 = client2.getQueryCache().get(defaultedOptions.queryHash)) == null ? void 0 : _e3.promise
+    );
+    promise == null ? void 0 : promise.catch(noop).finally(() => {
+      observer.updateResult();
+    });
+  }
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+function useQuery(options2, queryClient) {
+  return useBaseQuery(options2, QueryObserver);
+}
 const FormInput = forwardRef(function FormInput2(props, ref) {
   const { icon, errorMessage, isDirty, containerClassName, inputClassName, errorMessageClassName, hideErrors = false, ...delegatedProps } = props;
   const type = props.type ?? "text";
@@ -50723,7 +51306,7 @@ const downloadFile = async (document2) => {
     window.document.body.appendChild(link);
     link.click();
     window.document.body.removeChild(link);
-  }).catch(logger$1.error);
+  }).catch(logger$2.error);
 };
 async function exportFile(document2, getDocumentModelModule2) {
   var _a2, _b2;
@@ -50920,7 +51503,7 @@ async function signOperation(operation, sign, documentId, document2, reducer2, u
   if (!operation.context) return operation;
   if (!operation.context.signer) return operation;
   if (!reducer2) {
-    logger$1.error(
+    logger$2.error(
       `Document model '${document2.documentType}' does not have a reducer`
     );
     return operation;
@@ -52822,7 +53405,7 @@ function useFileNodeDocument(props) {
             }
           )
         ).catch((error) => {
-          logger$1.error(error);
+          logger$2.error(error);
           setFileNodeDocument({
             driveId,
             documentId,
@@ -52854,7 +53437,7 @@ function useFileNodeDocument(props) {
           fileNodeDocument.driveId,
           fileNodeDocument.documentId,
           fileNodeDocument.documentType
-        ).then(setSelectedDocument).catch(logger$1.error);
+        ).then(setSelectedDocument).catch(logger$2.error);
       }
     });
     return removeListener;
@@ -55612,7 +56195,7 @@ function makeLogger() {
   }
   return logger2;
 }
-const logger = makeLogger();
+const logger$1 = makeLogger();
 const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
 function isValidProtocol(protocol) {
   return protocol === "http" || protocol === "https";
@@ -55664,7 +56247,7 @@ function validateDsn(dsn) {
   const requiredComponents = ["protocol", "publicKey", "host", "projectId"];
   const hasMissingRequiredComponent = requiredComponents.find((component) => {
     if (!dsn[component]) {
-      logger.error(`Invalid Sentry Dsn: ${component} missing`);
+      logger$1.error(`Invalid Sentry Dsn: ${component} missing`);
       return true;
     }
     return false;
@@ -55673,15 +56256,15 @@ function validateDsn(dsn) {
     return false;
   }
   if (!projectId.match(/^\d+$/)) {
-    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+    logger$1.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
     return false;
   }
   if (!isValidProtocol(protocol)) {
-    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+    logger$1.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
     return false;
   }
   if (port && isNaN(parseInt(port, 10))) {
-    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+    logger$1.error(`Invalid Sentry Dsn: Invalid port ${port}`);
     return false;
   }
   return true;
@@ -55723,7 +56306,7 @@ function addNonEnumerableProperty(obj, name2, value) {
       configurable: true
     });
   } catch (o_O) {
-    DEBUG_BUILD$5 && logger.log(`Failed to add non-enumerable property "${name2}" to object`, obj);
+    DEBUG_BUILD$5 && logger$1.log(`Failed to add non-enumerable property "${name2}" to object`, obj);
   }
 }
 function markFunctionWrapped(wrapped, original) {
@@ -55938,7 +56521,7 @@ function triggerHandlers$1(type, data) {
     try {
       handler(data);
     } catch (e2) {
-      DEBUG_BUILD$5 && logger.error(
+      DEBUG_BUILD$5 && logger$1.error(
         `Error while triggering instrumentation handler.
 Type: ${type}
 Name: ${getFunctionName(handler)}
@@ -56220,7 +56803,7 @@ function supportsNativeFetch() {
       }
       doc.head.removeChild(sandbox);
     } catch (err) {
-      DEBUG_BUILD$5 && logger.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ", err);
+      DEBUG_BUILD$5 && logger$1.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ", err);
     }
   }
   return result;
@@ -56986,7 +57569,7 @@ function objectToBaggageHeader(object) {
     const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;
     const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;
     if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {
-      DEBUG_BUILD$5 && logger.warn(
+      DEBUG_BUILD$5 && logger$1.warn(
         `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`
       );
       return baggageHeader;
@@ -57257,7 +57840,7 @@ function notifyEventProcessors(processors, event, hint, index2 = 0) {
       resolve(event);
     } else {
       const result = processor({ ...event }, hint);
-      DEBUG_BUILD$4 && processor.id && result === null && logger.log(`Event processor "${processor.id}" dropped event`);
+      DEBUG_BUILD$4 && processor.id && result === null && logger$1.log(`Event processor "${processor.id}" dropped event`);
       if (isThenable(result)) {
         void result.then((final) => notifyEventProcessors(processors, final, hint, index2 + 1).then(resolve)).then(null, reject);
       } else {
@@ -58370,7 +58953,7 @@ class Scope {
   captureException(exception, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
     if (!this._client) {
-      logger.warn("No client configured on scope - will not capture exception!");
+      logger$1.warn("No client configured on scope - will not capture exception!");
       return eventId;
     }
     const syntheticException = new Error("Sentry syntheticException");
@@ -58397,7 +58980,7 @@ class Scope {
   captureMessage(message, level, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
     if (!this._client) {
-      logger.warn("No client configured on scope - will not capture message!");
+      logger$1.warn("No client configured on scope - will not capture message!");
       return eventId;
     }
     const syntheticException = new Error(message);
@@ -58424,7 +59007,7 @@ class Scope {
   captureEvent(event, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
     if (!this._client) {
-      logger.warn("No client configured on scope - will not capture event!");
+      logger$1.warn("No client configured on scope - will not capture event!");
       return eventId;
     }
     this._client.captureEvent(event, { ...hint, event_id: eventId }, this);
@@ -58798,7 +59381,7 @@ class Hub {
     try {
       return client2.getIntegration(integration);
     } catch (_oO) {
-      DEBUG_BUILD$4 && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
+      DEBUG_BUILD$4 && logger$1.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
       return null;
     }
   }
@@ -58826,11 +59409,11 @@ class Hub {
     if (DEBUG_BUILD$4 && !result) {
       const client2 = this.getClient();
       if (!client2) {
-        logger.warn(
+        logger$1.warn(
           "Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'"
         );
       } else {
-        logger.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
+        logger$1.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
 Sentry.addTracingExtensions();
 Sentry.init({...});
 `);
@@ -58926,7 +59509,7 @@ Sentry.init({...});
     if (sentry && sentry.extensions && typeof sentry.extensions[method] === "function") {
       return sentry.extensions[method].apply(this, args);
     }
-    DEBUG_BUILD$4 && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
+    DEBUG_BUILD$4 && logger$1.warn(`Extension method ${method} couldn't be found, doing nothing.`);
   }
 }
 function getMainCarrier() {
@@ -58992,7 +59575,7 @@ function errorCallback() {
   const activeTransaction = getActiveTransaction();
   if (activeTransaction) {
     const status = "internal_error";
-    DEBUG_BUILD$4 && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);
+    DEBUG_BUILD$4 && logger$1.log(`[Tracing] Transaction: ${status} -> Global error occured`);
     activeTransaction.setStatus(status);
   }
 }
@@ -59495,7 +60078,7 @@ class Span {
       const nameStr = spanToJSON(childSpan).description || "< unknown name >";
       const idStr = rootSpan.spanContext().spanId;
       const logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;
-      logger.log(logMessage);
+      logger$1.log(logMessage);
       this._logMessage = logMessage;
     }
     return childSpan;
@@ -59592,7 +60175,7 @@ class Span {
     rootSpan && rootSpan.spanContext().spanId !== this._spanId) {
       const logMessage = this._logMessage;
       if (logMessage) {
-        logger.log(logMessage.replace("Starting", "Finishing"));
+        logger$1.log(logMessage.replace("Starting", "Finishing"));
       }
     }
     this._endTime = spanTimeInputToSeconds(endTimestamp);
@@ -59909,7 +60492,7 @@ class Transaction extends Span {
       return void 0;
     }
     if (!this._name) {
-      DEBUG_BUILD$4 && logger.warn("Transaction has no name, falling back to `<unlabeled transaction>`.");
+      DEBUG_BUILD$4 && logger$1.warn("Transaction has no name, falling back to `<unlabeled transaction>`.");
       this._name = "<unlabeled transaction>";
     }
     super.end(endTimestamp);
@@ -59918,7 +60501,7 @@ class Transaction extends Span {
       client2.emit("finishTransaction", this);
     }
     if (this._sampled !== true) {
-      DEBUG_BUILD$4 && logger.log("[Tracing] Discarding transaction because its trace was not chosen to be sampled.");
+      DEBUG_BUILD$4 && logger$1.log("[Tracing] Discarding transaction because its trace was not chosen to be sampled.");
       if (client2) {
         client2.recordDroppedEvent("sample_rate", "transaction");
       }
@@ -59968,13 +60551,13 @@ class Transaction extends Span {
     };
     const hasMeasurements = Object.keys(this._measurements).length > 0;
     if (hasMeasurements) {
-      DEBUG_BUILD$4 && logger.log(
+      DEBUG_BUILD$4 && logger$1.log(
         "[Measurements] Adding measurements to transaction",
         JSON.stringify(this._measurements, void 0, 2)
       );
       transaction.measurements = this._measurements;
     }
-    DEBUG_BUILD$4 && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this._name}.`);
+    DEBUG_BUILD$4 && logger$1.log(`[Tracing] Finishing ${this.op} transaction: ${this._name}.`);
     return transaction;
   }
 }
@@ -60043,7 +60626,7 @@ class IdleTransaction extends Transaction {
     this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[4];
     this._autoFinishAllowed = !delayAutoFinishUntilSignal;
     if (_onScope) {
-      DEBUG_BUILD$4 && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanContext().spanId}`);
+      DEBUG_BUILD$4 && logger$1.log(`Setting idle transaction on scope. Span ID: ${this.spanContext().spanId}`);
       _idleHub.getScope().setSpan(this);
     }
     if (!delayAutoFinishUntilSignal) {
@@ -60067,7 +60650,7 @@ class IdleTransaction extends Transaction {
     }
     if (this.spanRecorder) {
       DEBUG_BUILD$4 && // eslint-disable-next-line deprecation/deprecation
-      logger.log("[Tracing] finishing IdleTransaction", new Date(endTimestampInS * 1e3).toISOString(), this.op);
+      logger$1.log("[Tracing] finishing IdleTransaction", new Date(endTimestampInS * 1e3).toISOString(), this.op);
       for (const callback of this._beforeFinishCallbacks) {
         callback(this, endTimestampInS);
       }
@@ -60078,7 +60661,7 @@ class IdleTransaction extends Transaction {
         if (!spanToJSON(span).timestamp) {
           span.setStatus("cancelled");
           span.end(endTimestampInS);
-          DEBUG_BUILD$4 && logger.log("[Tracing] cancelling span since transaction ended early", JSON.stringify(span, void 0, 2));
+          DEBUG_BUILD$4 && logger$1.log("[Tracing] cancelling span since transaction ended early", JSON.stringify(span, void 0, 2));
         }
         const { start_timestamp: startTime, timestamp: endTime } = spanToJSON(span);
         const spanStartedBeforeTransactionFinish = startTime && startTime < endTimestampInS;
@@ -60087,16 +60670,16 @@ class IdleTransaction extends Transaction {
         if (DEBUG_BUILD$4) {
           const stringifiedSpan = JSON.stringify(span, void 0, 2);
           if (!spanStartedBeforeTransactionFinish) {
-            logger.log("[Tracing] discarding Span since it happened after Transaction was finished", stringifiedSpan);
+            logger$1.log("[Tracing] discarding Span since it happened after Transaction was finished", stringifiedSpan);
           } else if (!spanEndedBeforeFinalTimeout) {
-            logger.log("[Tracing] discarding Span since it finished after Transaction final timeout", stringifiedSpan);
+            logger$1.log("[Tracing] discarding Span since it finished after Transaction final timeout", stringifiedSpan);
           }
         }
         return spanStartedBeforeTransactionFinish && spanEndedBeforeFinalTimeout;
       });
-      DEBUG_BUILD$4 && logger.log("[Tracing] flushing IdleTransaction");
+      DEBUG_BUILD$4 && logger$1.log("[Tracing] flushing IdleTransaction");
     } else {
-      DEBUG_BUILD$4 && logger.log("[Tracing] No active IdleTransaction");
+      DEBUG_BUILD$4 && logger$1.log("[Tracing] No active IdleTransaction");
     }
     if (this._onScope) {
       const scope = this._idleHub.getScope();
@@ -60134,7 +60717,7 @@ class IdleTransaction extends Transaction {
         this._popActivity(id);
       };
       this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanContext().spanId, maxlen);
-      DEBUG_BUILD$4 && logger.log("Starting heartbeat");
+      DEBUG_BUILD$4 && logger$1.log("Starting heartbeat");
       this._pingHeartbeat();
     }
     this.spanRecorder.add(this);
@@ -60177,7 +60760,7 @@ class IdleTransaction extends Transaction {
    */
   sendAutoFinishSignal() {
     if (!this._autoFinishAllowed) {
-      DEBUG_BUILD$4 && logger.log("[Tracing] Received finish signal for idle transaction.");
+      DEBUG_BUILD$4 && logger$1.log("[Tracing] Received finish signal for idle transaction.");
       this._restartIdleTimeout();
       this._autoFinishAllowed = true;
     }
@@ -60200,9 +60783,9 @@ class IdleTransaction extends Transaction {
    */
   _pushActivity(spanId) {
     this.cancelIdleTimeout(void 0, { restartOnChildSpanChange: !this._idleTimeoutCanceledPermanently });
-    DEBUG_BUILD$4 && logger.log(`[Tracing] pushActivity: ${spanId}`);
+    DEBUG_BUILD$4 && logger$1.log(`[Tracing] pushActivity: ${spanId}`);
     this.activities[spanId] = true;
-    DEBUG_BUILD$4 && logger.log("[Tracing] new activities count", Object.keys(this.activities).length);
+    DEBUG_BUILD$4 && logger$1.log("[Tracing] new activities count", Object.keys(this.activities).length);
   }
   /**
    * Remove an activity from usage
@@ -60210,9 +60793,9 @@ class IdleTransaction extends Transaction {
    */
   _popActivity(spanId) {
     if (this.activities[spanId]) {
-      DEBUG_BUILD$4 && logger.log(`[Tracing] popActivity ${spanId}`);
+      DEBUG_BUILD$4 && logger$1.log(`[Tracing] popActivity ${spanId}`);
       delete this.activities[spanId];
-      DEBUG_BUILD$4 && logger.log("[Tracing] new activities count", Object.keys(this.activities).length);
+      DEBUG_BUILD$4 && logger$1.log("[Tracing] new activities count", Object.keys(this.activities).length);
     }
     if (Object.keys(this.activities).length === 0) {
       const endTimestamp = timestampInSeconds();
@@ -60243,7 +60826,7 @@ class IdleTransaction extends Transaction {
     this._prevHeartbeatString = heartbeatString;
     if (this._heartbeatCounter >= 3) {
       if (this._autoFinishAllowed) {
-        DEBUG_BUILD$4 && logger.log("[Tracing] Transaction finished because of no change for 3 heart beats");
+        DEBUG_BUILD$4 && logger$1.log("[Tracing] Transaction finished because of no change for 3 heart beats");
         this.setStatus("deadline_exceeded");
         this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[0];
         this.end();
@@ -60256,7 +60839,7 @@ class IdleTransaction extends Transaction {
    * Pings the heartbeat
    */
   _pingHeartbeat() {
-    DEBUG_BUILD$4 && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);
+    DEBUG_BUILD$4 && logger$1.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);
     setTimeout(() => {
       this._beat();
     }, this._heartbeatInterval);
@@ -60285,12 +60868,12 @@ function sampleTransaction(transaction, options2, samplingContext) {
     transaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);
   }
   if (!isValidSampleRate(sampleRate)) {
-    DEBUG_BUILD$4 && logger.warn("[Tracing] Discarding transaction because of invalid sample rate.");
+    DEBUG_BUILD$4 && logger$1.warn("[Tracing] Discarding transaction because of invalid sample rate.");
     transaction.sampled = false;
     return transaction;
   }
   if (!sampleRate) {
-    DEBUG_BUILD$4 && logger.log(
+    DEBUG_BUILD$4 && logger$1.log(
       `[Tracing] Discarding transaction because ${typeof options2.tracesSampler === "function" ? "tracesSampler returned 0 or false" : "a negative sampling decision was inherited or tracesSampleRate is set to 0"}`
     );
     transaction.sampled = false;
@@ -60298,7 +60881,7 @@ function sampleTransaction(transaction, options2, samplingContext) {
   }
   transaction.sampled = Math.random() < sampleRate;
   if (!transaction.sampled) {
-    DEBUG_BUILD$4 && logger.log(
+    DEBUG_BUILD$4 && logger$1.log(
       `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(
         sampleRate
       )})`
@@ -60306,12 +60889,12 @@ function sampleTransaction(transaction, options2, samplingContext) {
     return transaction;
   }
   DEBUG_BUILD$4 && // eslint-disable-next-line deprecation/deprecation
-  logger.log(`[Tracing] starting ${transaction.op} transaction - ${spanToJSON(transaction).description}`);
+  logger$1.log(`[Tracing] starting ${transaction.op} transaction - ${spanToJSON(transaction).description}`);
   return transaction;
 }
 function isValidSampleRate(rate) {
   if (isNaN$1(rate) || !(typeof rate === "number" || typeof rate === "boolean")) {
-    DEBUG_BUILD$4 && logger.warn(
+    DEBUG_BUILD$4 && logger$1.warn(
       `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
         rate
       )} of type ${JSON.stringify(typeof rate)}.`
@@ -60319,7 +60902,7 @@ function isValidSampleRate(rate) {
     return false;
   }
   if (rate < 0 || rate > 1) {
-    DEBUG_BUILD$4 && logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);
+    DEBUG_BUILD$4 && logger$1.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);
     return false;
   }
   return true;
@@ -60337,7 +60920,7 @@ function _startTransaction(transactionContext, customSamplingContext) {
   const configInstrumenter = options2.instrumenter || "sentry";
   const transactionInstrumenter = transactionContext.instrumenter || "sentry";
   if (configInstrumenter !== transactionInstrumenter) {
-    DEBUG_BUILD$4 && logger.error(
+    DEBUG_BUILD$4 && logger$1.error(
       `A transaction was started with instrumenter=\`${transactionInstrumenter}\`, but the SDK is configured with the \`${configInstrumenter}\` instrumenter.
 The transaction will not be sampled. Please use the ${configInstrumenter} instrumentation to start transactions.`
     );
@@ -60520,7 +61103,7 @@ function afterSetupIntegrations(client2, integrations) {
 }
 function setupIntegration(client2, integration, integrationIndex) {
   if (integrationIndex[integration.name]) {
-    DEBUG_BUILD$4 && logger.log(`Integration skipped because it was already installed: ${integration.name}`);
+    DEBUG_BUILD$4 && logger$1.log(`Integration skipped because it was already installed: ${integration.name}`);
     return;
   }
   integrationIndex[integration.name] = integration;
@@ -60542,7 +61125,7 @@ function setupIntegration(client2, integration, integrationIndex) {
     });
     client2.addEventProcessor(processor);
   }
-  DEBUG_BUILD$4 && logger.log(`Integration installed: ${integration.name}`);
+  DEBUG_BUILD$4 && logger$1.log(`Integration installed: ${integration.name}`);
 }
 function findIndex(arr, callback) {
   for (let i2 = 0; i2 < arr.length; i2++) {
@@ -60627,7 +61210,7 @@ class BaseClient {
     if (options2.dsn) {
       this._dsn = makeDsn(options2.dsn);
     } else {
-      DEBUG_BUILD$4 && logger.warn("No DSN provided, client will not send events.");
+      DEBUG_BUILD$4 && logger$1.warn("No DSN provided, client will not send events.");
     }
     if (this._dsn) {
       const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options2);
@@ -60645,7 +61228,7 @@ class BaseClient {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
   captureException(exception, hint, scope) {
     if (checkOrSetAlreadyCaught(exception)) {
-      DEBUG_BUILD$4 && logger.log(ALREADY_SEEN_ERROR);
+      DEBUG_BUILD$4 && logger$1.log(ALREADY_SEEN_ERROR);
       return;
     }
     let eventId = hint && hint.event_id;
@@ -60675,7 +61258,7 @@ class BaseClient {
    */
   captureEvent(event, hint, scope) {
     if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
-      DEBUG_BUILD$4 && logger.log(ALREADY_SEEN_ERROR);
+      DEBUG_BUILD$4 && logger$1.log(ALREADY_SEEN_ERROR);
       return;
     }
     let eventId = hint && hint.event_id;
@@ -60693,7 +61276,7 @@ class BaseClient {
    */
   captureSession(session) {
     if (!(typeof session.release === "string")) {
-      DEBUG_BUILD$4 && logger.warn("Discarded session because of missing or non-string release");
+      DEBUG_BUILD$4 && logger$1.warn("Discarded session because of missing or non-string release");
     } else {
       this.sendSession(session);
       updateSession(session, { init: false });
@@ -60801,7 +61384,7 @@ class BaseClient {
     try {
       return this._integrations[integration.id] || null;
     } catch (_oO) {
-      DEBUG_BUILD$4 && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);
+      DEBUG_BUILD$4 && logger$1.warn(`Cannot retrieve integration ${integration.id} from the current Client`);
       return null;
     }
   }
@@ -60849,7 +61432,7 @@ class BaseClient {
     if (this._options.sendClientReports) {
       const count2 = typeof eventOrCount === "number" ? eventOrCount : 1;
       const key = `${reason}:${category}`;
-      DEBUG_BUILD$4 && logger.log(`Recording outcome: "${key}"${count2 > 1 ? ` (${count2} times)` : ""}`);
+      DEBUG_BUILD$4 && logger$1.log(`Recording outcome: "${key}"${count2 > 1 ? ` (${count2} times)` : ""}`);
       this._outcomes[key] = (this._outcomes[key] || 0) + count2;
     }
   }
@@ -60857,7 +61440,7 @@ class BaseClient {
    * @inheritDoc
    */
   captureAggregateMetrics(metricBucketItems) {
-    DEBUG_BUILD$4 && logger.log(`Flushing aggregated metrics, number of metrics: ${metricBucketItems.length}`);
+    DEBUG_BUILD$4 && logger$1.log(`Flushing aggregated metrics, number of metrics: ${metricBucketItems.length}`);
     const metricsEnvelope = createMetricEnvelope(
       metricBucketItems,
       this._dsn,
@@ -61012,9 +61595,9 @@ class BaseClient {
         if (DEBUG_BUILD$4) {
           const sentryError = reason;
           if (sentryError.logLevel === "log") {
-            logger.log(sentryError.message);
+            logger$1.log(sentryError.message);
           } else {
-            logger.warn(sentryError);
+            logger$1.warn(sentryError);
           }
         }
         return void 0;
@@ -61135,10 +61718,10 @@ Reason: ${reason}`
     this.emit("beforeEnvelope", envelope);
     if (this._isEnabled() && this._transport) {
       return this._transport.send(envelope).then(null, (reason) => {
-        DEBUG_BUILD$4 && logger.error("Error while sending event:", reason);
+        DEBUG_BUILD$4 && logger$1.error("Error while sending event:", reason);
       });
     } else {
-      DEBUG_BUILD$4 && logger.error("Transport disabled");
+      DEBUG_BUILD$4 && logger$1.error("Transport disabled");
     }
   }
   /**
@@ -61213,7 +61796,7 @@ function addEventProcessor(callback) {
 function initAndBind(clientClass, options2) {
   if (options2.debug === true) {
     if (DEBUG_BUILD$4) {
-      logger.enable();
+      logger$1.enable();
     } else {
       consoleSandbox(() => {
         console.warn("[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.");
@@ -61269,7 +61852,7 @@ function createTransport(options2, makeRequest, buffer2 = makePromiseBuffer(
     const requestTask = () => makeRequest({ body: serializeEnvelope(filteredEnvelope, options2.textEncoder) }).then(
       (response) => {
         if (response.statusCode !== void 0 && (response.statusCode < 200 || response.statusCode >= 300)) {
-          DEBUG_BUILD$4 && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
+          DEBUG_BUILD$4 && logger$1.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
         }
         rateLimits = updateRateLimits(rateLimits, response);
         return response;
@@ -61283,7 +61866,7 @@ function createTransport(options2, makeRequest, buffer2 = makePromiseBuffer(
       (result) => result,
       (error) => {
         if (error instanceof SentryError) {
-          DEBUG_BUILD$4 && logger.error("Skipped sending event because buffer is full.");
+          DEBUG_BUILD$4 && logger$1.error("Skipped sending event because buffer is full.");
           recordEnvelopeLoss("queue_overflow");
           return resolvedSyncPromise();
         } else {
@@ -61412,26 +61995,26 @@ function _mergeOptions(internalOptions = {}, clientOptions = {}) {
 }
 function _shouldDropEvent$1(event, options2) {
   if (options2.ignoreInternal && _isSentryError(event)) {
-    DEBUG_BUILD$4 && logger.warn(`Event dropped due to being internal Sentry Error.
+    DEBUG_BUILD$4 && logger$1.warn(`Event dropped due to being internal Sentry Error.
 Event: ${getEventDescription(event)}`);
     return true;
   }
   if (_isIgnoredError(event, options2.ignoreErrors)) {
-    DEBUG_BUILD$4 && logger.warn(
+    DEBUG_BUILD$4 && logger$1.warn(
       `Event dropped due to being matched by \`ignoreErrors\` option.
 Event: ${getEventDescription(event)}`
     );
     return true;
   }
   if (_isIgnoredTransaction(event, options2.ignoreTransactions)) {
-    DEBUG_BUILD$4 && logger.warn(
+    DEBUG_BUILD$4 && logger$1.warn(
       `Event dropped due to being matched by \`ignoreTransactions\` option.
 Event: ${getEventDescription(event)}`
     );
     return true;
   }
   if (_isDeniedUrl(event, options2.denyUrls)) {
-    DEBUG_BUILD$4 && logger.warn(
+    DEBUG_BUILD$4 && logger$1.warn(
       `Event dropped due to being matched by \`denyUrls\` option.
 Event: ${getEventDescription(
         event
@@ -61441,7 +62024,7 @@ Url: ${_getEventFilterUrl(event)}`
     return true;
   }
   if (!_isAllowedUrl(event, options2.allowUrls)) {
-    DEBUG_BUILD$4 && logger.warn(
+    DEBUG_BUILD$4 && logger$1.warn(
       `Event dropped due to not being matched by \`allowUrls\` option.
 Event: ${getEventDescription(
         event
@@ -61498,7 +62081,7 @@ function _getPossibleEventMessages(event) {
     }
   }
   if (DEBUG_BUILD$4 && possibleMessages.length === 0) {
-    logger.error(`Could not extract message for event ${getEventDescription(event)}`);
+    logger$1.error(`Could not extract message for event ${getEventDescription(event)}`);
   }
   return possibleMessages;
 }
@@ -61527,7 +62110,7 @@ function _getEventFilterUrl(event) {
     }
     return frames ? _getLastValidUrl(frames) : null;
   } catch (oO) {
-    DEBUG_BUILD$4 && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
+    DEBUG_BUILD$4 && logger$1.error(`Cannot extract url for event ${getEventDescription(event)}`);
     return null;
   }
 }
@@ -61567,7 +62150,7 @@ function registerBackgroundTabDetection() {
       if (WINDOW$2.document.hidden && activeTransaction) {
         const statusType = "cancelled";
         const { op, status } = spanToJSON(activeTransaction);
-        DEBUG_BUILD$3 && logger.log(`[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${op}`);
+        DEBUG_BUILD$3 && logger$1.log(`[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${op}`);
         if (!status) {
           activeTransaction.setStatus(statusType);
         }
@@ -61576,7 +62159,7 @@ function registerBackgroundTabDetection() {
       }
     });
   } else {
-    DEBUG_BUILD$3 && logger.warn("[Tracing] Could not set up background tab detection due to lack of global document");
+    DEBUG_BUILD$3 && logger$1.warn("[Tracing] Could not set up background tab detection due to lack of global document");
   }
 }
 const bindReporter = (callback, metric, reportAllChanges) => {
@@ -61977,7 +62560,7 @@ function triggerHandlers(type, data) {
     try {
       handler(data);
     } catch (e2) {
-      DEBUG_BUILD$3 && logger.error(
+      DEBUG_BUILD$3 && logger$1.error(
         `Error while triggering instrumentation handler.
 Type: ${type}
 Name: ${getFunctionName(handler)}
@@ -62177,7 +62760,7 @@ function _trackCLS() {
     if (!entry) {
       return;
     }
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding CLS");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding CLS");
     _measurements["cls"] = { value: metric.value, unit: "" };
     _clsEntry = entry;
   }, true);
@@ -62188,7 +62771,7 @@ function _trackLCP() {
     if (!entry) {
       return;
     }
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding LCP");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding LCP");
     _measurements["lcp"] = { value: metric.value, unit: "millisecond" };
     _lcpEntry = entry;
   }, true);
@@ -62201,7 +62784,7 @@ function _trackFID() {
     }
     const timeOrigin = msToSec(browserPerformanceTimeOrigin);
     const startTime = msToSec(entry.startTime);
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding FID");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding FID");
     _measurements["fid"] = { value: metric.value, unit: "millisecond" };
     _measurements["mark.fid"] = { value: timeOrigin + startTime, unit: "second" };
   });
@@ -62212,7 +62795,7 @@ function _trackTtfb() {
     if (!entry) {
       return;
     }
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding TTFB");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding TTFB");
     _measurements["ttfb"] = { value: metric.value, unit: "millisecond" };
   });
 }
@@ -62294,7 +62877,7 @@ function _trackINP(interactionIdToRouteNameMapping, interactionsSampleRate) {
       const transport = client2 && client2.getTransport();
       if (transport && envelope) {
         transport.send(envelope).then(null, (reason) => {
-          DEBUG_BUILD$3 && logger.error("Error while sending interaction:", reason);
+          DEBUG_BUILD$3 && logger$1.error("Error while sending interaction:", reason);
         });
       }
       return;
@@ -62306,7 +62889,7 @@ function addPerformanceEntries(transaction) {
   if (!performance2 || !WINDOW$2.performance.getEntries || !browserPerformanceTimeOrigin) {
     return;
   }
-  DEBUG_BUILD$3 && logger.log("[Tracing] Adding & adjusting spans using Performance API");
+  DEBUG_BUILD$3 && logger$1.log("[Tracing] Adding & adjusting spans using Performance API");
   const timeOrigin = msToSec(browserPerformanceTimeOrigin);
   const performanceEntries = performance2.getEntries();
   const { op, start_timestamp: transactionStartTime } = spanToJSON(transaction);
@@ -62328,11 +62911,11 @@ function addPerformanceEntries(transaction) {
         const firstHidden = getVisibilityWatcher();
         const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;
         if (entry.name === "first-paint" && shouldRecord) {
-          DEBUG_BUILD$3 && logger.log("[Measurements] Adding FP");
+          DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding FP");
           _measurements["fp"] = { value: entry.startTime, unit: "millisecond" };
         }
         if (entry.name === "first-contentful-paint" && shouldRecord) {
-          DEBUG_BUILD$3 && logger.log("[Measurements] Adding FCP");
+          DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding FCP");
           _measurements["fcp"] = { value: entry.startTime, unit: "millisecond" };
         }
         break;
@@ -62355,7 +62938,7 @@ function addPerformanceEntries(transaction) {
       const measurementTimestamp = timeOrigin + msToSec(oldValue);
       const normalizedValue = Math.abs((measurementTimestamp - transactionStartTime) * 1e3);
       const delta = normalizedValue - oldValue;
-      DEBUG_BUILD$3 && logger.log(`[Measurements] Normalized ${name2} from ${oldValue} to ${normalizedValue} (${delta})`);
+      DEBUG_BUILD$3 && logger$1.log(`[Measurements] Normalized ${name2} from ${oldValue} to ${normalizedValue} (${delta})`);
       _measurements[name2].value = normalizedValue;
     });
     const fidMark = _measurements["mark.fid"];
@@ -62490,7 +63073,7 @@ function _trackNavigator(transaction) {
 }
 function _tagMetricInfo(transaction) {
   if (_lcpEntry) {
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding LCP Data");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding LCP Data");
     if (_lcpEntry.element) {
       transaction.setTag("lcp.element", htmlTreeAsString(_lcpEntry.element));
     }
@@ -62503,7 +63086,7 @@ function _tagMetricInfo(transaction) {
     transaction.setTag("lcp.size", _lcpEntry.size);
   }
   if (_clsEntry && _clsEntry.sources) {
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding CLS Data");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding CLS Data");
     _clsEntry.sources.forEach(
       (source, index2) => (
         // TODO: Can we rewrite this to an attribute?
@@ -62526,7 +63109,7 @@ function _addTtfbRequestTimeToMeasurements(_measurements2) {
   }
   const { responseStart, requestStart } = navEntry;
   if (requestStart <= responseStart) {
-    DEBUG_BUILD$3 && logger.log("[Measurements] Adding TTFB Request Time");
+    DEBUG_BUILD$3 && logger$1.log("[Measurements] Adding TTFB Request Time");
     _measurements2["ttfb.requestTime"] = {
       value: responseStart - requestStart,
       unit: "millisecond"
@@ -62558,7 +63141,7 @@ function getSampleRate(transactionContext, options2, interactionsSampleRate) {
     sampleRate = 1;
   }
   if (!isValidSampleRate(sampleRate)) {
-    DEBUG_BUILD$3 && logger.warn("[Tracing] Discarding interaction span because of invalid sample rate.");
+    DEBUG_BUILD$3 && logger$1.warn("[Tracing] Discarding interaction span because of invalid sample rate.");
     return false;
   }
   if (sampleRate === true) {
@@ -62945,9 +63528,9 @@ const browserTracingIntegration = (_options = {}) => {
     latestRoute.name = finalContext.name;
     latestRoute.context = finalContext;
     if (finalContext.sampled === false) {
-      DEBUG_BUILD$3 && logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);
+      DEBUG_BUILD$3 && logger$1.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);
     }
-    DEBUG_BUILD$3 && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);
+    DEBUG_BUILD$3 && logger$1.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);
     const { location } = WINDOW$2;
     const idleTransaction = startIdleTransaction(
       hub,
@@ -62988,7 +63571,7 @@ const browserTracingIntegration = (_options = {}) => {
       const clientOptionsTracePropagationTargets = clientOptions && clientOptions.tracePropagationTargets;
       const tracePropagationTargets = clientOptionsTracePropagationTargets || options2.tracePropagationTargets;
       if (DEBUG_BUILD$3 && _hasSetTracePropagationTargets && clientOptionsTracePropagationTargets) {
-        logger.warn(
+        logger$1.warn(
           "[Tracing] The `tracePropagationTargets` option was set in the BrowserTracing integration and top level `Sentry.init`. The top level `Sentry.init` value is being used."
         );
       }
@@ -62997,7 +63580,7 @@ const browserTracingIntegration = (_options = {}) => {
       if (client2.on) {
         client2.on("startNavigationSpan", (context) => {
           if (activeSpan) {
-            DEBUG_BUILD$3 && logger.log(`[Tracing] Finishing current transaction with op: ${spanToJSON(activeSpan).op}`);
+            DEBUG_BUILD$3 && logger$1.log(`[Tracing] Finishing current transaction with op: ${spanToJSON(activeSpan).op}`);
             activeSpan.end();
           }
           activeSpan = _createRouteTransaction({
@@ -63007,7 +63590,7 @@ const browserTracingIntegration = (_options = {}) => {
         });
         client2.on("startPageLoadSpan", (context) => {
           if (activeSpan) {
-            DEBUG_BUILD$3 && logger.log(`[Tracing] Finishing current transaction with op: ${spanToJSON(activeSpan).op}`);
+            DEBUG_BUILD$3 && logger$1.log(`[Tracing] Finishing current transaction with op: ${spanToJSON(activeSpan).op}`);
             activeSpan.end();
           }
           activeSpan = _createRouteTransaction({
@@ -63098,7 +63681,7 @@ function registerInteractionListener(options2, latestRoute) {
     const op = "ui.action.click";
     const currentTransaction = getActiveTransaction();
     if (currentTransaction && currentTransaction.op && ["navigation", "pageload"].includes(currentTransaction.op)) {
-      DEBUG_BUILD$3 && logger.warn(
+      DEBUG_BUILD$3 && logger$1.warn(
         `[Tracing] Did not create ${op} transaction because a pageload or navigation transaction is in progress.`
       );
       return void 0;
@@ -63109,7 +63692,7 @@ function registerInteractionListener(options2, latestRoute) {
       inflightInteractionTransaction = void 0;
     }
     if (!latestRoute.name) {
-      DEBUG_BUILD$3 && logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);
+      DEBUG_BUILD$3 && logger$1.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);
       return void 0;
     }
     const { location } = WINDOW$2;
@@ -63520,7 +64103,7 @@ class BrowserClient extends BaseClient {
    */
   captureUserFeedback(feedback) {
     if (!this._isEnabled()) {
-      DEBUG_BUILD$2 && logger.warn("SDK not enabled, will not capture user feedback.");
+      DEBUG_BUILD$2 && logger$1.warn("SDK not enabled, will not capture user feedback.");
       return;
     }
     const envelope = createUserFeedbackEnvelope(feedback, {
@@ -63543,14 +64126,14 @@ class BrowserClient extends BaseClient {
   _flushOutcomes() {
     const outcomes = this._clearOutcomes();
     if (outcomes.length === 0) {
-      DEBUG_BUILD$2 && logger.log("No outcomes to send");
+      DEBUG_BUILD$2 && logger$1.log("No outcomes to send");
       return;
     }
     if (!this._dsn) {
-      DEBUG_BUILD$2 && logger.log("No dsn provided, will not send outcomes");
+      DEBUG_BUILD$2 && logger$1.log("No dsn provided, will not send outcomes");
       return;
     }
-    DEBUG_BUILD$2 && logger.log("Sending outcomes:", outcomes);
+    DEBUG_BUILD$2 && logger$1.log("Sending outcomes:", outcomes);
     const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));
     this._sendEnvelope(envelope);
   }
@@ -63576,7 +64159,7 @@ function getNativeFetchImplementation() {
       }
       document2.head.removeChild(sandbox);
     } catch (e2) {
-      DEBUG_BUILD$2 && logger.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ", e2);
+      DEBUG_BUILD$2 && logger$1.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ", e2);
     }
   }
   return cachedFetchImpl = fetchImpl.bind(WINDOW$1);
@@ -63807,7 +64390,7 @@ function _getDomBreadcrumbHandler(client2, dom) {
     let keyAttrs = typeof dom === "object" ? dom.serializeAttribute : void 0;
     let maxStringLength = typeof dom === "object" && typeof dom.maxStringLength === "number" ? dom.maxStringLength : void 0;
     if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {
-      DEBUG_BUILD$2 && logger.warn(
+      DEBUG_BUILD$2 && logger$1.warn(
         `\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`
       );
       maxStringLength = MAX_ALLOWED_STRING_LENGTH;
@@ -63998,7 +64581,7 @@ const _dedupeIntegration = () => {
       }
       try {
         if (_shouldDropEvent(currentEvent, previousEvent)) {
-          DEBUG_BUILD$2 && logger.warn("Event dropped due to being a duplicate of previously captured event.");
+          DEBUG_BUILD$2 && logger$1.warn("Event dropped due to being a duplicate of previously captured event.");
           return null;
         }
       } catch (_oO) {
@@ -64252,7 +64835,7 @@ function _enhanceEventWithInitialFrame(event, url, line2, column2) {
   return event;
 }
 function globalHandlerLog(type) {
-  DEBUG_BUILD$2 && logger.log(`Global Handler attached: ${type}`);
+  DEBUG_BUILD$2 && logger$1.log(`Global Handler attached: ${type}`);
 }
 function getOptions() {
   const client2 = getClient();
@@ -64555,7 +65138,7 @@ function init$1(options2 = {}) {
 }
 function startSessionTracking() {
   if (typeof WINDOW$1.document === "undefined") {
-    DEBUG_BUILD$2 && logger.warn("Session tracking in non-browser environment with @sentry/browser is not supported.");
+    DEBUG_BUILD$2 && logger$1.warn("Session tracking in non-browser environment with @sentry/browser is not supported.");
     return;
   }
   startSession({ ignoreDuration: true });
@@ -68877,7 +69460,7 @@ function logInfo(message, shouldAddBreadcrumb) {
   if (!DEBUG_BUILD$1) {
     return;
   }
-  logger.info(message);
+  logger$1.info(message);
   if (shouldAddBreadcrumb) {
     addLogBreadcrumb(message);
   }
@@ -68886,7 +69469,7 @@ function logInfoNextTick(message, shouldAddBreadcrumb) {
   if (!DEBUG_BUILD$1) {
     return;
   }
-  logger.info(message);
+  logger$1.info(message);
   if (shouldAddBreadcrumb) {
     setTimeout(() => {
       addLogBreadcrumb(message);
@@ -69021,7 +69604,7 @@ class WorkerHandler {
         }
         this._worker.removeEventListener("message", listener);
         if (!response.success) {
-          DEBUG_BUILD$1 && logger.error("[Replay]", response.response);
+          DEBUG_BUILD$1 && logger$1.error("[Replay]", response.response);
           reject(new Error("Error in compression worker"));
           return;
         }
@@ -69094,7 +69677,7 @@ class EventBufferCompressionWorker {
     this._totalSize = 0;
     this.hasCheckout = false;
     this._worker.postMessage("clear").then(null, (e2) => {
-      DEBUG_BUILD$1 && logger.warn('[Replay] Sending "clear" message to worker failed', e2);
+      DEBUG_BUILD$1 && logger$1.warn('[Replay] Sending "clear" message to worker failed', e2);
     });
   }
   /** @inheritdoc */
@@ -69192,7 +69775,7 @@ class EventBufferProxy {
     try {
       await Promise.all(addEventPromises);
     } catch (error) {
-      DEBUG_BUILD$1 && logger.warn("[Replay] Failed to add events when switching buffers.", error);
+      DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to add events when switching buffers.", error);
     }
   }
 }
@@ -69393,7 +69976,7 @@ async function _addEvent(replay, event, isCheckout) {
     return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);
   } catch (error) {
     const reason = error && error instanceof EventBufferSizeExceededError ? "addEventSizeExceeded" : "addEvent";
-    DEBUG_BUILD$1 && logger.error(error);
+    DEBUG_BUILD$1 && logger$1.error(error);
     await replay.stop({ reason });
     const client2 = getClient();
     if (client2) {
@@ -69424,7 +70007,7 @@ function maybeApplyCallback(event, callback) {
       return callback(event);
     }
   } catch (error) {
-    DEBUG_BUILD$1 && logger.error("[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...", error);
+    DEBUG_BUILD$1 && logger$1.error("[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...", error);
     return null;
   }
   return event;
@@ -69588,7 +70171,7 @@ function handleGlobalEventListener(replay, includeAfterSendEventHandling = false
         return event;
       }
       if (isRrwebError(event, hint) && !replay.getOptions()._experiments.captureExceptions) {
-        DEBUG_BUILD$1 && logger.log("[Replay] Ignoring error from rrweb internals", event);
+        DEBUG_BUILD$1 && logger$1.log("[Replay] Ignoring error from rrweb internals", event);
         return null;
       }
       const isErrorEventSampled = shouldSampleForBufferEvent(replay, event);
@@ -69777,10 +70360,10 @@ function getBodyString(body) {
       return [void 0];
     }
   } catch (e2) {
-    DEBUG_BUILD$1 && logger.warn("[Replay] Failed to serialize body", body);
+    DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to serialize body", body);
     return [void 0, "BODY_PARSE_ERROR"];
   }
-  DEBUG_BUILD$1 && logger.info("[Replay] Skipping network body because of body type", body);
+  DEBUG_BUILD$1 && logger$1.info("[Replay] Skipping network body because of body type", body);
   return [void 0, "UNPARSEABLE_BODY_TYPE"];
 }
 function mergeWarning(info, warning2) {
@@ -69930,7 +70513,7 @@ async function captureFetchBreadcrumbToReplay(breadcrumb, hint, options2) {
     const result = makeNetworkReplayBreadcrumb("resource.fetch", data);
     addNetworkBreadcrumb(options2.replay, result);
   } catch (error) {
-    DEBUG_BUILD$1 && logger.error("[Replay] Failed to capture fetch breadcrumb", error);
+    DEBUG_BUILD$1 && logger$1.error("[Replay] Failed to capture fetch breadcrumb", error);
   }
 }
 function enrichFetchBreadcrumb(breadcrumb, hint, options2) {
@@ -70023,7 +70606,7 @@ function getResponseData(bodyText, {
     }
     return buildNetworkRequestOrResponse(headers, size2, void 0);
   } catch (error) {
-    DEBUG_BUILD$1 && logger.warn("[Replay] Failed to serialize response body", error);
+    DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to serialize response body", error);
     return buildNetworkRequestOrResponse(headers, responseBodySize, void 0);
   }
 }
@@ -70036,7 +70619,7 @@ async function _parseFetchResponseBody(response) {
     const text = await _tryGetResponseText(res);
     return [text];
   } catch (error) {
-    DEBUG_BUILD$1 && logger.warn("[Replay] Failed to get text body from response", error);
+    DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to get text body from response", error);
     return [void 0, "BODY_PARSE_ERROR"];
   }
 }
@@ -70084,7 +70667,7 @@ function _tryCloneResponse(response) {
   try {
     return response.clone();
   } catch (error) {
-    DEBUG_BUILD$1 && logger.warn("[Replay] Failed to clone response body", error);
+    DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to clone response body", error);
   }
 }
 function _tryGetResponseText(response) {
@@ -70105,7 +70688,7 @@ async function captureXhrBreadcrumbToReplay(breadcrumb, hint, options2) {
     const result = makeNetworkReplayBreadcrumb("resource.xhr", data);
     addNetworkBreadcrumb(options2.replay, result);
   } catch (error) {
-    DEBUG_BUILD$1 && logger.error("[Replay] Failed to capture xhr breadcrumb", error);
+    DEBUG_BUILD$1 && logger$1.error("[Replay] Failed to capture xhr breadcrumb", error);
   }
 }
 function enrichXhrBreadcrumb(breadcrumb, hint, options2) {
@@ -70188,7 +70771,7 @@ function _getXhrResponseBody(xhr) {
   } catch (e2) {
     errors.push(e2);
   }
-  DEBUG_BUILD$1 && logger.warn("[Replay] Failed to get xhr response body", ...errors);
+  DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to get xhr response body", ...errors);
   return [void 0];
 }
 function _parseXhrResponse(body, responseType) {
@@ -70206,10 +70789,10 @@ function _parseXhrResponse(body, responseType) {
       return [void 0];
     }
   } catch (e2) {
-    DEBUG_BUILD$1 && logger.warn("[Replay] Failed to serialize body", body);
+    DEBUG_BUILD$1 && logger$1.warn("[Replay] Failed to serialize body", body);
     return [void 0, "BODY_PARSE_ERROR"];
   }
-  DEBUG_BUILD$1 && logger.info("[Replay] Skipping network body because of body type", body);
+  DEBUG_BUILD$1 && logger$1.info("[Replay] Skipping network body because of body type", body);
   return [void 0, "UNPARSEABLE_BODY_TYPE"];
 }
 function _getBodySize(body, responseType, textEncoder2) {
@@ -70263,7 +70846,7 @@ function beforeAddNetworkBreadcrumb(options2, breadcrumb, hint) {
       captureFetchBreadcrumbToReplay(breadcrumb, hint, options2);
     }
   } catch (e2) {
-    DEBUG_BUILD$1 && logger.warn("Error when enriching network breadcrumb");
+    DEBUG_BUILD$1 && logger$1.warn("Error when enriching network breadcrumb");
   }
 }
 function _isXhrBreadcrumb(breadcrumb) {
@@ -70458,7 +71041,7 @@ function getHandleRecordingEmit(replay) {
   let hadFirstEvent = false;
   return (event, _isCheckout) => {
     if (!replay.checkAndHandleExpiredSession()) {
-      DEBUG_BUILD$1 && logger.warn("[Replay] Received replay event after session expired.");
+      DEBUG_BUILD$1 && logger$1.warn("[Replay] Received replay event after session expired.");
       return;
     }
     const isCheckout = _isCheckout || !hadFirstEvent;
@@ -71237,7 +71820,7 @@ class ReplayContainer {
   }
   /** A wrapper to conditionally capture exceptions. */
   _handleException(error) {
-    DEBUG_BUILD$1 && logger.error("[Replay]", error);
+    DEBUG_BUILD$1 && logger$1.error("[Replay]", error);
     if (DEBUG_BUILD$1 && this._options._experiments && this._options._experiments.captureExceptions) {
       captureException(error);
     }
@@ -71497,7 +72080,7 @@ class ReplayContainer {
   async _runFlush() {
     const replayId = this.getSessionId();
     if (!this.session || !this.eventBuffer || !replayId) {
-      DEBUG_BUILD$1 && logger.error("[Replay] No session or eventBuffer found to flush.");
+      DEBUG_BUILD$1 && logger$1.error("[Replay] No session or eventBuffer found to flush.");
       return;
     }
     await this._addPerformanceEntries();
@@ -71551,7 +72134,7 @@ class ReplayContainer {
         return;
       }
       if (!this.checkAndHandleExpiredSession()) {
-        DEBUG_BUILD$1 && logger.error("[Replay] Attempting to finish replay event after session expired.");
+        DEBUG_BUILD$1 && logger$1.error("[Replay] Attempting to finish replay event after session expired.");
         return;
       }
       if (!this.session) {
@@ -71586,7 +72169,7 @@ class ReplayContainer {
       try {
         await this._flushLock;
       } catch (err) {
-        DEBUG_BUILD$1 && logger.error(err);
+        DEBUG_BUILD$1 && logger$1.error(err);
       } finally {
         this._debouncedFlush();
       }
@@ -72141,7 +72724,7 @@ function _extractErrorData(error, captureErrorCause) {
     }
     return extraErrorInfo;
   } catch (oO) {
-    DEBUG_BUILD && logger.error("Unable to extract extra data from the Error object:", oO);
+    DEBUG_BUILD && logger$1.error("Unable to extract extra data from the Error object:", oO);
   }
   return null;
 }
@@ -72183,7 +72766,7 @@ function _fetchResponseHandler(options2, requestInfo, response, requestInit) {
             cookies = _parseCookieString(cookieString);
           }
         } catch (e2) {
-          DEBUG_BUILD && logger.log(`Could not extract cookies from header ${cookieHeader}`);
+          DEBUG_BUILD && logger$1.log(`Could not extract cookies from header ${cookieHeader}`);
         }
         return {
           headers,
@@ -72213,12 +72796,12 @@ function _xhrResponseHandler(options2, xhr, method, headers) {
           responseCookies = _parseCookieString(cookieString);
         }
       } catch (e2) {
-        DEBUG_BUILD && logger.log("Could not extract cookies from response headers");
+        DEBUG_BUILD && logger$1.log("Could not extract cookies from response headers");
       }
       try {
         responseHeaders = _getXHRResponseHeaders(xhr);
       } catch (e2) {
-        DEBUG_BUILD && logger.log("Could not extract headers from response");
+        DEBUG_BUILD && logger$1.log("Could not extract headers from response");
       }
       requestHeaders = headers;
     }
@@ -72317,7 +72900,7 @@ function _wrapXHR(client2, options2) {
     try {
       _xhrResponseHandler(options2, xhr, method, headers);
     } catch (e2) {
-      DEBUG_BUILD && logger.warn("Error while extracting response event form XHR response", e2);
+      DEBUG_BUILD && logger$1.warn("Error while extracting response event form XHR response", e2);
     }
   });
 }
@@ -72611,7 +73194,7 @@ const useFilteredDocumentModels = () => {
   return filteredDocumentModels;
 };
 async function loadBaseEditors() {
-  const documentModelEditor = await __vitePreload(() => import("./index-DzXmrci3.js"), true ? __vite__mapDeps([4,2,1,3]) : void 0);
+  const documentModelEditor = await __vitePreload(() => import("./index-DSo3d6TG.js"), true ? __vite__mapDeps([4,2,1,3]) : void 0);
   await __vitePreload(() => Promise.resolve({}), true ? __vite__mapDeps([5]) : void 0);
   const module = documentModelEditor.documentModelEditorModule;
   return [module];
@@ -72653,11 +73236,11 @@ async function initReactor(reactor) {
   const drives = await reactor.getDrives();
   if (!drives.length && connectConfig.drives.sections.LOCAL.enabled) {
     return reactor.addDrive({
+      slug: "my-local-drive",
       global: {
-        id: hashKey$1(),
+        id: generateId(),
         name: "My Local Drive",
-        icon: null,
-        slug: "my-local-drive"
+        icon: null
       },
       local: {
         availableOffline: false,
@@ -72665,7 +73248,7 @@ async function initReactor(reactor) {
         listeners: [],
         triggers: []
       }
-    }).catch(logger$1.error);
+    }).catch(logger$2.error);
   }
 }
 async function createReactor() {
@@ -72764,11 +73347,11 @@ const connectCrypto = (async () => {
     return window.connectCrypto;
   }
   const { ConnectCrypto: ConnectCrypto2 } = await __vitePreload(async () => {
-    const { ConnectCrypto: ConnectCrypto3 } = await import("./index-q1LnGFn2.js");
+    const { ConnectCrypto: ConnectCrypto3 } = await import("./index-C47jzF-n.js");
     return { ConnectCrypto: ConnectCrypto3 };
   }, true ? __vite__mapDeps([6,1,2,3]) : void 0);
   const { BrowserKeyStorage: BrowserKeyStorage2 } = await __vitePreload(async () => {
-    const { BrowserKeyStorage: BrowserKeyStorage3 } = await import("./index-q1LnGFn2.js");
+    const { BrowserKeyStorage: BrowserKeyStorage3 } = await import("./index-C47jzF-n.js");
     return { BrowserKeyStorage: BrowserKeyStorage3 };
   }, true ? __vite__mapDeps([6,1,2,3]) : void 0);
   const connectCrypto2 = new ConnectCrypto2(new BrowserKeyStorage2());
@@ -72801,7 +73384,7 @@ function useConnectDid() {
     if (did) {
       return;
     }
-    connectCrypto.then((c2) => c2.did()).then((did2) => setDid(did2)).catch(logger$1.error);
+    connectCrypto.then((c2) => c2.did()).then((did2) => setDid(did2)).catch(logger$2.error);
   });
   return did;
 }
@@ -72817,7 +73400,7 @@ function useRenown() {
       return;
     }
     const { initRenownBrowser } = await __vitePreload(async () => {
-      const { initRenownBrowser: initRenownBrowser2 } = await import("./index-q1LnGFn2.js");
+      const { initRenownBrowser: initRenownBrowser2 } = await import("./index-C47jzF-n.js");
       return { initRenownBrowser: initRenownBrowser2 };
     }, true ? __vite__mapDeps([6,1,2,3]) : void 0);
     const renownBrowser = initRenownBrowser(did2);
@@ -72891,7 +73474,7 @@ const useLogin = () => {
         }
       } catch (error) {
         setStatus("not-authorized");
-        logger$1.error(error);
+        logger$2.error(error);
       }
     },
     [renown]
@@ -73029,11 +73612,11 @@ function useDocumentDrives$1() {
           const drive = await reactor.getDrive(id);
           documentDrives2.push(drive);
         } catch (error) {
-          logger$1.error(error);
+          logger$2.error(error);
         }
       }
     } catch (error) {
-      logger$1.error(error);
+      logger$2.error(error);
     } finally {
       setDocumentDrives(documentDrives2);
     }
@@ -73054,7 +73637,7 @@ function useDocumentDrives$1() {
         "syncStatus",
         async (_event, _status, error) => {
           if (error) {
-            logger$1.error(error);
+            logger$2.error(error);
           }
           await refreshDocumentDrives();
         }
@@ -73222,15 +73805,15 @@ function useDocumentDriveServer() {
       if (!isAllowedToCreateDocuments) {
         throw new Error("User is not allowed to create documents");
       }
-      const id = hashKey$1();
       let drive = documentDrives.find((d2) => d2.state.global.id === driveId);
       if (!drive) {
         throw new Error(`Drive with id ${driveId} not found`);
       }
+      const documentId = generateId();
       const action = generateAddNodeAction(
         drive.state.global,
         {
-          id,
+          id: documentId,
           name: name2,
           parentFolder: parentFolder ?? null,
           documentType: documentType2,
@@ -73239,7 +73822,9 @@ function useDocumentDriveServer() {
         ["global"]
       );
       drive = await _addDriveOperation(driveId, action);
-      const node2 = drive == null ? void 0 : drive.state.global.nodes.find((node22) => node22.id === id);
+      const node2 = drive == null ? void 0 : drive.state.global.nodes.find(
+        (node22) => node22.id === documentId
+      );
       if (!node2 || !isFileNode(node2)) {
         throw new Error("There was an error adding document");
       }
@@ -73351,16 +73936,18 @@ function useDocumentDriveServer() {
       if (!isAllowedToCreateDocuments) {
         throw new Error("User is not allowed to create folders");
       }
-      const id = hashKey$1();
+      const folderId = generateId();
       const drive = await _addDriveOperation(
         driveId,
         addFolder({
-          id,
+          id: folderId,
           name: name2,
           parentFolder
         })
       );
-      const node2 = drive == null ? void 0 : drive.state.global.nodes.find((node22) => node22.id === id);
+      const node2 = drive == null ? void 0 : drive.state.global.nodes.find(
+        (node22) => node22.id === folderId
+      );
       if (!node2 || !isFolderNode(node2)) {
         throw new Error("There was an error adding folder");
       }
@@ -73431,14 +74018,13 @@ function useDocumentDriveServer() {
         (drive2) => drive2.state.global.id === src2.driveId
       );
       if (!drive) return;
-      const generateId2 = () => hashKey$1();
       const copyNodesInput = generateNodesCopy(
         {
           srcId: src2.id,
           targetParentFolder: target.id,
           targetName: src2.name
         },
-        generateId2,
+        () => generateId(),
         drive.state.global.nodes
       );
       const copyActions = copyNodesInput.map(
@@ -73495,7 +74081,7 @@ function useDocumentDriveServer() {
       if (!isAllowedToCreateDocuments) {
         throw new Error("User is not allowed to create drives");
       }
-      const id = drive.global.id || hashKey$1();
+      const id = drive.global.id || generateId();
       drive = createState$1(drive);
       const newDrive = await reactor.addDrive(
         {
@@ -74492,21 +75078,21 @@ const ReadModeContextProvider = (props) => {
     const accessLevel = readMode ? "READ" : "WRITE";
     const server = ReadModeInstance.getServer();
     if (server && typeof server.setAllDefaultDrivesAccessLevel === "function") {
-      server.setAllDefaultDrivesAccessLevel(accessLevel).catch(logger$1.error);
+      server.setAllDefaultDrivesAccessLevel(accessLevel).catch(logger$2.error);
     }
   }, [readMode, ready]);
   useEffect(() => {
     if (!ready) {
       return;
     }
-    getReadDrives(ReadModeInstance).then((drives) => setReadDrives(drives)).catch(logger$1.error);
+    getReadDrives(ReadModeInstance).then((drives) => setReadDrives(drives)).catch(logger$2.error);
     const unsubscribe = ReadModeInstance.onReadDrivesUpdate((newDrives) => {
       setReadDrives(
         (readDrives2) => readDrives2.length !== newDrives.length || drivesToHash$1(readDrives2) !== drivesToHash$1(newDrives) ? newDrives : readDrives2
       );
-    }).catch(logger$1.error);
+    }).catch(logger$2.error);
     return () => {
-      unsubscribe.then((unsub) => unsub == null ? void 0 : unsub()).catch(logger$1.error);
+      unsubscribe.then((unsub) => unsub == null ? void 0 : unsub()).catch(logger$2.error);
     };
   }, [ready]);
   const context = useMemo(() => {
@@ -74591,7 +75177,8 @@ function useUiNodes() {
   const makeUiDriveNode = useCallback(
     async (drive) => {
       const isReadDrive = "readContext" in drive;
-      const { id, name: name2, icon, slug } = drive.state.global;
+      const { id, name: name2, icon } = drive.state.global;
+      const { slug } = drive;
       const { sharingType: _sharingType, availableOffline } = !isReadDrive ? drive.state.local : { sharingType: PUBLIC, availableOffline: false };
       const __sharingType = _sharingType == null ? void 0 : _sharingType.toUpperCase();
       const sharingType = __sharingType === "PRIVATE" ? LOCAL : __sharingType;
@@ -74776,11 +75363,11 @@ function useUiNodes() {
         const app2 = apps.find((a2) => a2.id === data.appId);
         const newDrive = await addDrive(
           {
+            slug: "",
             global: {
               name: data.name,
               id: void 0,
-              icon: null,
-              slug: null
+              icon: null
             },
             local: {
               availableOffline: data.availableOffline,
@@ -80131,7 +80718,7 @@ const DangerZone = ({
         clearStorage().then(() => {
           navigate("/");
           onRefresh();
-        }).catch(logger$1.error);
+        }).catch(logger$2.error);
       },
       onCancel: () => showModal("settingsModal", { onRefresh })
     });
@@ -87670,250 +88257,72 @@ class AnalyticsQueryEngine {
     return await this._analyticsStore.getDimensions();
   }
 }
-const AnalyticsContext = createContext(null);
-const defaultQueryClient = new QueryClient();
-function AnalyticsProvider({ children, store, queryClient = defaultQueryClient }) {
-  const engine = new AnalyticsQueryEngine(store);
-  const content = jsx$1(AnalyticsContext.Provider, { value: { store, engine }, children });
-  if (queryClient === false) {
-    return content;
-  }
-  return jsx$1(QueryClientProvider, { client: queryClient, children: content });
+function getGlobal(namespace2) {
+  var _a2;
+  if (typeof window === "undefined")
+    return void 0;
+  return (_a2 = window.powerhouse) == null ? void 0 : _a2[namespace2];
 }
-function useAnalyticsStore() {
-  const context = useContext(AnalyticsContext);
-  if (!(context == null ? void 0 : context.store)) {
-    throw new Error("No analytics store available. Use within an AnalyticsProvider.");
-  }
-  return context.store;
+function setGlobal(namespace2, value) {
+  if (typeof window === "undefined")
+    return;
+  window.powerhouse = window.powerhouse || {};
+  window.powerhouse[namespace2] = value;
 }
-function useAnalyticsEngine() {
-  const context = useContext(AnalyticsContext);
-  if (!(context == null ? void 0 : context.engine)) {
-    throw new Error("No analytics engine available. Use within an AnalyticsProvider.");
+const logger = childLogger(["reactor-browser", "analytics", "provider"]);
+const defaultQueryClient = new QueryClient();
+const analyticsOptionsKey = ["analytics", "options"];
+const analyticsStoreKey = ["analytics", "store"];
+async function createAnalyticsStore({ databaseName }) {
+  const globalAnalytics = getGlobal("analytics");
+  if (databaseName === (globalAnalytics == null ? void 0 : globalAnalytics.options.databaseName)) {
+    logger.warn("Analytics store already initialized with the same database name. Returning existing store.");
+    return globalAnalytics.store;
   }
-  return context.engine;
-}
-async function createAnalyticsStore() {
   const { BrowserAnalyticsStore } = await __vitePreload(async () => {
-    const { BrowserAnalyticsStore: BrowserAnalyticsStore2 } = await import("./browser-ClaMQmoS.js");
+    const { BrowserAnalyticsStore: BrowserAnalyticsStore2 } = await import("./browser--PdVaTAw.js");
     return { BrowserAnalyticsStore: BrowserAnalyticsStore2 };
   }, true ? __vite__mapDeps([7,2,1,3]) : void 0);
-  const store = new BrowserAnalyticsStore({
-    databaseName: `${connectConfig.routerBasename}:analytics`
-  });
+  const store = new BrowserAnalyticsStore({ databaseName });
   await store.init();
+  const engine = new AnalyticsQueryEngine(store);
+  setGlobal("analytics", { store, engine, options: { databaseName } });
   return store;
 }
-const analyticsStoreAtom = atomWithLazy(createAnalyticsStore);
-const unwrappedAnalyticsStore = unwrap(analyticsStoreAtom);
-const useUnwrappedAnalyticsStore = () => useAtomValue(unwrappedAnalyticsStore);
-const analyticsAsyncAtom = atom(void 0);
-analyticsAsyncAtom.onMount = (setAtom) => {
-  const baseOnMount = analyticsStoreAtom.onMount;
-  analyticsStoreAtom.onMount = (setStoreAtom) => {
-    setStoreAtom((storePromise) => {
-      storePromise.then((store) => setAtom(store)).catch(console.error);
-      return storePromise;
-    });
-    return baseOnMount == null ? void 0 : baseOnMount(setStoreAtom);
-  };
-};
-function diffDocumentStates(doc1, doc2) {
-  const changes = [];
-  const globalChanges = diffStateObjects(doc1, doc2, "state.global", "global");
-  changes.push(...globalChanges);
-  const additions = changes.filter((c2) => c2.type === "add").length;
-  const removals = changes.filter((c2) => c2.type === "remove").length;
-  const changesByScope = {
-    global: changes.filter((c2) => c2.scope === "global")
-  };
-  return {
-    totalChanges: changes.length,
-    additions,
-    removals,
-    changesByScope,
-    changes
-  };
+function useCreateAnalyticsStore(queryClient, options2) {
+  queryClient.setQueryDefaults(analyticsOptionsKey, {
+    queryFn: () => options2,
+    staleTime: Infinity,
+    gcTime: Infinity
+  });
+  queryClient.setQueryDefaults(analyticsStoreKey, {
+    queryFn: () => createAnalyticsStore(options2),
+    staleTime: Infinity,
+    gcTime: Infinity
+  });
 }
-function diffStateObjects(obj1, obj2, path, scope) {
-  const changes = [];
-  if (typeof obj1 !== "object" || typeof obj2 !== "object" || obj1 === null || obj2 === null) {
-    if (obj1 !== obj2) {
-      if (typeof obj1 === "string" && typeof obj2 === "string") {
-        return diffStateStrings(obj1, obj2, path, scope);
-      } else {
-        changes.push({
-          type: "remove",
-          path,
-          oldValue: obj1,
-          scope
-        });
-        changes.push({
-          type: "add",
-          path,
-          newValue: obj2,
-          scope
-        });
-      }
-    }
-    return changes;
-  }
-  if (Array.isArray(obj1) && Array.isArray(obj2)) {
-    if (obj1.length !== obj2.length) {
-      changes.push({
-        type: "remove",
-        path,
-        oldValue: obj1,
-        scope
-      });
-      changes.push({
-        type: "add",
-        path,
-        newValue: obj2,
-        scope
-      });
-      return changes;
-    }
-    for (let i2 = 0; i2 < obj1.length; i2++) {
-      const elementChanges = diffStateObjects(obj1[i2], obj2[i2], `${path}[${i2}]`, scope);
-      changes.push(...elementChanges);
-    }
-    return changes;
-  }
-  const obj1Record = obj1;
-  const obj2Record = obj2;
-  const obj1Keys = Object.keys(obj1Record);
-  const obj2Keys = Object.keys(obj2Record);
-  for (const key of obj1Keys) {
-    if (!(key in obj2Record)) {
-      changes.push({
-        type: "remove",
-        path: `${path}.${key}`,
-        oldValue: obj1Record[key],
-        scope
-      });
-    }
-  }
-  for (const key of obj2Keys) {
-    if (!(key in obj1Record)) {
-      changes.push({
-        type: "add",
-        path: `${path}.${key}`,
-        newValue: obj2Record[key],
-        scope
-      });
-    } else if (obj1Record[key] !== obj2Record[key]) {
-      const nestedChanges = diffStateObjects(obj1Record[key], obj2Record[key], `${path}.${key}`, scope);
-      changes.push(...nestedChanges);
-    }
-  }
-  return changes;
+function useAnalyticsStoreOptions() {
+  return useQuery({
+    queryKey: analyticsOptionsKey
+  });
 }
-function diffStateStrings(str1, str2, path, scope) {
-  const changes = [];
-  const maxLen = Math.max(str1.length, str2.length);
-  for (let i2 = 0; i2 < maxLen; i2++) {
-    if (i2 >= str1.length) {
-      changes.push({
-        type: "add",
-        path: `${path}[${i2}]`,
-        newValue: str2[i2],
-        scope
-      });
-    } else if (i2 >= str2.length) {
-      changes.push({
-        type: "remove",
-        path: `${path}[${i2}]`,
-        oldValue: str1[i2],
-        scope
-      });
-    } else if (str1[i2] !== str2[i2]) {
-      changes.push({
-        type: "remove",
-        path: `${path}[${i2}]`,
-        oldValue: str1[i2],
-        scope
-      });
-      changes.push({
-        type: "add",
-        path: `${path}[${i2}]`,
-        newValue: str2[i2],
-        scope
-      });
-    }
-  }
-  return changes;
+function useAnalyticsStore() {
+  const { data: storeOptions } = useAnalyticsStoreOptions();
+  const store = useQuery({
+    queryKey: analyticsStoreKey,
+    enabled: !!storeOptions,
+    retry: false
+  });
+  return store.data;
 }
-class DiffAnalyticsProcessor {
-  constructor(analyticsStore, logger2 = childLogger(["processor", "diff-analytics"])) {
-    __publicField(this, "analyticsStore");
-    __publicField(this, "logger");
-    this.analyticsStore = analyticsStore;
-    this.logger = logger2;
-  }
-  async onStrands(strands) {
-    if (strands.length === 0) {
-      return;
-    }
-    const inputs = [];
-    for (const strand of strands) {
-      if (strand.operations.length === 0) {
-        continue;
-      }
-      const firstOp = strand.operations[0];
-      const source = AnalyticsPath.fromString(`ph/${strand.driveId}/${strand.documentId}/${strand.branch}/${strand.scope}`);
-      if (firstOp.index === 0) {
-        await this.clearSource(source);
-      }
-      for (const operation of strand.operations) {
-        const diff2 = diffDocumentStates(operation.previousState, operation.state);
-        for (const change of diff2.changes) {
-          inputs.push(this.generateInput(strand.documentId, strand.branch, strand.scope, operation.index, change.type, 1, source, operation.timestamp, change.path));
-        }
-      }
-    }
-    if (inputs.length) {
-      await this.analyticsStore.addSeriesValues(inputs);
-    }
-  }
-  async onDisconnect() {
-  }
-  async clearSource(source) {
-    try {
-      await this.analyticsStore.clearSeriesBySource(source, true);
-    } catch (e2) {
-      this.logger.error("Failed to clear source", e2);
-    }
-  }
-  generateInput(documentId, branch, scope, revision, type, value, source, timestamp, path) {
-    const dimensions = {};
-    const changePath = path.split("[")[0].replaceAll(".", "/");
-    dimensions.changes = AnalyticsPath.fromString(`changes/${type}`);
-    dimensions.document = AnalyticsPath.fromString(`document/${documentId}/${branch}/${scope}/${revision}`);
-    dimensions.path = AnalyticsPath.fromString(`path/${changePath}`);
-    return {
-      dimensions,
-      metric: "Count",
-      start: DateTime.fromISO(timestamp),
-      source,
-      value
-    };
-  }
+function AnalyticsProvider({ children, databaseName, queryClient = defaultQueryClient }) {
+  useCreateAnalyticsStore(queryClient, { databaseName });
+  return jsx$1(QueryClientProvider, { client: queryClient, children });
+}
+function useAnalyticsEngine() {
+  const globalAnalytics = getGlobal("analytics");
+  return globalAnalytics == null ? void 0 : globalAnalytics.engine;
 }
-const processorFactory = (module) => (driveId) => {
-  return [
-    {
-      processor: new DiffAnalyticsProcessor(module.analyticsStore),
-      filter: {
-        branch: ["main"],
-        documentId: ["*"],
-        scope: ["*"],
-        documentType: ["*"]
-      }
-    }
-  ];
-};
 class ProcessorManager {
   constructor(listeners, drive) {
     __publicField(this, "listeners");
@@ -87989,15 +88398,7 @@ class ProcessorManager {
 }
 async function createProcessorManager() {
   const reactor = await atomStore.get(reactorAtom);
-  const analyticsStore = await atomStore.get(analyticsStoreAtom);
   const manager = new ProcessorManager(reactor.listeners, reactor);
-  const hostModule = {
-    analyticsStore
-  };
-  await manager.registerFactory(
-    "@powerhousedao/diff-analyzer",
-    processorFactory(hostModule)
-  );
   reactor.on("driveAdded", async (drive) => {
     await manager.registerDrive(drive.state.global.id);
   });
@@ -88005,12 +88406,13 @@ async function createProcessorManager() {
 }
 const processorManagerAtom = atomWithLazy(createProcessorManager);
 const useProcessorManager = () => useAtomValue(processorManagerAtom);
-unwrap(processorManagerAtom);
+const unwrappedProcessorManager = unwrap(processorManagerAtom);
+const useUnwrappedProcessorManager = () => useAtomValue(unwrappedProcessorManager);
 atomStore.sub(reactorAtom, () => {
   return atomStore.get(processorManagerAtom);
 });
 const Router = React__default.lazy(async () => {
-  const createRouterComponent = await __vitePreload(() => import("./router-CvCplkfB.js").then((n2) => n2.r), true ? __vite__mapDeps([8,1,2,3]) : void 0);
+  const createRouterComponent = await __vitePreload(() => import("./router-B-9X40Vx.js").then((n2) => n2.r), true ? __vite__mapDeps([8,1,2,3]) : void 0);
   const router = await createRouterComponent.default();
   return { default: router };
 });
@@ -88022,7 +88424,7 @@ const Preloader = () => {
   return null;
 };
 const ReactorAnalyticsProvider = lazy(
-  () => __vitePreload(() => import("./reactor-analytics-C3XNgGME.js"), true ? __vite__mapDeps([9,1,2,3]) : void 0)
+  () => __vitePreload(() => import("./reactor-analytics-C7JH8QS3.js"), true ? __vite__mapDeps([9,1,2,3]) : void 0)
 );
 const App = () => /* @__PURE__ */ jsx$1(React__default.StrictMode, { children: /* @__PURE__ */ jsx$1(Suspense, { fallback: /* @__PURE__ */ jsx$1(Fragment, {}), children: /* @__PURE__ */ jsxs(Provider, { store: atomStore, children: [
   /* @__PURE__ */ jsx$1(Preloader, {}),
@@ -88046,166 +88448,154 @@ const app = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty(
   default: App
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  isMac as $,
-  useLocation as A,
+  addExternalPackage as $,
+  useUiNodesContext as A,
   Button$1 as B,
-  useNavigate as C,
+  CONFLICT as C,
   DataRouterContext as D,
   ErrorResponseImpl as E,
-  useTranslation as F,
-  useUiNodes as G,
-  useDocumentDrives$1 as H,
-  useReadModeContext as I,
-  useAsyncReactor as J,
-  useConnectConfig as K,
-  SUCCESS as L,
-  toast as M,
-  CONFLICT as N,
-  ERROR as O,
+  useUnwrappedReactor as F,
+  useModal as G,
+  useLogin as H,
+  isElectron as I,
+  isMac as J,
+  useGetAppNameForEditorId as K,
+  createMemoryRouter as L,
+  ModalManager as M,
+  useAnalyticsStore as N,
+  Outlet as O,
   Popover as P,
-  isLatestVersion as Q,
+  useUnwrappedProcessorManager as Q,
   Router$1 as R,
-  Subscribable as S,
-  useParams as T,
-  useUiNodesContext as U,
-  useUnwrappedReactor as V,
+  SUCCESS as S,
+  AnalyticsProvider as T,
+  rawKeyInHexfromUncompressed as U,
+  compressedKeyInHexfromRaw as V,
   WagmiContext$1 as W,
-  useModal as X,
-  useLogin as Y,
-  ModalManager as Z,
-  isElectron as _,
+  encodeDIDfromHexString as X,
+  RENOWN_URL as Y,
+  getEnsInfo as Z,
+  getHMRModule as _,
   PopoverTrigger as a,
-  isHex as a$,
-  Outlet as a0,
-  useGetAppNameForEditorId as a1,
-  createMemoryRouter as a2,
-  useUnwrappedAnalyticsStore as a3,
-  AnalyticsProvider as a4,
-  rawKeyInHexfromUncompressed as a5,
-  compressedKeyInHexfromRaw as a6,
-  encodeDIDfromHexString as a7,
-  RENOWN_URL as a8,
-  getEnsInfo as a9,
-  setModelId as aA,
-  setModelDescription as aB,
-  setModelExtension as aC,
-  setAuthorName as aD,
-  setAuthorWebsite as aE,
-  setStateSchema as aF,
-  setInitialState as aG,
-  addModule as aH,
-  setModuleName as aI,
-  deleteModule as aJ,
-  addOperation as aK,
-  setOperationName as aL,
-  setOperationSchema as aM,
-  setOperationDescription as aN,
-  deleteOperation as aO,
-  addOperationError as aP,
-  deleteOperationError as aQ,
-  setOperationErrorName as aR,
-  BaseError$3 as aS,
-  getUrl as aT,
-  stringify$1 as aU,
-  decodeErrorResult as aV,
-  isAddressEqual as aW,
-  call as aX,
-  concat$3 as aY,
-  encodeAbiParameters as aZ,
-  HttpRequestError as a_,
-  getHMRModule as aa,
-  addExternalPackage as ab,
-  removeExternalPackage as ac,
-  subscribeExternalPackages as ad,
-  RENOWN_NETWORK_ID as ae,
-  RENOWN_CHAIN_ID as af,
-  getChain as ag,
-  DateTime as ah,
-  AnalyticsPath as ai,
-  PassthroughAnalyticsProfiler as aj,
-  clsx as ak,
-  get as al,
-  set as am,
-  appendErrors as an,
-  useFormContext as ao,
-  Primitive as ap,
-  cva as aq,
-  FormProvider as ar,
-  Controller as as,
-  Slot as at,
-  useForm as au,
-  Root2 as av,
-  List as aw,
-  Trigger as ax,
-  Content$1 as ay,
-  setModelName as az,
+  Trigger$1 as a$,
+  removeExternalPackage as a0,
+  subscribeExternalPackages as a1,
+  RENOWN_NETWORK_ID as a2,
+  RENOWN_CHAIN_ID as a3,
+  getChain as a4,
+  DateTime as a5,
+  AnalyticsPath as a6,
+  PassthroughAnalyticsProfiler as a7,
+  clsx as a8,
+  get as a9,
+  setOperationSchema as aA,
+  setOperationDescription as aB,
+  deleteOperation as aC,
+  addOperationError as aD,
+  deleteOperationError as aE,
+  setOperationErrorName as aF,
+  BaseError$3 as aG,
+  getUrl as aH,
+  stringify$1 as aI,
+  decodeErrorResult as aJ,
+  isAddressEqual as aK,
+  call as aL,
+  concat$3 as aM,
+  encodeAbiParameters as aN,
+  HttpRequestError as aO,
+  isHex as aP,
+  mergeClassNameProps as aQ,
+  MISSING as aR,
+  SYNCING as aS,
+  INITIAL_SYNC as aT,
+  ConnectDropdownMenu as aU,
+  useOnClickOutside as aV,
+  useEventListener as aW,
+  useCopyToClipboard as aX,
+  Select as aY,
+  Provider$1 as aZ,
+  Root3 as a_,
+  set as aa,
+  appendErrors as ab,
+  useFormContext as ac,
+  Primitive as ad,
+  cva as ae,
+  FormProvider as af,
+  Controller as ag,
+  Slot as ah,
+  useForm as ai,
+  Root2 as aj,
+  List as ak,
+  Trigger as al,
+  Content$1 as am,
+  setModelName as an,
+  setModelId as ao,
+  setModelDescription as ap,
+  setModelExtension as aq,
+  setAuthorName as ar,
+  setAuthorWebsite as as,
+  setStateSchema as at,
+  setInitialState as au,
+  addModule as av,
+  setModuleName as aw,
+  deleteModule as ax,
+  addOperation as ay,
+  setOperationName as az,
   PopoverContent as b,
-  mergeClassNameProps as b0,
-  MISSING as b1,
-  SYNCING as b2,
-  INITIAL_SYNC as b3,
-  ConnectDropdownMenu as b4,
-  useOnClickOutside as b5,
-  useEventListener as b6,
-  useCopyToClipboard as b7,
-  Select as b8,
-  Provider$1 as b9,
-  AnalyticsGranularity as bA,
-  useGetEditor as bB,
-  isSameDocument as bC,
-  useFilteredDocumentModels as bD,
-  useDriveEditor as bE,
-  useDocumentDriveById as bF,
-  app as bG,
-  Root3 as ba,
-  Trigger$1 as bb,
-  Portal as bc,
-  Content2 as bd,
-  validateInitialState as be,
-  validateStateSchemaName as bf,
-  validateModules as bg,
-  useDocumentDrives as bh,
-  useDriveContext as bi,
-  FILE as bj,
-  useConnectDid as bk,
-  useConnectCrypto as bl,
-  useAtomValue as bm,
-  themeAtom as bn,
-  useUser as bo,
-  useUserPermissions as bp,
-  exportFile as bq,
-  useGetDocumentModelModule as br,
-  addActionContext as bs,
-  signOperation as bt,
-  useHotkeys as bu,
-  DriveLayout as bv,
-  DriveContextProvider as bw,
-  SearchBar as bx,
-  useAnalyticsEngine as by,
-  useAnalyticsStore as bz,
+  Portal as b0,
+  Content2 as b1,
+  validateInitialState as b2,
+  validateStateSchemaName as b3,
+  validateModules as b4,
+  useDocumentDrives as b5,
+  useDriveContext as b6,
+  FILE as b7,
+  useConnectDid as b8,
+  useConnectCrypto as b9,
+  useAtomValue as ba,
+  themeAtom as bb,
+  useUser as bc,
+  useUserPermissions as bd,
+  exportFile as be,
+  useGetDocumentModelModule as bf,
+  addActionContext as bg,
+  signOperation as bh,
+  useHotkeys as bi,
+  DriveLayout as bj,
+  DriveContextProvider as bk,
+  SearchBar as bl,
+  useQueryClient as bm,
+  useAnalyticsEngine as bn,
+  AnalyticsGranularity as bo,
+  useGetEditor as bp,
+  isSameDocument as bq,
+  useFilteredDocumentModels as br,
+  useDriveEditor as bs,
+  useDocumentDriveById as bt,
+  app as bu,
   getEnsName as c,
   BaseError$1 as d,
-  resolveStaleTime as e,
-  isValidTimeout as f,
+  useDocumentDriveServer as e,
+  createRouter as f,
   getEnsAvatar as g,
-  timeUntilStale as h,
-  isServer as i,
-  focusManager as j,
-  fetchState as k,
-  replaceData as l,
-  notifyManager as m,
-  noop as n,
-  useDocumentDriveServer as o,
-  pendingThenable as p,
-  createRouter as q,
-  resolveEnabled as r,
-  shallowEqualObjects as s,
+  createBrowserHistory as h,
+  DataRouterStateContext as i,
+  useRoutesImpl as j,
+  useLocation as k,
+  logV6DeprecationWarnings as l,
+  mapRouteProperties as m,
+  useNavigate as n,
+  useTranslation as o,
+  useUiNodes as p,
+  useDocumentDrives$1 as q,
+  useReadModeContext as r,
+  useAsyncReactor as s,
   twMerge as t,
-  useQueryClient as u,
-  createBrowserHistory as v,
-  logV6DeprecationWarnings as w,
-  DataRouterStateContext as x,
-  useRoutesImpl as y,
-  mapRouteProperties as z
-};
-//# sourceMappingURL=app-DULISSV9.js.map
+  useQuery as u,
+  useConnectConfig as v,
+  toast as w,
+  ERROR as x,
+  isLatestVersion as y,
+  useParams as z
+};
+//# sourceMappingURL=app-BRmEr17M.js.map