@powerhousedao/connect 6.0.0-dev.95 → 6.0.0-dev.96

package/dist/src/services/index.js

@@ -215,12 +215,6 @@ function createStackParser(...parsers) {
     return stripSentryFramesAndReverse(frames.slice(framesToPop));
   };
 }
-function stackParserFromStackParserOptions(stackParser) {
-  if (Array.isArray(stackParser)) {
-    return createStackParser(...stackParser);
-  }
-  return stackParser;
-}
 function stripSentryFramesAndReverse(stack) {
   if (!stack.length) {
     return [];
@@ -4421,35 +4415,6 @@ var init_api = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/@sentry+core@10.40.0/node_modules/@sentry/core/build/esm/integration.js
-function filterDuplicates(integrations) {
-  const integrationsByName = {};
-  integrations.forEach((currentInstance) => {
-    const { name } = currentInstance;
-    const existingInstance = integrationsByName[name];
-    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {
-      return;
-    }
-    integrationsByName[name] = currentInstance;
-  });
-  return Object.values(integrationsByName);
-}
-function getIntegrationsToSetup(options) {
-  const defaultIntegrations = options.defaultIntegrations || [];
-  const userIntegrations = options.integrations;
-  defaultIntegrations.forEach((integration) => {
-    integration.isDefaultInstance = true;
-  });
-  let integrations;
-  if (Array.isArray(userIntegrations)) {
-    integrations = [...defaultIntegrations, ...userIntegrations];
-  } else if (typeof userIntegrations === "function") {
-    const resolvedUserIntegrations = userIntegrations(defaultIntegrations);
-    integrations = Array.isArray(resolvedUserIntegrations) ? resolvedUserIntegrations : [resolvedUserIntegrations];
-  } else {
-    integrations = defaultIntegrations;
-  }
-  return filterDuplicates(integrations);
-}
 function setupIntegrations(client, integrations) {
   const integrationIndex = {};
   integrations.forEach((integration) => {
@@ -5752,30 +5717,11 @@ var init_client = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/@sentry+core@10.40.0/node_modules/@sentry/core/build/esm/sdk.js
-function initAndBind(clientClass, options) {
-  if (options.debug === true) {
-    if (DEBUG_BUILD) {
-      debug.enable();
-    } else {
-      consoleSandbox(() => {
-        console.warn("[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.");
-      });
-    }
-  }
-  const scope = getCurrentScope();
-  scope.update(options.initialScope);
-  const client = new clientClass(options);
-  setCurrentClient(client);
-  client.init();
-  return client;
-}
 function setCurrentClient(client) {
   getCurrentScope().setClient(client);
 }
 var init_sdk = __esm(() => {
   init_currentScopes();
-  init_debug_build();
-  init_debug_logger();
 });
 
 // ../../node_modules/.pnpm/@sentry+core@10.40.0/node_modules/@sentry/core/build/esm/transports/offline.js
@@ -16578,41 +16524,6 @@ var init_spotlight = __esm(() => {
   spotlightBrowserIntegration = defineIntegration(_spotlightIntegration);
 });
 
-// ../../node_modules/.pnpm/@sentry+browser@10.40.0/node_modules/@sentry/browser/build/npm/esm/dev/utils/detectBrowserExtension.js
-function checkAndWarnIfIsEmbeddedBrowserExtension() {
-  if (_isEmbeddedBrowserExtension()) {
-    if (DEBUG_BUILD4) {
-      consoleSandbox(() => {
-        console.error("[Sentry] You cannot use Sentry.init() in a browser extension, see: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/");
-      });
-    }
-    return true;
-  }
-  return false;
-}
-function _isEmbeddedBrowserExtension() {
-  if (typeof WINDOW4.window === "undefined") {
-    return false;
-  }
-  const _window = WINDOW4;
-  if (_window.nw) {
-    return false;
-  }
-  const extensionObject = _window["chrome"] || _window["browser"];
-  if (!extensionObject?.runtime?.id) {
-    return false;
-  }
-  const href = getLocationHref();
-  const extensionProtocols = ["chrome-extension", "moz-extension", "ms-browser-extension", "safari-web-extension"];
-  const isDedicatedExtensionPage = WINDOW4 === WINDOW4.top && extensionProtocols.some((protocol) => href.startsWith(`${protocol}://`));
-  return !isDedicatedExtensionPage;
-}
-var init_detectBrowserExtension = __esm(() => {
-  init_esm();
-  init_debug_build3();
-  init_helpers();
-});
-
 // ../../node_modules/.pnpm/@sentry+browser@10.40.0/node_modules/@sentry/browser/build/npm/esm/dev/sdk.js
 function getDefaultIntegrations(_options) {
   return [
@@ -16629,35 +16540,12 @@ function getDefaultIntegrations(_options) {
     browserSessionIntegration()
   ];
 }
-function init(options = {}) {
-  const shouldDisableBecauseIsBrowserExtenstion = !options.skipBrowserExtensionCheck && checkAndWarnIfIsEmbeddedBrowserExtension();
-  let defaultIntegrations = options.defaultIntegrations == null ? getDefaultIntegrations() : options.defaultIntegrations;
-  if (options.spotlight) {
-    if (!defaultIntegrations) {
-      defaultIntegrations = [];
-    }
-    const args = typeof options.spotlight === "string" ? { sidecarUrl: options.spotlight } : undefined;
-    defaultIntegrations.push(spotlightBrowserIntegration(args));
-  }
-  const clientOptions = {
-    ...options,
-    enabled: shouldDisableBecauseIsBrowserExtenstion ? false : options.enabled,
-    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),
-    integrations: getIntegrationsToSetup({
-      integrations: options.integrations,
-      defaultIntegrations
-    }),
-    transport: options.transport || makeFetchTransport
-  };
-  return initAndBind(BrowserClient, clientOptions);
-}
 function forceLoad() {}
 function onLoad(callback) {
   callback();
 }
 var init_sdk2 = __esm(() => {
   init_esm();
-  init_client2();
   init_breadcrumbs2();
   init_browserapierrors();
   init_browsersession();
@@ -16665,10 +16553,6 @@ var init_sdk2 = __esm(() => {
   init_globalhandlers();
   init_httpcontext();
   init_linkederrors();
-  init_spotlight();
-  init_stack_parsers();
-  init_fetch3();
-  init_detectBrowserExtension();
 });
 
 // ../../node_modules/.pnpm/@sentry+browser@10.40.0/node_modules/@sentry/browser/build/npm/esm/dev/report-dialog.js
@@ -21031,12 +20915,12 @@ function record(options = {}) {
         console.warn(error3);
       }
     });
-    const init2 = () => {
+    const init = () => {
       takeFullSnapshot2();
       handlers3.push(observe2(document));
     };
     if (document.readyState === "interactive" || document.readyState === "complete") {
-      init2();
+      init();
     } else {
       handlers3.push(on("DOMContentLoaded", () => {
         wrappedEmit({
@@ -21044,7 +20928,7 @@ function record(options = {}) {
           data: {}
         });
         if (recordAfter === "DOMContentLoaded")
-          init2();
+          init();
       }));
       handlers3.push(on("load", () => {
         wrappedEmit({
@@ -21052,7 +20936,7 @@ function record(options = {}) {
           data: {}
         });
         if (recordAfter === "load")
-          init2();
+          init();
       }, window));
     }
     return () => {
@@ -24008,10 +23892,10 @@ function _INTERNAL_instrumentRequestInterface() {
   }
   const OriginalRequest = Request;
   try {
-    const SentryRequest = function(input, init2) {
-      const request = new OriginalRequest(input, init2);
-      if (init2?.body != null) {
-        request[ORIGINAL_BODY] = init2.body;
+    const SentryRequest = function(input, init) {
+      const request = new OriginalRequest(input, init);
+      if (init?.body != null) {
+        request[ORIGINAL_BODY] = init.body;
       }
       return request;
     };
@@ -27481,1889 +27365,6 @@ var init_dev = __esm(() => {
   init_webWorker();
 });
 
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/sdk.js
-import { version } from "react";
-function init2(options) {
-  const opts = {
-    ...options
-  };
-  applySdkMetadata(opts, "react");
-  setContext("react", { version });
-  return init(opts);
-}
-var init_sdk3 = __esm(() => {
-  init_dev();
-  init_esm();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/error.js
-import { version as version2 } from "react";
-function isAtLeastReact17(reactVersion) {
-  const reactMajor = reactVersion.match(/^([^.]+)/);
-  return reactMajor !== null && parseInt(reactMajor[0]) >= 17;
-}
-function setCause(error3, cause) {
-  const seenErrors = new WeakSet;
-  function recurse(error4, cause2) {
-    if (seenErrors.has(error4)) {
-      return;
-    }
-    if (error4.cause) {
-      seenErrors.add(error4);
-      return recurse(error4.cause, cause2);
-    }
-    error4.cause = cause2;
-  }
-  recurse(error3, cause);
-}
-function captureReactException(error3, { componentStack }, hint) {
-  if (isAtLeastReact17(version2) && isError(error3) && componentStack) {
-    const errorBoundaryError = new Error(error3.message);
-    errorBoundaryError.name = `React ErrorBoundary ${error3.name}`;
-    errorBoundaryError.stack = componentStack;
-    setCause(error3, errorBoundaryError);
-  }
-  return withScope2((scope) => {
-    scope.setContext("react", { componentStack });
-    return captureException(error3, hint);
-  });
-}
-function reactErrorHandler(callback) {
-  return (error3, errorInfo) => {
-    const hasCallback = !!callback;
-    const eventId = captureReactException(error3, errorInfo, {
-      mechanism: { handled: hasCallback, type: "auto.function.react.error_handler" }
-    });
-    if (hasCallback) {
-      callback(error3, errorInfo, eventId);
-    }
-  };
-}
-var init_error = __esm(() => {
-  init_dev();
-  init_esm();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/constants.js
-var REACT_RENDER_OP = "ui.react.render", REACT_UPDATE_OP = "ui.react.update", REACT_MOUNT_OP = "ui.react.mount";
-var init_constants8 = () => {};
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/hoist-non-react-statics.js
-function isMemo(component) {
-  return typeof component === "object" && component !== null && component.$$typeof === MemoType;
-}
-function getStatics(component) {
-  if (isMemo(component)) {
-    return MEMO_STATICS;
-  }
-  const componentType = component.$$typeof;
-  return componentType && TYPE_STATICS[componentType] || REACT_STATICS;
-}
-function hoistNonReactStatics(targetComponent, sourceComponent, excludelist) {
-  if (typeof sourceComponent !== "string") {
-    if (objectPrototype) {
-      const inheritedComponent = getPrototypeOf(sourceComponent);
-      if (inheritedComponent && inheritedComponent !== objectPrototype) {
-        hoistNonReactStatics(targetComponent, inheritedComponent);
-      }
-    }
-    let keys2 = getOwnPropertyNames(sourceComponent);
-    if (getOwnPropertySymbols) {
-      keys2 = keys2.concat(getOwnPropertySymbols(sourceComponent));
-    }
-    const targetStatics = getStatics(targetComponent);
-    const sourceStatics = getStatics(sourceComponent);
-    for (const key of keys2) {
-      if (!KNOWN_STATICS[key] && true && !sourceStatics?.[key] && !targetStatics?.[key] && !getOwnPropertyDescriptor(targetComponent, key)) {
-        const descriptor = getOwnPropertyDescriptor(sourceComponent, key);
-        if (descriptor) {
-          try {
-            defineProperty(targetComponent, key, descriptor);
-          } catch (e3) {}
-        }
-      }
-    }
-  }
-  return targetComponent;
-}
-var REACT_STATICS, KNOWN_STATICS, FORWARD_REF_STATICS, MEMO_STATICS, ForwardRefType, MemoType, TYPE_STATICS, defineProperty, getOwnPropertyNames, getOwnPropertySymbols, getOwnPropertyDescriptor, getPrototypeOf, objectPrototype;
-var init_hoist_non_react_statics = __esm(() => {
-  REACT_STATICS = {
-    childContextTypes: true,
-    contextType: true,
-    contextTypes: true,
-    defaultProps: true,
-    displayName: true,
-    getDefaultProps: true,
-    getDerivedStateFromError: true,
-    getDerivedStateFromProps: true,
-    mixins: true,
-    propTypes: true,
-    type: true
-  };
-  KNOWN_STATICS = {
-    name: true,
-    length: true,
-    prototype: true,
-    caller: true,
-    callee: true,
-    arguments: true,
-    arity: true
-  };
-  FORWARD_REF_STATICS = {
-    $$typeof: true,
-    render: true,
-    defaultProps: true,
-    displayName: true,
-    propTypes: true
-  };
-  MEMO_STATICS = {
-    $$typeof: true,
-    compare: true,
-    defaultProps: true,
-    displayName: true,
-    propTypes: true,
-    type: true
-  };
-  ForwardRefType = Symbol.for("react.forward_ref");
-  MemoType = Symbol.for("react.memo");
-  TYPE_STATICS = {};
-  TYPE_STATICS[ForwardRefType] = FORWARD_REF_STATICS;
-  TYPE_STATICS[MemoType] = MEMO_STATICS;
-  defineProperty = Object.defineProperty.bind(Object);
-  getOwnPropertyNames = Object.getOwnPropertyNames.bind(Object);
-  getOwnPropertySymbols = Object.getOwnPropertySymbols?.bind(Object);
-  getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor.bind(Object);
-  getPrototypeOf = Object.getPrototypeOf.bind(Object);
-  objectPrototype = Object.prototype;
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/profiler.js
-import * as React from "react";
-function withProfiler(WrappedComponent, options) {
-  const componentDisplayName = options?.name || WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;
-  const Wrapped = (props) => React.createElement(Profiler, { ...options, name: componentDisplayName, updateProps: props }, React.createElement(WrappedComponent, { ...props }));
-  Wrapped.displayName = `profiler(${componentDisplayName})`;
-  hoistNonReactStatics(Wrapped, WrappedComponent);
-  return Wrapped;
-}
-function useProfiler(name, options = {
-  disabled: false,
-  hasRenderSpan: true
-}) {
-  const [mountSpan] = React.useState(() => {
-    if (options?.disabled) {
-      return;
-    }
-    return startInactiveSpan({
-      name: `<${name}>`,
-      onlyIfParent: true,
-      op: REACT_MOUNT_OP,
-      attributes: {
-        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.react.profiler",
-        "ui.component_name": name
-      }
-    });
-  });
-  React.useEffect(() => {
-    if (mountSpan) {
-      mountSpan.end();
-    }
-    return () => {
-      if (mountSpan && options.hasRenderSpan) {
-        const startTime = spanToJSON(mountSpan).timestamp;
-        const endTimestamp = timestampInSeconds();
-        const renderSpan = startInactiveSpan({
-          name: `<${name}>`,
-          onlyIfParent: true,
-          op: REACT_RENDER_OP,
-          startTime,
-          attributes: {
-            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.react.profiler",
-            "ui.component_name": name
-          }
-        });
-        if (renderSpan) {
-          renderSpan.end(endTimestamp);
-        }
-      }
-    };
-  }, []);
-}
-var UNKNOWN_COMPONENT = "unknown", Profiler;
-var init_profiler = __esm(() => {
-  init_dev();
-  init_esm();
-  init_constants8();
-  init_hoist_non_react_statics();
-  Profiler = class Profiler extends React.Component {
-    constructor(props) {
-      super(props);
-      const { name, disabled = false } = this.props;
-      if (disabled) {
-        return;
-      }
-      this._mountSpan = startInactiveSpan({
-        name: `<${name}>`,
-        onlyIfParent: true,
-        op: REACT_MOUNT_OP,
-        attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.react.profiler",
-          "ui.component_name": name
-        }
-      });
-    }
-    componentDidMount() {
-      if (this._mountSpan) {
-        this._mountSpan.end();
-      }
-    }
-    shouldComponentUpdate({ updateProps, includeUpdates = true }) {
-      if (includeUpdates && this._mountSpan && updateProps !== this.props.updateProps) {
-        const changedProps = Object.keys(updateProps).filter((k2) => updateProps[k2] !== this.props.updateProps[k2]);
-        if (changedProps.length > 0) {
-          const now = timestampInSeconds();
-          this._updateSpan = withActiveSpan(this._mountSpan, () => {
-            return startInactiveSpan({
-              name: `<${this.props.name}>`,
-              onlyIfParent: true,
-              op: REACT_UPDATE_OP,
-              startTime: now,
-              attributes: {
-                [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.react.profiler",
-                "ui.component_name": this.props.name,
-                "ui.react.changed_props": changedProps
-              }
-            });
-          });
-        }
-      }
-      return true;
-    }
-    componentDidUpdate() {
-      if (this._updateSpan) {
-        this._updateSpan.end();
-        this._updateSpan = undefined;
-      }
-    }
-    componentWillUnmount() {
-      const endTimestamp = timestampInSeconds();
-      const { name, includeRender = true } = this.props;
-      if (this._mountSpan && includeRender) {
-        const startTime = spanToJSON(this._mountSpan).timestamp;
-        withActiveSpan(this._mountSpan, () => {
-          const renderSpan = startInactiveSpan({
-            onlyIfParent: true,
-            name: `<${name}>`,
-            op: REACT_RENDER_OP,
-            startTime,
-            attributes: {
-              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.react.profiler",
-              "ui.component_name": name
-            }
-          });
-          if (renderSpan) {
-            renderSpan.end(endTimestamp);
-          }
-        });
-      }
-    }
-    render() {
-      return this.props.children;
-    }
-  };
-  Object.assign(Profiler, {
-    defaultProps: {
-      disabled: false,
-      includeRender: true,
-      includeUpdates: true
-    }
-  });
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/debug-build.js
-var DEBUG_BUILD6;
-var init_debug_build4 = __esm(() => {
-  DEBUG_BUILD6 = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/errorboundary.js
-import * as React2 from "react";
-function withErrorBoundary(WrappedComponent, errorBoundaryOptions) {
-  const componentDisplayName = WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT2;
-  const Wrapped = React2.memo((props) => React2.createElement(ErrorBoundary, { ...errorBoundaryOptions }, React2.createElement(WrappedComponent, { ...props })));
-  Wrapped.displayName = `errorBoundary(${componentDisplayName})`;
-  hoistNonReactStatics(Wrapped, WrappedComponent);
-  return Wrapped;
-}
-var UNKNOWN_COMPONENT2 = "unknown", INITIAL_STATE, ErrorBoundary;
-var init_errorboundary = __esm(() => {
-  init_dev();
-  init_esm();
-  init_debug_build4();
-  init_error();
-  init_hoist_non_react_statics();
-  INITIAL_STATE = {
-    componentStack: null,
-    error: null,
-    eventId: null
-  };
-  ErrorBoundary = class ErrorBoundary extends React2.Component {
-    constructor(props) {
-      super(props);
-      this.state = INITIAL_STATE;
-      this._openFallbackReportDialog = true;
-      const client = getClient();
-      if (client && props.showDialog) {
-        this._openFallbackReportDialog = false;
-        this._cleanupHook = client.on("afterSendEvent", (event) => {
-          if (!event.type && this._lastEventId && event.event_id === this._lastEventId) {
-            showReportDialog({ ...props.dialogOptions, eventId: this._lastEventId });
-          }
-        });
-      }
-    }
-    componentDidCatch(error3, errorInfo) {
-      const { componentStack } = errorInfo;
-      const { beforeCapture, onError, showDialog, dialogOptions } = this.props;
-      withScope2((scope) => {
-        if (beforeCapture) {
-          beforeCapture(scope, error3, componentStack);
-        }
-        const handled = this.props.handled != null ? this.props.handled : !!this.props.fallback;
-        const eventId = captureReactException(error3, errorInfo, {
-          mechanism: { handled, type: "auto.function.react.error_boundary" }
-        });
-        if (onError) {
-          onError(error3, componentStack, eventId);
-        }
-        if (showDialog) {
-          this._lastEventId = eventId;
-          if (this._openFallbackReportDialog) {
-            showReportDialog({ ...dialogOptions, eventId });
-          }
-        }
-        this.setState({ error: error3, componentStack, eventId });
-      });
-    }
-    componentDidMount() {
-      const { onMount } = this.props;
-      if (onMount) {
-        onMount();
-      }
-    }
-    componentWillUnmount() {
-      const { error: error3, componentStack, eventId } = this.state;
-      const { onUnmount } = this.props;
-      if (onUnmount) {
-        if (this.state === INITIAL_STATE) {
-          onUnmount(null, null, null);
-        } else {
-          onUnmount(error3, componentStack, eventId);
-        }
-      }
-      if (this._cleanupHook) {
-        this._cleanupHook();
-        this._cleanupHook = undefined;
-      }
-    }
-    resetErrorBoundary() {
-      const { onReset } = this.props;
-      const { error: error3, componentStack, eventId } = this.state;
-      if (onReset) {
-        onReset(error3, componentStack, eventId);
-      }
-      this.setState(INITIAL_STATE);
-    }
-    render() {
-      const { fallback, children } = this.props;
-      const state = this.state;
-      if (state.componentStack === null) {
-        return typeof children === "function" ? children() : children;
-      }
-      const element = typeof fallback === "function" ? React2.createElement(fallback, {
-        error: state.error,
-        componentStack: state.componentStack,
-        resetError: () => this.resetErrorBoundary(),
-        eventId: state.eventId
-      }) : fallback;
-      if (React2.isValidElement(element)) {
-        return element;
-      }
-      if (fallback) {
-        DEBUG_BUILD6 && debug.warn("fallback did not produce a valid ReactElement");
-      }
-      return null;
-    }
-  };
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/redux.js
-function createReduxEnhancer(enhancerOptions) {
-  const options = {
-    ...defaultOptions,
-    ...enhancerOptions
-  };
-  return (next) => (reducer, initialState) => {
-    options.attachReduxState && getGlobalScope().addEventProcessor((event, hint) => {
-      try {
-        if (event.type === undefined && event.contexts.state.state.type === "redux") {
-          hint.attachments = [
-            ...hint.attachments || [],
-            { filename: "redux_state.json", data: JSON.stringify(event.contexts.state.state.value) }
-          ];
-        }
-      } catch {}
-      return event;
-    });
-    function sentryWrapReducer(reducer2) {
-      return (state, action) => {
-        const newState = reducer2(state, action);
-        const scope = getCurrentScope();
-        const transformedAction = options.actionTransformer(action);
-        if (typeof transformedAction !== "undefined" && transformedAction !== null) {
-          addBreadcrumb({
-            category: ACTION_BREADCRUMB_CATEGORY,
-            data: transformedAction,
-            type: ACTION_BREADCRUMB_TYPE
-          });
-        }
-        const transformedState = options.stateTransformer(newState);
-        if (typeof transformedState !== "undefined" && transformedState !== null) {
-          const client = getClient();
-          const options2 = client?.getOptions();
-          const normalizationDepth = options2?.normalizeDepth || 3;
-          const newStateContext = { state: { type: "redux", value: transformedState } };
-          addNonEnumerableProperty(newStateContext, "__sentry_override_normalization_depth__", 3 + normalizationDepth);
-          scope.setContext("state", newStateContext);
-        } else {
-          scope.setContext("state", null);
-        }
-        const { configureScopeWithState } = options;
-        if (typeof configureScopeWithState === "function") {
-          configureScopeWithState(scope, newState);
-        }
-        return newState;
-      };
-    }
-    const store = next(sentryWrapReducer(reducer), initialState);
-    store.replaceReducer = new Proxy(store.replaceReducer, {
-      apply: function(target, thisArg, args) {
-        target.apply(thisArg, [sentryWrapReducer(args[0])]);
-      }
-    });
-    return store;
-  };
-}
-var ACTION_BREADCRUMB_CATEGORY = "redux.action", ACTION_BREADCRUMB_TYPE = "info", defaultOptions;
-var init_redux = __esm(() => {
-  init_esm();
-  defaultOptions = {
-    attachReduxState: true,
-    actionTransformer: (action) => action,
-    stateTransformer: (state) => state || null
-  };
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouterv3.js
-function reactRouterV3BrowserTracingIntegration(options) {
-  const integration = browserTracingIntegration({
-    ...options,
-    instrumentPageLoad: false,
-    instrumentNavigation: false
-  });
-  const { history, routes, match, instrumentPageLoad = true, instrumentNavigation = true } = options;
-  return {
-    ...integration,
-    afterAllSetup(client) {
-      integration.afterAllSetup(client);
-      if (instrumentPageLoad && WINDOW4.location) {
-        normalizeTransactionName(routes, WINDOW4.location, match, (localName, source = "url") => {
-          startBrowserTracingPageLoadSpan(client, {
-            name: localName,
-            attributes: {
-              [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "pageload",
-              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.pageload.react.reactrouter_v3",
-              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source
-            }
-          });
-        });
-      }
-      if (instrumentNavigation && history.listen) {
-        history.listen((location) => {
-          if (location.action === "PUSH" || location.action === "POP") {
-            normalizeTransactionName(routes, location, match, (localName, source = "url") => {
-              startBrowserTracingNavigationSpan(client, {
-                name: localName,
-                attributes: {
-                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "navigation",
-                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.navigation.react.reactrouter_v3",
-                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source
-                }
-              });
-            });
-          }
-        });
-      }
-    }
-  };
-}
-function normalizeTransactionName(appRoutes, location, match, callback) {
-  let name = location.pathname;
-  match({
-    location,
-    routes: appRoutes
-  }, (error3, _redirectLocation, renderProps) => {
-    if (error3 || !renderProps) {
-      return callback(name);
-    }
-    const routePath = getRouteStringFromRoutes(renderProps.routes || []);
-    if (routePath.length === 0 || routePath === "/*") {
-      return callback(name);
-    }
-    name = routePath;
-    return callback(name, "route");
-  });
-}
-function getRouteStringFromRoutes(routes) {
-  if (!Array.isArray(routes) || routes.length === 0) {
-    return "";
-  }
-  const routesWithPaths = routes.filter((route) => !!route.path);
-  let index = -1;
-  for (let x2 = routesWithPaths.length - 1;x2 >= 0; x2--) {
-    const route = routesWithPaths[x2];
-    if (route.path?.startsWith("/")) {
-      index = x2;
-      break;
-    }
-  }
-  return routesWithPaths.slice(index).reduce((acc, { path }) => {
-    const pathSegment = acc === "/" || acc === "" ? path : `/${path}`;
-    return `${acc}${pathSegment}`;
-  }, "");
-}
-var init_reactrouterv3 = __esm(() => {
-  init_dev();
-  init_esm();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/tanstackrouter.js
-function tanstackRouterBrowserTracingIntegration(router, options = {}) {
-  const castRouterInstance = router;
-  const browserTracingIntegrationInstance = browserTracingIntegration({
-    ...options,
-    instrumentNavigation: false,
-    instrumentPageLoad: false
-  });
-  const { instrumentPageLoad = true, instrumentNavigation = true } = options;
-  return {
-    ...browserTracingIntegrationInstance,
-    afterAllSetup(client) {
-      browserTracingIntegrationInstance.afterAllSetup(client);
-      const initialWindowLocation = WINDOW4.location;
-      if (instrumentPageLoad && initialWindowLocation) {
-        const matchedRoutes = castRouterInstance.matchRoutes(initialWindowLocation.pathname, castRouterInstance.options.parseSearch(initialWindowLocation.search), { preload: false, throwOnError: false });
-        const lastMatch = matchedRoutes[matchedRoutes.length - 1];
-        const routeMatch = lastMatch?.routeId !== "__root__" ? lastMatch : undefined;
-        startBrowserTracingPageLoadSpan(client, {
-          name: routeMatch ? routeMatch.routeId : initialWindowLocation.pathname,
-          attributes: {
-            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "pageload",
-            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.pageload.react.tanstack_router",
-            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: routeMatch ? "route" : "url",
-            ...routeMatchToParamSpanAttributes(routeMatch)
-          }
-        });
-      }
-      if (instrumentNavigation) {
-        castRouterInstance.subscribe("onBeforeNavigate", (onBeforeNavigateArgs) => {
-          if (!onBeforeNavigateArgs.fromLocation || onBeforeNavigateArgs.toLocation.state === onBeforeNavigateArgs.fromLocation.state) {
-            return;
-          }
-          const matchedRoutesOnBeforeNavigate = castRouterInstance.matchRoutes(onBeforeNavigateArgs.toLocation.pathname, onBeforeNavigateArgs.toLocation.search, { preload: false, throwOnError: false });
-          const onBeforeNavigateLastMatch = matchedRoutesOnBeforeNavigate[matchedRoutesOnBeforeNavigate.length - 1];
-          const onBeforeNavigateRouteMatch = onBeforeNavigateLastMatch?.routeId !== "__root__" ? onBeforeNavigateLastMatch : undefined;
-          const navigationLocation = WINDOW4.location;
-          const navigationSpan = startBrowserTracingNavigationSpan(client, {
-            name: onBeforeNavigateRouteMatch ? onBeforeNavigateRouteMatch.routeId : navigationLocation.pathname,
-            attributes: {
-              [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "navigation",
-              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.navigation.react.tanstack_router",
-              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: onBeforeNavigateRouteMatch ? "route" : "url"
-            }
-          });
-          const unsubscribeOnResolved = castRouterInstance.subscribe("onResolved", (onResolvedArgs) => {
-            unsubscribeOnResolved();
-            if (navigationSpan) {
-              const matchedRoutesOnResolved = castRouterInstance.matchRoutes(onResolvedArgs.toLocation.pathname, onResolvedArgs.toLocation.search, { preload: false, throwOnError: false });
-              const onResolvedLastMatch = matchedRoutesOnResolved[matchedRoutesOnResolved.length - 1];
-              const onResolvedRouteMatch = onResolvedLastMatch?.routeId !== "__root__" ? onResolvedLastMatch : undefined;
-              if (onResolvedRouteMatch) {
-                navigationSpan.updateName(onResolvedRouteMatch.routeId);
-                navigationSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, "route");
-                navigationSpan.setAttributes(routeMatchToParamSpanAttributes(onResolvedRouteMatch));
-              }
-            }
-          });
-        });
-      }
-    }
-  };
-}
-function routeMatchToParamSpanAttributes(match) {
-  if (!match) {
-    return {};
-  }
-  const paramAttributes = {};
-  Object.entries(match.params).forEach(([key, value]) => {
-    paramAttributes[`url.path.params.${key}`] = value;
-    paramAttributes[`url.path.parameter.${key}`] = value;
-    paramAttributes[`params.${key}`] = value;
-  });
-  return paramAttributes;
-}
-var init_tanstackrouter = __esm(() => {
-  init_dev();
-  init_esm();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouter.js
-import * as React3 from "react";
-function reactRouterV4BrowserTracingIntegration(options) {
-  const integration = browserTracingIntegration({
-    ...options,
-    instrumentPageLoad: false,
-    instrumentNavigation: false
-  });
-  const { history, routes, matchPath, instrumentPageLoad = true, instrumentNavigation = true } = options;
-  return {
-    ...integration,
-    afterAllSetup(client) {
-      integration.afterAllSetup(client);
-      instrumentReactRouter(client, instrumentPageLoad, instrumentNavigation, history, "reactrouter_v4", routes, matchPath);
-    }
-  };
-}
-function reactRouterV5BrowserTracingIntegration(options) {
-  const integration = browserTracingIntegration({
-    ...options,
-    instrumentPageLoad: false,
-    instrumentNavigation: false
-  });
-  const { history, routes, matchPath, instrumentPageLoad = true, instrumentNavigation = true } = options;
-  return {
-    ...integration,
-    afterAllSetup(client) {
-      integration.afterAllSetup(client);
-      instrumentReactRouter(client, instrumentPageLoad, instrumentNavigation, history, "reactrouter_v5", routes, matchPath);
-    }
-  };
-}
-function instrumentReactRouter(client, instrumentPageLoad, instrumentNavigation, history, instrumentationName, allRoutes = [], matchPath) {
-  function getInitPathName() {
-    if (history.location) {
-      return history.location.pathname;
-    }
-    if (WINDOW4.location) {
-      return WINDOW4.location.pathname;
-    }
-    return;
-  }
-  function normalizeTransactionName2(pathname) {
-    if (allRoutes.length === 0 || !matchPath) {
-      return [pathname, "url"];
-    }
-    const branches = matchRoutes(allRoutes, pathname, matchPath);
-    for (const branch of branches) {
-      if (branch.match.isExact) {
-        return [branch.match.path, "route"];
-      }
-    }
-    return [pathname, "url"];
-  }
-  if (instrumentPageLoad) {
-    const initPathName = getInitPathName();
-    if (initPathName) {
-      const [name, source] = normalizeTransactionName2(initPathName);
-      startBrowserTracingPageLoadSpan(client, {
-        name,
-        attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "pageload",
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.pageload.react.${instrumentationName}`,
-          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source
-        }
-      });
-    }
-  }
-  if (instrumentNavigation && history.listen) {
-    history.listen((location, action) => {
-      if (action && (action === "PUSH" || action === "POP")) {
-        const [name, source] = normalizeTransactionName2(location.pathname);
-        startBrowserTracingNavigationSpan(client, {
-          name,
-          attributes: {
-            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "navigation",
-            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.navigation.react.${instrumentationName}`,
-            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source
-          }
-        });
-      }
-    });
-  }
-}
-function matchRoutes(routes, pathname, matchPath, branch = []) {
-  routes.some((route) => {
-    const match = route.path ? matchPath(pathname, route) : branch.length ? branch[branch.length - 1].match : computeRootMatch(pathname);
-    if (match) {
-      branch.push({ route, match });
-      if (route.routes) {
-        matchRoutes(route.routes, pathname, matchPath, branch);
-      }
-    }
-    return !!match;
-  });
-  return branch;
-}
-function computeRootMatch(pathname) {
-  return { path: "/", url: "/", params: {}, isExact: pathname === "/" };
-}
-function withSentryRouting(Route) {
-  const componentDisplayName = Route.displayName || Route.name;
-  const WrappedRoute = (props) => {
-    if (props?.computedMatch?.isExact) {
-      const route = props.computedMatch.path;
-      const activeRootSpan = getActiveRootSpan();
-      getCurrentScope().setTransactionName(route);
-      if (activeRootSpan) {
-        activeRootSpan.updateName(route);
-        activeRootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, "route");
-      }
-    }
-    return React3.createElement(Route, { ...props });
-  };
-  WrappedRoute.displayName = `sentryRoute(${componentDisplayName})`;
-  hoistNonReactStatics(WrappedRoute, Route);
-  return WrappedRoute;
-}
-function getActiveRootSpan() {
-  const span = getActiveSpan();
-  const rootSpan = span && getRootSpan(span);
-  if (!rootSpan) {
-    return;
-  }
-  const op = spanToJSON(rootSpan).op;
-  return op === "navigation" || op === "pageload" ? rootSpan : undefined;
-}
-var init_reactrouter = __esm(() => {
-  init_dev();
-  init_esm();
-  init_hoist_non_react_statics();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouter-compat-utils/route-manifest.js
-function stripBasenameFromPathname(pathname, basename3) {
-  if (!basename3 || basename3 === "/") {
-    return pathname;
-  }
-  if (!pathname.toLowerCase().startsWith(basename3.toLowerCase())) {
-    return pathname;
-  }
-  const startIndex = basename3.endsWith("/") ? basename3.length - 1 : basename3.length;
-  const nextChar = pathname.charAt(startIndex);
-  if (nextChar && nextChar !== "/") {
-    return pathname;
-  }
-  return pathname.slice(startIndex) || "/";
-}
-function matchRouteManifest(pathname, manifest, basename3) {
-  if (!pathname || !manifest || !manifest.length) {
-    return null;
-  }
-  const normalizedPathname = basename3 ? stripBasenameFromPathname(pathname, basename3) : pathname;
-  let sorted = SORTED_MANIFEST_CACHE.get(manifest);
-  if (!sorted) {
-    sorted = sortBySpecificity(manifest);
-    SORTED_MANIFEST_CACHE.set(manifest, sorted);
-    DEBUG_BUILD6 && debug.log("[React Router] Sorted route manifest by specificity:", sorted.length, "patterns");
-  }
-  for (const pattern of sorted) {
-    if (matchesPattern(normalizedPathname, pattern)) {
-      DEBUG_BUILD6 && debug.log("[React Router] Matched pathname", normalizedPathname, "to pattern", pattern);
-      return pattern;
-    }
-  }
-  DEBUG_BUILD6 && debug.log("[React Router] No manifest match found for pathname:", normalizedPathname);
-  return null;
-}
-function matchesPattern(pathname, pattern) {
-  if (pattern === "/") {
-    return pathname === "/" || pathname === "";
-  }
-  const pathSegments = splitPath2(pathname);
-  const patternSegments = splitPath2(pattern);
-  const hasWildcard = patternSegments.length > 0 && patternSegments[patternSegments.length - 1] === "*";
-  if (hasWildcard) {
-    const patternSegmentsWithoutWildcard = patternSegments.slice(0, -1);
-    if (pathSegments.length < patternSegmentsWithoutWildcard.length) {
-      return false;
-    }
-    for (const [i2, patternSegment] of patternSegmentsWithoutWildcard.entries()) {
-      if (!segmentMatches(pathSegments[i2], patternSegment)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (pathSegments.length !== patternSegments.length) {
-    return false;
-  }
-  for (const [i2, patternSegment] of patternSegments.entries()) {
-    if (!segmentMatches(pathSegments[i2], patternSegment)) {
-      return false;
-    }
-  }
-  return true;
-}
-function segmentMatches(pathSegment, patternSegment) {
-  if (pathSegment === undefined || patternSegment === undefined) {
-    return false;
-  }
-  if (PARAM_RE.test(patternSegment)) {
-    return true;
-  }
-  return pathSegment === patternSegment;
-}
-function splitPath2(path) {
-  return path.split("/").filter(Boolean);
-}
-function computeScore(pattern) {
-  const segments = pattern.split("/");
-  let score = segments.length;
-  if (segments.includes("*")) {
-    score += SPLAT_PENALTY;
-  }
-  for (const segment of segments) {
-    if (segment === "*") {
-      continue;
-    } else if (PARAM_RE.test(segment)) {
-      score += DYNAMIC_SEGMENT_SCORE;
-    } else if (segment === "") {
-      score += EMPTY_SEGMENT_SCORE;
-    } else {
-      score += STATIC_SEGMENT_SCORE;
-    }
-  }
-  return score;
-}
-function sortBySpecificity(manifest) {
-  return [...manifest].sort((a2, b2) => {
-    const aScore = computeScore(a2);
-    const bScore = computeScore(b2);
-    return bScore - aScore;
-  });
-}
-var SORTED_MANIFEST_CACHE, PARAM_RE, STATIC_SEGMENT_SCORE = 10, DYNAMIC_SEGMENT_SCORE = 3, EMPTY_SEGMENT_SCORE = 1, SPLAT_PENALTY = -2;
-var init_route_manifest = __esm(() => {
-  init_esm();
-  init_debug_build4();
-  SORTED_MANIFEST_CACHE = new WeakMap;
-  PARAM_RE = /^:[\w-]+$/;
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouter-compat-utils/utils.js
-function setNavigationContext(targetPath, span) {
-  const token = {};
-  if (_navigationContextStack.length >= MAX_CONTEXT_STACK_SIZE) {
-    DEBUG_BUILD6 && debug.warn("[React Router] Navigation context stack overflow - removing oldest context");
-    _navigationContextStack.shift();
-  }
-  _navigationContextStack.push({ token, targetPath, span });
-  return token;
-}
-function clearNavigationContext(token) {
-  const top = _navigationContextStack[_navigationContextStack.length - 1];
-  if (top?.token === token) {
-    _navigationContextStack.pop();
-  }
-}
-function getNavigationContext() {
-  const length = _navigationContextStack.length;
-  return length > 0 ? _navigationContextStack[length - 1] ?? null : null;
-}
-function initializeRouterUtils(matchRoutes2, stripBasename = false) {
-  _matchRoutes = matchRoutes2;
-  _stripBasename = stripBasename;
-}
-function pickPath(match) {
-  return trimWildcard(match.route.path || "");
-}
-function pickSplat(match) {
-  return match.params["*"] || "";
-}
-function trimWildcard(path) {
-  return path[path.length - 1] === "*" ? path.slice(0, -1) : path;
-}
-function trimSlash(path) {
-  return path[path.length - 1] === "/" ? path.slice(0, -1) : path;
-}
-function pathEndsWithWildcard(path) {
-  return path.endsWith("*");
-}
-function transactionNameHasWildcard(name) {
-  return name.includes("/*") || name.endsWith("*");
-}
-function pathIsWildcardAndHasChildren(path, branch) {
-  return pathEndsWithWildcard(path) && !!branch.route.children?.length || false;
-}
-function routeIsDescendant(route) {
-  return !!(!route.children && route.element && route.path?.endsWith("/*"));
-}
-function sendIndexPath(pathBuilder, pathname, basename3) {
-  const reconstructedPath = pathBuilder && pathBuilder.length > 0 ? pathBuilder : _stripBasename ? stripBasenameFromPathname(pathname, basename3) : pathname;
-  let formattedPath = reconstructedPath.slice(-2) === "/*" ? reconstructedPath.slice(0, -2) : reconstructedPath;
-  if (formattedPath.length > 1 && formattedPath[formattedPath.length - 1] === "/") {
-    formattedPath = formattedPath.slice(0, -1);
-  }
-  return [formattedPath, "route"];
-}
-function getNumberOfUrlSegments(url) {
-  return url.split(/\\?\//).filter((s2) => s2.length > 0 && s2 !== ",").length;
-}
-function prefixWithSlash(path) {
-  return path[0] === "/" ? path : `/${path}`;
-}
-function rebuildRoutePathFromAllRoutes(allRoutes, location) {
-  const matchedRoutes = _matchRoutes(allRoutes, location);
-  if (!matchedRoutes || matchedRoutes.length === 0) {
-    return "";
-  }
-  for (const match of matchedRoutes) {
-    if (match.route.path && match.route.path !== "*") {
-      const path = pickPath(match);
-      const strippedPath = stripBasenameFromPathname(location.pathname, prefixWithSlash(match.pathnameBase));
-      if (location.pathname === strippedPath) {
-        return trimSlash(strippedPath);
-      }
-      return trimSlash(trimSlash(path || "") + prefixWithSlash(rebuildRoutePathFromAllRoutes(allRoutes.filter((route) => route !== match.route), {
-        pathname: strippedPath
-      })));
-    }
-  }
-  return "";
-}
-function locationIsInsideDescendantRoute(location, routes) {
-  const matchedRoutes = _matchRoutes(routes, location);
-  if (matchedRoutes) {
-    for (const match of matchedRoutes) {
-      if (routeIsDescendant(match.route) && pickSplat(match)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function getFallbackTransactionName(location, basename3) {
-  return _stripBasename ? stripBasenameFromPathname(location.pathname, basename3) : location.pathname || "";
-}
-function getNormalizedName(routes, location, branches, basename3 = "") {
-  if (!routes || routes.length === 0) {
-    return [_stripBasename ? stripBasenameFromPathname(location.pathname, basename3) : location.pathname, "url"];
-  }
-  if (!branches) {
-    return [getFallbackTransactionName(location, basename3), "url"];
-  }
-  let pathBuilder = "";
-  for (const branch of branches) {
-    const route = branch.route;
-    if (!route) {
-      continue;
-    }
-    if (route.index) {
-      return sendIndexPath(pathBuilder, branch.pathname, basename3);
-    }
-    const path = route.path;
-    if (!path || pathIsWildcardAndHasChildren(path, branch)) {
-      continue;
-    }
-    const newPath = path[0] === "/" || pathBuilder[pathBuilder.length - 1] === "/" ? path : `/${path}`;
-    pathBuilder = trimSlash(pathBuilder) + prefixWithSlash(newPath);
-    if (trimSlash(location.pathname) !== trimSlash(basename3 + branch.pathname)) {
-      continue;
-    }
-    if (getNumberOfUrlSegments(pathBuilder) !== getNumberOfUrlSegments(branch.pathname) && !pathEndsWithWildcard(pathBuilder)) {
-      return [(_stripBasename ? "" : basename3) + newPath, "route"];
-    }
-    if (pathIsWildcardAndHasChildren(pathBuilder, branch)) {
-      pathBuilder = pathBuilder.slice(0, -1);
-    }
-    return [(_stripBasename ? "" : basename3) + pathBuilder, "route"];
-  }
-  return [getFallbackTransactionName(location, basename3), "url"];
-}
-function resolveRouteNameAndSource(location, routes, allRoutes, branches, basename3 = "", lazyRouteManifest, enableAsyncRouteHandlers) {
-  if (enableAsyncRouteHandlers && lazyRouteManifest && lazyRouteManifest.length > 0) {
-    const manifestMatch = matchRouteManifest(location.pathname, lazyRouteManifest, basename3);
-    if (manifestMatch) {
-      return [(_stripBasename ? "" : basename3) + manifestMatch, "route"];
-    }
-  }
-  let name;
-  let source = "url";
-  const isInDescendantRoute = locationIsInsideDescendantRoute(location, allRoutes);
-  if (isInDescendantRoute) {
-    name = prefixWithSlash(rebuildRoutePathFromAllRoutes(allRoutes, location));
-    source = "route";
-  }
-  if (!isInDescendantRoute || !name) {
-    [name, source] = getNormalizedName(routes, location, branches, basename3);
-  }
-  return [name || location.pathname, source];
-}
-function getActiveRootSpan2() {
-  const span = getActiveSpan();
-  const rootSpan = span ? getRootSpan(span) : undefined;
-  if (!rootSpan) {
-    return;
-  }
-  const op = spanToJSON(rootSpan).op;
-  return op === "navigation" || op === "pageload" ? rootSpan : undefined;
-}
-var _matchRoutes, _stripBasename = false, _navigationContextStack, MAX_CONTEXT_STACK_SIZE = 10;
-var init_utils12 = __esm(() => {
-  init_esm();
-  init_debug_build4();
-  init_route_manifest();
-  _navigationContextStack = [];
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouter-compat-utils/lazy-routes.js
-function captureCurrentLocation() {
-  const navContext = getNavigationContext();
-  if (navContext) {
-    if (navContext.targetPath) {
-      return {
-        pathname: navContext.targetPath,
-        search: "",
-        hash: "",
-        state: null,
-        key: "default"
-      };
-    }
-    return null;
-  }
-  if (typeof WINDOW4 !== "undefined") {
-    try {
-      const windowLocation = WINDOW4.location;
-      if (windowLocation) {
-        return {
-          pathname: windowLocation.pathname,
-          search: windowLocation.search || "",
-          hash: windowLocation.hash || "",
-          state: null,
-          key: "default"
-        };
-      }
-    } catch {
-      DEBUG_BUILD6 && debug.warn("[React Router] Could not access window.location");
-    }
-  }
-  return null;
-}
-function captureActiveSpan() {
-  const navContext = getNavigationContext();
-  if (navContext) {
-    return navContext.span;
-  }
-  return getActiveRootSpan2();
-}
-function createAsyncHandlerProxy(originalFunction, route, handlerKey, processResolvedRoutes) {
-  const proxy = new Proxy(originalFunction, {
-    apply(target, thisArg, argArray) {
-      const locationAtInvocation = captureCurrentLocation();
-      const spanAtInvocation = captureActiveSpan();
-      const result = target.apply(thisArg, argArray);
-      handleAsyncHandlerResult(result, route, handlerKey, processResolvedRoutes, locationAtInvocation, spanAtInvocation);
-      return result;
-    }
-  });
-  addNonEnumerableProperty(proxy, "__sentry_proxied__", true);
-  return proxy;
-}
-function handleAsyncHandlerResult(result, route, handlerKey, processResolvedRoutes, currentLocation, capturedSpan) {
-  if (isThenable(result)) {
-    result.then((resolvedRoutes) => {
-      if (Array.isArray(resolvedRoutes)) {
-        processResolvedRoutes(resolvedRoutes, route, currentLocation ?? undefined, capturedSpan);
-      }
-    }).catch((e3) => {
-      DEBUG_BUILD6 && debug.warn(`Error resolving async handler '${handlerKey}' for route`, route, e3);
-    });
-  } else if (Array.isArray(result)) {
-    processResolvedRoutes(result, route, currentLocation ?? undefined, capturedSpan);
-  }
-}
-function checkRouteForAsyncHandler(route, processResolvedRoutes) {
-  if (route.handle && typeof route.handle === "object") {
-    for (const key of Object.keys(route.handle)) {
-      const maybeFn = route.handle[key];
-      if (typeof maybeFn === "function" && !maybeFn.__sentry_proxied__) {
-        route.handle[key] = createAsyncHandlerProxy(maybeFn, route, key, processResolvedRoutes);
-      }
-    }
-  }
-  if (Array.isArray(route.children)) {
-    for (const child of route.children) {
-      checkRouteForAsyncHandler(child, processResolvedRoutes);
-    }
-  }
-}
-var init_lazy_routes = __esm(() => {
-  init_dev();
-  init_esm();
-  init_debug_build4();
-  init_utils12();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouter-compat-utils/instrumentation.js
-import * as React4 from "react";
-function scheduleCallback(callback) {
-  if (WINDOW4?.requestAnimationFrame) {
-    return WINDOW4.requestAnimationFrame(callback);
-  }
-  return setTimeout(callback, 0);
-}
-function cancelScheduledCallback(id) {
-  if (WINDOW4?.cancelAnimationFrame) {
-    WINDOW4.cancelAnimationFrame(id);
-  } else {
-    clearTimeout(id);
-  }
-}
-function computeLocationKey(location) {
-  return `${location.pathname}${location.search || ""}${location.hash || ""}`;
-}
-function isParameterizedRoute(routeName) {
-  return routeName.includes(":") || routeName.includes("*");
-}
-function shouldSkipNavigation(trackedNav, locationKey, proposedName, spanHasEnded) {
-  if (!trackedNav) {
-    return { skip: false, shouldUpdate: false };
-  }
-  const isDuplicate = trackedNav.locationKey === locationKey && (trackedNav.isPlaceholder || !spanHasEnded);
-  if (isDuplicate) {
-    const currentHasWildcard = !!trackedNav.routeName && transactionNameHasWildcard(trackedNav.routeName);
-    const proposedHasWildcard = transactionNameHasWildcard(proposedName);
-    const currentIsParameterized = !!trackedNav.routeName && isParameterizedRoute(trackedNav.routeName);
-    const proposedIsParameterized = isParameterizedRoute(proposedName);
-    const isWildcardUpgrade = currentHasWildcard && !proposedHasWildcard;
-    const isRawToParameterized = !currentIsParameterized && proposedIsParameterized;
-    const isMoreSpecific = proposedName !== trackedNav.routeName && proposedName.length > (trackedNav.routeName?.length || 0) && !proposedHasWildcard;
-    const shouldUpdate = !!(trackedNav.routeName && (isWildcardUpgrade || isRawToParameterized || isMoreSpecific));
-    return { skip: true, shouldUpdate };
-  }
-  return { skip: false, shouldUpdate: false };
-}
-function addResolvedRoutesToParent(resolvedRoutes, parentRoute) {
-  const existingChildren = parentRoute.children || [];
-  const newRoutes = resolvedRoutes.filter((newRoute) => !existingChildren.some((existing) => existing === newRoute || newRoute.path && existing.path === newRoute.path || newRoute.id && existing.id === newRoute.id));
-  if (newRoutes.length > 0) {
-    parentRoute.children = [...existingChildren, ...newRoutes];
-  }
-}
-function trackLazyRouteLoad(span, promise) {
-  let promises = pendingLazyRouteLoads.get(span);
-  if (!promises) {
-    promises = new Set;
-    pendingLazyRouteLoads.set(span, promises);
-  }
-  promises.add(promise);
-  promise.finally(() => {
-    const currentPromises = pendingLazyRouteLoads.get(span);
-    if (currentPromises) {
-      currentPromises.delete(promise);
-    }
-  });
-}
-function createDeferredLazyRoutePromise(span) {
-  const deferredPromise = new Promise((resolve3) => {
-    deferredLazyRouteResolvers.set(span, resolve3);
-  });
-  trackLazyRouteLoad(span, deferredPromise);
-}
-function resolveDeferredLazyRoutePromise(span) {
-  const resolver = deferredLazyRouteResolvers.get(span);
-  if (resolver) {
-    resolver();
-    deferredLazyRouteResolvers.delete(span);
-    if (span.__sentry_may_have_lazy_routes__) {
-      span.__sentry_may_have_lazy_routes__ = false;
-    }
-  }
-}
-function processResolvedRoutes(resolvedRoutes, parentRoute, currentLocation = null, capturedSpan) {
-  resolvedRoutes.forEach((child) => {
-    allRoutes.add(child);
-    if (_enableAsyncRouteHandlers) {
-      checkRouteForAsyncHandler(child, processResolvedRoutes);
-    }
-  });
-  if (parentRoute) {
-    addResolvedRoutesToParent(resolvedRoutes, parentRoute);
-  }
-  const targetSpan = capturedSpan ?? getActiveRootSpan2();
-  if (targetSpan) {
-    const spanJson = spanToJSON(targetSpan);
-    if (spanJson.timestamp) {
-      DEBUG_BUILD6 && debug.warn("[React Router] Lazy handler resolved after span ended - skipping update");
-      return;
-    }
-    const spanOp = spanJson.op;
-    let location = currentLocation;
-    if (!location && !capturedSpan) {
-      if (typeof WINDOW4 !== "undefined") {
-        const globalLocation = WINDOW4.location;
-        if (globalLocation?.pathname) {
-          location = { pathname: globalLocation.pathname };
-        }
-      }
-    }
-    if (location) {
-      if (spanOp === "pageload") {
-        updatePageloadTransaction({
-          activeRootSpan: targetSpan,
-          location: { pathname: location.pathname },
-          routes: Array.from(allRoutes),
-          allRoutes: Array.from(allRoutes)
-        });
-      } else if (spanOp === "navigation") {
-        updateNavigationSpan(targetSpan, location, Array.from(allRoutes), false, _matchRoutes2);
-      }
-    }
-  }
-}
-function updateNavigationSpan(activeRootSpan, location, allRoutes2, forceUpdate = false, matchRoutes2) {
-  const spanJson = spanToJSON(activeRootSpan);
-  const currentName = spanJson.description;
-  const hasBeenNamed = activeRootSpan?.__sentry_navigation_name_set__;
-  const currentNameHasWildcard = currentName && transactionNameHasWildcard(currentName);
-  const shouldUpdate = !hasBeenNamed || forceUpdate || currentNameHasWildcard;
-  if (shouldUpdate && !spanJson.timestamp) {
-    const currentBranches = matchRoutes2(allRoutes2, location);
-    const [name, source] = resolveRouteNameAndSource(location, allRoutes2, allRoutes2, currentBranches || [], _basename, _lazyRouteManifest, _enableAsyncRouteHandlers);
-    const currentSource = spanJson.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-    const isImprovement = name && (!currentName || !hasBeenNamed && (currentSource !== "route" || source === "route") || currentSource !== "route" && source === "route" || currentSource === "route" && source === "route" && currentNameHasWildcard);
-    if (isImprovement) {
-      activeRootSpan.updateName(name);
-      activeRootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-      if (!transactionNameHasWildcard(name) && source === "route") {
-        addNonEnumerableProperty(activeRootSpan, "__sentry_navigation_name_set__", true);
-      }
-    }
-  }
-}
-function setupRouterSubscription(router, routes, version3, basename3, activeRootSpan) {
-  let isInitialPageloadComplete = false;
-  let hasSeenPageloadSpan = !!activeRootSpan && spanToJSON(activeRootSpan).op === "pageload";
-  let hasSeenPopAfterPageload = false;
-  let scheduledNavigationHandler = null;
-  let lastHandledPathname = null;
-  router.subscribe((state) => {
-    if (!isInitialPageloadComplete) {
-      const currentRootSpan = getActiveRootSpan2();
-      const isCurrentlyInPageload = currentRootSpan && spanToJSON(currentRootSpan).op === "pageload";
-      if (isCurrentlyInPageload) {
-        hasSeenPageloadSpan = true;
-      } else if (hasSeenPageloadSpan) {
-        if (state.historyAction === "POP" && !hasSeenPopAfterPageload) {
-          hasSeenPopAfterPageload = true;
-        } else {
-          isInitialPageloadComplete = true;
-        }
-      }
-    }
-    const shouldHandleNavigation = state.historyAction === "PUSH" || state.historyAction === "POP" && isInitialPageloadComplete;
-    if (shouldHandleNavigation) {
-      const currentLocationKey = computeLocationKey(state.location);
-      const navigationHandler = () => {
-        if (lastHandledPathname === currentLocationKey) {
-          return;
-        }
-        lastHandledPathname = currentLocationKey;
-        scheduledNavigationHandler = null;
-        handleNavigation({
-          location: state.location,
-          routes,
-          navigationType: state.historyAction,
-          version: version3,
-          basename: basename3,
-          allRoutes: Array.from(allRoutes)
-        });
-      };
-      if (state.navigation.state !== "idle") {
-        if (lastHandledPathname !== currentLocationKey) {
-          lastHandledPathname = null;
-        }
-        if (scheduledNavigationHandler !== null) {
-          cancelScheduledCallback(scheduledNavigationHandler);
-        }
-        scheduledNavigationHandler = scheduleCallback(navigationHandler);
-      } else {
-        if (scheduledNavigationHandler !== null) {
-          cancelScheduledCallback(scheduledNavigationHandler);
-          scheduledNavigationHandler = null;
-        }
-        navigationHandler();
-      }
-    }
-  });
-}
-function createV6CompatibleWrapCreateBrowserRouter(createRouterFunction, version3) {
-  if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes2) {
-    DEBUG_BUILD6 && debug.warn(`reactRouterV${version3}Instrumentation was unable to wrap the \`createRouter\` function because of one or more missing parameters.`);
-    return createRouterFunction;
-  }
-  return function(routes, opts) {
-    addRoutesToAllRoutes(routes);
-    if (_enableAsyncRouteHandlers) {
-      for (const route of routes) {
-        checkRouteForAsyncHandler(route, processResolvedRoutes);
-      }
-    }
-    const activeRootSpan = getActiveRootSpan2();
-    const hasPatchRoutesOnNavigation = opts && "patchRoutesOnNavigation" in opts && typeof opts.patchRoutesOnNavigation === "function";
-    if (hasPatchRoutesOnNavigation && activeRootSpan) {
-      addNonEnumerableProperty(activeRootSpan, "__sentry_may_have_lazy_routes__", true);
-      createDeferredLazyRoutePromise(activeRootSpan);
-    }
-    const wrappedOpts = wrapPatchRoutesOnNavigation(opts, false, activeRootSpan);
-    const router = createRouterFunction(routes, wrappedOpts);
-    const basename3 = opts?.basename;
-    if (router.state.historyAction === "POP" && activeRootSpan) {
-      updatePageloadTransaction({
-        activeRootSpan,
-        location: router.state.location,
-        routes,
-        basename: basename3,
-        allRoutes: Array.from(allRoutes)
-      });
-    }
-    _basename = basename3 || "";
-    setupRouterSubscription(router, routes, version3, basename3, activeRootSpan);
-    return router;
-  };
-}
-function createV6CompatibleWrapCreateMemoryRouter(createRouterFunction, version3) {
-  if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes2) {
-    DEBUG_BUILD6 && debug.warn(`reactRouterV${version3}Instrumentation was unable to wrap the \`createMemoryRouter\` function because of one or more missing parameters.`);
-    return createRouterFunction;
-  }
-  return function(routes, opts) {
-    addRoutesToAllRoutes(routes);
-    if (_enableAsyncRouteHandlers) {
-      for (const route of routes) {
-        checkRouteForAsyncHandler(route, processResolvedRoutes);
-      }
-    }
-    const memoryActiveRootSpanEarly = getActiveRootSpan2();
-    const hasPatchRoutesOnNavigation = opts && "patchRoutesOnNavigation" in opts && typeof opts.patchRoutesOnNavigation === "function";
-    if (hasPatchRoutesOnNavigation && memoryActiveRootSpanEarly) {
-      addNonEnumerableProperty(memoryActiveRootSpanEarly, "__sentry_may_have_lazy_routes__", true);
-      createDeferredLazyRoutePromise(memoryActiveRootSpanEarly);
-    }
-    const wrappedOpts = wrapPatchRoutesOnNavigation(opts, true, memoryActiveRootSpanEarly);
-    const router = createRouterFunction(routes, wrappedOpts);
-    const basename3 = opts?.basename;
-    let initialEntry = undefined;
-    const initialEntries = opts?.initialEntries;
-    const initialIndex = opts?.initialIndex;
-    const hasOnlyOneInitialEntry = initialEntries && initialEntries.length === 1;
-    const hasIndexedEntry = initialIndex !== undefined && initialEntries && initialEntries[initialIndex];
-    initialEntry = hasOnlyOneInitialEntry ? initialEntries[0] : hasIndexedEntry ? initialEntries[initialIndex] : undefined;
-    const location = initialEntry ? typeof initialEntry === "string" ? { pathname: initialEntry } : initialEntry : router.state.location;
-    const memoryActiveRootSpan = getActiveRootSpan2();
-    if (router.state.historyAction === "POP" && memoryActiveRootSpan) {
-      updatePageloadTransaction({
-        activeRootSpan: memoryActiveRootSpan,
-        location,
-        routes,
-        basename: basename3,
-        allRoutes: Array.from(allRoutes)
-      });
-    }
-    _basename = basename3 || "";
-    setupRouterSubscription(router, routes, version3, basename3, memoryActiveRootSpan);
-    return router;
-  };
-}
-function createReactRouterV6CompatibleTracingIntegration(options, version3) {
-  const integration = browserTracingIntegration({ ...options, instrumentPageLoad: false, instrumentNavigation: false });
-  const {
-    useEffect: useEffect2,
-    useLocation,
-    useNavigationType,
-    createRoutesFromChildren,
-    matchRoutes: matchRoutes2,
-    stripBasename,
-    enableAsyncRouteHandlers = false,
-    instrumentPageLoad = true,
-    instrumentNavigation = true,
-    lazyRouteTimeout,
-    lazyRouteManifest
-  } = options;
-  return {
-    ...integration,
-    setup(client) {
-      integration.setup(client);
-      const finalTimeout = options.finalTimeout ?? 30000;
-      const defaultMaxWait = (options.idleTimeout ?? 1000) * 3;
-      const configuredMaxWait = lazyRouteTimeout ?? defaultMaxWait;
-      if (configuredMaxWait === Infinity) {
-        _lazyRouteTimeout = finalTimeout;
-        DEBUG_BUILD6 && debug.log("[React Router] lazyRouteTimeout set to Infinity, capping at finalTimeout:", finalTimeout, "ms to prevent indefinite hangs");
-      } else if (Number.isNaN(configuredMaxWait)) {
-        DEBUG_BUILD6 && debug.warn("[React Router] lazyRouteTimeout must be a number, falling back to default:", defaultMaxWait);
-        _lazyRouteTimeout = defaultMaxWait;
-      } else if (configuredMaxWait < 0) {
-        DEBUG_BUILD6 && debug.warn("[React Router] lazyRouteTimeout must be non-negative or Infinity, got:", configuredMaxWait, "falling back to:", defaultMaxWait);
-        _lazyRouteTimeout = defaultMaxWait;
-      } else {
-        _lazyRouteTimeout = configuredMaxWait;
-      }
-      _useEffect = useEffect2;
-      _useLocation = useLocation;
-      _useNavigationType = useNavigationType;
-      _matchRoutes2 = matchRoutes2;
-      _createRoutesFromChildren = createRoutesFromChildren;
-      _enableAsyncRouteHandlers = enableAsyncRouteHandlers;
-      _lazyRouteManifest = lazyRouteManifest;
-      initializeRouterUtils(matchRoutes2, stripBasename || false);
-    },
-    afterAllSetup(client) {
-      integration.afterAllSetup(client);
-      const initPathName = WINDOW4.location?.pathname;
-      if (instrumentPageLoad && initPathName) {
-        startBrowserTracingPageLoadSpan(client, {
-          name: initPathName,
-          attributes: {
-            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "url",
-            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "pageload",
-            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.pageload.react.reactrouter_v${version3}`
-          }
-        });
-      }
-      if (instrumentNavigation) {
-        CLIENTS_WITH_INSTRUMENT_NAVIGATION.add(client);
-      }
-    }
-  };
-}
-function createV6CompatibleWrapUseRoutes(origUseRoutes, version3) {
-  if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes2) {
-    DEBUG_BUILD6 && debug.warn("reactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters.");
-    return origUseRoutes;
-  }
-  const SentryRoutes = (props) => {
-    const isMountRenderPass = React4.useRef(true);
-    const { routes, locationArg } = props;
-    const Routes = origUseRoutes(routes, locationArg);
-    const location = _useLocation();
-    const navigationType = _useNavigationType();
-    const stableLocationParam = typeof locationArg === "string" || locationArg?.pathname ? locationArg : location;
-    _useEffect(() => {
-      const normalizedLocation = typeof stableLocationParam === "string" ? { pathname: stableLocationParam } : stableLocationParam;
-      if (isMountRenderPass.current) {
-        addRoutesToAllRoutes(routes);
-        updatePageloadTransaction({
-          activeRootSpan: getActiveRootSpan2(),
-          location: normalizedLocation,
-          routes,
-          allRoutes: Array.from(allRoutes)
-        });
-        isMountRenderPass.current = false;
-      } else {
-        handleNavigation({
-          location: normalizedLocation,
-          routes,
-          navigationType,
-          version: version3,
-          allRoutes: Array.from(allRoutes)
-        });
-      }
-    }, [navigationType, stableLocationParam]);
-    return Routes;
-  };
-  return (routes, locationArg) => {
-    return React4.createElement(SentryRoutes, { routes, locationArg });
-  };
-}
-function wrapPatchRoutesOnNavigation(opts, isMemoryRouter = false, capturedSpan) {
-  if (!opts || !("patchRoutesOnNavigation" in opts) || typeof opts.patchRoutesOnNavigation !== "function") {
-    return opts || {};
-  }
-  const originalPatchRoutes = opts.patchRoutesOnNavigation;
-  return {
-    ...opts,
-    patchRoutesOnNavigation: async (args) => {
-      const targetPath = args?.path;
-      const activeRootSpan = getActiveRootSpan2() ?? capturedSpan;
-      if (!isMemoryRouter) {
-        const originalPatch = args?.patch;
-        const matches = args?.matches;
-        if (originalPatch) {
-          args.patch = (routeId, children) => {
-            addRoutesToAllRoutes(children);
-            if (matches && matches.length > 0) {
-              const leafMatch = matches[matches.length - 1];
-              const leafRoute = leafMatch?.route;
-              if (leafRoute) {
-                const matchingRoute = Array.from(allRoutes).find((route) => {
-                  const idMatches = route.id !== undefined && route.id === routeId;
-                  const referenceMatches = route === leafRoute;
-                  const pathMatches = route.path !== undefined && leafRoute.path !== undefined && route.path === leafRoute.path;
-                  return idMatches || referenceMatches || pathMatches;
-                });
-                if (matchingRoute) {
-                  addResolvedRoutesToParent(children, matchingRoute);
-                }
-              }
-            }
-            const spanJson = activeRootSpan ? spanToJSON(activeRootSpan) : undefined;
-            if (targetPath && activeRootSpan && spanJson && !spanJson.timestamp && spanJson.op === "navigation") {
-              updateNavigationSpan(activeRootSpan, { pathname: targetPath, search: "", hash: "", state: null, key: "default" }, Array.from(allRoutes), true, _matchRoutes2);
-            }
-            return originalPatch(routeId, children);
-          };
-        }
-      }
-      const lazyLoadPromise = (async () => {
-        const contextToken = setNavigationContext(targetPath, activeRootSpan);
-        let result;
-        try {
-          result = await originalPatchRoutes(args);
-        } finally {
-          clearNavigationContext(contextToken);
-          if (activeRootSpan) {
-            resolveDeferredLazyRoutePromise(activeRootSpan);
-          }
-        }
-        const spanJson = activeRootSpan ? spanToJSON(activeRootSpan) : undefined;
-        if (activeRootSpan && spanJson && !spanJson.timestamp && spanJson.op === "navigation") {
-          const pathname = targetPath;
-          if (pathname) {
-            updateNavigationSpan(activeRootSpan, { pathname, search: "", hash: "", state: null, key: "default" }, Array.from(allRoutes), false, _matchRoutes2);
-          }
-        }
-        return result;
-      })();
-      if (activeRootSpan) {
-        trackLazyRouteLoad(activeRootSpan, lazyLoadPromise);
-      }
-      return lazyLoadPromise;
-    }
-  };
-}
-function handleNavigation(opts) {
-  const { location, routes, navigationType, version: version3, matches, basename: basename3, allRoutes: allRoutes2 } = opts;
-  const branches = Array.isArray(matches) ? matches : _matchRoutes2(allRoutes2 || routes, location, basename3);
-  const client = getClient();
-  if (!client || !CLIENTS_WITH_INSTRUMENT_NAVIGATION.has(client)) {
-    return;
-  }
-  const activeRootSpan = getActiveRootSpan2();
-  if (activeRootSpan && spanToJSON(activeRootSpan).op === "pageload" && navigationType === "POP") {
-    return;
-  }
-  if ((navigationType === "PUSH" || navigationType === "POP") && branches) {
-    const [name, source] = resolveRouteNameAndSource(location, allRoutes2 || routes, allRoutes2 || routes, branches, basename3, _lazyRouteManifest, _enableAsyncRouteHandlers);
-    const locationKey = computeLocationKey(location);
-    const trackedNav = activeNavigationSpans.get(client);
-    const trackedSpanHasEnded = trackedNav && !trackedNav.isPlaceholder ? !!spanToJSON(trackedNav.span).timestamp : false;
-    const { skip, shouldUpdate } = shouldSkipNavigation(trackedNav, locationKey, name, trackedSpanHasEnded);
-    if (skip) {
-      if (shouldUpdate && trackedNav) {
-        const oldName = trackedNav.routeName;
-        if (trackedNav.isPlaceholder) {
-          trackedNav.routeName = name;
-          DEBUG_BUILD6 && debug.log(`[Tracing] Updated placeholder navigation name from "${oldName}" to "${name}" (will apply to real span)`);
-        } else {
-          trackedNav.span.updateName(name);
-          trackedNav.span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-          addNonEnumerableProperty(trackedNav.span, "__sentry_navigation_name_set__", true);
-          trackedNav.routeName = name;
-          DEBUG_BUILD6 && debug.log(`[Tracing] Updated navigation span name from "${oldName}" to "${name}"`);
-        }
-      } else {
-        DEBUG_BUILD6 && debug.log(`[Tracing] Skipping duplicate navigation for location: ${locationKey}`);
-      }
-      return;
-    }
-    const placeholderSpan = { end: () => {} };
-    const placeholderEntry = {
-      span: placeholderSpan,
-      routeName: name,
-      pathname: location.pathname,
-      locationKey,
-      isPlaceholder: true
-    };
-    activeNavigationSpans.set(client, placeholderEntry);
-    let navigationSpan;
-    try {
-      navigationSpan = startBrowserTracingNavigationSpan(client, {
-        name: placeholderEntry.routeName,
-        attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source,
-          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "navigation",
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.navigation.react.reactrouter_v${version3}`
-        }
-      });
-    } catch (e3) {
-      activeNavigationSpans.delete(client);
-      throw e3;
-    }
-    if (navigationSpan) {
-      activeNavigationSpans.set(client, {
-        span: navigationSpan,
-        routeName: placeholderEntry.routeName,
-        pathname: location.pathname,
-        locationKey
-      });
-      patchSpanEnd(navigationSpan, location, routes, basename3, "navigation");
-    } else {
-      activeNavigationSpans.delete(client);
-    }
-  }
-}
-function addRoutesToAllRoutes(routes) {
-  routes.forEach((route) => {
-    const extractedChildRoutes = getChildRoutesRecursively(route);
-    extractedChildRoutes.forEach((r3) => {
-      allRoutes.add(r3);
-    });
-  });
-}
-function getChildRoutesRecursively(route, allRoutes2 = new Set) {
-  if (!allRoutes2.has(route)) {
-    allRoutes2.add(route);
-    if (route.children && !route.index) {
-      route.children.forEach((child) => {
-        const childRoutes = getChildRoutesRecursively(child, allRoutes2);
-        childRoutes.forEach((r3) => {
-          allRoutes2.add(r3);
-        });
-      });
-    }
-  }
-  return allRoutes2;
-}
-function updatePageloadTransaction({
-  activeRootSpan,
-  location,
-  routes,
-  matches,
-  basename: basename3,
-  allRoutes: allRoutes2
-}) {
-  const branches = Array.isArray(matches) ? matches : _matchRoutes2(allRoutes2 || routes, location, basename3);
-  if (branches) {
-    const [name, source] = resolveRouteNameAndSource(location, allRoutes2 || routes, allRoutes2 || routes, branches, basename3, _lazyRouteManifest, _enableAsyncRouteHandlers);
-    getCurrentScope().setTransactionName(name || "/");
-    if (activeRootSpan) {
-      activeRootSpan.updateName(name);
-      activeRootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-      patchSpanEnd(activeRootSpan, location, routes, basename3, "pageload");
-    }
-  } else if (activeRootSpan) {
-    patchSpanEnd(activeRootSpan, location, routes, basename3, "pageload");
-  }
-}
-function shouldUpdateWildcardSpanName(currentName, currentSource, newName, newSource, allowNoCurrentName = false) {
-  if (!newName) {
-    return false;
-  }
-  if (!currentName && allowNoCurrentName) {
-    return true;
-  }
-  const hasWildcard = currentName && transactionNameHasWildcard(currentName);
-  if (hasWildcard && newSource === "route" && !transactionNameHasWildcard(newName)) {
-    return true;
-  }
-  if (currentSource !== "route" && newSource === "route") {
-    return true;
-  }
-  return false;
-}
-function tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename3, spanType, allRoutes2) {
-  try {
-    const currentSource = spanJson.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-    if (currentSource === "route" && currentName && !transactionNameHasWildcard(currentName)) {
-      return;
-    }
-    const currentAllRoutes = Array.from(allRoutes2);
-    const routesToUse = currentAllRoutes.length > 0 ? currentAllRoutes : routes;
-    const branches = _matchRoutes2(routesToUse, location, basename3);
-    if (!branches) {
-      return;
-    }
-    const [name, source] = resolveRouteNameAndSource(location, routesToUse, routesToUse, branches, basename3, _lazyRouteManifest, _enableAsyncRouteHandlers);
-    const isImprovement = shouldUpdateWildcardSpanName(currentName, currentSource, name, source, true);
-    const spanNotEnded = spanType === "pageload" || !spanJson.timestamp;
-    if (isImprovement && spanNotEnded) {
-      span.updateName(name);
-      span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-    }
-  } catch (error3) {
-    DEBUG_BUILD6 && debug.warn(`Error updating span details before ending: ${error3}`);
-  }
-}
-function patchSpanEnd(span, location, routes, basename3, spanType) {
-  const patchedPropertyName = `__sentry_${spanType}_end_patched__`;
-  const hasEndBeenPatched = span?.[patchedPropertyName];
-  if (hasEndBeenPatched || !span.end) {
-    return;
-  }
-  const originalEnd = span.end.bind(span);
-  let endCalled = false;
-  span.end = function patchedEnd(...args) {
-    if (endCalled) {
-      return;
-    }
-    endCalled = true;
-    const endTimestamp = args.length > 0 ? args[0] : Date.now() / 1000;
-    const spanJson = spanToJSON(span);
-    const currentName = spanJson.description;
-    const currentSource = spanJson.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-    const cleanupNavigationSpan = () => {
-      const client = getClient();
-      if (client && spanType === "navigation") {
-        const trackedNav = activeNavigationSpans.get(client);
-        if (trackedNav && trackedNav.span === span) {
-          activeNavigationSpans.delete(client);
-        }
-      }
-    };
-    const pendingPromises = pendingLazyRouteLoads.get(span);
-    const mayHaveLazyRoutes = span.__sentry_may_have_lazy_routes__;
-    const hasPendingOrMayHaveLazyRoutes = pendingPromises && pendingPromises.size > 0 || mayHaveLazyRoutes;
-    const shouldWaitForLazyRoutes = hasPendingOrMayHaveLazyRoutes && currentName && (transactionNameHasWildcard(currentName) || currentSource !== "route");
-    if (shouldWaitForLazyRoutes) {
-      if (_lazyRouteTimeout === 0) {
-        tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename3, spanType, allRoutes);
-        cleanupNavigationSpan();
-        originalEnd(endTimestamp);
-        return;
-      }
-      const timeoutPromise = new Promise((r3) => setTimeout(r3, _lazyRouteTimeout));
-      let waitPromise;
-      if (pendingPromises && pendingPromises.size > 0) {
-        const allSettled = Promise.allSettled(pendingPromises).then(() => {});
-        waitPromise = _lazyRouteTimeout === Infinity ? allSettled : Promise.race([allSettled, timeoutPromise]);
-      } else {
-        waitPromise = timeoutPromise;
-      }
-      waitPromise.then(() => {
-        const updatedSpanJson = spanToJSON(span);
-        tryUpdateSpanNameBeforeEnd(span, updatedSpanJson, updatedSpanJson.description, location, routes, basename3, spanType, allRoutes);
-        cleanupNavigationSpan();
-        originalEnd(endTimestamp);
-      }).catch(() => {
-        cleanupNavigationSpan();
-        originalEnd(endTimestamp);
-      });
-      return;
-    }
-    tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename3, spanType, allRoutes);
-    cleanupNavigationSpan();
-    originalEnd(endTimestamp);
-  };
-  addNonEnumerableProperty(span, patchedPropertyName, true);
-}
-function createV6CompatibleWithSentryReactRouterRouting(Routes, version3) {
-  if (!_useEffect || !_useLocation || !_useNavigationType || !_createRoutesFromChildren || !_matchRoutes2) {
-    DEBUG_BUILD6 && debug.warn(`reactRouterV6Instrumentation was unable to wrap Routes because of one or more missing parameters.
-      useEffect: ${_useEffect}. useLocation: ${_useLocation}. useNavigationType: ${_useNavigationType}.
-      createRoutesFromChildren: ${_createRoutesFromChildren}. matchRoutes: ${_matchRoutes2}.`);
-    return Routes;
-  }
-  const SentryRoutes = (props) => {
-    const isMountRenderPass = React4.useRef(true);
-    const location = _useLocation();
-    const navigationType = _useNavigationType();
-    _useEffect(() => {
-      const routes = _createRoutesFromChildren(props.children);
-      if (isMountRenderPass.current) {
-        addRoutesToAllRoutes(routes);
-        updatePageloadTransaction({
-          activeRootSpan: getActiveRootSpan2(),
-          location,
-          routes,
-          allRoutes: Array.from(allRoutes)
-        });
-        isMountRenderPass.current = false;
-      } else {
-        handleNavigation({ location, routes, navigationType, version: version3, allRoutes: Array.from(allRoutes) });
-      }
-    }, [location, navigationType]);
-    return React4.createElement(Routes, { ...props });
-  };
-  hoistNonReactStatics(SentryRoutes, Routes);
-  return SentryRoutes;
-}
-var _useEffect, _useLocation, _useNavigationType, _createRoutesFromChildren, _matchRoutes2, _enableAsyncRouteHandlers = false, _lazyRouteTimeout = 3000, _lazyRouteManifest, _basename = "", CLIENTS_WITH_INSTRUMENT_NAVIGATION, activeNavigationSpans, allRoutes, pendingLazyRouteLoads, deferredLazyRouteResolvers;
-var init_instrumentation = __esm(() => {
-  init_dev();
-  init_esm();
-  init_debug_build4();
-  init_hoist_non_react_statics();
-  init_lazy_routes();
-  init_utils12();
-  CLIENTS_WITH_INSTRUMENT_NAVIGATION = new WeakSet;
-  activeNavigationSpans = new WeakMap;
-  allRoutes = new Set;
-  pendingLazyRouteLoads = new WeakMap;
-  deferredLazyRouteResolvers = new WeakMap;
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouterv6.js
-function reactRouterV6BrowserTracingIntegration(options) {
-  return createReactRouterV6CompatibleTracingIntegration(options, "6");
-}
-function wrapUseRoutesV6(origUseRoutes) {
-  return createV6CompatibleWrapUseRoutes(origUseRoutes, "6");
-}
-function wrapCreateBrowserRouterV6(createRouterFunction) {
-  return createV6CompatibleWrapCreateBrowserRouter(createRouterFunction, "6");
-}
-function wrapCreateMemoryRouterV6(createMemoryRouterFunction) {
-  return createV6CompatibleWrapCreateMemoryRouter(createMemoryRouterFunction, "6");
-}
-function withSentryReactRouterV6Routing(routes) {
-  return createV6CompatibleWithSentryReactRouterRouting(routes, "6");
-}
-var init_reactrouterv6 = __esm(() => {
-  init_instrumentation();
-});
-
-// ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/reactrouterv7.js
-function reactRouterV7BrowserTracingIntegration(options) {
-  return createReactRouterV6CompatibleTracingIntegration(options, "7");
-}
-function withSentryReactRouterV7Routing(routes) {
-  return createV6CompatibleWithSentryReactRouterRouting(routes, "7");
-}
-function wrapCreateBrowserRouterV7(createRouterFunction) {
-  return createV6CompatibleWrapCreateBrowserRouter(createRouterFunction, "7");
-}
-function wrapCreateMemoryRouterV7(createMemoryRouterFunction) {
-  return createV6CompatibleWrapCreateMemoryRouter(createMemoryRouterFunction, "7");
-}
-function wrapUseRoutesV7(origUseRoutes) {
-  return createV6CompatibleWrapUseRoutes(origUseRoutes, "7");
-}
-var init_reactrouterv7 = __esm(() => {
-  init_instrumentation();
-});
-
 // ../../node_modules/.pnpm/@sentry+react@10.40.0_react@19.2.4/node_modules/@sentry/react/build/esm/index.js
 var exports_esm = {};
 __export(exports_esm, {
@@ -29531,16 +27532,6 @@ __export(exports_esm, {
   BrowserClient: () => BrowserClient
 });
 var init_esm6 = __esm(() => {
-  init_sdk3();
-  init_error();
-  init_profiler();
-  init_errorboundary();
-  init_redux();
-  init_reactrouterv3();
-  init_tanstackrouter();
-  init_reactrouter();
-  init_reactrouterv6();
-  init_reactrouterv7();
   init_dev();
 });
 
@@ -29576,7 +27567,7 @@ import {
   ToastContainer as BaseToastContainer,
   toast as baseToast
 } from "@powerhousedao/design-system/connect";
-import { createElement as createElement5 } from "react";
+import { createElement } from "react";
 function toast(content, options) {
   const {
     type = "default",
@@ -29585,7 +27576,7 @@ function toast(content, options) {
   } = options || {};
   return baseToast(content, { type, containerId, ...restOptions });
 }
-var CONNECT_TOAST_CONTAINER_ID = "connect", ToastContainer = () => createElement5(BaseToastContainer, {
+var CONNECT_TOAST_CONTAINER_ID = "connect", ToastContainer = () => createElement(BaseToastContainer, {
   containerId: CONNECT_TOAST_CONTAINER_ID
 });
 var init_toast = () => {};