diff --git a/CLAUDE.md b/CLAUDE.md
index cd7c4ad..3ce597f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -123,8 +123,23 @@ is what makes a user gesture honour the interceptor — do not simplify it back.
 `driveSheetRef` retries a ref call across up to 10 `requestAnimationFrame`s,
 re-checking status each time. The store can reach a terminal status before the
 adapter mounts (a portal sheet must teleport first); a single attempt silently
-no-ops and wedges the sheet — and for `'closing'`, wedges every later open in the
-group on the `group-busy` guard.
+no-ops and wedges the sheet. A sheet stuck at `'closing'` does **not** wedge
+later opens in the group — `group-busy` is `'opening'`-only. It costs
+`closeAllAnimated` skipping it, `requestClose` answering `not-closable`, no back
+handler at all (`useIsTopmostAndOpen` needs `'open'` *and* top) and its own id
+answering `already-active` for the rest of the session.
+
+`useAdapterRef` catches up once on mount off the sheet's live status: `'open'` →
+`ref.current.expand()`, `'closing'` → `finishClosing(id)`. The coordinator
+drives status *changes*, so an adapter that replaces another under a live status
+has nobody else to drive it. `'opening'` is left to `driveSheetRef`. A fresh
+adapter cannot animate a close it never opened, so `'closing'` is ended in the
+store as in `driveSheetRef`'s give-up path — a mid-close remount ends the sheet
+without re-animating it out. `'hidden'` is deliberately excluded: a
+`switch`-parked sheet sits there *on* the stack and is restored by
+`detachFromGroup`, and `mount()` parks every persistent sheet there with its
+adapter rendered, so `finishClosing` would delete a live sheet on every
+persistent mount.
 
 Also exported publicly for adapter authors: `requestClose(id)` and
 `closeAllAnimated(groupId, opts)`.
@@ -137,7 +152,7 @@ Four maps that outlive React, which is why `resetBottomSheetRegistries()` exists
 
 | Registry | Holds | Non-obvious part |
 |---|---|---|
-| `refsMap` | adapter refs | Refs are not serializable, so they cannot live in the store. Registered **only after** the store accepts the open, or a rejected open leaks an entry nothing can reclaim. Cleaned up by `QueueItem`'s unmount. |
+| `refsMap` | adapter refs | Refs are not serializable, so they cannot live in the store. Registered **before** the store write, because that write is what schedules the `QueueItem` render which reads the map. A rejected open reclaims only the entry it created — an orphan is unreclaimable, and deleting a pre-existing one strips a live sheet. Cleaned up by `QueueItem`'s unmount. |
 | `animatedRegistry` | `SharedValue<number>` per sheet | Created **eagerly** in `open()` / `mount()` so the backdrop always finds one. `resetAnimatedIndex` rewinds to `-1` on open, so a re-opened persistent sheet does not carry last cycle's value. `getAnimatedIndex` is a pure read and never creates. |
 | `onBeforeCloseRegistry` | close interceptors | Found from outside React by `requestClose` / `handleDismiss`. Its presence also flips `preventDismiss` on the store record. |
 | `portalSessionRegistry` | monotonic counter per id | Feeds the `Portal`/`PortalHost` name. **Persists across sheet deletion on purpose** — reusing a name after a replace hits a react-native-teleport connection bug. |
@@ -198,6 +213,25 @@ backdrop below its own sheet but above the one beneath. The offset lifts the
 whole stack above arbitrary app chrome — without it any host view with a modest
 `zIndex` paints over the sheets.
 
+`BottomSheetHost` takes `SheetWrapper?: ComponentType<SheetWrapperProps>`;
+`QueueItem` renders it around an inline sheet's `content`, inside
+`BottomSheetContext`, with `getSheetRef(id)` as `sheetRef`. The render-time
+registry read is sound because `open()` registers the ref and then writes the
+store in one synchronous call, and the store write only *schedules* the render
+that mounts the item — the item's first render already sees the final entry,
+which it must, because the compiler caches the read on `id` and never re-runs
+it. An inline id is minted per open and the item's unmount cleanup removes it,
+so the value cannot change while the item is mounted; the read is guarded on
+`usePortal` because a persistent id *can* be re-registered under a
+still-mounted item. A caller-supplied inline id re-opened in the same tick as
+its removal keeps one ref object: `open()` reuses whatever is registered for the
+id, so the wrapper and the coordinator hold the same ref. The prop *value*
+must be stable for the life of the host: it is the element type, so a new value
+remounts every inline sheet (replayed open animation, a stateful wrapper's state
+gone). A derived value (`flag ? Wrapper : undefined`) breaks it even under the
+compiler, which outlines a capture-free inline arrow — hence a dev warning on
+change, not just a "module scope" line in the JSDoc.
+
 `BottomSheetBackdrop` is mounted from the sheet's first frame and faded purely by
 `animatedIndex`. Do not add a timer or delay gate: deferring the mount drops the
 opening frames the adapter already drove, and the backdrop pops in mid-fade.
diff --git a/docs/docs/api/components.md b/docs/docs/api/components.md
index c98a8ae..56c0c17 100644
--- a/docs/docs/api/components.md
+++ b/docs/docs/api/components.md
@@ -45,6 +45,45 @@ Renders the bottom sheet stack. Must be placed inside `BottomSheetManagerProvide
 Place `BottomSheetHost` **outside** of `BottomSheetScaleView` to prevent sheets from scaling.
 :::
 
+### Props
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `SheetWrapper` | `React.ComponentType<SheetWrapperProps>` | Rendered around every **inline** sheet's content, inside that sheet's context. Receives `{ id, sheetRef, children }`. Portal and persistent sheets render where they are declared and are not wrapped. The prop **value** must stay stable for the life of the host — see below. |
+
+The wrapper is used as an element **type**, so a new prop value remounts every inline sheet: the adapter replays its open animation and a stateful wrapper loses its state — an error boundary forgets that it already failed. Pass a module-scope component; an inline arrow and a derived value (`flag ? SheetErrorBoundary : undefined`, or swapping one module-scope wrapper for another) both break it, the latter on the frame the flag resolves, typically while a sheet is open. Changing the value warns once per host in dev.
+
+Use it to put an error boundary around each sheet, so one sheet failing never takes the host down. The fallback **must** render an adapter bound to `sheetRef`, so the manager keeps driving the sheet — `useBottomSheetContext().close()` still closes it. A fallback without an adapter leaves a sheet that crashes mid-close stuck at `closing`: `closeAll` skips it, `close()` answers `not-closable`, the Android back button is dead for the group, and its id is unusable until `destroyAll()`.
+
+```tsx
+class SheetErrorBoundary extends React.Component<
+  SheetWrapperProps,
+  { failed: boolean }
+> {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  render() {
+    if (!this.state.failed) {
+      return this.props.children;
+    }
+    return (
+      <CustomModalAdapter ref={this.props.sheetRef}>
+        <Text>This sheet could not be shown.</Text>
+        <CloseButton />
+      </CustomModalAdapter>
+    );
+  }
+}
+
+<BottomSheetHost SheetWrapper={SheetErrorBoundary} />;
+```
+
+An adapter that mounts while its sheet is already `open` is expanded on mount, so the fallback appears in place without extra wiring. If it mounts while the sheet is `closing`, the sheet is ended instead — a crash mid-dismissal finishes the close rather than popping the error card back up.
+
+Give the fallback no scrim of its own — the manager's backdrop is still mounted behind it, and a second dim stacks on the first. Expect one visual artefact instead: a fallback adapter that seeds its position from zero rewinds the sheet's shared `animatedIndex` to -1 on its first render, so under an open sheet the manager backdrop blanks and fades back in behind the fallback. Seed the adapter from the sheet's current status to avoid it. Note too that the crashed adapter's unmount re-enables the manager scrim through its backdrop cleanup, so a sheet that passed `backdrop={false}` gets the group backdrop back for its fallback.
+
 ---
 
 ## BottomSheetScaleView
diff --git a/docs/docs/api/types.md b/docs/docs/api/types.md
index 8d35c8b..68366e5 100644
--- a/docs/docs/api/types.md
+++ b/docs/docs/api/types.md
@@ -195,6 +195,22 @@ type SheetRef = RefObject<SheetAdapterRef | null>;
 
 ---
 
+### SheetWrapperProps
+
+```ts
+interface SheetWrapperProps {
+  id: string; // same as useBottomSheetContext().id
+  sheetRef: SheetRef | undefined; // the ref the coordinator drives; bind a fallback adapter to it
+  children: ReactNode;
+}
+```
+
+Props of the component passed to `BottomSheetHost`'s `SheetWrapper`.
+
+`sheetRef` is `undefined` when no ref is registered for the id — the wrapper still renders, but nothing drives a fallback adapter: the mount catch-up is skipped (it neither opens under `open` nor ends the sheet under `closing`) and a programmatic close removes the sheet with no exit animation.
+
+---
+
 ## Configuration Types
 
 ### ScaleConfig
diff --git a/docs/docs/custom-adapters.md b/docs/docs/custom-adapters.md
index ada0809..1f53e0d 100644
--- a/docs/docs/custom-adapters.md
+++ b/docs/docs/custom-adapters.md
@@ -292,6 +292,10 @@ const ref = useAdapterRef(forwardedRef);
 useImperativeHandle(ref, () => ({ expand: ..., close: ... }));
 ```
 
+An adapter that mounts while its sheet is already `open` is expanded once on mount, and one that mounts while the sheet is `closing` ends that sheet instead (it never opened, so it cannot animate the close out). The coordinator only reacts to status changes, so this is what lets an adapter rendered *in place of* another — an error-boundary fallback under `BottomSheetHost`'s `SheetWrapper` — come up open, or finish a dismissal it interrupted. Your adapter needs nothing extra for it beyond `useAdapterRef` + `useImperativeHandle`.
+
+An adapter that seeds its position from zero rewinds the sheet's shared `animatedIndex` on that mount, which the backdrop follows — see [`BottomSheetHost`](/api/components#bottomsheethost) for what a consumer sees and how to avoid it.
+
 ### Prop-Controlled vs Ref-Controlled Libraries
 
 **Ref-controlled** (e.g., TrueSheet with `present()`/`dismiss()`):
diff --git a/example/src/App.tsx b/example/src/App.tsx
index fd09c07..4b27ff6 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -9,6 +9,7 @@ import { KeyboardProvider } from 'react-native-keyboard-controller';
 import { SafeAreaProvider } from 'react-native-safe-area-context';
 
 import { BottomSheetDebugMonitor } from './components/BottomSheetDebugMonitor';
+import { SheetErrorBoundary } from './components/SheetErrorBoundary';
 import { UserProvider } from './context/UserContext';
 import { HomeScreen } from './screens';
 import {
@@ -37,7 +38,12 @@ export default function App() {
                 <HomeScreen />
               </UserProvider>
             </BottomSheetScaleView>
-            <BottomSheetHost />
+            {/*
+              Every inline sheet in this group renders inside
+              SheetErrorBoundary, so a sheet whose body throws is replaced by a
+              fallback sheet instead of taking the host down with it.
+            */}
+            <BottomSheetHost SheetWrapper={SheetErrorBoundary} />
             {/* Persistent sheet - always mounted, opens instantly */}
             <BottomSheetPersistent id="scanner-sheet">
               <ScannerSheet />
diff --git a/example/src/components/SheetErrorBoundary.tsx b/example/src/components/SheetErrorBoundary.tsx
new file mode 100644
index 0000000..deb05f1
--- /dev/null
+++ b/example/src/components/SheetErrorBoundary.tsx
@@ -0,0 +1,83 @@
+import { Component } from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import {
+  CustomModalAdapter,
+  useBottomSheetContext,
+  type SheetWrapperProps,
+} from 'react-native-bottom-sheet-stack';
+
+import { colors, sharedStyles } from '../styles/theme';
+import { Badge } from './Badge';
+import { Button, SecondaryButton } from './Button';
+
+/** Replaces the sheet that threw; bound to its ref, so the manager keeps driving it. */
+function FallbackSheet({
+  sheetRef,
+  onRetry,
+}: {
+  sheetRef: SheetWrapperProps['sheetRef'];
+  onRetry: () => void;
+}) {
+  const { close } = useBottomSheetContext();
+
+  return (
+    <CustomModalAdapter ref={sheetRef} contentContainerStyle={styles.content}>
+      <View style={styles.card}>
+        <Badge label="Fallback" color={colors.error} />
+        <Text style={sharedStyles.h1}>This sheet could not be shown</Text>
+        <Text style={sharedStyles.text}>
+          Its content threw while rendering. The host and every other sheet in
+          the stack are untouched — only this one was replaced.
+        </Text>
+        <View style={styles.actions}>
+          <Button title="Retry" onPress={onRetry} />
+          <SecondaryButton title="Close" onPress={close} />
+        </View>
+      </View>
+    </CustomModalAdapter>
+  );
+}
+
+/** Module scope on purpose: `QueueItem` is memoized. */
+export class SheetErrorBoundary extends Component<
+  SheetWrapperProps,
+  { failed: boolean }
+> {
+  state = { failed: false };
+
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+
+  render() {
+    if (!this.state.failed) {
+      return this.props.children;
+    }
+
+    return (
+      <FallbackSheet
+        sheetRef={this.props.sheetRef}
+        onRetry={() => this.setState({ failed: false })}
+      />
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  content: {
+    paddingHorizontal: 24,
+  },
+  card: {
+    backgroundColor: colors.surface,
+    borderRadius: 20,
+    padding: 24,
+    width: '100%',
+    borderWidth: 1,
+    borderColor: colors.border,
+    gap: 8,
+  },
+  actions: {
+    gap: 12,
+    marginTop: 12,
+  },
+});
diff --git a/example/src/components/index.ts b/example/src/components/index.ts
index 25d63a0..dda458f 100644
--- a/example/src/components/index.ts
+++ b/example/src/components/index.ts
@@ -2,3 +2,4 @@ export { Badge } from './Badge';
 export { Button, SecondaryButton, SmallButton } from './Button';
 export { DemoCard, FeatureItem } from './DemoCard';
 export { Sheet } from './Sheet';
+export { SheetErrorBoundary } from './SheetErrorBoundary';
diff --git a/example/src/screens/HomeScreen.tsx b/example/src/screens/HomeScreen.tsx
index 5c7db40..342af30 100644
--- a/example/src/screens/HomeScreen.tsx
+++ b/example/src/screens/HomeScreen.tsx
@@ -13,6 +13,7 @@ import {
   BackdropDemo,
   ContextComparisonSheet,
   ContextSheetPortal,
+  ErrorBoundaryDemoSheet,
   ForceCloseDemo,
   GroupASheet,
   HeavySheet,
@@ -216,6 +217,15 @@ export function HomeScreen() {
             onPress={() => open(<ForceCloseDemo />, { scaleBackground: true })}
           />
 
+          <DemoCard
+            title="Sheet error boundary"
+            description="Crash one inline sheet's body — a fallback sheet replaces it, the host stays up"
+            color={colors.error}
+            onPress={() =>
+              open(<ErrorBoundaryDemoSheet />, { scaleBackground: true })
+            }
+          />
+
           <DemoCard
             title="Group Isolation"
             description="Two managers, two stacks — closeAll() in one leaves the other standing"
diff --git a/example/src/sheets/ErrorBoundarySheets.tsx b/example/src/sheets/ErrorBoundarySheets.tsx
new file mode 100644
index 0000000..6ef0a9b
--- /dev/null
+++ b/example/src/sheets/ErrorBoundarySheets.tsx
@@ -0,0 +1,42 @@
+import type { BottomSheetMethods } from '@gorhom/bottom-sheet/lib/typescript/types';
+import { forwardRef, useState } from 'react';
+import { Text, View } from 'react-native';
+import { useBottomSheetContext } from 'react-native-bottom-sheet-stack';
+
+import { Badge, Button, SecondaryButton, Sheet } from '../components';
+import { colors, sharedStyles } from '../styles/theme';
+
+/** Throws after it has opened — the case the wrapper exists for. */
+export const ErrorBoundaryDemoSheet = forwardRef<BottomSheetMethods>(
+  (_, ref) => {
+    const { close } = useBottomSheetContext();
+    const [crashed, setCrashed] = useState(false);
+
+    if (crashed) {
+      throw new Error('ErrorBoundaryDemoSheet failed to render');
+    }
+
+    return (
+      <Sheet ref={ref}>
+        <Badge label="Inline" color={colors.error} />
+        <Text style={sharedStyles.h1}>Sheet error boundary</Text>
+        <Text style={sharedStyles.text}>
+          The default host wraps every inline sheet in `SheetErrorBoundary`.
+          Crash this one and a fallback sheet takes its place, bound to the same
+          ref — Retry remounts this content, Close animates the sheet out.
+          Nothing else in the stack notices.
+        </Text>
+
+        <View style={{ gap: 12, marginTop: 8 }}>
+          <Button
+            title="Crash this sheet's body"
+            onPress={() => setCrashed(true)}
+          />
+          <SecondaryButton title="Close" onPress={close} />
+        </View>
+      </Sheet>
+    );
+  }
+);
+
+ErrorBoundaryDemoSheet.displayName = 'ErrorBoundaryDemoSheet';
diff --git a/example/src/sheets/index.ts b/example/src/sheets/index.ts
index d093eb4..b027af9 100644
--- a/example/src/sheets/index.ts
+++ b/example/src/sheets/index.ts
@@ -38,3 +38,4 @@ export {
 } from './BackdropSheets';
 export { GroupASheet, GroupBSheet } from './GroupIsolationSheets';
 export { StatusDemoPanel, StatusDemoSheet } from './SheetStatusSheets';
+export { ErrorBoundaryDemoSheet } from './ErrorBoundarySheets';
diff --git a/src/BottomSheetHost.tsx b/src/BottomSheetHost.tsx
index 2fcdd53..9a9a9a4 100644
--- a/src/BottomSheetHost.tsx
+++ b/src/BottomSheetHost.tsx
@@ -1,5 +1,6 @@
-import { useEffect } from 'react';
+import { useEffect, useRef, type ComponentType, type ReactNode } from 'react';
 
+import type { SheetRef } from './adapter.types';
 import { useBottomSheetStore, useClearGroup } from './store';
 import { initBottomSheetCoordinator } from './bottomSheetCoordinator';
 import { useBottomSheetManagerContext } from './BottomSheetManager.context';
@@ -77,11 +78,61 @@ function reconcilePendingTransitions(groupId: string): () => void {
   };
 }
 
-export function BottomSheetHost() {
+export interface SheetWrapperProps {
+  id: string;
+  /**
+   * The ref the coordinator drives; bind a fallback adapter to it. `undefined`
+   * when nothing is registered for the id: the wrapper still renders, but no
+   * catch-up or programmatic close reaches its fallback adapter.
+   */
+  sheetRef: SheetRef | undefined;
+  children: ReactNode;
+}
+
+function useSheetWrapperIdentityWarning(
+  SheetWrapper?: ComponentType<SheetWrapperProps>
+) {
+  const seen = useRef({ last: SheetWrapper, warned: false });
+
+  // Compares the value instead of skipping the first run: StrictMode replays
+  // effects with the same ref object.
+  useEffect(() => {
+    const state = seen.current;
+    if (state.last === SheetWrapper) {
+      return;
+    }
+    state.last = SheetWrapper;
+
+    if (__DEV__ && !state.warned) {
+      state.warned = true;
+      console.warn(
+        '[BottomSheet] `SheetWrapper` changed between renders, which remounts ' +
+          'every inline sheet (open animation replays, a stateful wrapper loses ' +
+          'its state). Keep the value stable: a module-scope component, not an ' +
+          'inline arrow or a branch on a flag.'
+      );
+    }
+  }, [SheetWrapper]);
+}
+
+interface BottomSheetHostProps {
+  /**
+   * Wraps each inline sheet's content inside its context — the place for a
+   * per-sheet error boundary whose fallback is an adapter bound to `sheetRef`.
+   * Portal and persistent sheets are not wrapped. Keep the value stable for the
+   * life of the host: it is the element type, so a new value (an inline arrow,
+   * `flag ? Wrapper : undefined`) remounts every inline sheet; dev warns.
+   */
+  SheetWrapper?: ComponentType<SheetWrapperProps>;
+}
+
+export function BottomSheetHost({ SheetWrapper }: BottomSheetHostProps) {
   const sheetRenderData = useSheetRenderData();
   const clearGroup = useClearGroup();
   const { groupId } = useBottomSheetManagerContext();
 
+  useSheetWrapperIdentityWarning(SheetWrapper);
+
   useEffect(() => {
     const unsubscribe = initBottomSheetCoordinator(groupId);
     const cancelReconcile = reconcilePendingTransitions(groupId);
@@ -105,6 +156,7 @@ export function BottomSheetHost() {
           id={id}
           stackIndex={stackIndex}
           isActive={isActive}
+          SheetWrapper={SheetWrapper}
         />
       ))}
     </>
diff --git a/src/QueueItem.tsx b/src/QueueItem.tsx
index 915c418..495d93c 100644
--- a/src/QueueItem.tsx
+++ b/src/QueueItem.tsx
@@ -1,4 +1,9 @@
-import { memo, useEffect, type PropsWithChildren } from 'react';
+import {
+  memo,
+  useEffect,
+  type ComponentType,
+  type PropsWithChildren,
+} from 'react';
 import { StyleSheet, View } from 'react-native';
 import Animated from 'react-native-reanimated';
 import { useSafeAreaFrame } from 'react-native-safe-area-context';
@@ -15,20 +20,23 @@ import {
   useSheetUsePortal,
 } from './store';
 import { BottomSheetBackdrop } from './BottomSheetBackdrop';
+import type { SheetWrapperProps } from './BottomSheetHost';
 import { removeOnBeforeClose } from './onBeforeCloseRegistry';
-import { cleanupSheetRef } from './refsMap';
+import { cleanupSheetRef, getSheetRef } from './refsMap';
 import { useSheetScaleAnimatedStyle } from './useScaleAnimation';
 
 interface QueueItemProps {
   id: string;
   stackIndex: number;
   isActive: boolean;
+  SheetWrapper?: ComponentType<SheetWrapperProps>;
 }
 
 export const QueueItem = memo(function QueueItem({
   id,
   stackIndex,
   isActive,
+  SheetWrapper,
 }: QueueItemProps) {
   const content = useSheetContent(id);
   const usePortal = useSheetUsePortal(id);
@@ -43,6 +51,19 @@ export const QueueItem = memo(function QueueItem({
 
   const animatedIndex = getAnimatedIndex(id);
 
+  // `open()` registers the ref, then writes the store, and React only schedules
+  // the render that write causes — so this cached first read sees the entry.
+  // Guarded: a persistent id can be re-registered under a still-mounted item.
+  const sheetRef = usePortal ? undefined : getSheetRef(id);
+
+  const inlineContent = SheetWrapper ? (
+    <SheetWrapper id={id} sheetRef={sheetRef}>
+      {content}
+    </SheetWrapper>
+  ) : (
+    content
+  );
+
   useEffect(() => {
     return () => {
       cleanupSheetRef(id);
@@ -82,7 +103,7 @@ export const QueueItem = memo(function QueueItem({
           />
         ) : (
           <BottomSheetContext.Provider value={{ id }}>
-            {content}
+            {inlineContent}
           </BottomSheetContext.Provider>
         )}
       </ScaleWrapper>
diff --git a/src/__tests__/adapterRef.test.tsx b/src/__tests__/adapterRef.test.tsx
new file mode 100644
index 0000000..ebd5b83
--- /dev/null
+++ b/src/__tests__/adapterRef.test.tsx
@@ -0,0 +1,90 @@
+import { renderHook } from '@testing-library/react-native';
+
+import { BottomSheetRefContext } from '../BottomSheetRef.context';
+import { useAdapterRef } from '../useAdapterRef';
+import {
+  inSheet,
+  makeRef,
+  portal,
+  setupSheetTest,
+  stackOf,
+  statusOf,
+  store,
+} from './testUtils';
+
+setupSheetTest();
+
+describe('useAdapterRef', () => {
+  it('prefers the ref from context over the forwarded one', () => {
+    const contextRef = makeRef();
+    const forwarded = makeRef();
+    const { result } = renderHook(() => useAdapterRef(forwarded), {
+      wrapper: ({ children }) => (
+        <BottomSheetRefContext.Provider value={contextRef}>
+          {children}
+        </BottomSheetRefContext.Provider>
+      ),
+    });
+    expect(result.current).toBe(contextRef);
+  });
+
+  it('expands on mount when the sheet is already open', () => {
+    store().open(portal('a'));
+    store().markOpen('a');
+    const ref = makeRef();
+
+    renderHook(() => useAdapterRef(ref), { wrapper: inSheet('a') });
+
+    expect(ref.current.expand).toHaveBeenCalledTimes(1);
+  });
+
+  it('leaves an opening sheet to the coordinator', () => {
+    store().open(portal('a'));
+    const ref = makeRef();
+
+    renderHook(() => useAdapterRef(ref), { wrapper: inSheet('a') });
+
+    expect(ref.current.expand).not.toHaveBeenCalled();
+  });
+
+  it('ends a sheet whose adapter mounts while it is closing', () => {
+    store().open(portal('a'));
+    store().markOpen('a');
+    store().startClosing('a');
+    const ref = makeRef();
+
+    renderHook(() => useAdapterRef(ref), { wrapper: inSheet('a') });
+
+    expect(ref.current.close).not.toHaveBeenCalled();
+    expect(store().sheetsById.a).toBeUndefined();
+    expect(stackOf('g1')).toEqual([]);
+  });
+
+  it('leaves a sheet parked as hidden by switch for the store to restore', () => {
+    store().open(portal('a'));
+    store().markOpen('a');
+    store().open(portal('b'), 'switch');
+    store().markOpen('b');
+    expect(statusOf('a')).toBe('hidden');
+    const ref = makeRef();
+
+    renderHook(() => useAdapterRef(ref), { wrapper: inSheet('a') });
+
+    expect(statusOf('a')).toBe('hidden');
+    expect(stackOf('g1')).toEqual(['a', 'b']);
+
+    store().startClosing('b');
+    expect(statusOf('a')).toBe('opening');
+  });
+
+  it('does nothing for a hidden persistent sheet or outside a sheet context', () => {
+    store().mount({ id: 'p', groupId: 'g1' });
+    const hiddenRef = makeRef();
+    renderHook(() => useAdapterRef(hiddenRef), { wrapper: inSheet('p') });
+    expect(hiddenRef.current.expand).not.toHaveBeenCalled();
+
+    const bareRef = makeRef();
+    renderHook(() => useAdapterRef(bareRef));
+    expect(bareRef.current.expand).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/hooks.test.tsx b/src/__tests__/hooks.test.tsx
index 1682a86..c5eee67 100644
--- a/src/__tests__/hooks.test.tsx
+++ b/src/__tests__/hooks.test.tsx
@@ -43,16 +43,21 @@ describe('useBottomSheetManager', () => {
       store().markOpen('a');
     });
 
+    const registered = getSheetRef('a');
+
     let second: string | null = 'unset';
     act(() => {
       second = result.current.open(<Sheet />, { id: 'a' });
     });
 
     expect(second).toBeNull();
+    // The live sheet keeps the ref the coordinator drives: a rejected open
+    // reclaims only an entry it registered itself.
+    expect(getSheetRef('a')).toBe(registered);
   });
 
-  // The ref map is only cleaned up by QueueItem's unmount, which never happens
-  // for a rejected open — so registering early leaked an unreclaimable entry.
+  // Inline IDs are random and QueueItem's unmount is the map's only other
+  // cleanup, so an entry a rejected open leaves behind is unreclaimable.
   it('does not leak a ref when the open is declined', () => {
     const { result } = renderHook(() => useBottomSheetManager(), { wrapper });
 
diff --git a/src/__tests__/host.test.tsx b/src/__tests__/host.test.tsx
new file mode 100644
index 0000000..2f59a8b
--- /dev/null
+++ b/src/__tests__/host.test.tsx
@@ -0,0 +1,398 @@
+import {
+  Component,
+  createRef,
+  useEffect,
+  useImperativeHandle,
+  type ReactElement,
+  type Ref,
+} from 'react';
+import { Text } from 'react-native';
+import { SafeAreaProvider } from 'react-native-safe-area-context';
+import { act, render } from '@testing-library/react-native';
+
+import { BottomSheetHost, type SheetWrapperProps } from '../BottomSheetHost';
+import { BottomSheetManagerProvider } from '../BottomSheetManager.provider';
+import { BottomSheetPersistent } from '../BottomSheetPersistent';
+import type { SheetAdapterRef } from '../adapter.types';
+import { getSheetRef, setSheetRef } from '../refsMap';
+import { useAdapterRef } from '../useAdapterRef';
+import { useBottomSheetContext } from '../useBottomSheetContext';
+import { useBottomSheetManager } from '../useBottomSheetManager';
+import { makeRef, portal, setupSheetTest, store } from './testUtils';
+
+// QueueItem reads the frame, which the real provider gets from native.
+const initialMetrics = {
+  frame: { x: 0, y: 0, width: 390, height: 844 },
+  insets: { top: 0, left: 0, right: 0, bottom: 0 },
+};
+
+setupSheetTest();
+
+const openInline = (id: string, content: ReactElement, groupId = 'g1') => {
+  store().open({ kind: 'inline', id, groupId, content });
+  setSheetRef(id, makeRef());
+};
+
+const managerHolder = {} as { api: ReturnType<typeof useBottomSheetManager> };
+
+const ManagerProbe = () => {
+  const api = useBottomSheetManager();
+  useEffect(() => {
+    managerHolder.api = api;
+  });
+  return null;
+};
+
+const hostTree = (SheetWrapper?: React.ComponentType<SheetWrapperProps>) => (
+  <SafeAreaProvider initialMetrics={initialMetrics}>
+    <BottomSheetManagerProvider id="g1">
+      <ManagerProbe />
+      <BottomSheetHost SheetWrapper={SheetWrapper} />
+    </BottomSheetManagerProvider>
+  </SafeAreaProvider>
+);
+
+const renderHost = (SheetWrapper?: React.ComponentType<SheetWrapperProps>) =>
+  render(hostTree(SheetWrapper));
+
+const seenSheetRefs: unknown[] = [];
+const lastSeenSheetRef = () => seenSheetRefs[seenSheetRefs.length - 1];
+
+const RecordingWrapper = ({ sheetRef, children }: SheetWrapperProps) => {
+  seenSheetRefs.push(sheetRef);
+  return <>{children}</>;
+};
+
+// Stands in for an adapter, so the ref `open()` clones in carries a handle the
+// coordinator can drive. Module scope: the compiler outlines the
+// `useImperativeHandle` factory there.
+const BodyAdapter = ({
+  label,
+  ref,
+}: {
+  label: string;
+  ref?: Ref<SheetAdapterRef>;
+}) => {
+  useImperativeHandle(ref, () => ({ expand: jest.fn(), close: jest.fn() }));
+  return <Text>{label}</Text>;
+};
+
+// The coordinator queues its ref calls on requestAnimationFrame, which RN's
+// jest setup polyfills with a timeout. A frame still pending when the file ends
+// runs against a torn-down environment and fails the whole run.
+const flushFrame = () =>
+  act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  });
+
+const fallbackExpand = jest.fn();
+const fallbackClose = jest.fn();
+
+// Module scope: the compiler outlines the `useImperativeHandle` factory there,
+// so a spy declared inside a test would be out of its reach.
+const FallbackAdapter = ({
+  sheetRef,
+}: {
+  sheetRef: SheetWrapperProps['sheetRef'];
+}) => {
+  const ref = useAdapterRef(sheetRef);
+  useImperativeHandle(ref, () => ({
+    expand: fallbackExpand,
+    close: fallbackClose,
+  }));
+  return <Text>fallback</Text>;
+};
+
+const Crashable = () => {
+  const { params } = useBottomSheetContext();
+  if ((params as { crash?: boolean } | undefined)?.crash) {
+    throw new Error('boom');
+  }
+  return <Text>alive</Text>;
+};
+
+class FallbackBoundary extends Component<
+  SheetWrapperProps,
+  { failed: boolean }
+> {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  render() {
+    return this.state.failed ? (
+      <FallbackAdapter sheetRef={this.props.sheetRef} />
+    ) : (
+      this.props.children
+    );
+  }
+}
+
+describe('BottomSheetHost SheetWrapper', () => {
+  it('renders inline content unchanged when no wrapper is given', () => {
+    const screen = renderHost();
+    act(() => openInline('a', <Text>body</Text>));
+    expect(screen.getByText('body')).toBeTruthy();
+  });
+
+  it('wraps each inline sheet with the wrapper, inside the sheet context', () => {
+    const seen: Array<{ id: string; sheetRef: unknown; contextId: string }> =
+      [];
+    const Wrapper = ({ id, sheetRef, children }: SheetWrapperProps) => {
+      const context = useBottomSheetContext();
+      seen.push({ id, sheetRef, contextId: context.id });
+      return <>{children}</>;
+    };
+    const screen = renderHost(Wrapper);
+
+    act(() => openInline('a', <Text>body</Text>));
+
+    expect(screen.getByText('body')).toBeTruthy();
+    expect(seen).toHaveLength(1);
+    expect(seen[0]).toEqual({
+      id: 'a',
+      sheetRef: getSheetRef('a'),
+      contextId: 'a',
+    });
+  });
+
+  it('wraps an inline sheet with no registered ref, handing the wrapper undefined', () => {
+    const seen: Array<{ id: string; sheetRef: unknown }> = [];
+    const Wrapper = ({ id, sheetRef, children }: SheetWrapperProps) => {
+      seen.push({ id, sheetRef });
+      return <>{children}</>;
+    };
+    const screen = renderHost(Wrapper);
+
+    act(() =>
+      store().open({
+        kind: 'inline',
+        id: 'a',
+        groupId: 'g1',
+        content: <Text>body</Text>,
+      })
+    );
+
+    expect(seen).toStrictEqual([{ id: 'a', sheetRef: undefined }]);
+    expect(screen.getByText('body')).toBeTruthy();
+  });
+
+  it('does not wrap portal sheets', () => {
+    const Wrapper = jest.fn(({ children }: SheetWrapperProps) => (
+      <>{children}</>
+    ));
+    renderHost(Wrapper);
+
+    act(() => store().open(portal('p')));
+
+    expect(Wrapper).not.toHaveBeenCalled();
+  });
+
+  it('lets a boundary replace one sheet while the others stay mounted', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    class Boundary extends Component<SheetWrapperProps, { failed: boolean }> {
+      state = { failed: false };
+      static getDerivedStateFromError() {
+        return { failed: true };
+      }
+      render() {
+        return this.state.failed ? <Text>fallback</Text> : this.props.children;
+      }
+    }
+    const Throws = () => {
+      throw new Error('boom');
+    };
+    const screen = renderHost(Boundary);
+
+    act(() => {
+      openInline('a', <Text>first</Text>);
+      store().markOpen('a');
+      openInline('b', <Throws />);
+    });
+
+    expect(screen.getByText('first')).toBeTruthy();
+    expect(screen.getByText('fallback')).toBeTruthy();
+    expect(store().stackOrderByGroup.g1).toEqual(['a', 'b']);
+  });
+
+  it('drives a fallback adapter that replaces a sheet which throws after opening', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    fallbackExpand.mockClear();
+
+    const screen = renderHost(FallbackBoundary);
+    act(() => {
+      store().open({
+        kind: 'inline',
+        id: 'a',
+        groupId: 'g1',
+        content: <Crashable />,
+      });
+      setSheetRef('a', createRef<SheetAdapterRef>());
+      store().markOpen('a');
+    });
+    expect(screen.getByText('alive')).toBeTruthy();
+
+    act(() => store().updateParams('a', { crash: true }));
+
+    expect(screen.getByText('fallback')).toBeTruthy();
+    expect(getSheetRef('a')?.current?.expand).toBe(fallbackExpand);
+    expect(fallbackExpand).toHaveBeenCalledTimes(1);
+  });
+
+  it('ends a sheet whose fallback adapter mounts while it is closing', async () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    fallbackExpand.mockClear();
+    fallbackClose.mockClear();
+
+    const bodyClose = jest.fn();
+    const bodyRef = createRef<SheetAdapterRef>() as {
+      current: SheetAdapterRef | null;
+    };
+
+    renderHost(FallbackBoundary);
+    act(() => {
+      store().open({
+        kind: 'inline',
+        id: 'a',
+        groupId: 'g1',
+        content: <Crashable />,
+      });
+      setSheetRef('a', bodyRef);
+      bodyRef.current = { expand: jest.fn(), close: bodyClose };
+      store().markOpen('a');
+    });
+
+    await act(async () => {
+      store().startClosing('a');
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+    expect(bodyClose).toHaveBeenCalledTimes(1);
+    expect(store().sheetsById.a?.status).toBe('closing');
+
+    act(() => store().updateParams('a', { crash: true }));
+
+    expect(store().sheetsById.a).toBeUndefined();
+    expect(store().stackOrderByGroup.g1).toBeUndefined();
+    expect(fallbackClose).not.toHaveBeenCalled();
+    expect(fallbackExpand).not.toHaveBeenCalled();
+    expect(
+      store().open({
+        kind: 'inline',
+        id: 'a',
+        groupId: 'g1',
+        content: <Text>again</Text>,
+      })
+    ).toEqual({ opened: true, id: 'a' });
+
+    // That re-open has no adapter, so leaving it would keep the coordinator
+    // retrying past teardown.
+    act(() => store().clearGroup('g1'));
+    await flushFrame();
+  });
+});
+
+describe('registered ref identity', () => {
+  beforeEach(() => {
+    seenSheetRefs.length = 0;
+  });
+
+  it('hands the wrapper the registered ref on its first render', async () => {
+    const screen = renderHost(RecordingWrapper);
+
+    act(() => {
+      managerHolder.api.open(<BodyAdapter label="first" />, { id: 'x' });
+      store().markOpen('x');
+    });
+
+    expect(screen.getByText('first')).toBeTruthy();
+    expect(getSheetRef('x')).toBeDefined();
+    // The compiler caches the read on the item's id, so a first render that
+    // misses the entry misses it for the item's whole life.
+    expect(seenSheetRefs[0]).toBe(getSheetRef('x'));
+
+    await flushFrame();
+  });
+
+  it('hands the wrapper the registered ref when an id is re-opened in one tick', async () => {
+    const screen = renderHost(RecordingWrapper);
+
+    act(() => {
+      managerHolder.api.open(<BodyAdapter label="first" />, { id: 'x' });
+      store().markOpen('x');
+    });
+
+    expect(screen.getByText('first')).toBeTruthy();
+    expect(lastSeenSheetRef()).toBe(getSheetRef('x'));
+
+    // The item keys on the id, so it never unmounts across this pair and its
+    // cached read of the registry stands.
+    act(() => {
+      managerHolder.api.destroyAll();
+      managerHolder.api.open(<BodyAdapter label="second" />, { id: 'x' });
+    });
+
+    expect(screen.getByText('second')).toBeTruthy();
+    expect(lastSeenSheetRef()).toBe(getSheetRef('x'));
+
+    await flushFrame();
+  });
+
+  it('leaves a mounted persistent sheet its own ref when the manager opens that id', async () => {
+    render(
+      <SafeAreaProvider initialMetrics={initialMetrics}>
+        <BottomSheetManagerProvider id="g1">
+          <ManagerProbe />
+          <BottomSheetPersistent id="persistent-notepad">
+            <Text>notepad</Text>
+          </BottomSheetPersistent>
+          <BottomSheetHost />
+        </BottomSheetManagerProvider>
+      </SafeAreaProvider>
+    );
+
+    const persistentRef = getSheetRef('persistent-notepad');
+    expect(persistentRef).toBeDefined();
+
+    act(() => {
+      managerHolder.api.open(<BodyAdapter label="inline" />, {
+        id: 'persistent-notepad',
+      });
+      // The persistent sheet's own ref carries no handle here, so leaving it
+      // 'opening' would keep the coordinator retrying past teardown.
+      store().markOpen('persistent-notepad');
+    });
+
+    expect(getSheetRef('persistent-notepad')).toBe(persistentRef);
+
+    await flushFrame();
+  });
+});
+
+const StableWrapper = ({ children }: SheetWrapperProps) => <>{children}</>;
+
+const freshWrapper = () => (props: SheetWrapperProps) => <>{props.children}</>;
+
+const identityWarnings = () =>
+  (console.warn as jest.Mock).mock.calls.filter(([message]) =>
+    /changed between renders/.test(String(message))
+  );
+
+describe('SheetWrapper identity warning', () => {
+  it('warns once when the prop value changes between renders', () => {
+    const { rerender } = render(hostTree(freshWrapper()));
+
+    rerender(hostTree(freshWrapper()));
+    rerender(hostTree(freshWrapper()));
+
+    expect(identityWarnings()).toHaveLength(1);
+  });
+
+  it('stays quiet for a stable wrapper across the same re-renders', () => {
+    const { rerender } = render(hostTree(StableWrapper));
+
+    rerender(hostTree(StableWrapper));
+    rerender(hostTree(StableWrapper));
+
+    expect(identityWarnings()).toHaveLength(0);
+  });
+});
diff --git a/src/index.tsx b/src/index.tsx
index fc92ead..5746b84 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -67,6 +67,7 @@ export {
 export { useOnBeforeClose } from './useOnBeforeClose';
 
 // Types
+export type { SheetWrapperProps } from './BottomSheetHost';
 export type { BackdropConfig, BackdropComponentProps } from './backdrop.types';
 export type { ScaleConfig, ScaleAnimationConfig } from './useScaleAnimation';
 export type {
diff --git a/src/useAdapterRef.ts b/src/useAdapterRef.ts
index eac2368..3c0a169 100644
--- a/src/useAdapterRef.ts
+++ b/src/useAdapterRef.ts
@@ -1,7 +1,9 @@
-import type { ForwardedRef } from 'react';
+import { useEffect, type ForwardedRef } from 'react';
 
 import type { SheetAdapterRef, SheetRef } from './adapter.types';
+import { useMaybeBottomSheetContext } from './BottomSheet.context';
 import { useMaybeBottomSheetRef } from './BottomSheetRef.context';
+import { useBottomSheetStore } from './store';
 
 /**
  * Returns the correct ref for a custom adapter.
@@ -21,8 +23,28 @@ import { useMaybeBottomSheetRef } from './BottomSheetRef.context';
  * ```
  */
 export function useAdapterRef(
-  forwardedRef: ForwardedRef<SheetAdapterRef>
-): SheetRef | ForwardedRef<SheetAdapterRef> {
+  forwardedRef: ForwardedRef<SheetAdapterRef> | undefined
+): SheetRef | ForwardedRef<SheetAdapterRef> | undefined {
   const contextRef = useMaybeBottomSheetRef();
-  return contextRef ?? forwardedRef;
+  const ref = contextRef ?? forwardedRef;
+  const id = useMaybeBottomSheetContext()?.id;
+
+  // The coordinator drives status *changes*, so an adapter mounting under a
+  // live status has nobody to drive it: under `open` it opens itself; under
+  // `closing` it cannot animate a close it never opened, so the sheet is ended
+  // in the store, as driveSheetRef's give-up path does. Passive effect: the
+  // imperative handle is attached by then.
+  useEffect(() => {
+    if (!id || typeof ref !== 'object') {
+      return;
+    }
+    const status = useBottomSheetStore.getState().sheetsById[id]?.status;
+    if (status === 'open') {
+      ref?.current?.expand();
+    } else if (status === 'closing') {
+      useBottomSheetStore.getState().finishClosing(id);
+    }
+  }, [id, ref]);
+
+  return ref;
 }
diff --git a/src/useBottomSheetManager.tsx b/src/useBottomSheetManager.tsx
index e44504a..715ebc5 100644
--- a/src/useBottomSheetManager.tsx
+++ b/src/useBottomSheetManager.tsx
@@ -6,7 +6,7 @@ import type { CascadeOptions, CloseAllResult, CloseResult } from './store';
 import { useMaybeBottomSheetManagerContext } from './BottomSheetManager.context';
 import type { SheetAdapterRef } from './adapter.types';
 import { closeAllAnimated, requestClose } from './bottomSheetCoordinator';
-import { setSheetRef } from './refsMap';
+import { cleanupSheetRef, getSheetRef, setSheetRef } from './refsMap';
 
 export const useBottomSheetManager = () => {
   const bottomSheetManagerContext = useMaybeBottomSheetManagerContext();
@@ -44,12 +44,19 @@ export const useBottomSheetManager = () => {
       options.groupId || bottomSheetManagerContext?.groupId || 'default';
 
     const id = options.id || Math.random().toString(36);
-    const ref = React.createRef<SheetAdapterRef>();
+    // One id, one ref object: QueueItem caches its render-time read, and a
+    // persistent sheet registers its own ref on mount.
+    const existing = getSheetRef(id);
+    const ref = existing ?? React.createRef<SheetAdapterRef>();
 
     const contentWithRef = React.cloneElement(content, {
       ref,
     } as { ref: typeof ref });
 
+    // Before the store write: QueueItem reads the map in the render that
+    // write schedules.
+    setSheetRef(id, ref);
+
     const result = storeOpen(
       {
         kind: 'inline',
@@ -62,16 +69,15 @@ export const useBottomSheetManager = () => {
       options.mode
     );
 
-    // Registered only after the store accepts the sheet. The ref map is
-    // module-global and is only ever cleaned up by QueueItem's unmount — so
-    // registering before a rejected open would leak an entry that nothing can
-    // reclaim, once per rejected call, since inline IDs are random.
+    // Reclaim only what this call registered (random inline ids would leak one
+    // entry per rejection); a pre-existing ref belongs to a live sheet.
     if (!result.opened) {
+      if (!existing) {
+        cleanupSheetRef(id);
+      }
       return null;
     }
 
-    setSheetRef(id, ref);
-
     applyDeprecatedBackdrop(id, options.backdrop, setBackdrop);
 
     return id;