@shipfox/client-shell 1.0.0 → 3.0.1

package/src/index.ts

@@ -1 +0,0 @@
-export * from './contract.js';

package/src/runtime/active-workspace.ts

@@ -1,13 +0,0 @@
-import {useParams} from '@tanstack/react-router';
-import {useAuthState, type Workspace} from './auth.js';
-
-export function useActiveWorkspace(): Workspace {
-  const workspace = useMaybeActiveWorkspace();
-  if (!workspace) throw new Error('useActiveWorkspace called outside a /workspaces/$wid route');
-  return workspace;
-}
-
-export function useMaybeActiveWorkspace(): Workspace | undefined {
-  const {wid} = useParams({strict: false}) as {wid?: string};
-  return useAuthState().workspaces.find((workspace) => workspace.id === wid);
-}

package/src/runtime/anchor-paths.ts

@@ -1,18 +0,0 @@
-const anchorPaths = {
-  root: '/',
-  workspaceLayout: '/workspaces/$wid',
-  projectLayout: '/workspaces/$wid/projects/$pid',
-  workspaceSettings: '/workspaces/$wid/settings',
-} as const;
-
-export {anchorPaths};
-
-export function routePathForAnchor(anchor: keyof typeof anchorPaths, fullPath: string): string {
-  const anchorPath = anchorPaths[anchor];
-  if (anchor === 'root') return fullPath;
-  if (fullPath === anchorPath) return '/';
-  if (!fullPath.startsWith(`${anchorPath}/`)) {
-    throw new Error(`Route "${fullPath}" must be nested under anchor "${anchor}" (${anchorPath}).`);
-  }
-  return fullPath.slice(anchorPath.length);
-}

package/src/runtime/anchors.tsx

@@ -1,106 +0,0 @@
-import {ShipfoxLoader} from '@shipfox/react-ui/loader';
-import {Header, Text} from '@shipfox/react-ui/typography';
-import {createRootRouteWithContext, createRoute, Outlet, redirect} from '@tanstack/react-router';
-import {MainLayout} from '#components/main-layout.js';
-import {NotFoundPage} from '#components/not-found-page.js';
-import {SettingsNav} from '#components/settings-nav.js';
-import type {NavTabEntry, SettingsSectionEntry} from '#contract.js';
-import {useActiveWorkspace} from './active-workspace.js';
-import {anchorPaths} from './anchor-paths.js';
-import {useChrome} from './chrome-context.js';
-import {rememberLastWorkspaceId} from './last-workspace.js';
-import type {RouterContext} from './router-context.js';
-import {WorkspaceLayoutErrorRoute, WorkspaceSetupPending} from './workspace-setup.js';
-
-export {routePathForAnchor} from './anchor-paths.js';
-
-export function buildAnchorSkeleton({
-  navigation,
-  settingsSections,
-}: {
-  navigation: readonly NavTabEntry[];
-  settingsSections: readonly SettingsSectionEntry[];
-}) {
-  const rootRoute = createRootRouteWithContext<RouterContext>()({
-    component: Outlet,
-    notFoundComponent: NotFoundPage,
-  });
-  const workspaceLayout = createRoute({
-    getParentRoute: () => rootRoute,
-    path: anchorPaths.workspaceLayout,
-    beforeLoad: async ({context, params, location}) => {
-      try {
-        rememberLastWorkspaceId(params.wid);
-      } catch {
-        // Local storage is best effort.
-      }
-      const auth = context.auth;
-      if (!auth || auth.isLoading || !context.queryClient) return;
-      if (!auth.isAuthenticated)
-        throw redirect({to: '/auth/login' as never, search: {redirect: location.href} as never});
-      if (!auth.workspaces.some((workspace) => workspace.id === params.wid))
-        throw redirect({to: '/'});
-      if (!context.workspaceSetup)
-        throw new Error('Client composition includes workspace routes but no workspaceSetup gate.');
-      return await context.workspaceSetup({
-        queryClient: context.queryClient,
-        workspaceId: params.wid,
-        pathname: location.pathname,
-      });
-    },
-    pendingComponent: () => (
-      <div className="flex h-screen items-center justify-center">
-        <ShipfoxLoader size={64} animation="circular" color="orange" background="dark" />
-      </div>
-    ),
-    errorComponent: WorkspaceLayoutErrorRoute,
-    component: () => {
-      const setupState = workspaceLayout.useRouteContext() as {hideProjectNavigation?: boolean};
-      return setupState.hideProjectNavigation === undefined ? (
-        <WorkspaceSetupPending />
-      ) : (
-        <MainLayout
-          navigation={navigation}
-          hideProjectNavigation={setupState.hideProjectNavigation}
-        />
-      );
-    },
-  });
-  const projectLayout = createRoute({
-    getParentRoute: () => workspaceLayout,
-    path: '/projects/$pid',
-    component: () => {
-      const {ProjectLayoutGuard} = useChrome();
-      return <ProjectLayoutGuard />;
-    },
-  });
-  const workspaceSettings = createRoute({
-    getParentRoute: () => workspaceLayout,
-    path: '/settings',
-    component: () => {
-      const workspace = useActiveWorkspace();
-      return (
-        <div className="flex w-full flex-col gap-24">
-          <header className="flex flex-col gap-6">
-            <Header variant="h2">Workspace settings</Header>
-            <Text size="sm" className="text-foreground-neutral-muted">
-              Configure {workspace.name}.
-            </Text>
-          </header>
-
-          <div className="grid grid-cols-[180px_minmax(0,1fr)] gap-32 max-[760px]:grid-cols-1">
-            <SettingsNav entries={settingsSections} />
-            <Outlet />
-          </div>
-        </div>
-      );
-    },
-  });
-  return {
-    anchors: {root: rootRoute, workspaceLayout, projectLayout, workspaceSettings},
-    rootRoute,
-    workspaceLayout,
-    projectLayout,
-    workspaceSettings,
-  };
-}

package/src/runtime/assemble-route-tree.ts

@@ -1,42 +0,0 @@
-import {createRoute} from '@tanstack/react-router';
-import type {ComposedRoute} from '#compose/compose-routes.js';
-import {buildAnchorSkeleton, routePathForAnchor} from '#runtime/anchors.js';
-import type {RouteImpl} from '#runtime/define-route.js';
-
-export type ResolveRouteImpl = (specifier: string) => RouteImpl | Promise<RouteImpl>;
-
-export async function assembleRouteTree(
-  routes: readonly ComposedRoute[],
-  options: {
-    resolveImpl: ResolveRouteImpl;
-    navigation: Parameters<typeof buildAnchorSkeleton>[0]['navigation'];
-    settingsSections: Parameters<typeof buildAnchorSkeleton>[0]['settingsSections'];
-  },
-) {
-  const skeleton = buildAnchorSkeleton(options);
-  const children = await Promise.all(
-    routes.map(async (route) => {
-      const impl = await options.resolveImpl(route.impl);
-      return {
-        parent: route.parent,
-        route: createRoute({
-          getParentRoute: () => skeleton.anchors[route.parent] as never,
-          path: routePathForAnchor(route.parent, route.path),
-          ...impl.options,
-        } as never),
-      };
-    }),
-  );
-  const childrenFor = (anchor: keyof typeof skeleton.anchors) =>
-    children.filter((child) => child.parent === anchor).map((child) => child.route);
-  const projectLayout = skeleton.projectLayout.addChildren(childrenFor('projectLayout'));
-  const workspaceSettings = skeleton.workspaceSettings.addChildren(
-    childrenFor('workspaceSettings'),
-  );
-  const workspaceLayout = skeleton.workspaceLayout.addChildren([
-    ...childrenFor('workspaceLayout'),
-    projectLayout,
-    workspaceSettings,
-  ]);
-  return skeleton.rootRoute.addChildren([...childrenFor('root'), workspaceLayout]);
-}

package/src/runtime/auth.tsx

@@ -1,213 +0,0 @@
-import type {LoginResponseDto, UserDto} from '@shipfox/api-auth-dto';
-import type {MembershipWithWorkspaceDto} from '@shipfox/api-workspaces-dto';
-import {ApiError, apiRequest, configureApiClient} from '@shipfox/client-api';
-import {useQueryClient} from '@tanstack/react-query';
-import {atom, useAtomValue, useSetAtom, useStore} from 'jotai';
-import type {PropsWithChildren} from 'react';
-import {useCallback, useEffect, useMemo} from 'react';
-
-const REFRESH_EARLY_MS = 5 * 60 * 1000;
-const REFRESH_RETRY_DELAY_MS = 60_000;
-const BASE64_URL_REPLACEMENTS = {dash: /-/g, underscore: /_/g} as const;
-
-export type AuthStatus = 'loading' | 'authenticated' | 'guest';
-
-export interface Workspace {
-  id: string;
-  name: string;
-  membershipId: string;
-}
-
-export interface AuthState {
-  status: AuthStatus;
-  token?: string;
-  user?: UserDto;
-  workspaces?: Workspace[];
-}
-
-export interface AuthStateValue extends AuthState {
-  isLoading: boolean;
-  isAuthenticated: boolean;
-  workspaces: Workspace[];
-  hasWorkspace: boolean;
-}
-
-export const initialAuthState: AuthState = {status: 'loading'};
-export const authStateAtom = atom<AuthState>(initialAuthState);
-export const authRefreshQueryKey = ['auth', 'refresh'] as const;
-export const userWorkspacesQueryKey = ['workspaces', 'mine'] as const;
-
-export function toAuthenticatedState(
-  result: LoginResponseDto,
-  memberships: MembershipWithWorkspaceDto[] = [],
-): AuthState {
-  return {
-    status: 'authenticated',
-    token: result.token,
-    user: result.user,
-    workspaces: memberships.map((membership) => ({
-      id: membership.workspace_id,
-      name: membership.workspace_name,
-      membershipId: membership.id,
-    })),
-  };
-}
-
-export function useAuthState(): AuthStateValue {
-  const state = useAtomValue(authStateAtom);
-  return useMemo(
-    () => ({
-      ...state,
-      workspaces: state.workspaces ?? [],
-      isLoading: state.status === 'loading',
-      isAuthenticated: state.status === 'authenticated',
-      hasWorkspace: (state.workspaces ?? []).length > 0,
-    }),
-    [state],
-  );
-}
-
-export async function listUserWorkspaces(token?: string) {
-  return await apiRequest<{memberships: MembershipWithWorkspaceDto[]}>(
-    '/workspaces',
-    token ? {headers: {authorization: `Bearer ${token}`}} : {},
-  );
-}
-
-async function refreshAuthRequest() {
-  return await apiRequest<LoginResponseDto>('/auth/refresh', {method: 'POST'});
-}
-
-function decodeBase64Url(value: string): string {
-  const base64 = value
-    .replace(BASE64_URL_REPLACEMENTS.dash, '+')
-    .replace(BASE64_URL_REPLACEMENTS.underscore, '/');
-  return atob(base64.padEnd(Math.ceil(base64.length / 4) * 4, '='));
-}
-
-function readJwtExp(token: string): number | undefined {
-  const [, payload] = token.split('.');
-  if (!payload) return undefined;
-  try {
-    const parsed = JSON.parse(decodeBase64Url(payload)) as {exp?: unknown};
-    return typeof parsed.exp === 'number' && Number.isFinite(parsed.exp) ? parsed.exp : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function getAuthRefreshDelayMs(token: string, nowMs = Date.now()): number | undefined {
-  const exp = readJwtExp(token);
-  return exp === undefined ? undefined : exp * 1000 - nowMs - REFRESH_EARLY_MS;
-}
-
-export function useRefreshAuth() {
-  const queryClient = useQueryClient();
-  const setState = useSetAtom(authStateAtom);
-  return useCallback(async () => {
-    try {
-      const result = await queryClient.fetchQuery({
-        queryKey: authRefreshQueryKey,
-        queryFn: refreshAuthRequest,
-        retry: false,
-        staleTime: 0,
-      });
-      let memberships: MembershipWithWorkspaceDto[] = [];
-      try {
-        const workspaces = await queryClient.fetchQuery({
-          queryKey: userWorkspacesQueryKey,
-          queryFn: () => listUserWorkspaces(result.token),
-          retry: false,
-          staleTime: 0,
-        });
-        memberships = workspaces.memberships;
-      } catch {
-        // A valid session remains usable while workspace hydration retries on the next route load.
-      }
-      setState(toAuthenticatedState(result, memberships));
-      return result;
-    } catch (error) {
-      if (error instanceof ApiError && error.status === 401) setState({status: 'guest'});
-      throw error;
-    }
-  }, [queryClient, setState]);
-}
-
-export interface AuthRuntimeProps extends PropsWithChildren {
-  effects?: boolean;
-}
-
-export function AuthRuntime({children, effects = true}: AuthRuntimeProps) {
-  const store = useStore();
-  const authState = useAtomValue(authStateAtom);
-  const refreshAuth = useRefreshAuth();
-
-  useEffect(() => {
-    if (!effects) return;
-    configureApiClient({
-      getAccessToken: () => store.get(authStateAtom).token,
-      refreshAccessToken: async () => (await refreshAuth()).token,
-    });
-  }, [effects, refreshAuth, store]);
-
-  useEffect(() => {
-    if (!effects) return;
-    refreshAuth().catch(() => undefined);
-  }, [effects, refreshAuth]);
-
-  useEffect(() => {
-    if (!effects || authState.status !== 'authenticated' || !authState.token) return;
-
-    let timeout: ReturnType<typeof setTimeout> | undefined;
-    let disposed = false;
-    let refreshing = false;
-    const clearRefreshTimer = () => {
-      if (timeout !== undefined) clearTimeout(timeout);
-      timeout = undefined;
-    };
-    const scheduleRefresh = (delayMs: number) => {
-      clearRefreshTimer();
-      timeout = setTimeout(runRefresh, Math.max(0, delayMs));
-    };
-    const retryIfStillDue = () => {
-      const current = store.get(authStateAtom);
-      if (current.status !== 'authenticated' || !current.token) return;
-      const delay = getAuthRefreshDelayMs(current.token);
-      if (delay !== undefined && delay <= 0) scheduleRefresh(REFRESH_RETRY_DELAY_MS);
-    };
-    function runRefresh() {
-      if (disposed || refreshing) return;
-      refreshing = true;
-      clearRefreshTimer();
-      refreshAuth()
-        .catch(() => undefined)
-        .finally(() => {
-          refreshing = false;
-          if (!disposed) retryIfStillDue();
-        });
-    }
-    const refreshIfDue = () => {
-      const current = store.get(authStateAtom);
-      if (current.status !== 'authenticated' || !current.token) return;
-      const delay = getAuthRefreshDelayMs(current.token);
-      if (delay !== undefined && delay <= 0) runRefresh();
-    };
-    const refreshIfVisible = () => {
-      if (document.visibilityState === 'visible') refreshIfDue();
-    };
-    const delay = getAuthRefreshDelayMs(authState.token);
-    if (delay !== undefined) scheduleRefresh(delay);
-    window.addEventListener('focus', refreshIfDue);
-    window.addEventListener('online', refreshIfDue);
-    document.addEventListener('visibilitychange', refreshIfVisible);
-    return () => {
-      disposed = true;
-      clearRefreshTimer();
-      window.removeEventListener('focus', refreshIfDue);
-      window.removeEventListener('online', refreshIfDue);
-      document.removeEventListener('visibilitychange', refreshIfVisible);
-    };
-  }, [authState.status, authState.token, effects, refreshAuth, store]);
-
-  return children;
-}

package/src/runtime/chrome-context.tsx

@@ -1,22 +0,0 @@
-import type {ComponentType, PropsWithChildren} from 'react';
-import {createContext, useContext} from 'react';
-
-export interface ChromeSlots {
-  ProjectBreadcrumb: ComponentType;
-  ProjectLayoutGuard: ComponentType;
-}
-
-const ChromeContext = createContext<ChromeSlots | undefined>(undefined);
-
-export function ChromeProvider({
-  chrome,
-  children,
-}: PropsWithChildren<{chrome: ChromeSlots | undefined}>) {
-  return <ChromeContext.Provider value={chrome}>{children}</ChromeContext.Provider>;
-}
-
-export function useChrome(): ChromeSlots {
-  const chrome = useContext(ChromeContext);
-  if (!chrome) throw new Error('Client composition must provide browser chrome slots.');
-  return chrome;
-}

package/src/runtime/compose-client-app.tsx

@@ -1,122 +0,0 @@
-import {configureApiClient} from '@shipfox/client-api';
-import {
-  ConfigErrorScreen,
-  getWindowRuntimeConfig,
-  loadConfig,
-  setLoadedConfig,
-} from '@shipfox/client-config';
-import {ThemeProvider} from '@shipfox/react-ui/theme';
-import {Toaster} from '@shipfox/react-ui/toast';
-import {TooltipProvider} from '@shipfox/react-ui/tooltip';
-import {QueryClient} from '@tanstack/react-query';
-import {type AnyRouter, RouterProvider} from '@tanstack/react-router';
-import {createStore} from 'jotai';
-import {StrictMode, useEffect} from 'react';
-import {createRoot} from 'react-dom/client';
-import {composeRoutes} from '#compose/compose-routes.js';
-import {mergeConfigShapes} from '#compose/merge-config.js';
-import {validateProviderIds} from '#compose/validate-providers.js';
-import {validateNavigation, validateSettingsSections} from '#compose/validate-registries.js';
-import type {ClientFeature} from '#contract.js';
-import {useAuthState} from './auth.js';
-import {ChromeProvider, type ChromeSlots} from './chrome-context.js';
-import {ShellProviderStack} from './provider-stack.js';
-import type {WorkspaceSetupGate} from './workspace-setup.js';
-
-export function composeClientApp({
-  features,
-  router,
-  chrome,
-  workspaceSetup,
-}: {
-  features: readonly ClientFeature[];
-  router: AnyRouter;
-  chrome?: ChromeSlots;
-  workspaceSetup?: WorkspaceSetupGate;
-}) {
-  const routes = composeRoutes(features);
-  validateProviderIds(features);
-  validateNavigation(
-    features,
-    routes.map((route) => route.path),
-  );
-  validateSettingsSections(
-    features,
-    routes.map((route) => route.path),
-  );
-  const config = loadConfig(mergeConfigShapes(features), {
-    runtime: getWindowRuntimeConfig(),
-    build: (import.meta as ImportMeta & {env?: Record<string, unknown>}).env,
-  });
-  if (config.ok) setLoadedConfig(config.config);
-
-  return {
-    mount(element: HTMLElement): void {
-      const root = createRoot(element);
-      if (!config.ok) {
-        root.render(
-          <StrictMode>
-            <ThemeProvider>
-              <TooltipProvider>
-                <ConfigErrorScreen errors={config.errors} />
-              </TooltipProvider>
-            </ThemeProvider>
-          </StrictMode>,
-        );
-        return;
-      }
-
-      configureApiClient({baseUrl: configApiUrl(config.config)});
-      const queryClient = new QueryClient();
-      root.render(
-        <StrictMode>
-          <ChromeProvider chrome={chrome}>
-            <ShellProviderStack features={features} queryClient={queryClient} store={createStore()}>
-              <RoutedApp
-                router={router}
-                queryClient={queryClient}
-                workspaceSetup={workspaceSetup}
-              />
-              <Toaster />
-            </ShellProviderStack>
-          </ChromeProvider>
-        </StrictMode>,
-      );
-    },
-  };
-}
-
-function RoutedApp({
-  router,
-  queryClient,
-  workspaceSetup,
-}: {
-  router: AnyRouter;
-  queryClient: QueryClient;
-  workspaceSetup: WorkspaceSetupGate | undefined;
-}) {
-  const auth = useAuthState();
-
-  useEffect(() => {
-    if (!auth.isLoading) router.invalidate();
-  }, [auth.isLoading, router]);
-
-  return (
-    <RouterProvider
-      router={router as never}
-      context={{auth, queryClient, workspaceSetup} as never}
-    />
-  );
-}
-
-function configApiUrl(config: unknown): string {
-  if (
-    typeof config !== 'object' ||
-    config === null ||
-    !('apiUrl' in config) ||
-    typeof config.apiUrl !== 'string'
-  ) {
-    throw new Error('Composed client configuration must include a string apiUrl.');
-  }
-  return config.apiUrl;
-}

package/src/runtime/define-route.test.ts

@@ -1,15 +0,0 @@
-import {defineRoute, isRouteImpl} from './define-route.js';
-
-describe('isRouteImpl', () => {
-  test('accepts implementations created by defineRoute', () => {
-    const route = defineRoute({component: () => null});
-
-    expect(isRouteImpl(route)).toBe(true);
-  });
-
-  test('rejects a default component without a route implementation', () => {
-    const component = () => null;
-
-    expect(isRouteImpl(component)).toBe(false);
-  });
-});

package/src/runtime/define-route.ts

@@ -1,33 +0,0 @@
-import type {ComponentType} from 'react';
-
-export interface RouteImplOptions {
-  component?: ComponentType;
-  loader?: unknown;
-  validateSearch?: unknown;
-  beforeLoad?: unknown;
-  staticData?: unknown;
-  pendingComponent?: ComponentType;
-  errorComponent?: ComponentType;
-}
-
-const routeImplBrand = Symbol('routeImpl');
-
-export interface RouteImpl<O extends RouteImplOptions = RouteImplOptions> {
-  readonly options: O;
-  readonly [routeImplBrand]: true;
-}
-
-export function defineRoute<const O extends RouteImplOptions>(options: O): RouteImpl<O> {
-  return {options, [routeImplBrand]: true};
-}
-
-export function isRouteImpl(value: unknown): value is RouteImpl {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    routeImplBrand in value &&
-    'options' in value &&
-    typeof value.options === 'object' &&
-    value.options !== null
-  );
-}

package/src/runtime/index.ts

@@ -1,19 +0,0 @@
-export {WorkspaceCrumb, type WorkspaceCrumbProps} from '#components/workspace-crumb.js';
-export {WorkspaceSwitcher} from '#components/workspace-switcher.js';
-export * from '../compose/compose-routes.js';
-export * from '../compose/errors.js';
-export * from '../compose/merge-config.js';
-export * from '../compose/normalize-route-path.js';
-export * from '../compose/validate-providers.js';
-export * from '../compose/validate-registries.js';
-export * from './active-workspace.js';
-export * from './anchor-paths.js';
-export * from './anchors.js';
-export * from './auth.js';
-export * from './chrome-context.js';
-export * from './compose-client-app.js';
-export * from './define-route.js';
-export * from './last-workspace.js';
-export * from './nav-order.js';
-export * from './router-context.js';
-export * from './workspace-setup.js';

package/src/runtime/last-workspace.ts

@@ -1,22 +0,0 @@
-import {atomWithStorage} from 'jotai/utils';
-
-const storageKey = 'shipfox.lastWorkspaceId';
-
-export const lastWorkspaceIdAtom = atomWithStorage<string | undefined>(storageKey, undefined);
-
-export function getLastWorkspaceId(): string | undefined {
-  if (typeof window === 'undefined') return undefined;
-  try {
-    const raw = window.localStorage.getItem(storageKey);
-    if (!raw) return undefined;
-    const parsed: unknown = JSON.parse(raw);
-    return typeof parsed === 'string' ? parsed : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function rememberLastWorkspaceId(workspaceId: string): void {
-  if (typeof window === 'undefined') return;
-  window.localStorage.setItem(storageKey, JSON.stringify(workspaceId));
-}

package/src/runtime/nav-order.ts

@@ -1 +0,0 @@
-export const NAV_ORDER = {projects: 100, settings: 900, runs: 100, workflows: 200} as const;

package/src/runtime/provider-stack.tsx

@@ -1,39 +0,0 @@
-import {ThemeProvider} from '@shipfox/react-ui/theme';
-import {TooltipProvider} from '@shipfox/react-ui/tooltip';
-import {type QueryClient, QueryClientProvider} from '@tanstack/react-query';
-import {type createStore, Provider as JotaiProvider} from 'jotai';
-import type {PropsWithChildren, ReactNode} from 'react';
-import type {ClientFeature} from '#contract.js';
-import {AuthRuntime, type AuthRuntimeProps} from './auth.js';
-
-type Store = ReturnType<typeof createStore>;
-
-export function ShellProviderStack({
-  features,
-  queryClient,
-  store,
-  auth,
-  children,
-}: PropsWithChildren<{
-  features: readonly ClientFeature[];
-  queryClient: QueryClient;
-  store: Store;
-  auth?: Pick<AuthRuntimeProps, 'effects'>;
-}>) {
-  const featureProviders = features.flatMap((feature) => feature.providers ?? []);
-  const nestedProviders = featureProviders.reduceRight<ReactNode>(
-    (content, provider) => <provider.Component key={provider.id}>{content}</provider.Component>,
-    children,
-  );
-  return (
-    <ThemeProvider>
-      <TooltipProvider>
-        <QueryClientProvider client={queryClient}>
-          <JotaiProvider store={store}>
-            <AuthRuntime {...auth}>{nestedProviders}</AuthRuntime>
-          </JotaiProvider>
-        </QueryClientProvider>
-      </TooltipProvider>
-    </ThemeProvider>
-  );
-}