@oxyhq/services 22.8.6 → 22.9.0

package/src/ui/components/SurfaceScreen.tsx

@@ -0,0 +1,166 @@
+import React, { useCallback, useEffect, useMemo, type ErrorInfo } from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import { useStore } from 'zustand';
+import { useTheme } from '@oxyhq/bloom/theme';
+import type { SurfaceControls } from '@oxyhq/bloom/surfaces';
+import type { RouteName } from '../navigation/routes';
+import { getScreenComponent } from '../navigation/routes';
+import type { SurfaceNavStack } from '../navigation/surfaceNavStack';
+import type { SurfacePresentation } from '../navigation/surfaceRegistry';
+import {
+  closeAllRouteSurfaces,
+  navigateWithinOrPresent,
+  presentRoute,
+  replaceWithinOrPresent,
+} from '../navigation/surfaces';
+import type { BaseScreenProps } from '../types/navigation';
+
+/** Error boundary catching screen render failures (e.g. a lazy `require()` throw). */
+interface ScreenErrorBoundaryState {
+  error: Error | null;
+}
+
+class ScreenErrorBoundary extends React.Component<
+  { screenName: string; children: React.ReactNode },
+  ScreenErrorBoundaryState
+> {
+  state: ScreenErrorBoundaryState = { error: null };
+
+  static getDerivedStateFromError(error: Error): ScreenErrorBoundaryState {
+    return { error };
+  }
+
+  componentDidCatch(error: Error, info: ErrorInfo): void {
+    if (__DEV__) {
+      console.error(
+        `[SurfaceScreen] Screen "${this.props.screenName}" crashed:`,
+        error,
+        info.componentStack,
+      );
+    }
+  }
+
+  componentDidUpdate(prevProps: { screenName: string }): void {
+    if (prevProps.screenName !== this.props.screenName && this.state.error) {
+      this.setState({ error: null });
+    }
+  }
+
+  render(): React.ReactNode {
+    if (this.state.error) {
+      return (
+        <View style={errorStyles.container}>
+          <Text style={errorStyles.title}>Something went wrong</Text>
+          {__DEV__ && <Text style={errorStyles.message}>{this.state.error.message}</Text>}
+        </View>
+      );
+    }
+    return this.props.children;
+  }
+}
+
+const errorStyles = StyleSheet.create({
+  container: { flex: 1, alignItems: 'center', justifyContent: 'center', padding: 24 },
+  title: { fontSize: 16, fontWeight: '600', marginBottom: 8 },
+  message: { fontSize: 13, textAlign: 'center' },
+});
+
+export interface SurfaceScreenProps {
+  /** This surface's route history (the NAV-WITHIN axis). */
+  navStack: SurfaceNavStack;
+  /** Bloom's per-surface controls (dismiss / present a child) — the DEPTH axis. */
+  surface: SurfaceControls;
+  /** This surface's presentation, so `navigate` knows when to drill in vs. stack. */
+  presentation: SurfacePresentation;
+}
+
+/**
+ * Binds one SDK surface to its content: resolves the lazy screen for the current
+ * nav-stack frame and renders it inside the error boundary with the per-surface
+ * navigation props. Mounted by `surfaces.present` as the Bloom surface's content.
+ *
+ * Dismissal is driven through the nav stack's `closing` flag (watched in an
+ * effect) rather than a captured-controls call, so a dismiss requested before
+ * this surface mounted still resolves the Bloom surface exactly once.
+ */
+function SurfaceScreen({ navStack, surface, presentation }: SurfaceScreenProps) {
+  const theme = useTheme();
+  const state = useStore(navStack.store);
+  const top = state.frames[state.frames.length - 1];
+
+  useEffect(() => {
+    if (state.closing) surface.dismiss(state.closeResult);
+  }, [state.closing, state.closeResult, surface]);
+
+  const ScreenComponent = useMemo(() => getScreenComponent(top.route) ?? null, [top.route]);
+
+  const navigate = useCallback(
+    (route: RouteName, props?: Record<string, unknown>) =>
+      navigateWithinOrPresent(presentation, navStack, route, props),
+    [navStack, presentation],
+  );
+
+  const replace = useCallback(
+    (route: RouteName, props?: Record<string, unknown>) =>
+      replaceWithinOrPresent(presentation, navStack, route, props),
+    [navStack, presentation],
+  );
+
+  const dismiss = useCallback((result?: unknown) => navStack.requestDismiss(result), [navStack]);
+
+  const canGoBack = useCallback(() => navStack.canGoBack(), [navStack]);
+
+  const setStep = useCallback((step: number) => navStack.setStep(step), [navStack]);
+
+  // Screen-facing back: pop a frame, else step a wizard back, else dismiss the
+  // surface — the exact behaviour the single `BottomSheetRouter` had per session.
+  const goBack = useCallback((): void => {
+    if (navStack.goBack()) return;
+    const current = navStack.getTop();
+    if (current.step > 0) {
+      navStack.setStep(current.step - 1);
+      return;
+    }
+    navStack.requestDismiss();
+  }, [navStack]);
+
+  const present = useCallback(
+    (route: RouteName, props?: Record<string, unknown>) => presentRoute(route, props).result,
+    [],
+  );
+
+  const screenProps = useMemo<BaseScreenProps>(() => {
+    const { initialStep: _omitInitialStep, ...rest } = top.props;
+    return {
+      // NAV-WITHIN
+      navigate,
+      goBack,
+      replace,
+      canGoBack,
+      initialStep: top.step,
+      step: top.step,
+      onStepChange: setStep,
+      setStep,
+      currentScreen: top.route,
+      // DEPTH — `onClose`/`onAuthenticated` unwind the whole session (matching the
+      // old `closeBottomSheet`); `dismiss`/`present` are the per-surface controls.
+      onClose: closeAllRouteSurfaces,
+      onAuthenticated: closeAllRouteSurfaces,
+      dismiss,
+      present,
+      // Theme + the route's own props.
+      theme: theme.mode,
+      ...rest,
+    };
+  }, [navigate, goBack, replace, canGoBack, setStep, present, dismiss, theme.mode, top.route, top.step, top.props]);
+
+  if (!ScreenComponent) return null;
+
+  return (
+    <ScreenErrorBoundary screenName={top.route}>
+      <ScreenComponent {...screenProps} />
+    </ScreenErrorBoundary>
+  );
+}
+
+export default SurfaceScreen;

package/src/ui/components/fileManagement/UploadPreview.tsx

@@ -4,23 +4,15 @@ import { Image as ExpoImage } from 'expo-image';
 import { Ionicons } from '@expo/vector-icons';
 import { Dialog, type DialogControlProps } from '@oxyhq/bloom';
 import { useTheme } from '@oxyhq/bloom/theme';
-import type { RNFileDescriptor } from '@oxyhq/core';
 import { formatFileSize, getFileIcon } from '../../utils/fileManagement';
-
-interface PendingFile {
-    file: File | Blob | RNFileDescriptor;
-    preview?: string;
-    size: number;
-    name: string;
-    type: string;
-}
+import type { PendingUploadFile } from '../../screens/fileManagement/shared';
 
 interface UploadPreviewProps {
     control?: DialogControlProps;
-    pendingFiles: PendingFile[];
+    pendingFiles: PendingUploadFile[];
     onConfirm: () => void;
     onCancel: () => void;
-    onRemoveFile: (index: number) => void;
+    onRemoveFile: (id: string) => void;
     inline?: boolean;
 }
 
@@ -34,10 +26,10 @@ const previewStyles = StyleSheet.create({
 });
 
 const UploadPreviewContent: React.FC<{
-    pendingFiles: PendingFile[];
+    pendingFiles: PendingUploadFile[];
     onConfirm: () => void;
     onCancel: () => void;
-    onRemoveFile: (index: number) => void;
+    onRemoveFile: (id: string) => void;
     showActions?: boolean;
 }> = ({
     pendingFiles,
@@ -61,11 +53,11 @@ const UploadPreviewContent: React.FC<{
             </View>
 
             <ScrollView className="flex-1 p-[16px]">
-                {pendingFiles.map((pendingFile, index) => {
+                {pendingFiles.map((pendingFile) => {
                     const isImage = pendingFile.type.startsWith('image/');
                     return (
                         <View
-                            key={`${pendingFile.name}-${pendingFile.size}-${index}`}
+                            key={pendingFile.id}
                             className="bg-secondary border-border flex-row items-center p-[12px] rounded-[12px] border mb-[12px] gap-[12px]"
                         >
                             {isImage && pendingFile.preview ? (
@@ -96,7 +88,7 @@ const UploadPreviewContent: React.FC<{
                             </View>
                             <TouchableOpacity
                                 className="p-[4px]"
-                                onPress={() => onRemoveFile(index)}
+                                onPress={() => onRemoveFile(pendingFile.id)}
                             >
                                 <Ionicons name="close-circle" size={24} color={colors.error} />
                             </TouchableOpacity>

package/src/ui/context/OxyContext.tsx

@@ -45,6 +45,7 @@ import { useDeviceManagement } from '../hooks/useDeviceManagement';
 import { getStorageKeys, createPlatformStorage, type StorageInterface } from '../utils/storageHelpers';
 import type { RouteName } from '../navigation/routes';
 import { showBottomSheet as globalShowBottomSheet } from '../navigation/bottomSheetManager';
+import { presentDetached, type SurfaceInstance } from '../navigation/surfaces';
 import { useQueryClient, onlineManager } from '@tanstack/react-query';
 import { clearQueryCache } from '../hooks/queryClient';
 import { useAvatarPicker } from '../hooks/useAvatarPicker';
@@ -643,6 +644,11 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   const commitSwitchedSessionRef = useRef(commitSwitchedSession);
   commitSwitchedSessionRef.current = commitSwitchedSession;
 
+  // The live AccountDialog surface (a stacked Bloom surface), while open. Held so
+  // `openAccountDialog` can no-op when already open and `closeAccountDialog` /
+  // `onSignedIn` can dismiss it. Cleared when the surface settles.
+  const accountDialogSurfaceRef = useRef<SurfaceInstance<'AccountDialog'> | null>(null);
+
   const accountDialogControllerRef = useRef<AccountDialogController | null>(null);
   if (!accountDialogControllerRef.current) {
     accountDialogControllerRef.current = createAccountDialogController({
@@ -655,7 +661,10 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       socketFactory: io,
       commitSession: (session) => handleWebSessionRef.current(session),
       commitSwitchedSession: (session) => commitSwitchedSessionRef.current(session),
-      onSignedIn: () => setAccountDialogOpen(false),
+      onSignedIn: () => {
+        accountDialogSurfaceRef.current?.dismiss();
+        setAccountDialogOpen(false);
+      },
       openUrl: (url) => {
         if (isWebBrowser()) {
           redirectToAuthorize(url);
@@ -680,11 +689,28 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const openAccountDialog = useCallback((view?: AccountDialogView): void => {
     accountDialogControllerRef.current?.setView(view ?? 'accounts');
+    // Present the AccountDialog surface on the shared Bloom stack the FIRST time
+    // (subsequent opens just re-point the controller's view above). `presentDetached`
+    // keeps it OUT of the `showBottomSheet` route-surface lineage, so closing the
+    // bottom-sheet session never touches the account dialog and vice-versa.
+    if (!accountDialogSurfaceRef.current) {
+      const instance = presentDetached(
+        'AccountDialog',
+        { initialView: view ?? 'accounts' },
+        { placement: { base: 'bottom', md: 'center' }, dismissOnBackdrop: false, maxWidth: 420 },
+      );
+      accountDialogSurfaceRef.current = instance;
+      instance.result.finally(() => {
+        if (accountDialogSurfaceRef.current === instance) accountDialogSurfaceRef.current = null;
+        setAccountDialogOpen(false);
+      });
+    }
     setAccountDialogOpen(true);
   }, []);
 
   const closeAccountDialog = useCallback((): void => {
     accountDialogControllerRef.current?.cancelSignIn();
+    accountDialogSurfaceRef.current?.dismiss();
     setAccountDialogOpen(false);
   }, []);
 

package/src/ui/navigation/__tests__/getSurfaceConfig.test.ts

@@ -0,0 +1,39 @@
+import { getSurfaceConfig, getSurfacePresentation } from '../surfaceRegistry';
+
+/**
+ * `getSurfaceConfig` resolves which Bloom surface a route is presented in. The
+ * flagship image picker (FileManagement in image-only select mode) upgrades to a
+ * full-bleed `'fullScreen'` surface that owns its own scrolling; every other
+ * route stays on the responsive `'sheet'`. These guard the routing contract.
+ */
+describe('getSurfaceConfig presentation', () => {
+    const imageOnlyPickerProps = {
+        selectMode: true,
+        disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
+    };
+
+    it('defaults every route to the responsive sheet', () => {
+        expect(getSurfaceConfig('ManageAccount', {}).presentation).toBe('sheet');
+        expect(getSurfaceConfig('AvatarCrop', {}).presentation).toBe('sheet');
+        expect(getSurfacePresentation('ManageAccount', {})).toBe('sheet');
+    });
+
+    it('routes the FileManagement image-only picker to a full-screen surface', () => {
+        const config = getSurfaceConfig('FileManagement', imageOnlyPickerProps);
+        expect(config.presentation).toBe('fullScreen');
+        // The full-bleed picker owns its own FlatList → the host must not wrap it.
+        expect(config.scrollable).toBe(false);
+    });
+
+    it('keeps FileManagement on the sheet when it is not an image-only picker', () => {
+        // Browse mode (no selectMode) — the standard file manager.
+        expect(getSurfaceConfig('FileManagement', {}).presentation).toBe('sheet');
+        // Select mode that still allows non-image types is not the flagship picker.
+        expect(
+            getSurfaceConfig('FileManagement', {
+                selectMode: true,
+                disabledMimeTypes: ['video/'],
+            }).presentation,
+        ).toBe('sheet');
+    });
+});

package/src/ui/navigation/bottomSheetManager.ts

@@ -1,88 +1,61 @@
 import type { RouteName } from './routes';
 import { isValidRoute } from './routes';
-import { createStore } from 'zustand/vanilla';
+import { getSurfacePresentation } from './surfaceRegistry';
+import { closeAllRouteSurfaces, presentRoute, topRouteSurface } from './surfaces';
 
 /**
- * Bottom Sheet State Manager
+ * Bottom-sheet manager — the INTERNAL adapter that keeps the historical
+ * `showBottomSheet` / `closeBottomSheet` API working on top of the new Bloom
+ * surface stack (`navigation/surfaces.ts`). The public signatures are unchanged;
+ * this file just re-expresses them as thin calls into the typed surface layer.
+ *
+ * The old single-surface store is gone: `showBottomSheet` now open-or-navigates
+ * the "base" (top-most) route surface, and cross-presentation targets (the
+ * full-bleed image picker) stack a NEW surface on top — Bloom coordinates the
+ * z-order / backdrop / dismiss so nothing clashes.
  */
 
-export interface BottomSheetState {
-    currentScreen: RouteName | null;
-    screenProps: Record<string, unknown>;
-    currentStep?: number;
-    history: Array<{ screen: RouteName; props: Record<string, unknown>; step?: number }>;
-    isOpen: boolean;
-    fullScreen: boolean;
-}
-
-const initialState: BottomSheetState = {
-    currentScreen: null,
-    screenProps: {},
-    currentStep: undefined,
-    history: [],
-    isOpen: false,
-    fullScreen: false,
-};
-
-export const bottomSheetStore = createStore<BottomSheetState>(() => initialState);
-
-export const getState = () => bottomSheetStore.getState();
-
+/**
+ * Open a bottom-sheet route. If the top-most active surface hosts the SAME
+ * presentation (the common all-sheets case) the route is drilled into it; a route
+ * with a different presentation (the image picker's full-bleed surface) is
+ * presented as a NEW surface on top. Opening with no active surface presents the
+ * first one.
+ *
+ * `fullScreen` is accepted for signature compatibility and ignored — a route's
+ * surface is now derived from its registry config, not a per-call flag.
+ */
 export const showBottomSheet = (
-    screenOrConfig: RouteName | { screen: RouteName; props?: Record<string, unknown>; fullScreen?: boolean },
+  screenOrConfig:
+    | RouteName
+    | { screen: RouteName; props?: Record<string, unknown>; fullScreen?: boolean },
 ): void => {
-    const screen = typeof screenOrConfig === 'string' ? screenOrConfig : screenOrConfig.screen;
-    const props = typeof screenOrConfig === 'string' ? {} : (screenOrConfig.props || {});
-    const fullScreen = typeof screenOrConfig === 'string' ? false : (screenOrConfig.fullScreen ?? false);
-
-    if (!isValidRoute(screen)) {
-        if (__DEV__) console.warn(`[BottomSheet] Invalid route: ${screen}`);
-        return;
-    }
-
-    const state = bottomSheetStore.getState();
-
-    // Push current screen to history if navigating to different screen
-    if (state.currentScreen && state.currentScreen !== screen) {
-        bottomSheetStore.setState({
-            history: [...state.history, {
-                screen: state.currentScreen,
-                props: state.screenProps,
-                step: state.currentStep,
-            }],
-        });
-    }
-
-    bottomSheetStore.setState({
-        currentScreen: screen,
-        screenProps: props,
-        currentStep: typeof props.initialStep === 'number' ? props.initialStep : undefined,
-        isOpen: true,
-        fullScreen,
-    });
+  const screen = typeof screenOrConfig === 'string' ? screenOrConfig : screenOrConfig.screen;
+  const props = typeof screenOrConfig === 'string' ? {} : screenOrConfig.props ?? {};
+
+  if (!isValidRoute(screen)) {
+    if (__DEV__) console.warn(`[BottomSheet] Invalid route: ${screen}`);
+    return;
+  }
+
+  const top = topRouteSurface();
+  if (top && top.presentation === getSurfacePresentation(screen, props)) {
+    top.navigate(screen, props);
+  } else {
+    presentRoute(screen, props);
+  }
 };
 
+/** Dismiss the whole bottom-sheet session (every active route surface). */
 export const closeBottomSheet = (): void => {
-    bottomSheetStore.setState(initialState);
+  closeAllRouteSurfaces();
 };
 
+/**
+ * Step back within the top-most surface's route history. Returns `true` when a
+ * frame was popped, `false` when the surface is already at its root frame.
+ */
 export const goBack = (): boolean => {
-    const { history } = bottomSheetStore.getState();
-
-    if (history.length > 0) {
-        const prev = history[history.length - 1];
-        bottomSheetStore.setState({
-            currentScreen: prev.screen,
-            screenProps: prev.props,
-            currentStep: prev.step,
-            history: history.slice(0, -1),
-        });
-        return true;
-    }
-
-    return false;
-};
-
-export const updateState = (updates: Partial<BottomSheetState>) => {
-    bottomSheetStore.setState((state) => ({ ...state, ...updates }));
+  const top = topRouteSurface();
+  return top ? top.goBack() : false;
 };

package/src/ui/navigation/routes.ts

@@ -1,4 +1,4 @@
-import type { ComponentType, ReactNode } from 'react';
+import type { ComponentType } from 'react';
 import type { BaseScreenProps } from '../types/navigation';
 
 // Lazy loading: Screens are loaded on-demand to break require cycles
@@ -42,7 +42,8 @@ export type RouteName =
     | 'AvatarCrop' // Square-crop editor presented before avatar upload
     | 'Notifications' // Per-channel notification preferences
     | 'ConnectedApps' // OAuth-authorized third-party apps the user can revoke
-    | 'Preferences'; // General user preferences (theme, reduce-motion, etc.)
+    | 'Preferences' // General user preferences (theme, reduce-motion, etc.)
+    | 'AccountDialog'; // Unified account switcher + sign-in surface (folded OxyAccountDialog body)
 
 // Lazy screen loaders - functions that return screen components on-demand
 // This breaks the require cycle by deferring imports until screens are actually needed
@@ -86,6 +87,10 @@ const screenLoaders: Record<RouteName, () => ComponentType<BaseScreenProps>> = {
     Notifications: () => require('../screens/NotificationsScreen').default,
     ConnectedApps: () => require('../screens/ConnectedAppsScreen').default,
     Preferences: () => require('../screens/PreferencesScreen').default,
+    // Unified account switcher + sign-in surface. Its body lives in the
+    // `OxyAccountDialog` component (folded from the standalone dialog); the
+    // surface stack provides the Dialog chrome around it.
+    AccountDialog: () => require('../components/OxyAccountDialog').default,
 };
 
 // Cache loaded components to avoid re-requiring
@@ -121,107 +126,3 @@ export const getScreenComponent = (routeName: RouteName): ComponentType<BaseScre
 export const isValidRoute = (routeName: string): routeName is RouteName => {
     return routeName in screenLoaders;
 };
-
-/**
- * Configuration that BottomSheetRouter applies to the underlying BottomSheet
- * for a given route. Adding new options here is additive — never rename or
- * remove fields without bumping the consumer surface as a breaking change.
- */
-export interface SheetRouteConfig {
-    /**
-     * Which surface hosts the route. `'sheet'` (default) renders the screen in
-     * the in-tree `BottomSheet`. `'dialog'` renders it in a responsive Bloom
-     * `<Dialog>` (bottom-sheet on narrow, centered card on `md+`) — used for the
-     * flagship image picker, which reads better as a centered panel on wide
-     * viewports than a full-width sheet. `BottomSheetRouter` keeps BOTH surfaces
-     * mounted and routes the active screen into exactly one based on this value.
-     */
-    presentation: 'sheet' | 'dialog';
-    /**
-     * When `false`, BottomSheet skips its internal ScrollView and lets the
-     * screen own scrolling. Required for screens that render a FlatList,
-     * SectionList, or any other VirtualizedList — nesting one inside a
-     * plain ScrollView breaks windowing and triggers a RN warning.
-     *
-     * Ignored for `presentation: 'dialog'` routes — those don't render in the
-     * in-tree `BottomSheet` at all.
-     */
-    scrollable: boolean;
-    /**
-     * Controls the body-pan activation strategy on the underlying bloom
-     * `BottomSheet`. `true` uses RNGH's `manualActivation` with scroll-handoff
-     * (recommended for scrollable content — the only RNGH 2.x pattern that
-     * doesn't steal vertical events from the inner scroller on Android).
-     * `false` uses an always-active body pan that gates on scroll offset.
-     *
-     * Defaults to `true` for all routes — matches the historical in-tree
-     * BottomSheet behavior. Per-route opt-out is possible if a screen needs
-     * the always-active pan instead.
-     */
-    manualActivation: boolean;
-    /**
-     * When `true`, the backdrop dims proportionally with drag distance (iOS
-     * Photos style). Defaults to `true` for all routes — matches the
-     * historical in-tree BottomSheet behavior.
-     */
-    dynamicBackdrop: boolean;
-    /**
-     * Optional custom handle slot. When provided, replaces the default
-     * 36×5 pill drag handle. The handle remains unconditionally draggable
-     * via the dedicated handle gesture (when `manualActivation` is `true`).
-     * Use sparingly — screens should default to the standard handle for
-     * platform consistency.
-     */
-    handleComponent?: () => ReactNode;
-}
-
-/**
- * Predicate matching FileManagementScreen's internal `isImageOnlyPicker`
- * derivation. When the consumer restricts to image MIME types (no videos,
- * no audio, no documents), FileManagement renders the flagship PhotoPickerView
- * which owns its own FlatList. The sheet must therefore stop scrolling
- * children. Kept in sync with `FileManagementScreen` — both check the same
- * disabled MIME type families.
- */
-const isFileManagementImageOnlyPicker = (props: Record<string, unknown>): boolean => {
-    if (!props.selectMode) return false;
-    const disabled = props.disabledMimeTypes;
-    if (!Array.isArray(disabled) || disabled.length === 0) return false;
-    const has = (predicate: (mt: string) => boolean): boolean =>
-        disabled.some((mt) => typeof mt === 'string' && predicate(mt));
-    const blocksVideos = has((mt) => mt === 'video/' || mt.startsWith('video/'));
-    const blocksAudio = has((mt) => mt === 'audio/' || mt.startsWith('audio/'));
-    const blocksDocs = has(
-        (mt) => mt === 'application/pdf' || mt === 'application/' || mt.startsWith('application/'),
-    );
-    return blocksVideos && blocksAudio && blocksDocs;
-};
-
-/** Defaults shared across all routes — preserves the historical in-tree BS UX. */
-const DEFAULT_SHEET_CONFIG: SheetRouteConfig = {
-    presentation: 'sheet',
-    scrollable: true,
-    manualActivation: true,
-    dynamicBackdrop: true,
-};
-
-/**
- * Returns the bottom-sheet configuration for a route. Defaults match the
- * pre-refactor in-tree `BottomSheet` (scrollable, manualActivation,
- * dynamicBackdrop). Routes opt out per-field as needed.
- */
-export const getSheetConfig = (
-    routeName: RouteName | null,
-    screenProps: Record<string, unknown>,
-): SheetRouteConfig => {
-    if (!routeName) return DEFAULT_SHEET_CONFIG;
-    if (routeName === 'FileManagement' && isFileManagementImageOnlyPicker(screenProps)) {
-        // The flagship photo picker renders in a responsive Bloom `<Dialog>`
-        // (bottom-sheet on narrow, centered card on `md+`) rather than the
-        // in-tree BottomSheet — it owns its own FlatList and reads better as a
-        // centered panel on wide viewports. The Dialog surface, not this
-        // config's `scrollable`, governs its scrolling.
-        return { ...DEFAULT_SHEET_CONFIG, presentation: 'dialog' };
-    }
-    return DEFAULT_SHEET_CONFIG;
-};