diff --git a/packages/vkui/src/components/AppRoot/ScrollContext.tsx b/packages/vkui/src/components/AppRoot/ScrollContext.tsx
index 48e9c103450..3e148463661 100644
--- a/packages/vkui/src/components/AppRoot/ScrollContext.tsx
+++ b/packages/vkui/src/components/AppRoot/ScrollContext.tsx
@@ -13,6 +13,7 @@ const clearDisableScrollStyle = (node: HTMLElement) => {
     top: '',
     left: '',
     right: '',
+    overscrollBehavior: '',
     overflowY: '',
     overflowX: '',
   });
@@ -117,11 +118,13 @@ export const GlobalScrollController = ({ children }: ScrollControllerProps): Rea
     const overflowY = window!.innerWidth > document!.documentElement.clientWidth ? 'scroll' : '';
     const overflowX = window!.innerHeight > document!.documentElement.clientHeight ? 'scroll' : '';
 
+    document!.documentElement.style.setProperty('overscroll-behavior', 'none');
     Object.assign(document!.body.style, {
       position: 'fixed',
       top: `-${scrollY}px`,
       left: `-${scrollX}px`,
       right: '0',
+      overscrollBehavior: 'none',
       overflowY,
       overflowX,
     });
@@ -131,6 +134,7 @@ export const GlobalScrollController = ({ children }: ScrollControllerProps): Rea
     const scrollY = document!.body.style.top;
     const scrollX = document!.body.style.left;
 
+    document!.documentElement.style.removeProperty('overscroll-behavior');
     clearDisableScrollStyle(document!.body);
     window!.scrollTo(-parseInt(scrollX || '0'), -parseInt(scrollY || '0'));
   }, [document, window]);
diff --git a/packages/vkui/src/components/ModalCard/ModalCard.e2e-playground.tsx b/packages/vkui/src/components/ModalCard/ModalCard.e2e-playground.tsx
index 00b576a1487..7fb8bd9b637 100644
--- a/packages/vkui/src/components/ModalCard/ModalCard.e2e-playground.tsx
+++ b/packages/vkui/src/components/ModalCard/ModalCard.e2e-playground.tsx
@@ -9,7 +9,7 @@ import {
 import { Button } from '../Button/Button';
 import { ButtonGroup } from '../ButtonGroup/ButtonGroup';
 import { Image } from '../Image/Image';
-import { ModalRoot } from '../ModalRoot/ModalRootAdaptive';
+import { ModalRoot } from '../ModalRoot/ModalRoot';
 import { Spacing } from '../Spacing/Spacing';
 import { Textarea } from '../Textarea/Textarea';
 import { UsersStack } from '../UsersStack/UsersStack';
diff --git a/packages/vkui/src/components/ModalCard/ModalCard.module.css b/packages/vkui/src/components/ModalCard/ModalCard.module.css
index a421a005080..ce0c5b046f5 100644
--- a/packages/vkui/src/components/ModalCard/ModalCard.module.css
+++ b/packages/vkui/src/components/ModalCard/ModalCard.module.css
@@ -1,65 +1,82 @@
 .host {
-  box-sizing: border-box;
-  position: absolute;
-  inset-block-start: 0;
-  padding: 8px;
-  inset-inline-start: 0;
+  padding: var(--vkui--spacing_size_m);
+  margin-inline: auto;
   inline-size: 100%;
-  block-size: 100%;
-  display: flex;
-  align-items: flex-end;
+  box-sizing: border-box;
 }
 
 .host:focus {
   outline: none;
 }
 
-.in {
-  inline-size: 100%;
-  margin-inline: auto;
-  transform: translateY(calc(100% + 16px));
-  transition: transform 340ms var(--vkui--animation_easing_platform);
+.hostMaxWidthS {
+  max-inline-size: 400px;
 }
 
-/**
- * iOS
- */
-
-.ios .in {
+.hostMaxWidthM {
   max-inline-size: 414px;
 }
 
-/**
- * Android + vkcom
- */
-
-.android .in {
+.hostMaxWidthL {
   max-inline-size: 440px;
 }
 
-.vkcom .in {
-  max-inline-size: 400px;
-}
+/* Mobile */
+@media (--viewWidth-smallTabletMinus) {
+  .host {
+    --vkui_internal_ModalCard--snapPoint: 100%;
+    --vkui_internal_ModalCard--safeAreaInsetBottom: var(--vkui_internal--safe_area_inset_bottom);
 
-/**
- * Desktop
- */
+    position: absolute;
+    inset-inline: 0;
+    inset-block-end: 0;
+    margin-block-end: var(--vkui_internal_ModalCard--safeAreaInsetBottom);
+    transform: translate3d(0, calc(100% - var(--vkui_internal_ModalCard--snapPoint)), 0);
+    transition: transform var(--vkui--animation_duration_l) var(--vkui--animation_easing_platform);
+  }
 
-.desktop {
-  align-items: center;
-}
+  .hostStateEnter {
+    transform: translate3d(0, 100%, 0);
+    transition-property: none;
+  }
+
+  .hostStateEntering {
+    transition-property: transform;
+    transition-delay: 0.2s;
+  }
 
-.desktop .in {
-  transform: unset;
-  opacity: 0;
-  transition: opacity 340ms var(--vkui--animation_easing_platform);
+  .hostStateExiting {
+    transform: translate3d(0, 100%, 0);
+    transition-property: transform;
+  }
+
+  .hostStateExited {
+    transform: translate3d(0, 100%, 0);
+    transition-property: transform;
+  }
 }
+/* Desktop */
+@media (--viewWidth-smallTabletPlus) {
+  .host {
+    margin-block: auto;
+    opacity: 1;
+    transition: opacity 340ms var(--vkui--animation_easing_platform);
+  }
+
+  .hostStateEnter {
+    opacity: 0;
+    transition-property: none;
+  }
+
+  .hostStateEntering {
+    opacity: 1;
+  }
+
+  .hostStateExiting {
+    opacity: 0;
+  }
 
-/**
- * CMP:
- * ModalRoot
- */
-/* stylelint-disable-next-line selector-pseudo-class-disallowed-list */
-:global(.vkuiInternalModalRoot--touched) .in {
-  transition: none;
+  .hostStateExited {
+    opacity: 0;
+  }
 }
diff --git a/packages/vkui/src/components/ModalCard/ModalCard.stories.tsx b/packages/vkui/src/components/ModalCard/ModalCard.stories.tsx
index f5af257b3b5..9e6c75371bd 100644
--- a/packages/vkui/src/components/ModalCard/ModalCard.stories.tsx
+++ b/packages/vkui/src/components/ModalCard/ModalCard.stories.tsx
@@ -1,7 +1,6 @@
 import * as React from 'react';
 import type { Meta, StoryObj } from '@storybook/react';
 import { Icon56MoneyTransferOutline, Icon56NotificationOutline } from '@vkontakte/icons';
-import { ModalWrapper } from '../../storybook/ModalWrapper';
 import { CanvasFullLayout, DisableCartesianParam } from '../../storybook/constants';
 import { getAvatarUrl } from '../../testing/mock';
 import { Avatar } from '../Avatar/Avatar';
@@ -23,17 +22,14 @@ export default story;
 
 type Story = StoryObj<ModalCardProps>;
 
-const MODAL_CARD_MONEY_SEND = 'money-send';
-const MODAL_CARD_APP_TO_MENU = 'app-to-menu';
-const MODAL_CARD_ABOUT = 'say-about';
-const MODAL_CARD_NOTIFICATIONS = 'notifications';
-const MODAL_CARD_CHAT_INVITE = 'chat-invite';
-
 export const SimpleCard: Story = {
-  render: () => (
-    <ModalWrapper modalId={MODAL_CARD_MONEY_SEND}>
+  render: function Render() {
+    const [open, setOpen] = React.useState(true);
+    const handleClose = () => setOpen(false);
+    return (
       <ModalCard
-        id={MODAL_CARD_MONEY_SEND}
+        open={open}
+        onClose={handleClose}
         icon={<Icon56MoneyTransferOutline />}
         title="Отправляйте деньги друзьям, используя банковскую карту"
         description="Номер карты получателя не нужен — он сам решит, куда зачислить средства."
@@ -43,15 +39,18 @@ export const SimpleCard: Story = {
           </Button>
         }
       />
-    </ModalWrapper>
-  ),
+    );
+  },
 };
 
 export const CardWithAvatar: Story = {
-  render: () => (
-    <ModalWrapper modalId={MODAL_CARD_APP_TO_MENU}>
+  render: function Render() {
+    const [open, setOpen] = React.useState(true);
+    const handleClose = () => setOpen(false);
+    return (
       <ModalCard
-        id={MODAL_CARD_APP_TO_MENU}
+        open={open}
+        onClose={handleClose}
         icon={<Image borderRadius="l" src={getAvatarUrl('app_zagadki', 200)} size={72} />}
         title="Добавить игру «Загадки детства» в меню?"
         description="Игра появится под списком разделов на экране меню и будет всегда под рукой."
@@ -61,15 +60,18 @@ export const CardWithAvatar: Story = {
           </Button>
         }
       />
-    </ModalWrapper>
-  ),
+    );
+  },
 };
 
 export const CardWithTextArea: Story = {
-  render: () => (
-    <ModalWrapper modalId={MODAL_CARD_ABOUT}>
+  render: function Render() {
+    const [open, setOpen] = React.useState(true);
+    const handleClose = () => setOpen(false);
+    return (
       <ModalCard
-        id={MODAL_CARD_ABOUT}
+        open={open}
+        onClose={handleClose}
         title="Расскажите о себе"
         actions={
           <Button size="l" mode="primary" stretched>
@@ -79,15 +81,18 @@ export const CardWithTextArea: Story = {
       >
         <Textarea defaultValue="В Грузии" />
       </ModalCard>
-    </ModalWrapper>
-  ),
+    );
+  },
 };
 
 export const CardWithMultipleButtons: Story = {
-  render: () => (
-    <ModalWrapper modalId={MODAL_CARD_NOTIFICATIONS}>
+  render: function Render() {
+    const [open, setOpen] = React.useState(true);
+    const handleClose = () => setOpen(false);
+    return (
       <ModalCard
-        id={MODAL_CARD_NOTIFICATIONS}
+        open={open}
+        onClose={handleClose}
         icon={<Icon56NotificationOutline />}
         title="Приложение запрашивает разрешение на отправку Вам уведомлений"
         actions={
@@ -101,15 +106,18 @@ export const CardWithMultipleButtons: Story = {
           </ButtonGroup>
         }
       />
-    </ModalWrapper>
-  ),
+    );
+  },
 };
 
 export const CardWithComplexContent: Story = {
-  render: () => (
-    <ModalWrapper modalId={MODAL_CARD_CHAT_INVITE}>
+  render: function Render() {
+    const [open, setOpen] = React.useState(true);
+    const handleClose = () => setOpen(false);
+    return (
       <ModalCard
-        id={MODAL_CARD_CHAT_INVITE}
+        open={open}
+        onClose={handleClose}
         icon={<Avatar src={getAvatarUrl('chat_basketball', 200)} size={72} />}
         title="Баскетбол на выходных"
         titleComponent="h2"
@@ -147,6 +155,6 @@ export const CardWithComplexContent: Story = {
           <br />и ещё 3 человека
         </UsersStack>
       </ModalCard>
-    </ModalWrapper>
-  ),
+    );
+  },
 };
diff --git a/packages/vkui/src/components/ModalCard/ModalCard.tsx b/packages/vkui/src/components/ModalCard/ModalCard.tsx
index ddecc3f4d5b..5cf87d87cab 100644
--- a/packages/vkui/src/components/ModalCard/ModalCard.tsx
+++ b/packages/vkui/src/components/ModalCard/ModalCard.tsx
@@ -1,91 +1,53 @@
 'use client';
 
-import * as React from 'react';
-import { classNames } from '@vkontakte/vkjs';
-import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
-import { useExternRef } from '../../hooks/useExternRef';
-import { usePlatform } from '../../hooks/usePlatform';
+import { useId } from 'react';
 import { getNavId, type NavIdProps } from '../../lib/getNavId';
 import { warnOnce } from '../../lib/warnOnce';
-import { ModalCardBase, type ModalCardBaseProps } from '../ModalCardBase/ModalCardBase';
-import { ModalRootContext, useModalRegistry } from '../ModalRoot/ModalRootContext';
-import { RootComponent } from '../RootComponent/RootComponent';
-import styles from './ModalCard.module.css';
-
-const platformClassNames = {
-  ios: styles.ios,
-  android: styles.android,
-  vkcom: styles.vkcom,
-};
-
-export interface ModalCardProps extends NavIdProps, ModalCardBaseProps {}
+import { useModalManager } from '../ModalRoot/useModalManager';
+import { ModalCardPrivate, type ModalCardPrivateProps } from './ModalCardPrivate';
 
 const warn = warnOnce('ModalCard');
 
+export interface ModalCardProps extends NavIdProps, ModalCardPrivateProps {
+  keepMounted?: boolean;
+}
+
 /**
  * @see https://vkcom.github.io/VKUI/#/ModalCard
  */
 export const ModalCard = ({
-  icon,
-  title,
-  titleComponent,
-  description,
-  descriptionComponent,
-  children,
-  actions,
-  onClose,
+  id: idProp,
   nav,
-  id,
-  size,
-  modalDismissButtonTestId,
-  getRootRef,
-  dismissButtonMode,
-  dismissLabel,
+  open = true,
+  modalOverlayTestId,
+  disableAutoFocus,
+  onOpen,
+  onOpened,
+  onClose,
+  onClosed,
+  keepMounted = false,
   ...restProps
 }: ModalCardProps): React.ReactNode => {
-  const { isDesktop } = useAdaptivityWithJSMediaQueries();
-  const platform = usePlatform();
-
-  const modalContext = React.useContext(ModalRootContext);
-  const { refs } = useModalRegistry(getNavId({ nav, id }, warn), 'card');
-  const rootRef = useExternRef(getRootRef, refs.modalElement);
-
-  const contextValue = React.useMemo(() => ({ labelId: `${id}-label` }), [id]);
+  const generatingId = useId();
+  const id = getNavId({ nav, id: idProp }, warn) || generatingId;
+
+  const { unmounted, ...resolvedProps } = useModalManager({
+    id,
+    open,
+    keepMounted,
+    modalOverlayTestId,
+    disableAutoFocus,
+    onOpen,
+    onOpened,
+    onClose,
+    onClosed,
+  });
+
+  if (unmounted) {
+    return null;
+  }
 
   return (
-    <RootComponent
-      {...restProps}
-      getRootRef={rootRef}
-      tabIndex={-1}
-      role="dialog"
-      aria-modal="true"
-      aria-labelledby={contextValue.labelId}
-      id={id}
-      baseClassName={classNames(
-        styles.host,
-        platformClassNames.hasOwnProperty(platform)
-          ? platformClassNames[platform]
-          : platformClassNames.android,
-        isDesktop && styles.desktop,
-      )}
-    >
-      <ModalCardBase
-        className={styles.in}
-        getRootRef={refs.innerElement}
-        icon={icon}
-        title={title}
-        titleComponent={titleComponent}
-        description={description}
-        descriptionComponent={descriptionComponent}
-        actions={actions}
-        onClose={onClose || modalContext.onClose}
-        size={size}
-        modalDismissButtonTestId={modalDismissButtonTestId}
-        dismissButtonMode={dismissButtonMode}
-        dismissLabel={dismissLabel}
-      >
-        {children}
-      </ModalCardBase>
-    </RootComponent>
+    <ModalCardPrivate id={id} aria-labelledby={`${id}-label`} {...resolvedProps} {...restProps} />
   );
 };
diff --git a/packages/vkui/src/components/ModalCard/ModalCardPrivate.tsx b/packages/vkui/src/components/ModalCard/ModalCardPrivate.tsx
new file mode 100644
index 00000000000..f00c0c561a1
--- /dev/null
+++ b/packages/vkui/src/components/ModalCard/ModalCardPrivate.tsx
@@ -0,0 +1,204 @@
+'use client';
+
+import * as React from 'react';
+import { classNames, noop } from '@vkontakte/vkjs';
+import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
+import { useExternRef } from '../../hooks/useExternRef';
+import { useFocusTrap } from '../../hooks/useFocusTrap';
+import { usePlatform } from '../../hooks/usePlatform';
+import { useVirtualKeyboardState } from '../../hooks/useVirtualKeyboardState';
+import { Keys, pressedKey } from '../../lib/accessibility';
+import { useCSSTransition, type UseCSSTransitionState } from '../../lib/animation';
+import { useBottomSheet, type UseBottomSheetHandlers } from '../../lib/sheet';
+import { useScrollLock } from '../AppRoot/ScrollContext';
+import { ModalCardBase, type ModalCardBaseProps } from '../ModalCardBase/ModalCardBase';
+import { ModalPageBackdrop } from '../ModalPageBackdrop/ModalPageBackdrop';
+import { ModalPageRoot } from '../ModalPageRoot/ModalPageRoot';
+import styles from './ModalCard.module.css';
+
+const sizeByPlatformClassNames = {
+  vkcom: styles['hostMaxWidthS'],
+  ios: styles['hostMaxWidthM'],
+  android: styles['hostMaxWidthL'],
+};
+
+const transitionStateClassNames: Partial<Record<UseCSSTransitionState, string>> = {
+  appear: styles['hostStateEnter'],
+  appearing: styles['hostStateEntering'],
+  appeared: undefined,
+  enter: styles['hostStateEnter'],
+  entering: styles['hostStateEntering'],
+  entered: undefined,
+  exit: undefined,
+  exiting: styles['hostStateExiting'],
+  exited: styles['hostStateExited'],
+};
+
+export interface ModalCardPrivateProps
+  extends Omit<ModalCardBaseProps, 'onTransitionEnd' | keyof UseBottomSheetHandlers> {
+  open?: boolean;
+  /**
+   * Отключает фокус на интерактивный элемент после открытия модалки.
+   */
+  disableAutoFocus?: boolean;
+  /**
+   * Отключает закрытие нажатием на кнопку ESC.
+   */
+  disableCloseOnEscKey?: boolean;
+  /**
+   * Скрывает задний фон, чтобы элементы за модальным окном были доступны.
+   */
+  disableBackdrop?: boolean;
+  /**
+   * `data-testid` для оверлея.
+   */
+  modalOverlayTestId?: string;
+  /**
+   * Будет вызвано при начале открытия модалки.
+   */
+  onOpen?: VoidFunction;
+  /**
+   * Будет вызвано при окончательном открытии модалки.
+   */
+  onOpened?: VoidFunction;
+  /**
+   * Будет вызвано при окончательном закрытии модалки.
+   */
+  onClosed?: VoidFunction;
+}
+
+/**
+ * В компоненте заложена вся логика модального окна.
+ *
+ * @private
+ */
+export const ModalCardPrivate = ({
+  icon,
+  title,
+  titleComponent,
+  description,
+  descriptionComponent,
+  children,
+  actions,
+  id,
+  size,
+  open,
+  style: styleProp,
+  className,
+  preventClose,
+  modalOverlayTestId,
+  modalDismissButtonTestId,
+  getRootRef,
+  dismissButtonMode,
+  dismissLabel,
+  disableAutoFocus,
+  disableBackdrop,
+  disableCloseOnEscKey,
+  onOpen,
+  onOpened,
+  onClose = noop,
+  onClosed,
+  ...restProps
+}: ModalCardPrivateProps): React.ReactNode => {
+  const platform = usePlatform();
+  const [transitionState, { ref, onTransitionEnd }] = useCSSTransition<HTMLDivElement>(open, {
+    enableAppear: true,
+    onEnter() {
+      onOpen?.();
+    },
+    onEntered() {
+      onOpened?.();
+    },
+    onExited() {
+      onClosed?.();
+    },
+  });
+  const opened = transitionState === 'appeared' || transitionState === 'entered';
+  const hidden = transitionState === 'exited';
+  const closable = !preventClose && opened;
+
+  const { isDesktop } = useAdaptivityWithJSMediaQueries();
+  const bottomSheetEnabled = !isDesktop && !preventClose && transitionState !== 'exited';
+
+  const [keyboardOpened, safeAreaBottomInset] = useVirtualKeyboardState(bottomSheetEnabled);
+  const [{ setSheetEl, setBackdropEl }, bottomSheetEventHandlers] = useBottomSheet(
+    bottomSheetEnabled,
+    {
+      blocked: keyboardOpened,
+      initialSnapPoint: 'auto',
+      sheetCSSProperty: '--vkui_internal_ModalCard--snapPoint',
+      backdropCSSProperty: '--vkui_internal--ModalPageBackdrop--opacity',
+      onDismiss() {
+        onClose();
+      },
+    },
+  );
+  const handleRef = useExternRef<HTMLDivElement>(setSheetEl, ref, getRootRef);
+  const style = keyboardOpened
+    ? {
+        ...styleProp,
+        '--vkui_internal_ModalCard--safeAreaInsetBottom': `${safeAreaBottomInset}px`,
+      }
+    : styleProp;
+  const backdrop = disableBackdrop ? null : (
+    <ModalPageBackdrop
+      getRootRef={setBackdropEl}
+      data-testid={modalOverlayTestId}
+      visible={open}
+      onClick={
+        closable
+          ? function handleBackdropClick() {
+              onClose();
+            }
+          : undefined
+      }
+    />
+  );
+  const handleEscKeyDown =
+    disableCloseOnEscKey || !closable
+      ? undefined
+      : (event: React.KeyboardEvent<HTMLElement>) => {
+          if (pressedKey(event) === Keys.ESCAPE) {
+            onClose();
+          }
+        };
+
+  useScrollLock(!hidden);
+  useFocusTrap(ref, { autoFocus: !disableAutoFocus, disabled: !opened || hidden });
+
+  return (
+    <ModalPageRoot hidden={hidden} onKeyDown={handleEscKeyDown}>
+      {backdrop}
+      <ModalCardBase
+        {...restProps}
+        tabIndex={-1}
+        role="dialog"
+        aria-modal="true"
+        id={id}
+        getRootRef={handleRef}
+        style={style}
+        className={classNames(
+          styles.host,
+          sizeByPlatformClassNames[platform],
+          transitionStateClassNames[transitionState],
+          className,
+        )}
+        onTransitionEnd={onTransitionEnd}
+        {...bottomSheetEventHandlers}
+        icon={icon}
+        title={title}
+        titleComponent={titleComponent}
+        description={description}
+        descriptionComponent={descriptionComponent}
+        actions={actions}
+        onClose={onClose}
+        size={size}
+        modalDismissButtonTestId={modalDismissButtonTestId}
+        dismissButtonMode={dismissButtonMode}
+        dismissLabel={dismissLabel}
+      >
+        {children}
+      </ModalCardBase>
+    </ModalPageRoot>
+  );
+};
diff --git a/packages/vkui/src/components/ModalCardBase/ModalCardBase.module.css b/packages/vkui/src/components/ModalCardBase/ModalCardBase.module.css
index a808a4207e3..d9f0a0a2211 100644
--- a/packages/vkui/src/components/ModalCardBase/ModalCardBase.module.css
+++ b/packages/vkui/src/components/ModalCardBase/ModalCardBase.module.css
@@ -4,7 +4,6 @@
   background: var(--vkui--color_background_modal);
   border-radius: 12px;
   padding: 16px;
-  margin-block-end: var(--vkui_internal--safe_area_inset_bottom);
   display: flex;
   flex-direction: column;
   justify-content: center;
diff --git a/packages/vkui/src/components/ModalCardBase/ModalCardBase.tsx b/packages/vkui/src/components/ModalCardBase/ModalCardBase.tsx
index 7915b62017a..2d68c410f5e 100644
--- a/packages/vkui/src/components/ModalCardBase/ModalCardBase.tsx
+++ b/packages/vkui/src/components/ModalCardBase/ModalCardBase.tsx
@@ -3,7 +3,6 @@
 import * as React from 'react';
 import { classNames, hasReactNode } from '@vkontakte/vkjs';
 import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
-import { useKeyboard } from '../../hooks/useKeyboard';
 import { usePlatform } from '../../hooks/usePlatform';
 import type { HTMLAttributesWithRootRef } from '../../types';
 import { AdaptivityContext } from '../AdaptivityProvider/AdaptivityContext';
@@ -106,7 +105,6 @@ export const ModalCardBase = ({
 }: ModalCardBaseProps): React.ReactNode => {
   const platform = usePlatform();
   const { isDesktop } = useAdaptivityWithJSMediaQueries();
-  const isSoftwareKeyboardOpened = useKeyboard().isOpened;
 
   const size = isDesktop ? sizeProp : undefined;
   const withSafeZone =
@@ -130,12 +128,7 @@ export const ModalCardBase = ({
         maxWidth: size,
       }}
     >
-      <div
-        className={classNames(
-          styles.container,
-          isSoftwareKeyboardOpened && styles.containerSoftwareKeyboardOpened,
-        )}
-      >
+      <div className={styles.container}>
         {hasReactNode(icon) && <div className={styles.icon}>{icon}</div>}
         {hasReactNode(title) && (
           <Title level="2" weight="2" className={styles.title} Component={titleComponent}>
diff --git a/packages/vkui/src/components/ModalPage/ModalPage.module.css b/packages/vkui/src/components/ModalPage/ModalPage.module.css
index 54cc2ad8c71..76cc72fd124 100644
--- a/packages/vkui/src/components/ModalPage/ModalPage.module.css
+++ b/packages/vkui/src/components/ModalPage/ModalPage.module.css
@@ -1,158 +1,174 @@
 .host {
-  inline-size: 100%;
-  block-size: 100%;
-  overflow: hidden;
-  position: absolute;
-  box-sizing: border-box;
-  pointer-events: none;
-}
+  --vkui_internal_ModalPage--userHeight: 100%;
+  --vkui_internal_ModalPage--desktopMaxWidth: 100%;
 
-.host:focus {
-  outline: none;
-}
-
-.desktop {
   display: flex;
-  justify-content: center;
-  align-items: center;
-}
-
-.inWrap {
   inline-size: 100%;
-  block-size: 100%;
-  position: absolute;
-  inset-inline: 0;
-  inset-block-end: 0;
+  block-size: var(--vkui_internal_ModalPage--userHeight);
   margin-inline: auto;
-  display: flex;
-  align-items: flex-end;
-  pointer-events: initial;
-  transform: translateY(100%);
-  transition: transform 320ms var(--vkui--animation_easing_platform);
+  outline: none;
+  box-sizing: border-box;
 }
 
-.ios .inWrap {
-  transition: transform 400ms var(--vkui--animation_easing_platform);
-}
+/* Mobile */
+@media (--viewWidth-smallTabletMinus) {
+  .host {
+    position: absolute;
+    inset-inline: 0;
+    inset-block-end: 0;
+    max-inline-size: var(--vkui--size_popup_small--regular);
+    pointer-events: none;
+  }
 
-.desktop .inWrap {
-  position: relative;
-  align-items: initial;
-  margin-block: 32px;
-  margin-inline: 56px;
-  block-size: auto;
-  max-block-size: 640px;
-  opacity: 0;
-  transform: none;
-  transition: opacity 340ms var(--vkui--animation_easing_platform);
-}
+  .hostSafeAreaInsetTop {
+    max-block-size: calc(100% - var(--vkui_internal--safe_area_inset_top));
+  }
 
-@media (max-height: 672px) {
-  .desktop .inWrap {
-    max-block-size: calc(100% - 32px * 2);
+  .hostSafeAreaInsetTopWithCustomOffset {
+    max-block-size: calc(
+      100% - (var(--vkui_internal--safe_area_inset_top) + var(--vkui_internal--panel_header_height))
+    );
   }
 }
+/* Desktop */
+@media (--viewWidth-smallTabletPlus) {
+  .host {
+    position: relative;
+    margin-block: auto;
+    max-inline-size: var(--vkui_internal_ModalPage--desktopMaxWidth);
+    max-block-size: calc(100% - 64px); /* FIXME 64px??? */
+    block-size: auto;
+  }
 
-.sizeS .inWrap {
-  max-inline-size: var(--vkui--size_popup_small--regular);
-}
+  .hostMaxWidthS {
+    --vkui_internal_ModalPage--desktopMaxWidth: var(--vkui--size_popup_small--regular);
+  }
 
-.sizeM .inWrap {
-  max-inline-size: var(--vkui--size_popup_medium--regular);
-}
+  .hostMaxWidthM {
+    --vkui_internal_ModalPage--desktopMaxWidth: var(--vkui--size_popup_medium--regular);
+  }
 
-.sizeL .inWrap {
-  max-inline-size: var(--vkui--size_popup_large--regular);
+  .hostMaxWidthL {
+    --vkui_internal_ModalPage--desktopMaxWidth: var(--vkui--size_popup_large--regular);
+  }
 }
 
-.in {
-  background-color: var(--vkui--color_background_modal);
-  overflow: visible;
-  position: relative;
-  box-sizing: border-box;
+.document {
+  --vkui_internal_ModalPageDocument--snapPoint: auto;
+  --vkui_internal_ModalPageDocument--safeAreaInsetBottom: var(
+    --vkui_internal--safe_area_inset_bottom
+  );
+
   inline-size: 100%;
-  block-size: 100%;
+  block-size: var(--vkui_internal_ModalPageDocument--snapPoint);
+  box-sizing: border-box;
+
+  /*
+   * Удерживает высоту в пределах 100% родителя при переполнении контента.
+   */
   display: flex;
+  flex-shrink: 1;
   flex-direction: column;
-  border-start-end-radius: var(--vkui--size_border_radius_paper--regular);
-  border-start-start-radius: var(--vkui--size_border_radius_paper--regular);
-
-  --vkui_internal--background: var(--vkui--color_background_modal);
 }
+/* Mobile */
+@media (--viewWidth-smallTabletMinus) {
+  .document {
+    position: absolute;
+    inset-inline-start: 0;
+    inset-block-end: 0;
+    max-block-size: 100%;
+    padding-block-end: var(--vkui_internal_ModalPageDocument--safeAreaInsetBottom);
+    pointer-events: auto;
+    touch-action: pan-y;
+    transition: block-size var(--vkui--animation_duration_l) cubic-bezier(0.22, 1, 0.6, 1.03);
+  }
 
-.desktop .in {
-  block-size: auto;
-  box-shadow: var(--vkui--elevation3);
-  border-end-end-radius: var(--vkui--size_border_radius_paper--regular);
-  border-end-start-radius: var(--vkui--size_border_radius_paper--regular);
-}
+  .documentStateEnter {
+    transform: translate3d(0, 100%, 0);
+    transition: none;
+  }
 
-.header {
-  inline-size: 100%;
-}
+  .documentStateEntering {
+    transform: translate3d(0, 0, 0);
+    transition: transform var(--vkui--animation_duration_l) var(--vkui--animation_easing_platform)
+      0.1s !important; /* stylelint-disable-line declaration-no-important */
+  }
 
-.contentWrap {
-  position: relative;
-  display: flex;
-  block-size: 100%;
-  flex-direction: column;
-  overflow: hidden;
-  border-end-start-radius: inherit;
-  border-end-end-radius: inherit;
-}
+  .documentStateEntered {
+    transform: translate3d(0, 0, 0);
+  }
 
-.header:empty + .contentWrap {
-  border-radius: inherit;
-}
+  .documentStateExit {
+    transform: translate3d(0, 0, 0);
+    transition: none;
+  }
 
-.content {
-  block-size: 100%;
-  overflow-y: hidden;
-  overflow-x: hidden;
-  box-sizing: border-box;
-}
+  .documentStateExiting {
+    transform: translate3d(0, 100%, 0);
+    transition: transform var(--vkui--animation_duration_l) var(--vkui--animation_easing_platform) !important; /* stylelint-disable-line declaration-no-important */
+  }
 
-/* stylelint-disable-next-line selector-pseudo-class-disallowed-list */
-.desktop .content,
-:global(.vkuiInternalModalRoot__modal--expandable) .content {
-  overflow-y: auto;
-  -webkit-overflow-scrolling: touch;
+  .documentStateExited {
+    transform: translate3d(0, 100%, 0);
+  }
 }
+/* Desktop */
+@media (--viewWidth-smallTabletPlus) {
+  .document {
+    position: relative;
+  }
 
-/* stylelint-disable-next-line selector-pseudo-class-disallowed-list */
-.desktop .contentIn,
-:global(.vkuiInternalModalRoot__modal--expandable) .contentIn {
-  block-size: 100%;
-}
+  .documentStateEnter {
+    opacity: 0;
+  }
 
-/* существует для того, чтобы использовать в расчёте translateY
- * чтобы поднять ModalPage не только на высоту контента, но и на высоту bottom-inset
- * особенно важно для ModalPage c динамической высотой
- */
-.bottomInset {
-  block-size: var(--vkui_internal--safe_area_inset_bottom);
-  flex-shrink: 0;
-}
+  .documentStateEntering {
+    opacity: 1;
+    transition: opacity 0.2s ease-in 0.1s;
+  }
 
-/**
- * CMP:
- * ModalRoot
- *
- * [дополнительно] также ищи в файле `ModalRoot__modal--expandable`
- */
-/* stylelint-disable-next-line selector-pseudo-class-disallowed-list */
-:global(.vkuiInternalModalRoot--touched) .inWrap {
-  transition: none;
-}
+  .documentStateEntered {
+    opacity: 1;
+  }
+
+  .documentStateExit {
+    opacity: 1;
+  }
 
-/* stylelint-disable-next-line selector-pseudo-class-disallowed-list */
-:global(.vkuiInternalModalRoot--switching) .inWrap {
-  pointer-events: none;
+  .documentStateExiting {
+    opacity: 0;
+    transition: opacity 0.1s ease-out;
+  }
+
+  .documentStateExited {
+    opacity: 0;
+  }
 }
 
-/* stylelint-disable-next-line selector-pseudo-class-disallowed-list */
-:global(.vkuiInternalModalRoot__modal--collapsed) .content,
-:global(.vkuiInternalModalRoot__modal--dragging) .content {
+.children {
+  inline-size: 100%;
+  block-size: 100%;
+  border-start-start-radius: var(--vkui--size_border_radius_paper--regular);
+  border-start-end-radius: var(--vkui--size_border_radius_paper--regular);
+  background-color: var(--vkui--color_background_modal);
   overflow: hidden;
-  touch-action: pan-y;
+
+  /*
+   * Удерживает высоту в пределах 100% родителя при переполнении контента.
+   *
+   * - см. `ModalPageHeader`
+   * - см. `ModalPageContent`
+   * - см. `ModalPageFooter`
+   */
+  display: flex;
+  flex-shrink: 1;
+  flex-direction: column;
+}
+/* Desktop */
+@media (--viewWidth-smallTabletPlus) {
+  .children {
+    border-end-end-radius: var(--vkui--size_border_radius_paper--regular);
+    border-end-start-radius: var(--vkui--size_border_radius_paper--regular);
+    box-shadow: var(--vkui--elevation3);
+  }
 }
diff --git a/packages/vkui/src/components/ModalPage/ModalPage.stories.tsx b/packages/vkui/src/components/ModalPage/ModalPage.stories.tsx
index b54a6bcc6a5..1bb0635c61e 100644
--- a/packages/vkui/src/components/ModalPage/ModalPage.stories.tsx
+++ b/packages/vkui/src/components/ModalPage/ModalPage.stories.tsx
@@ -3,28 +3,35 @@ import type { Meta, StoryObj } from '@storybook/react';
 import { Icon24Dismiss, Icon56MoneyTransferOutline } from '@vkontakte/icons';
 import { useAdaptivityConditionalRender } from '../../hooks/useAdaptivityConditionalRender';
 import { usePlatform } from '../../hooks/usePlatform';
-import { ModalWrapper } from '../../storybook/ModalWrapper';
 import { CanvasFullLayout, DisableCartesianParam } from '../../storybook/constants';
-import { getRandomUser, getRandomUsers } from '../../testing/mock';
+import { cities, getRandomUser, getRandomUsers } from '../../testing/mock';
 import { Avatar } from '../Avatar/Avatar';
+import { Button } from '../Button/Button';
+import { Card } from '../Card/Card';
+import { CardScroll } from '../CardScroll/CardScroll';
 import { CellButton } from '../CellButton/CellButton';
 import { Checkbox } from '../Checkbox/Checkbox';
+import { CustomSelect } from '../CustomSelect/CustomSelect';
 import { DatePicker } from '../DatePicker/DatePicker';
+import { Div } from '../Div/Div';
 import { FormItem } from '../FormItem/FormItem';
 import { Gradient } from '../Gradient/Gradient';
 import { Group } from '../Group/Group';
 import { Header } from '../Header/Header';
+import { HorizontalCell } from '../HorizontalCell/HorizontalCell';
+import { HorizontalScroll } from '../HorizontalScroll/HorizontalScroll';
 import { Input } from '../Input/Input';
+import { ModalPageFooter } from '../ModalPageFooter/ModalPageFooter';
 import { ModalPageHeader } from '../ModalPageHeader/ModalPageHeader';
-import { ModalRootContext } from '../ModalRoot/ModalRootContext';
 import { PanelHeaderButton } from '../PanelHeaderButton/PanelHeaderButton';
 import { PanelHeaderClose } from '../PanelHeaderClose/PanelHeaderClose';
 import { PanelHeaderSubmit } from '../PanelHeaderSubmit/PanelHeaderSubmit';
 import { Placeholder } from '../Placeholder/Placeholder';
 import { Radio } from '../Radio/Radio';
+import { SegmentedControl } from '../SegmentedControl/SegmentedControl';
 import { SelectMimicry } from '../SelectMimicry/SelectMimicry';
 import { SimpleCell } from '../SimpleCell/SimpleCell';
-import { ModalPage, type ModalPageProps } from './ModalPage';
+import { type CloseEventPayload, ModalPage, type ModalPageProps } from './ModalPage';
 
 const story: Meta<ModalPageProps> = {
   title: 'Modals/ModalPage',
@@ -36,29 +43,20 @@ export default story;
 
 type Story = StoryObj<ModalPageProps>;
 
-const MODAL_PAGE_FILTERS = 'filters';
-const MODAL_PAGE_FULLSCREEN = 'fullscreen';
-const MODAL_PAGE_DYNAMIC = 'dynamic';
 const randomUser = getRandomUser();
 const users = getRandomUsers(25);
 
-const DoneButton = () => {
-  const { onClose } = React.useContext(ModalRootContext);
-
-  return <PanelHeaderSubmit onClick={onClose} />;
+const DoneButton = ({ onClick }: React.ComponentProps<'div'>) => {
+  return <PanelHeaderSubmit onClick={onClick} />;
 };
 
-const AndroidCloseButton = ({ className }: { className?: string }) => {
-  const { onClose } = React.useContext(ModalRootContext);
-
-  return <PanelHeaderClose className={className} onClick={onClose} />;
+const AndroidCloseButton = ({ className, onClick }: React.ComponentProps<'div'>) => {
+  return <PanelHeaderClose className={className} onClick={onClick} />;
 };
 
-const IosCloseButton = ({ className }: { className?: string }) => {
-  const { onClose } = React.useContext(ModalRootContext);
-
+const IosCloseButton = ({ className, onClick }: React.ComponentProps<'div'>) => {
   return (
-    <PanelHeaderButton onClick={onClose} className={className}>
+    <PanelHeaderButton onClick={onClick} className={className}>
       <Icon24Dismiss />
     </PanelHeaderButton>
   );
@@ -71,32 +69,43 @@ export const DynamicModalPage: Story = {
     const [expanded, setExpanded] = React.useState(false);
     const toggle = React.useCallback(() => setExpanded(!expanded), [expanded]);
 
+    const [open, setOpen] = React.useState(true);
+    const handleButtonClick = () => {
+      setOpen(false);
+    };
+
     return (
-      <ModalWrapper modalId={MODAL_PAGE_DYNAMIC}>
-        <ModalPage
-          id={MODAL_PAGE_DYNAMIC}
-          dynamicContentHeight
-          header={
-            <ModalPageHeader
-              before={
-                sizeX.compact &&
-                platform === 'android' && <AndroidCloseButton className={sizeX.compact.className} />
-              }
-              after={
-                sizeX.compact &&
-                platform === 'ios' && <IosCloseButton className={sizeX.compact.className} />
-              }
-            >
-              Dynamic modal
-            </ModalPageHeader>
-          }
-        >
-          <Group>
-            <CellButton onClick={toggle}>{expanded ? 'collapse' : 'expand'}</CellButton>
-            {expanded && <Placeholder icon={<Icon56MoneyTransferOutline />} />}
-          </Group>
-        </ModalPage>
-      </ModalWrapper>
+      <ModalPage
+        open={open}
+        dynamicContentHeight
+        header={
+          <ModalPageHeader
+            before={
+              sizeX.compact &&
+              platform === 'android' && (
+                <AndroidCloseButton
+                  className={sizeX.compact.className}
+                  onClick={handleButtonClick}
+                />
+              )
+            }
+            after={
+              sizeX.compact &&
+              platform === 'ios' && (
+                <IosCloseButton className={sizeX.compact.className} onClick={handleButtonClick} />
+              )
+            }
+          >
+            Dynamic modal
+          </ModalPageHeader>
+        }
+        onClose={() => setOpen(false)}
+      >
+        <Group>
+          <CellButton onClick={toggle}>{expanded ? 'collapse' : 'expand'}</CellButton>
+          {expanded && <Placeholder icon={<Icon56MoneyTransferOutline />} />}
+        </Group>
+      </ModalPage>
     );
   },
 };
@@ -106,123 +115,327 @@ export const FullscreenModalPage: Story = {
     const platform = usePlatform();
     const { sizeX } = useAdaptivityConditionalRender();
 
+    const [open, setOpen] = React.useState(true);
+    const handleButtonClick = () => {
+      setOpen(false);
+    };
+
     return (
-      <ModalWrapper modalId={MODAL_PAGE_FULLSCREEN}>
-        <ModalPage
-          id={MODAL_PAGE_FULLSCREEN}
-          settlingHeight={100}
-          hideCloseButton={platform === 'ios'}
+      <ModalPage
+        open={open}
+        settlingHeight={100}
+        hideCloseButton={platform === 'ios'}
+        header={
+          <ModalPageHeader
+            before={
+              sizeX.compact &&
+              platform === 'android' && (
+                <AndroidCloseButton
+                  className={sizeX.compact.className}
+                  onClick={handleButtonClick}
+                />
+              )
+            }
+            after={platform === 'ios' && <IosCloseButton onClick={handleButtonClick} />}
+          >
+            @{randomUser.screen_name}
+          </ModalPageHeader>
+        }
+        onClose={() => setOpen(false)}
+      >
+        <Gradient mode="tint">
+          <Placeholder
+            icon={<Avatar size={96} src={randomUser.photo_100} />}
+            title={randomUser.first_name + ' ' + randomUser.last_name}
+          ></Placeholder>
+        </Gradient>
+        <Group
           header={
-            <ModalPageHeader
-              before={
-                sizeX.compact &&
-                platform === 'android' && <AndroidCloseButton className={sizeX.compact.className} />
-              }
-              after={platform === 'ios' && <IosCloseButton />}
-            >
-              @{randomUser.screen_name}
-            </ModalPageHeader>
+            <Header mode="secondary" indicator="25">
+              Друзья
+            </Header>
           }
         >
-          <Gradient mode="tint">
-            <Placeholder
-              icon={<Avatar size={96} src={randomUser.photo_100} />}
-              title={randomUser.first_name + ' ' + randomUser.last_name}
-            ></Placeholder>
-          </Gradient>
-          <Group
-            header={
-              <Header mode="secondary" indicator="25">
-                Друзья
-              </Header>
+          {users.map((user) => {
+            return (
+              <SimpleCell before={<Avatar src={user.photo_100} />} key={user.id}>
+                {user.name}
+              </SimpleCell>
+            );
+          })}
+        </Group>
+      </ModalPage>
+    );
+  },
+};
+
+export const ModalPageWithFilters: Story = {
+  render: function Render() {
+    const { sizeX } = useAdaptivityConditionalRender();
+    const [open, setOpen] = React.useState(true);
+    const handleButtonClick = () => {
+      setOpen(false);
+    };
+
+    return (
+      <ModalPage
+        open={open}
+        header={
+          <ModalPageHeader
+            before={
+              sizeX.compact && (
+                <AndroidCloseButton
+                  className={sizeX.compact.className}
+                  onClick={handleButtonClick}
+                />
+              )
             }
+            after={<DoneButton onClick={handleButtonClick} />}
           >
-            {users.map((user) => {
-              return (
-                <SimpleCell before={<Avatar src={user.photo_100} />} key={user.id}>
-                  {user.name}
-                </SimpleCell>
-              );
-            })}
-          </Group>
-        </ModalPage>
-      </ModalWrapper>
+            Фильтры
+          </ModalPageHeader>
+        }
+        onClose={() => setOpen(false)}
+      >
+        <Group>
+          <FormItem top="Страна">
+            <SelectMimicry placeholder="Выбрать страну" />
+          </FormItem>
+          <FormItem top="Город">
+            <SelectMimicry placeholder="Выбрать город" disabled />
+          </FormItem>
+        </Group>
+        <Group>
+          <FormItem top="Пол">
+            <Radio name="sex" value={0} defaultChecked>
+              Любой
+            </Radio>
+            <Radio name="sex" value={1}>
+              Мужской
+            </Radio>
+            <Radio name="sex" value={2}>
+              Женский
+            </Radio>
+          </FormItem>
+        </Group>
+        <Group>
+          <FormItem top="Школа">
+            <SelectMimicry placeholder="Выбрать школу" disabled />
+          </FormItem>
+          <FormItem top="Университет">
+            <SelectMimicry placeholder="Выбрать университет" disabled />
+          </FormItem>
+        </Group>
+        <Group>
+          <FormItem top="Дополнительно">
+            <Checkbox>С фотографией</Checkbox>
+            <Checkbox>Сейчас на сайте</Checkbox>
+          </FormItem>
+        </Group>
+        <Group>
+          <FormItem top="Работа">
+            <Input placeholder="Место работы" />
+          </FormItem>
+          <FormItem>
+            <Input placeholder="Должность" />
+          </FormItem>
+
+          <FormItem top="Дата рождения">
+            <DatePicker
+              min={{ day: 1, month: 1, year: 1901 }}
+              max={{ day: 1, month: 1, year: 2006 }}
+              dayPlaceholder="Д"
+              monthPlaceholder="ММ"
+              yearPlaceholder="ГГ"
+            />
+          </FormItem>
+        </Group>
+      </ModalPage>
     );
   },
 };
 
-export const ModalPageWithFilters: Story = {
+export const Sandbox: Story = {
   render: function Render() {
+    const platform = usePlatform();
     const { sizeX } = useAdaptivityConditionalRender();
+    const [open, setOpen] = React.useState(true);
+    const [expanded, setExpanded] = React.useState(false);
+    const commonFriends = React.useMemo(() => getRandomUsers(30), []);
+    const toggle = React.useCallback(() => setExpanded(!expanded), [expanded]);
+
+    const [settlingHeight, setSettlingHeight] = React.useState(50);
+
+    const handleModalClose = (event?: CloseEventPayload) => {
+      // eslint-disable-next-line no-console
+      console.log('reason', event?.reason);
+      setOpen(false);
+    };
 
     return (
-      <ModalWrapper modalId={MODAL_PAGE_FILTERS}>
+      <>
+        <Button onClick={() => setOpen((prev) => !prev)}>Открыть модалку</Button>
         <ModalPage
-          id={MODAL_PAGE_FILTERS}
+          id="test"
+          open={open}
           header={
             <ModalPageHeader
-              before={sizeX.compact && <AndroidCloseButton className={sizeX.compact.className} />}
-              after={<DoneButton />}
+              before={
+                sizeX.compact &&
+                platform === 'android' && (
+                  <AndroidCloseButton
+                    className={sizeX.compact.className}
+                    onClick={() => handleModalClose()}
+                  />
+                )
+              }
+              after={
+                sizeX.compact &&
+                platform === 'ios' && (
+                  <IosCloseButton
+                    className={sizeX.compact.className}
+                    onClick={() => handleModalClose()}
+                  />
+                )
+              }
             >
-              Фильтры
+              Dynamic modal
             </ModalPageHeader>
           }
+          footer={
+            <ModalPageFooter>
+              <Input name="footer" type="text" placeholder="message" />
+            </ModalPageFooter>
+          }
+          settlingHeight={settlingHeight}
+          height="100%"
+          // dynamicContentHeight
+          onClose={handleModalClose}
         >
-          <Group>
-            <FormItem top="Страна">
-              <SelectMimicry placeholder="Выбрать страну" />
-            </FormItem>
-            <FormItem top="Город">
-              <SelectMimicry placeholder="Выбрать город" disabled />
-            </FormItem>
-          </Group>
-          <Group>
-            <FormItem top="Пол">
-              <Radio name="sex" value={0} defaultChecked>
-                Любой
-              </Radio>
-              <Radio name="sex" value={1}>
-                Мужской
-              </Radio>
-              <Radio name="sex" value={2}>
-                Женский
-              </Radio>
-            </FormItem>
-          </Group>
-          <Group>
-            <FormItem top="Школа">
-              <SelectMimicry placeholder="Выбрать школу" disabled />
-            </FormItem>
-            <FormItem top="Университет">
-              <SelectMimicry placeholder="Выбрать университет" disabled />
-            </FormItem>
-          </Group>
-          <Group>
-            <FormItem top="Дополнительно">
-              <Checkbox>С фотографией</Checkbox>
-              <Checkbox>Сейчас на сайте</Checkbox>
-            </FormItem>
-          </Group>
-          <Group>
-            <FormItem top="Работа">
-              <Input placeholder="Место работы" />
+          <FormItem top="settlingHeight">
+            <SegmentedControl
+              options={[
+                { label: '50%', value: 50 },
+                { label: '100%', value: 100 },
+              ]}
+              onChange={(value) => setSettlingHeight(value as number)}
+            />
+          </FormItem>
+          <Div>
+            <Div
+              style={{ borderRadius: 12, border: '1px solid tomato' }}
+              onTouchStart={(e) => {
+                e.stopPropagation();
+              }}
+            >
+              <code>event.stopPropagation()</code> zone
+            </Div>
+          </Div>
+          <div>
+            <FormItem label="top">
+              <Input name="top" placeholder="Some text top" />
             </FormItem>
+            <Group header={<Header mode="secondary">Недавние</Header>}>
+              <HorizontalScroll>
+                <div style={{ display: 'flex' }}>
+                  {commonFriends.map((item) => {
+                    return (
+                      <HorizontalCell key={item.id} title={item.first_name}>
+                        <Avatar size={56} src={item.photo_200} />
+                      </HorizontalCell>
+                    );
+                  })}
+                </div>
+              </HorizontalScroll>
+            </Group>
             <FormItem>
-              <Input placeholder="Должность" />
+              <CustomSelect
+                options={cities}
+                placeholder="forceDropdownPortal={false}"
+                forceDropdownPortal={false}
+              />
             </FormItem>
-
-            <FormItem top="Дата рождения">
-              <DatePicker
-                min={{ day: 1, month: 1, year: 1901 }}
-                max={{ day: 1, month: 1, year: 2006 }}
-                dayPlaceholder="Д"
-                monthPlaceholder="ММ"
-                yearPlaceholder="ГГ"
+            <FormItem>
+              <CustomSelect
+                options={cities}
+                placeholder="forceDropdownPortal={true}"
+                forceDropdownPortal={true}
               />
             </FormItem>
-          </Group>
+            <Div>
+              But I must explain to you how all this mistaken idea of denouncing pleasure and
+              praising pain was born and I will give you a complete account of the system, and
+              expound the
+            </Div>
+            <CardScroll>
+              {Array(50)
+                .fill(null)
+                .map((_, index) => (
+                  <Card key={index}>
+                    <div style={{ height: 96 }} />
+                  </Card>
+                ))}
+            </CardScroll>
+            <CellButton onClick={toggle}>{expanded ? 'Show more' : 'Hide more'}</CellButton>
+            {expanded && (
+              <Div>
+                actual teachings of the great explorer of the truth, the master-builder of human
+                happiness. No one rejects, dislikes, or avoids pleasure itself, because it is
+                pleasure, but because those who do not know how to pursue pleasure rationally
+                encounter consequences that are extremely painful. Nor again is there anyone who
+                loves or pursues or desires to obtain pain of itself, because it is pain, but
+                because occasionally circumstances occur in which toil and pain can procure him some
+                great pleasure. To take a trivial example, which of us ever undertakes laborious
+                physical exercise, except to obtain some advantage from it? But who has any right to
+                find fault with a man who chooses to enjoy a pleasure that has no annoying
+                consequences, or one who avoids a pain that produces no resultant pleasure? But I
+                must explain to you how all this mistaken idea of denouncing pleasure and praising
+                pain was born and I will give you a complete account of the system, and expound the
+                actual teachings of the great explorer of the truth, the master-builder of human
+                happiness. No one rejects, dislikes, or avoids pleasure itself, because it is
+                pleasure, but because those who do not know how to pursue pleasure rationally
+                encounter consequences that are extremely painful. Nor again is there anyone who
+                loves or pursues or desires to obtain pain of itself, because it is pain, but
+                because occasionally circumstances occur in which toil and pain can procure him some
+                great pleasure. To take a trivial example, which of us ever undertakes laborious
+                physical exercise, except to obtain some advantage from it? But who has any right to
+                find fault with a man who chooses to enjoy a pleasure that has no annoying
+                consequences, or one who avoids a pain that produces no resultant pleasure? But I
+                must explain to you how all this mistaken idea of denouncing pleasure and praising
+                pain was born and I will give you a complete account of the system, and expound the
+                actual teachings of the great explorer of the truth, the master-builder of human
+                <FormItem>
+                  <Input name="middle" placeholder="Some text" />
+                </FormItem>
+                happiness. No one rejects, dislikes, or avoids pleasure itself, because it is
+                pleasure, but because those who do not know how to pursue pleasure rationally
+                encounter consequences that are extremely painful. Nor again is there anyone who
+                loves or pursues or desires to obtain pain of itself, because it is pain, but
+                because occasionally circumstances occur in which toil and pain can procure him some
+                great pleasure. To take a trivial example, which of us ever undertakes laborious
+                physical exercise, except to obtain some advantage from it? But who has any right to
+                find fault with a man who chooses to enjoy a pleasure that has no annoying
+                consequences, or one who avoids a pain that produces no resultant pleasure? But I
+                must explain to you how all this mistaken idea of denouncing pleasure and praising
+                pain was born and I will give you a complete account of the system, and expound the
+                actual teachings of the great explorer of the truth, the master-builder of human
+                happiness. No one rejects, dislikes, or avoids pleasure itself, because it is
+                pleasure, but because those who do not know how to pursue pleasure rationally
+                encounter consequences that are extremely painful. Nor again is there anyone who
+                loves or pursues or desires to obtain pain of itself, because it is pain, but
+                because occasionally circumstances occur in which toil and pain can procure him some
+                great pleasure. To take a trivial example, which of us ever undertakes laborious
+                physical exercise, except to obtain some advantage from it? But who has any right to
+                find fault with a man who chooses to enjoy a pleasure that has no annoying
+                consequences, or one who avoids a pain that produces no resultant pleasure?
+              </Div>
+            )}
+            <FormItem label="bottom">
+              <Input name="bottom" placeholder="Some text bottom" />
+            </FormItem>
+          </div>
         </ModalPage>
-      </ModalWrapper>
+      </>
     );
   },
 };
diff --git a/packages/vkui/src/components/ModalPage/ModalPage.test.tsx b/packages/vkui/src/components/ModalPage/ModalPage.test.tsx
index 8312f83bd70..cce29437d50 100644
--- a/packages/vkui/src/components/ModalPage/ModalPage.test.tsx
+++ b/packages/vkui/src/components/ModalPage/ModalPage.test.tsx
@@ -1,9 +1,9 @@
-import { render, screen } from '@testing-library/react';
+import { render } from '@testing-library/react';
 import { baselineComponent } from '../../testing/utils';
 import { ConfigProvider } from '../ConfigProvider/ConfigProvider';
 import { ModalPage } from './ModalPage';
 
-describe('ModalPage', () => {
+describe(ModalPage, () => {
   baselineComponent((props) => <ModalPage nav="id" {...props} />, {
     // TODO [a11y]: "ARIA dialog and alertdialog nodes should have an accessible name (aria-dialog-name)"
     //              https://dequeuniversity.com/rules/axe/4.5/aria-dialog-name?application=axeAPI
@@ -11,13 +11,13 @@ describe('ModalPage', () => {
   });
 
   test('testid for modal page content', () => {
-    const { rerender } = render(<ModalPage nav="id" />);
+    const result = render(<ModalPage nav="id" />);
 
-    expect(screen.queryByTestId('modal-page-id')).not.toBeTruthy();
-    expect(screen.queryByTestId('modal-content-id')).not.toBeTruthy();
-    expect(screen.queryByTestId('modal-dismiss-button')).not.toBeTruthy();
+    expect(result.queryByTestId('modal-page-id')).not.toBeTruthy();
+    expect(result.queryByTestId('modal-content-id')).not.toBeTruthy();
+    expect(result.queryByTestId('modal-dismiss-button')).not.toBeTruthy();
 
-    rerender(
+    result.rerender(
       <ModalPage
         nav="id"
         data-testid="modal-page-id"
@@ -26,16 +26,16 @@ describe('ModalPage', () => {
       />,
     );
 
-    expect(screen.queryByTestId('modal-page-id')).toBeTruthy();
-    expect(screen.queryByTestId('modal-content-id')).toBeTruthy();
-    expect(screen.queryByTestId('modal-dismiss-button')).not.toBeTruthy();
+    expect(result.queryByTestId('modal-page-id')).toBeTruthy();
+    expect(result.queryByTestId('modal-content-id')).toBeTruthy();
+    expect(result.queryByTestId('modal-dismiss-button')).not.toBeTruthy();
 
-    rerender(
+    result.rerender(
       <ConfigProvider platform="vkcom">
         <ModalPage nav="id" modalDismissButtonTestId="modal-dismiss-button" />
       </ConfigProvider>,
     );
 
-    expect(screen.queryByTestId('modal-dismiss-button')).toBeTruthy();
+    expect(result.queryByTestId('modal-dismiss-button')).toBeTruthy();
   });
 });
diff --git a/packages/vkui/src/components/ModalPage/ModalPage.tsx b/packages/vkui/src/components/ModalPage/ModalPage.tsx
index 1c82f365de4..ba3ab23b2ec 100644
--- a/packages/vkui/src/components/ModalPage/ModalPage.tsx
+++ b/packages/vkui/src/components/ModalPage/ModalPage.tsx
@@ -1,184 +1,66 @@
 'use client';
 
-import * as React from 'react';
-import { classNames } from '@vkontakte/vkjs';
-import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
-import { useExternRef } from '../../hooks/useExternRef';
-import { useOrientationChange } from '../../hooks/useOrientationChange';
-import { usePlatform } from '../../hooks/usePlatform';
+import { useId } from 'react';
 import { getNavId, type NavIdProps } from '../../lib/getNavId';
-import { multiRef } from '../../lib/utils';
 import { warnOnce } from '../../lib/warnOnce';
-import type { HTMLAttributesWithRootRef } from '../../types';
-import { ModalDismissButton } from '../ModalDismissButton/ModalDismissButton';
-import { ModalRootContext, useModalRegistry } from '../ModalRoot/ModalRootContext';
-import { RootComponent } from '../RootComponent/RootComponent';
+import { useModalManager } from '../ModalRoot/useModalManager';
 import { ModalPageContext } from './ModalPageContext';
-import styles from './ModalPage.module.css';
+import { ModalPagePrivate } from './ModalPagePrivate';
+import type { ModalPagePrivateProps } from './types';
 
-const sizeClassName = {
-  s: styles.sizeS,
-  m: styles.sizeM,
-  l: styles.sizeL,
-};
+const warn = warnOnce('ModalPage');
 
-export interface ModalPageProps extends HTMLAttributesWithRootRef<HTMLDivElement>, NavIdProps {
-  /**
-   * Шапка модальной страницы, `<ModalPageHeader />`
-   */
-  header?: React.ReactNode;
-  /**
-   * Задаёт контенту максимальную ширину для десктопной версии.
-   */
-  size?: 's' | 'm' | 'l' | number;
-  /**
-   * Задаёт модальному окну фиксированную высоту.
-   * Можно передать числовое значение в пикселях, а можно строкой, в том числе и в процентах "50%".
-   * В мобильной версии 'settlingHeight' будет считаться относительно заданного height.
-   */
-  height?: string | number;
-  /**
-   * Будет вызвано при начале открытия модалки.
-   */
-  onOpen?: VoidFunction;
-  /**
-   * Будет вызвано при окончательном открытии модалки.
-   */
-  onOpened?: VoidFunction;
-  /**
-   * Будет вызвано при начале закрытия модалки.
-   */
-  onClose?: VoidFunction;
-  /**
-   * Будет вызвано при окончательном закрытии модалки.
-   */
-  onClosed?: VoidFunction;
-  /**
-   * Процент, на который изначально будет открыта модальная страница. При `settlingHeight={100}` модальная страница раскрывается на всю высоту.
-   */
-  settlingHeight?: number;
-  /**
-   * Если высота контента в модальной странице может поменяться, нужно установить это свойство
-   */
-  dynamicContentHeight?: boolean;
-  getModalContentRef?: React.Ref<HTMLDivElement>;
-  /**
-   * Скрывает кнопку закрытия (актуально для iOS, т.к. можно отрисовать кнопку закрытия внутри модалки)
-   */
-  hideCloseButton?: boolean;
-  modalContentTestId?: string;
-  /**
-   * `data-testid` для кнопки закрытия
-   */
-  modalDismissButtonTestId?: string;
-  /**
-   * Позволяет отключить возможность закрытия модальной страницы (смахивание, клавиша `ESC`, клик по подложке)
-   *
-   * ⚠️ ВНИМАНИЕ: использование этой опции негативно сказывается на пользовательском опыте
-   */
-  preventClose?: boolean;
+export interface ModalPageProps extends ModalPagePrivateProps, NavIdProps {
+  keepMounted?: boolean;
 }
 
-const warn = warnOnce('ModalPage');
-
 /**
  * @see https://vkcom.github.io/VKUI/#/ModalPage
  */
 export const ModalPage = ({
-  children,
-  header,
-  size: sizeProp = 's',
+  id: idProp,
+  nav,
+  open = true,
+  modalOverlayTestId,
+  disableAutoFocus,
   onOpen,
   onOpened,
   onClose,
   onClosed,
-  settlingHeight, // 75
-  dynamicContentHeight,
-  getModalContentRef,
-  nav,
-  id: idProp,
-  hideCloseButton = false,
-  height,
-  modalContentTestId,
-  modalDismissButtonTestId,
-  getRootRef,
-  preventClose,
+  size = 's',
+  settlingHeight = 50,
+  keepMounted = false,
   ...restProps
-}: ModalPageProps): React.ReactNode => {
-  const generatingId = React.useId();
-  const id = idProp || generatingId;
+}: ModalPageProps) => {
+  const generatingId = useId();
+  const id = getNavId({ nav, id: idProp }, warn) || generatingId;
 
-  const { updateModalHeight } = React.useContext(ModalRootContext);
+  const { unmounted, ...resolvedProps } = useModalManager({
+    id,
+    open,
+    keepMounted,
+    modalOverlayTestId,
+    disableAutoFocus,
+    onOpen,
+    onOpened,
+    onClose,
+    onClosed,
+  });
 
-  const platform = usePlatform();
-  const orientation = useOrientationChange();
-  const { sizeX, isDesktop } = useAdaptivityWithJSMediaQueries();
-
-  React.useEffect(() => {
-    if (dynamicContentHeight) {
-      updateModalHeight();
-    }
-  }, [children, dynamicContentHeight, orientation, updateModalHeight]);
-
-  const isCloseButtonShown = !hideCloseButton && isDesktop;
-  const size = isDesktop ? sizeProp : 's';
-
-  const modalContext = React.useContext(ModalRootContext);
-  const { refs } = useModalRegistry(getNavId({ nav, id }, warn), 'page');
-  const rootRef = useExternRef(getRootRef, refs.modalElement);
-
-  const contextValue = React.useMemo(() => ({ labelId: `${id}-label` }), [id]);
+  if (unmounted) {
+    return null;
+  }
 
   return (
-    <ModalPageContext.Provider value={contextValue}>
-      <RootComponent
-        {...restProps}
-        getRootRef={rootRef}
-        tabIndex={-1}
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby={contextValue.labelId}
+    <ModalPageContext.Provider value={{ id }}>
+      <ModalPagePrivate
         id={id}
-        baseClassName={classNames(
-          styles.host,
-          platform === 'ios' && styles.ios,
-          isDesktop && styles.desktop,
-          sizeX === 'regular' && 'vkuiInternalModalPage--sizeX-regular',
-          typeof size === 'string' && sizeClassName[size],
-        )}
-      >
-        <div
-          className={styles.inWrap}
-          style={{
-            maxWidth: typeof size === 'number' ? size : undefined,
-            height,
-          }}
-          ref={refs.innerElement}
-        >
-          <div className={styles.in}>
-            <div className={styles.header} ref={refs.headerElement}>
-              {header}
-            </div>
-
-            <div className={styles.contentWrap}>
-              <div
-                className={styles.content}
-                ref={multiRef<HTMLDivElement>(refs.contentElement, getModalContentRef)}
-                {...(modalContentTestId && { 'data-testid': modalContentTestId })}
-              >
-                <div className={styles.contentIn}>{children}</div>
-              </div>
-              <div ref={refs.bottomInset} className={styles.bottomInset} />
-            </div>
-            {isCloseButtonShown && (
-              <ModalDismissButton
-                data-testid={modalDismissButtonTestId}
-                onClick={onClose || modalContext.onClose}
-              />
-            )}
-          </div>
-        </div>
-      </RootComponent>
+        size={size}
+        aria-labelledby={`${id}-label`}
+        settlingHeight={settlingHeight}
+        {...resolvedProps}
+        {...restProps}
+      />
     </ModalPageContext.Provider>
   );
 };
diff --git a/packages/vkui/src/components/ModalPage/ModalPageContext.tsx b/packages/vkui/src/components/ModalPage/ModalPageContext.tsx
index 113dcc20a8f..3c267ef89ce 100644
--- a/packages/vkui/src/components/ModalPage/ModalPageContext.tsx
+++ b/packages/vkui/src/components/ModalPage/ModalPageContext.tsx
@@ -1,8 +1,10 @@
-import * as React from 'react';
+import { createContext, useContext } from 'react';
 
 export interface ModalPageContextInterface {
-  labelId?: string;
+  id: string;
 }
 
 export const ModalPageContext: React.Context<ModalPageContextInterface> =
-  React.createContext<ModalPageContextInterface>({});
+  createContext<ModalPageContextInterface>({ id: '' });
+
+export const useModalPageContext = () => useContext(ModalPageContext);
diff --git a/packages/vkui/src/components/ModalPage/ModalPagePrivate.tsx b/packages/vkui/src/components/ModalPage/ModalPagePrivate.tsx
new file mode 100644
index 00000000000..a48ddc501e3
--- /dev/null
+++ b/packages/vkui/src/components/ModalPage/ModalPagePrivate.tsx
@@ -0,0 +1,216 @@
+'use client';
+
+import { type KeyboardEvent } from 'react';
+import { classNames, hasReactNode, noop } from '@vkontakte/vkjs';
+import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
+import { useExternRef } from '../../hooks/useExternRef';
+import { useVirtualKeyboardState } from '../../hooks/useVirtualKeyboardState';
+import { Keys, pressedKey } from '../../lib/accessibility';
+import { useCSSTransition, type UseCSSTransitionState } from '../../lib/animation';
+import { useBottomSheet } from '../../lib/sheet';
+import type { CSSCustomProperties } from '../../types';
+import { useScrollLock } from '../AppRoot/ScrollContext';
+import { useConfigProvider } from '../ConfigProvider/ConfigProviderContext';
+import { FocusTrap } from '../FocusTrap/FocusTrap';
+import { ModalDismissButton } from '../ModalDismissButton/ModalDismissButton';
+import { ModalPageBackdrop } from '../ModalPageBackdrop/ModalPageBackdrop';
+import { ModalPageContent } from '../ModalPageContent/ModalPageContent';
+import { ModalPageRoot } from '../ModalPageRoot/ModalPageRoot';
+import type { ModalPagePrivateProps } from './types';
+import styles from './ModalPage.module.css';
+
+const transitionStateClassNames: Partial<Record<UseCSSTransitionState, string>> = {
+  appear: styles['documentStateEnter'],
+  appearing: styles['documentStateEntering'],
+  appeared: styles['documentStateEntered'],
+  enter: styles['documentStateEnter'],
+  entering: styles['documentStateEntering'],
+  entered: styles['documentStateEntered'],
+  exit: styles['documentStateExit'],
+  exiting: styles['documentStateExiting'],
+  exited: styles['documentStateExited'],
+};
+
+/**
+ * В компоненте заложена вся логика модального окна.
+ *
+ * @private
+ */
+export const ModalPagePrivate = ({
+  open,
+  header,
+  footer,
+  size: desktopMaxWidth,
+  height,
+  children,
+  className,
+  style,
+  dynamicContentHeight,
+  settlingHeight,
+  preventClose,
+  getModalContentRef,
+  modalOverlayTestId,
+  modalContentTestId,
+  modalDismissButtonTestId,
+  disableAutoFocus,
+  hideCloseButton,
+  disableCloseOnEscKey,
+  preserveBackdropOpacity,
+  disableBackdrop,
+  onOpen,
+  onOpened,
+  onClose = noop,
+  onClosed,
+  ...restProps
+}: ModalPagePrivateProps) => {
+  const { hasCustomPanelHeaderAfter } = useConfigProvider();
+  const [transitionState, { ref, onTransitionEnd }] = useCSSTransition<HTMLDivElement>(open, {
+    enableAppear: true,
+    onEnter() {
+      onOpen?.();
+    },
+    onEntered() {
+      onOpened?.();
+    },
+    onExited() {
+      onClosed?.();
+    },
+  });
+  const opened = transitionState === 'appeared' || transitionState === 'entered';
+  const hidden = transitionState === 'exited';
+  const closable = !preventClose && opened;
+
+  const { sizeX, isDesktop } = useAdaptivityWithJSMediaQueries();
+  const bottomSheetEnabled = !isDesktop && !preventClose && transitionState !== 'exited';
+  const [keyboardOpened, safeAreaBottomInset] = useVirtualKeyboardState(bottomSheetEnabled);
+
+  const [{ initialStyle, setSheetEl, setSheetScrollEl, setBackdropEl }, bottomSheetEventHandlers] =
+    useBottomSheet(bottomSheetEnabled, {
+      blocked: keyboardOpened,
+      initialSnapPoint: dynamicContentHeight ? 'auto' : settlingHeight,
+      sheetCSSProperty: '--vkui_internal_ModalPageDocument--snapPoint',
+      backdropCSSProperty: '--vkui_internal--ModalPageBackdrop--opacity',
+      onDismiss() {
+        onClose({ reason: 'swipe-down' });
+      },
+    });
+  const documentStyle = keyboardOpened
+    ? {
+        '--vkui_internal_ModalPageDocument--safeAreaInsetBottom': `${safeAreaBottomInset}px`,
+        ...initialStyle,
+      }
+    : initialStyle;
+  const handleSheetRef = useExternRef<HTMLDivElement>(setSheetEl, ref);
+  const handleSheetScrollRef = useExternRef<HTMLDivElement>(setSheetScrollEl, getModalContentRef);
+
+  const [desktopMaxWidthClassName, desktopMaxWidthStyle] = resolveDesktopMaxWidth(desktopMaxWidth);
+  const backdrop = disableBackdrop ? null : (
+    <ModalPageBackdrop
+      getRootRef={setBackdropEl}
+      data-testid={modalOverlayTestId}
+      visible={preserveBackdropOpacity || open}
+      onClick={
+        closable
+          ? function handleBackdropClick(event) {
+              onClose(Object.assign({ reason: 'click-backdrop' as const }, event));
+            }
+          : undefined
+      }
+    />
+  );
+  const closeButton =
+    hideCloseButton || !isDesktop ? null : (
+      <ModalDismissButton
+        data-testid={modalDismissButtonTestId}
+        onClick={
+          closable
+            ? function handleDismissButtonClick(event) {
+                onClose(Object.assign({ reason: 'click-close-button' as const }, event));
+              }
+            : undefined
+        }
+      />
+    );
+  const handleEscKeyDown =
+    disableCloseOnEscKey || !closable
+      ? undefined
+      : (event: KeyboardEvent<HTMLElement>) => {
+          if (pressedKey(event) === Keys.ESCAPE) {
+            onClose(Object.assign({ reason: 'escape-key' as const }, event));
+          }
+        };
+
+  useScrollLock(!hidden);
+
+  return (
+    <ModalPageRoot hidden={hidden} onKeyDown={handleEscKeyDown}>
+      {backdrop}
+      <FocusTrap
+        {...restProps}
+        autoFocus={!disableAutoFocus}
+        role="dialog"
+        aria-modal="true"
+        disabled={!opened || hidden}
+        className={classNames(
+          className,
+          styles.host,
+          sizeX === 'regular' && 'vkuiInternalModalPage--sizeX-regular',
+          hasCustomPanelHeaderAfter
+            ? styles.hostSafeAreaInsetTopWithCustomOffset
+            : styles.hostSafeAreaInsetTop,
+          desktopMaxWidthClassName,
+        )}
+        style={{
+          ...style,
+          ...desktopMaxWidthStyle,
+          ...getHeightCSSVariable(height),
+        }}
+      >
+        <div
+          {...bottomSheetEventHandlers}
+          ref={handleSheetRef}
+          role="document"
+          style={documentStyle}
+          className={classNames(styles.document, transitionStateClassNames[transitionState])}
+          onTransitionEnd={onTransitionEnd}
+        >
+          <div className={styles.children}>
+            {hasReactNode(header) && header}
+            <ModalPageContent getRootRef={handleSheetScrollRef} data-testid={modalContentTestId}>
+              {children}
+            </ModalPageContent>
+            {hasReactNode(footer) && footer}
+          </div>
+          {closeButton}
+        </div>
+      </FocusTrap>
+    </ModalPageRoot>
+  );
+};
+
+const desktopMaxWidthClassNames = {
+  s: styles['hostMaxWidthS'],
+  m: styles['hostMaxWidthM'],
+  l: styles['hostMaxWidthL'],
+};
+
+function resolveDesktopMaxWidth(
+  desktopMaxWidth: ModalPagePrivateProps['size'] = 's',
+): [string | undefined, CSSCustomProperties | undefined] {
+  if (typeof desktopMaxWidth === 'string') {
+    return [desktopMaxWidthClassNames[desktopMaxWidth], undefined];
+  }
+
+  return [
+    undefined,
+    typeof desktopMaxWidth === 'number'
+      ? { '--vkui_internal_ModalPage--desktopMaxWidth': `${desktopMaxWidth}px` }
+      : undefined,
+  ];
+}
+
+function getHeightCSSVariable(height?: number | string): CSSCustomProperties | undefined {
+  return height !== undefined
+    ? { '--vkui_internal_ModalPage--userHeight': `${height}` }
+    : undefined;
+}
diff --git a/packages/vkui/src/components/ModalPage/checklist.md b/packages/vkui/src/components/ModalPage/checklist.md
new file mode 100644
index 00000000000..928be4f473e
--- /dev/null
+++ b/packages/vkui/src/components/ModalPage/checklist.md
@@ -0,0 +1,25 @@
+## Features
+
+- [x] открытие до определенного размера
+- [x] закрытие на ESC
+  - [x] должна быть возможность **отключить** поведение
+- [x] отключение backdrop, чтобы не блокировался контент
+- [x] возможность самому управлять состоянием закрытия
+  - [x] создать коллбек обработчик
+- [x] стики контента
+  - [x] шапка
+  - [x] подвал
+    - [x] едет вниз вместе
+- [x] закрытие на нажатие на задний фон
+- [x] закрытие при сильном смахивании вниз
+- [x] анимации
+  - [x] bounce
+  - [x] rubber: натяжение при перетаскивании
+- [x] не блокирует скролл
+  - [x] горизонтальный
+  - [x] вертикальный
+- [x] не блокирует поле ввода
+- [x] backdrop становится светлее в зависимости от процента сворачивания
+- [x] есть возможность отключить на опр-ых элементах
+  - [x] используя stopPropagation()
+  - [x] используя data-атрибут
diff --git a/packages/vkui/src/components/ModalPage/types.ts b/packages/vkui/src/components/ModalPage/types.ts
new file mode 100644
index 00000000000..f65ed279d99
--- /dev/null
+++ b/packages/vkui/src/components/ModalPage/types.ts
@@ -0,0 +1,104 @@
+import type { HTMLAttributesWithRootRef } from '../../types';
+
+export type CloseReason = 'click-backdrop' | 'click-close-button' | 'escape-key' | 'swipe-down';
+
+export type CloseEventPayload =
+  | (React.MouseEvent<HTMLElement> & { reason: Extract<CloseReason, 'click-backdrop'> })
+  | (React.MouseEvent<HTMLElement> & { reason: Extract<CloseReason, 'click-close-button'> })
+  | { reason: Extract<CloseReason, 'swipe-down'> }
+  | (React.KeyboardEvent<HTMLElement> & { reason: Extract<CloseReason, 'escape-key'> });
+
+type OmittedStyleAttribute = {
+  style?: Omit<React.CSSProperties, 'height' | 'maxWidth' | 'maxHeight'>;
+};
+
+export interface ModalPagePrivateProps
+  extends Omit<HTMLAttributesWithRootRef<HTMLDivElement>, 'style'>,
+    OmittedStyleAttribute {
+  open?: boolean;
+  /**
+   * Шапка модальной страницы, `<ModalPageHeader />`
+   */
+  header?: React.ReactNode;
+  /**
+   * Подвал модальной страницы, `<ModalPageFooter />`
+   */
+  footer?: React.ReactNode;
+  /**
+   * Задаёт контенту максимальную ширину на десктопе.
+   */
+  size?: 's' | 'm' | 'l' | number;
+  /**
+   * Задаёт модальному окну фиксированную высоту.
+   * Можно передать числовое значение в пикселях, а можно строкой, в том числе и в процентах "50%".
+   * В мобильной версии 'settlingHeight' будет считаться относительно заданного height.
+   */
+  height?: string | number;
+  /**
+   * Процент, на который изначально будет открыта модальная страница.
+   *
+   * > ⚠️ Следует использовать следующие значения: `25`, `50`, `75`, `100`.
+   * > При передаче `< 25` значение приведётся к `25`, при передаче `> 75` значение приведётся к `75`.
+   *
+   * Игнорируется при включении `dynamicContentHeight`.
+   */
+  settlingHeight?: number;
+  /**
+   * Если высота контента в модальной странице может поменяться, нужно установить это свойство
+   */
+  dynamicContentHeight?: boolean;
+  /**
+   * Отключает фокус на интерактивный элемент после открытия модалки.
+   */
+  disableAutoFocus?: boolean;
+  /**
+   * Скрывает кнопку закрытия (актуально для iOS, т.к. можно отрисовать кнопку закрытия внутри модалки)
+   */
+  hideCloseButton?: boolean;
+  /**
+   * Отключает закрытие нажатием на кнопку ESC.
+   */
+  disableCloseOnEscKey?: boolean;
+  /**
+   * Скрывает задний фон, чтобы элементы за модальным окном были доступны.
+   */
+  disableBackdrop?: boolean;
+  /**
+   * `data-testid` для содержимого модального окна.
+   */
+  modalContentTestId?: string;
+  /**
+   * Возвращает DOM-элемент содержимого модального окна.
+   */
+  getModalContentRef?: React.Ref<HTMLDivElement>;
+  /**
+   * `data-testid` для оверлея.
+   */
+  modalOverlayTestId?: string;
+  /**
+   * `data-testid` для кнопки закрытия
+   */
+  modalDismissButtonTestId?: string;
+  /**
+   * Позволяет отключить возможность закрытия модальной страницы (смахивание, клавиша `ESC`, клик по подложке)
+   *
+   * ⚠️ ВНИМАНИЕ: использование этой опции негативно сказывается на пользовательском опыте
+   */
+  preventClose?: boolean;
+  /**
+   * Будет вызвано при начале открытия модалки.
+   */
+  onOpen?: VoidFunction;
+  /**
+   * Будет вызвано при окончательном открытии модалки.
+   */
+  onOpened?: VoidFunction;
+  /**
+   * Будет вызвано при начале закрытия модалки.
+   */
+  onClose?: (payload: CloseEventPayload) => void;
+  /**
+   * Будет вызвано при окончательном закрытии модалки.
+   */
+  onClosed?: VoidFunction;
+}
diff --git a/packages/vkui/src/components/ModalPageBackdrop/ModalPageBackdrop.module.css b/packages/vkui/src/components/ModalPageBackdrop/ModalPageBackdrop.module.css
new file mode 100644
index 00000000000..69bd43d473e
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageBackdrop/ModalPageBackdrop.module.css
@@ -0,0 +1,60 @@
+.host {
+  --vkui_internal--ModalPageBackdrop--duration: 0;
+  --vkui_internal--ModalPageBackdrop--opacity: 1;
+
+  position: absolute;
+  inset: 0;
+  background-color: rgba(0, 0, 0, 0.4);
+  user-select: none;
+  -webkit-tap-highlight-color: transparent;
+  transition: opacity 0.5s ease;
+  will-change: opacity;
+}
+
+/* stylelint-disable declaration-no-important */
+.hostStateEnter {
+  opacity: 0;
+  transition: none;
+}
+
+.hostStateEntering {
+  opacity: var(--vkui_internal--ModalPageBackdrop--opacity);
+  transition-property: opacity !important;
+  transition-timing-function: ease-in !important;
+}
+
+.hostStateEntered {
+  opacity: var(--vkui_internal--ModalPageBackdrop--opacity);
+}
+
+.hostStateExit {
+  opacity: var(--vkui_internal--ModalPageBackdrop--opacity);
+  transition: none;
+}
+
+.hostStateExiting {
+  opacity: 0;
+  transition-property: opacity !important;
+  transition-timing-function: ease-out !important;
+}
+
+.hostStateExited {
+  opacity: 0;
+}
+/* Mobile */
+@media (--viewWidth-smallTabletMinus) {
+  .hostStateEntering,
+  .hostStateExiting {
+    transition-duration: var(--vkui--animation_duration_l) !important;
+  }
+}
+/* Desktop */
+@media (--viewWidth-smallTabletPlus) {
+  .hostStateEntering {
+    transition-duration: 0.2s !important;
+  }
+
+  .hostStateExiting {
+    transition-duration: 0.1s !important;
+  }
+}
diff --git a/packages/vkui/src/components/ModalPageBackdrop/ModalPageBackdrop.tsx b/packages/vkui/src/components/ModalPageBackdrop/ModalPageBackdrop.tsx
new file mode 100644
index 00000000000..1a215f4adf6
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageBackdrop/ModalPageBackdrop.tsx
@@ -0,0 +1,50 @@
+'use client';
+
+import { classNames } from '@vkontakte/vkjs';
+import { useExternRef } from '../../hooks/useExternRef';
+import { useCSSTransition, type UseCSSTransitionState } from '../../lib/animation/useCSSTransition';
+import type { HasRootRef } from '../../types';
+import styles from './ModalPageBackdrop.module.css';
+
+const transitionStateClassNames: Partial<Record<UseCSSTransitionState, string>> = {
+  appear: styles['hostStateEnter'],
+  appearing: styles['hostStateEntering'],
+  appeared: styles['hostStateEntered'],
+  enter: styles['hostStateEnter'],
+  entering: styles['hostStateEntering'],
+  entered: styles['hostStateEntered'],
+  exit: styles['hostStateExit'],
+  exiting: styles['hostStateExiting'],
+  exited: styles['hostStateExited'],
+};
+
+export interface ModalPageBackdropProps extends HasRootRef<HTMLDivElement> {
+  visible?: boolean;
+  onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+}
+
+/**
+ * @private
+ */
+export const ModalPageBackdrop = ({
+  visible,
+  getRootRef,
+  onClick,
+  ...restProps
+}: ModalPageBackdropProps) => {
+  const [transitionState, { ref, onTransitionEnd }] = useCSSTransition<HTMLDivElement>(visible, {
+    enableAppear: true,
+  });
+  const handleRef = useExternRef(getRootRef, ref);
+
+  return (
+    <div
+      {...restProps}
+      ref={handleRef}
+      aria-hidden="true"
+      className={classNames(styles.host, transitionStateClassNames[transitionState])}
+      onClick={onClick}
+      onTransitionEnd={onTransitionEnd}
+    />
+  );
+};
diff --git a/packages/vkui/src/components/ModalPageContent/ModalPageContent.module.css b/packages/vkui/src/components/ModalPageContent/ModalPageContent.module.css
new file mode 100644
index 00000000000..e49ee3c0d85
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageContent/ModalPageContent.module.css
@@ -0,0 +1,4 @@
+.host {
+  /* см. `.children {}` в `ModalPage` */
+  flex: 1 1 100%;
+}
diff --git a/packages/vkui/src/components/ModalPageContent/ModalPageContent.tsx b/packages/vkui/src/components/ModalPageContent/ModalPageContent.tsx
new file mode 100644
index 00000000000..20a9771263c
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageContent/ModalPageContent.tsx
@@ -0,0 +1,25 @@
+'use client';
+
+import { classNames } from '@vkontakte/vkjs';
+import type { HTMLAttributesWithRootRef } from '../../types';
+import { CustomScrollView } from '../CustomScrollView/CustomScrollView';
+import styles from './ModalPageContent.module.css';
+
+export type ModalPageContentProps = HTMLAttributesWithRootRef<HTMLDivElement>;
+
+export const ModalPageContent = ({
+  children,
+  className,
+  getRootRef,
+  ...restProps
+}: ModalPageContentProps) => {
+  return (
+    <CustomScrollView
+      className={classNames(className, styles.host)}
+      getRootRef={getRootRef}
+      {...restProps}
+    >
+      {children}
+    </CustomScrollView>
+  );
+};
diff --git a/packages/vkui/src/components/ModalPageFooter/ModalPageFooter.module.css b/packages/vkui/src/components/ModalPageFooter/ModalPageFooter.module.css
new file mode 100644
index 00000000000..26933317cd0
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageFooter/ModalPageFooter.module.css
@@ -0,0 +1,14 @@
+.host {
+  inline-size: 100%;
+  border-end-start-radius: inherit;
+  border-end-end-radius: inherit;
+  background-color: var(--vkui--color_background_modal);
+
+  /* см. `.children {}` в `ModalPage` */
+  flex: 0 0 auto;
+}
+
+.inner {
+  padding-block: 16px;
+  padding-inline: 24px;
+}
diff --git a/packages/vkui/src/components/ModalPageFooter/ModalPageFooter.tsx b/packages/vkui/src/components/ModalPageFooter/ModalPageFooter.tsx
new file mode 100644
index 00000000000..7900ba7494e
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageFooter/ModalPageFooter.tsx
@@ -0,0 +1,25 @@
+'use client';
+
+import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
+import type { HTMLAttributesWithRootRef } from '../../types';
+import { RootComponent } from '../RootComponent/RootComponent';
+import { Separator } from '../Separator/Separator';
+import styles from './ModalPageFooter.module.css';
+
+export interface ModalPageFooterProps extends HTMLAttributesWithRootRef<HTMLDivElement> {
+  noSeparator?: boolean;
+}
+
+export const ModalPageFooter = ({
+  noSeparator = false,
+  children,
+  ...restProps
+}: ModalPageFooterProps) => {
+  const { sizeX } = useAdaptivityWithJSMediaQueries();
+  return (
+    <RootComponent baseClassName={styles.host} {...restProps}>
+      {!noSeparator && <Separator padding={sizeX !== 'regular'} />}
+      <div className={styles.inner}>{children}</div>
+    </RootComponent>
+  );
+};
diff --git a/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.module.css b/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.module.css
index 2ecc15fad16..7c7397cc871 100644
--- a/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.module.css
+++ b/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.module.css
@@ -1,12 +1,19 @@
 .host {
   --vkui_internal--safe_area_inset_top: 0;
+
+  border-start-start-radius: inherit;
+  border-start-end-radius: inherit;
+  background-color: var(--vkui--color_background_modal);
+
+  /* см. `.children {}` в `ModalPage` */
+  flex: 0 0 auto;
 }
 
-.withGaps {
+.hostWithGaps {
   padding-inline: 4px;
 }
 
-.desktop.withGaps {
+.hostDesktop.hostWithGaps {
   padding-inline: 8px;
 }
 
diff --git a/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.tsx b/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.tsx
index 4896ca7ae18..e8d50920274 100644
--- a/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.tsx
+++ b/packages/vkui/src/components/ModalPageHeader/ModalPageHeader.tsx
@@ -31,15 +31,15 @@ export const ModalPageHeader = ({
 }: ModalPageHeaderProps): React.ReactNode => {
   const platform = usePlatform();
   const { isDesktop, sizeX } = useAdaptivityWithJSMediaQueries();
-  const { labelId } = React.useContext(ModalPageContext);
+  const { id } = React.useContext(ModalPageContext);
 
   return (
     <>
       <div
         className={classNames(
           styles.host,
-          platform !== 'vkcom' && styles.withGaps,
-          isDesktop && styles.desktop,
+          platform !== 'vkcom' && styles.hostWithGaps,
+          isDesktop && styles.hostDesktop,
         )}
         ref={getRootRef}
       >
@@ -47,7 +47,7 @@ export const ModalPageHeader = ({
           className={classNames('vkuiInternalModalPageHeader__in', className)}
           typographyProps={{
             Component: 'h2',
-            id: labelId,
+            id: `${id}-label`,
             ...typographyProps,
           }}
           {...restProps}
diff --git a/packages/vkui/src/components/ModalPageRoot/ModalPageRoot.module.css b/packages/vkui/src/components/ModalPageRoot/ModalPageRoot.module.css
new file mode 100644
index 00000000000..4a3cd9a76f7
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageRoot/ModalPageRoot.module.css
@@ -0,0 +1,16 @@
+.host:not([hidden]) {
+  isolation: isolate;
+  position: fixed;
+  inset: 0;
+  z-index: var(--vkui--z_index_modal);
+  overflow: hidden;
+}
+
+/* Desktop */
+@media (--viewWidth-smallTabletPlus) {
+  .host:not([hidden]) {
+    display: flex;
+    align-items: flex-start;
+    justify-content: flex-start;
+  }
+}
diff --git a/packages/vkui/src/components/ModalPageRoot/ModalPageRoot.tsx b/packages/vkui/src/components/ModalPageRoot/ModalPageRoot.tsx
new file mode 100644
index 00000000000..8f863a57bc4
--- /dev/null
+++ b/packages/vkui/src/components/ModalPageRoot/ModalPageRoot.tsx
@@ -0,0 +1,31 @@
+import { classNames } from '@vkontakte/vkjs';
+import type { HTMLAttributesWithRootRef } from '../../types';
+import styles from './ModalPageRoot.module.css';
+
+export interface ModalPageRootProps
+  extends Omit<HTMLAttributesWithRootRef<HTMLDivElement>, 'hidden' | 'aria-hidden'> {
+  hidden?: boolean;
+}
+
+/**
+ * @private
+ */
+export const ModalPageRoot = ({
+  className,
+  hidden,
+  children,
+  getRootRef,
+  ...restProps
+}: ModalPageRootProps) => {
+  return (
+    <div
+      ref={getRootRef}
+      className={classNames(className, styles.host)}
+      hidden={hidden}
+      aria-hidden={hidden}
+      {...restProps}
+    >
+      {children}
+    </div>
+  );
+};
diff --git a/packages/vkui/src/components/ModalRoot/ModalRoot.module.css b/packages/vkui/src/components/ModalRoot/ModalRoot.module.css
deleted file mode 100644
index d60c0dff1d3..00000000000
--- a/packages/vkui/src/components/ModalRoot/ModalRoot.module.css
+++ /dev/null
@@ -1,59 +0,0 @@
-.host {
-  inline-size: 100%;
-  block-size: 100%;
-}
-
-.mask {
-  opacity: 1;
-  inline-size: 100%;
-  block-size: 100%;
-  position: absolute;
-  inset-inline-start: 0;
-  inset-block-start: 0;
-  background: rgba(0, 0, 0, 0.4);
-  user-select: none;
-  transition: opacity 167ms ease-out;
-  animation: animation-modalroot-fade-in 0.32s ease;
-}
-
-.touched .mask {
-  transition: none;
-}
-
-.switching .mask {
-  /** Во время автоматической анимации смены модалок с фоном взаимодействовать нельзя */
-  pointer-events: none;
-}
-
-.viewport {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-}
-
-:not(.desktop).host .viewport {
-  inset-block-start: var(--vkui_internal--safe_area_inset_top);
-}
-
-:not(.desktop).hasCustomPanelHeaderAfterSlot .viewport {
-  inset-block-start: calc(
-    var(--vkui_internal--safe_area_inset_top) + var(--vkui_internal--panel_header_height)
-  );
-}
-
-.modal {
-  position: absolute;
-  inline-size: 100%;
-  block-size: 100%;
-  box-sizing: border-box;
-}
-
-@keyframes animation-modalroot-fade-in {
-  from {
-    opacity: 0;
-  }
-
-  to {
-    opacity: 1;
-  }
-}
diff --git a/packages/vkui/src/components/ModalRoot/ModalRoot.stories.tsx b/packages/vkui/src/components/ModalRoot/ModalRoot.stories.tsx
index e937237425d..4a7af7ac38e 100644
--- a/packages/vkui/src/components/ModalRoot/ModalRoot.stories.tsx
+++ b/packages/vkui/src/components/ModalRoot/ModalRoot.stories.tsx
@@ -3,6 +3,7 @@ import type { Meta, StoryObj } from '@storybook/react';
 import { ModalWrapper } from '../../storybook/ModalWrapper';
 import { CanvasFullLayout, DisableCartesianParam } from '../../storybook/constants';
 import { Button } from '../Button/Button';
+import { ButtonGroup } from '../ButtonGroup/ButtonGroup';
 import { Group } from '../Group/Group';
 import { Input } from '../Input/Input';
 import { ModalPage } from '../ModalPage/ModalPage';
@@ -10,9 +11,8 @@ import { Placeholder } from '../Placeholder/Placeholder';
 import { Spinner } from '../Spinner/Spinner';
 import { SplitCol } from '../SplitCol/SplitCol';
 import { SplitLayout } from '../SplitLayout/SplitLayout';
-import { ModalRoot } from './ModalRootAdaptive';
+import { ModalRoot } from './ModalRoot';
 import type { ModalRootProps } from './types';
-import { useModalRootContext } from './useModalRootContext';
 
 const story: Meta<ModalRootProps> = {
   title: 'Modals/ModalRoot',
@@ -28,10 +28,64 @@ const MODAL_PAGE_DYNAMIC = 'modal-page-dynamic';
 const MODAL_ROOT_WITH_AUTO_FOCUS = 'modal-root-with-auto-focus';
 const MODAL_PAGE_WITH_AUTO_FOCUS = 'modal-page-with-auto-focus';
 
+export const Managing: Story = {
+  render: function Render() {
+    const [activeModal, setActiveModal] = React.useState<string | null>(null);
+
+    const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
+      const { id } = event.currentTarget.dataset;
+      if (id) {
+        setActiveModal(id);
+      }
+    };
+
+    return (
+      <>
+        <ButtonGroup>
+          <Button data-id="1" onClick={handleClick}>
+            1
+          </Button>
+          <Button data-id="2" onClick={handleClick}>
+            2
+          </Button>
+          <Button data-id="3" onClick={handleClick}>
+            3
+          </Button>
+        </ButtonGroup>
+        <ModalRoot activeModal={activeModal} onClose={() => setActiveModal(null)}>
+          <ModalPage id="1">
+            Lorem ipsum dolor sit amet consectetur adipisicing elit. Esse sint, veritatis rem alias
+            minima expedita laborum. Nam ipsa quos fugit modi quidem, corporis deleniti, veritatis,
+            asperiores aliquid ducimus perferendis excepturi?
+            <Button data-id="2" onClick={handleClick}>
+              2
+            </Button>
+          </ModalPage>
+          <ModalPage id="2" dynamicContentHeight>
+            Lorem ipsum dolor sit amet consectetur adipisicing elit. Esse sint, veritatis rem alias
+            minima expedita laborum. Nam ipsa quos fugit modi quidem, corporis deleniti, veritatis,
+            asperiores aliquid ducimus perferendis excepturi?
+            <Button data-id="3" onClick={handleClick}>
+              3
+            </Button>
+          </ModalPage>
+          <ModalPage id="3">
+            Lorem ipsum dolor sit amet consectetur adipisicing elit. Esse sint, veritatis rem alias
+            minima expedita laborum. Nam ipsa quos fugit modi quidem, corporis deleniti, veritatis,
+            asperiores aliquid ducimus perferendis excepturi?
+            <Button data-id="1" onClick={handleClick}>
+              1
+            </Button>
+          </ModalPage>
+        </ModalRoot>
+      </>
+    );
+  },
+};
+
 export const ModalDynamicHeight: Story = {
   render: function Render() {
     const [isLoading, setIsLoading] = React.useState(true);
-    const { updateModalHeight } = useModalRootContext();
     const timer = React.useRef<ReturnType<typeof setTimeout>>();
 
     React.useEffect(() => {
@@ -44,13 +98,6 @@ export const ModalDynamicHeight: Story = {
       };
     }, []);
 
-    // После установки стейта и перерисовки компонента SelectModal сообщим ModalRoot об изменениях
-    React.useEffect(() => {
-      if (!isLoading) {
-        updateModalHeight();
-      }
-    }, [isLoading, updateModalHeight]);
-
     return (
       <ModalWrapper modalId={MODAL_PAGE_DYNAMIC}>
         <ModalPage id={MODAL_PAGE_DYNAMIC} dynamicContentHeight>
diff --git a/packages/vkui/src/components/ModalRoot/ModalRoot.test.tsx b/packages/vkui/src/components/ModalRoot/ModalRoot.test.tsx
index eb13e22020d..2610b2e22c5 100644
--- a/packages/vkui/src/components/ModalRoot/ModalRoot.test.tsx
+++ b/packages/vkui/src/components/ModalRoot/ModalRoot.test.tsx
@@ -1,103 +1,144 @@
 import * as React from 'react';
 import { act } from 'react';
 import { fireEvent, render, screen } from '@testing-library/react';
-import { baselineComponent, mountTest, userEvent, waitCSSTransitionEnd } from '../../testing/utils';
-import { Button } from '../Button/Button';
+import { baselineComponent, fakeTimers, waitCSSTransitionEnd } from '../../testing/utils';
 import { ModalCard } from '../ModalCard/ModalCard';
 import { ModalPage } from '../ModalPage/ModalPage';
-import { ModalRootTouch } from './ModalRoot';
-import { ModalRootDesktop } from './ModalRootDesktop';
-import { withModalRootContext } from './withModalRootContext';
-import styles from './ModalRoot.module.css';
-import modalPageStyles from '../ModalPage/ModalPage.module.css';
-
-const clickFade = async () => await userEvent.click(document.querySelector(`.${styles.mask}`)!);
-
-beforeEach(() => {
-  jest.useFakeTimers();
-});
-afterEach(() => {
-  jest.clearAllTimers();
-  jest.useRealTimers();
-});
+import { ModalRoot } from './ModalRoot';
+
+fakeTimers();
+
+describe(ModalRoot, () => {
+  baselineComponent(ModalRoot, { forward: false, a11y: false, getRootRef: false });
+
+  describe.each([
+    { displayName: 'ModalPage', Component: ModalPage },
+    { displayName: 'ModalCard', Component: ModalCard },
+  ])('With $displayName', ({ displayName, Component }) => {
+    const waitCSSTransitionEndConditionally = async (el: HTMLElement) =>
+      displayName === 'ModalPage'
+        ? await waitCSSTransitionEnd(getFirstHTMLElementChild(el))
+        : await waitCSSTransitionEnd(el);
+
+    test.each(['global', 'local'])('mount and unmount (should use %s callbacks)', async (type) => {
+      const globalCallbacks = { onOpen: jest.fn(), onOpened: jest.fn(), onClose: jest.fn(), onClosed: jest.fn() }; // prettier-ignore
+      const localCallbacks = { onOpen: jest.fn(), onOpened: jest.fn(), onClose: jest.fn(), onClosed: jest.fn() }; // prettier-ignore
+
+      const h = render(
+        <ModalRoot activeModal="m" {...globalCallbacks}>
+          {type === 'local' ? (
+            <Component id="m" data-testid="m" {...localCallbacks} />
+          ) : (
+            <Component id="m" data-testid="m" />
+          )}
+        </ModalRoot>,
+      );
+      await waitCSSTransitionEndConditionally(h.getByTestId('m'));
+      expect(h.getByTestId('m')).toBeInTheDocument();
+
+      h.rerender(
+        <ModalRoot activeModal={null} {...globalCallbacks}>
+          {type === 'local' ? (
+            <Component id="m" data-testid="m" {...localCallbacks} />
+          ) : (
+            <Component id="m" data-testid="m" />
+          )}
+        </ModalRoot>,
+      );
+      await waitCSSTransitionEndConditionally(h.getByTestId('m'));
+      expect(h.queryByTestId('m')).not.toBeInTheDocument();
+
+      if (type === 'global') {
+        expect(globalCallbacks.onOpen).toHaveBeenCalledTimes(1);
+        expect(globalCallbacks.onOpen).toHaveBeenCalledWith('m');
+        expect(globalCallbacks.onOpened).toHaveBeenCalledTimes(1);
+        expect(globalCallbacks.onOpened).toHaveBeenCalledWith('m');
+        expect(globalCallbacks.onClose).toHaveBeenCalledTimes(0);
+        expect(globalCallbacks.onClosed).toHaveBeenCalledTimes(1);
+        expect(globalCallbacks.onClosed).toHaveBeenCalledWith('m');
+      } else {
+        expect(globalCallbacks.onOpen).toHaveBeenCalledTimes(0);
+        expect(globalCallbacks.onOpened).toHaveBeenCalledTimes(0);
+        expect(globalCallbacks.onClose).toHaveBeenCalledTimes(0);
+        expect(globalCallbacks.onClosed).toHaveBeenCalledTimes(0);
+
+        expect(localCallbacks.onOpen).toHaveBeenCalledTimes(1);
+        expect(localCallbacks.onOpen).toHaveBeenCalledWith();
+        expect(localCallbacks.onOpened).toHaveBeenCalledTimes(1);
+        expect(localCallbacks.onOpened).toHaveBeenCalledWith();
+        expect(localCallbacks.onClose).toHaveBeenCalledTimes(0);
+        expect(localCallbacks.onClosed).toHaveBeenCalledTimes(1);
+        expect(localCallbacks.onClosed).toHaveBeenCalledWith();
+      }
+    });
 
-const mockDate = () => {
-  const startGestureDate = new Date(2024, 7, 5);
-  jest.useFakeTimers();
-  jest.setSystemTime(startGestureDate);
-  const endGestureDate = new Date(startGestureDate);
+    test('open by prop vs open by context', async () => {
+      const h = render(
+        <ModalRoot activeModal={null}>
+          <Component id="m" open data-testid="m" />
+        </ModalRoot>,
+      );
+      expect(h.queryByTestId('m')).not.toBeInTheDocument();
 
-  return {
-    next: (ms = 500) => {
-      endGestureDate.setMilliseconds(endGestureDate.getMilliseconds() + ms);
-      jest.setSystemTime(endGestureDate);
-    },
-  };
-};
+      h.rerender(
+        <ModalRoot activeModal="m">
+          <Component id="m" open data-testid="m" />
+        </ModalRoot>,
+      );
+      await waitCSSTransitionEndConditionally(h.getByTestId('m'));
+      expect(h.queryByTestId('m')).toBeInTheDocument();
+    });
 
-describe.each([
-  ['ModalRootTouch', ModalRootTouch],
-  ['ModalRootDesktop', ModalRootDesktop],
-] as const)('%s', (name, ModalRoot: any) => {
-  baselineComponent<any>(ModalRoot, { forward: false, a11y: false, getRootRef: false });
-  describe('With ModalPage', () =>
-    mountTest(() => (
-      <ModalRoot activeModal="m">
-        <ModalPage id="m" />
-      </ModalRoot>
-    )));
-  describe('With ModalCard', () =>
-    mountTest(() => (
-      <ModalRoot activeModal="m">
-        <ModalCard id="m" />
-      </ModalRoot>
-    )));
+    test('keepMounted', async () => {
+      const h = render(
+        <ModalRoot activeModal={null}>
+          <Component id="m" keepMounted data-testid="m" />
+        </ModalRoot>,
+      );
+      expect(h.queryByTestId('m')).toBeInTheDocument();
+    });
+  });
 
   describe('shows active modal', () => {
     const modals = [
       <ModalPage id="m" data-testid="m" key="m" />,
       <ModalPage id="other" data-testid="other" key="o" />,
     ];
-    it('on mount', () => {
+    it('on mount', async () => {
       const h = render(<ModalRoot activeModal="m">{modals}</ModalRoot>);
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
       expect(h.queryByTestId('m')).not.toBeNull();
       expect(h.queryByTestId('other')).toBeNull();
     });
-    it('shows via prop update', () => {
+    it('shows via prop update', async () => {
       const h = render(<ModalRoot activeModal={null}>{modals}</ModalRoot>);
-      act(jest.runAllTimers);
+      expect(h.queryByTestId('m')).toBeNull();
+      expect(h.queryByTestId('other')).toBeNull();
+
       h.rerender(<ModalRoot activeModal="m">{modals}</ModalRoot>);
-      act(jest.runAllTimers);
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
       expect(h.queryByTestId('m')).not.toBeNull();
       expect(h.queryByTestId('other')).toBeNull();
     });
     it('hides via prop update', async () => {
       const h = render(<ModalRoot activeModal="m">{modals}</ModalRoot>);
-      act(jest.runAllTimers);
       await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
       expect(h.queryByTestId('m')).not.toBeNull();
       expect(h.queryByTestId('other')).toBeNull();
 
       h.rerender(<ModalRoot activeModal={null}>{modals}</ModalRoot>);
-      act(jest.runAllTimers);
       await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
       expect(h.queryByTestId('m')).toBeNull();
       expect(h.queryByTestId('other')).toBeNull();
     });
     it('changes via prop update', async () => {
       const h = render(<ModalRoot activeModal="m">{modals}</ModalRoot>);
-      act(jest.runAllTimers);
       await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
       expect(h.queryByTestId('m')).not.toBeNull();
       expect(h.queryByTestId('other')).toBeNull();
 
       h.rerender(<ModalRoot activeModal="other">{modals}</ModalRoot>);
-      act(jest.runAllTimers);
-      if (
-        name === 'ModalRootTouch' /* note: 'ModalRootDesktop' смена `activeModal` без анимаций */
-      ) {
-        await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
-      }
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
       await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('other')));
       expect(h.queryByTestId('m')).toBeNull();
       expect(h.queryByTestId('other')).not.toBeNull();
@@ -109,115 +150,70 @@ describe.each([
       it('calls modal onClose', async () => {
         const onClose = jest.fn();
         const onCloseRoot = jest.fn();
-        render(
+        const h = render(
           <ModalRoot onClose={onCloseRoot} activeModal="m">
-            <ModalPage id="m" onClose={onClose} />
+            <ModalPage id="m" data-testid="m" modalOverlayTestId="overlay" onClose={onClose} />
           </ModalRoot>,
         );
-        // wait for animations
-        act(jest.runAllTimers);
-        await clickFade();
+        await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
+        fireEvent.click(h.getByTestId('overlay'));
         expect(onClose).toHaveBeenCalledTimes(1);
         expect(onCloseRoot).not.toHaveBeenCalled();
       });
       it('calls root onClose if modal has no onClose', async () => {
         const onCloseRoot = jest.fn();
-        render(
+        const h = render(
           <ModalRoot onClose={onCloseRoot} activeModal="m">
-            <ModalPage id="m" />
+            <ModalPage id="m" data-testid="m" modalOverlayTestId="overlay" />
           </ModalRoot>,
         );
-        // wait for animations
-        act(jest.runAllTimers);
-        await clickFade();
+        await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
+        fireEvent.click(h.getByTestId('overlay'));
         expect(onCloseRoot).toHaveBeenCalledTimes(1);
       });
       it('does not call root onClose when preventClose is provided', async () => {
         const onCloseRoot = jest.fn();
-        render(
+        const h = render(
           <ModalRoot onClose={onCloseRoot} activeModal="m">
-            <ModalPage id="m" preventClose />
+            <ModalPage preventClose id="m" data-testid="m" modalOverlayTestId="overlay" />
           </ModalRoot>,
         );
-        // wait for animations
-        act(jest.runAllTimers);
-        await clickFade();
-        expect(onCloseRoot).not.toHaveBeenCalled();
-        await userEvent.keyboard('{Escape}');
+        await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
+        fireEvent.click(h.getByTestId('overlay'));
+        fireEvent.keyDown(h.getByTestId('m'), { key: 'Escape', code: 'Escape' });
         expect(onCloseRoot).not.toHaveBeenCalled();
       });
     });
-    if (name === 'ModalRootDesktop') {
-      it('on esc click', async () => {
-        const onCloseRoot = jest.fn();
-        render(
-          <ModalRoot onClose={onCloseRoot} activeModal="m">
-            <ModalPage id="m" />
-          </ModalRoot>,
-        );
-        // wait for animations
-        act(jest.runAllTimers);
-        await userEvent.keyboard('{Escape}');
-        expect(onCloseRoot).toHaveBeenCalledTimes(1);
-      });
-    }
-  });
-
-  it('check modal mask with fast modal change', async () => {
-    const onClose = jest.fn();
-    const modals = [
-      <ModalPage id="m" key="m" />,
-      <ModalPage id="other" key="o" onClose={onClose} />,
-    ];
-
-    const h = render(<ModalRoot activeModal="m">{modals}</ModalRoot>);
-    act(jest.runAllTimers);
-    h.rerender(<ModalRoot activeModal={null}>{modals}</ModalRoot>);
-    h.rerender(<ModalRoot activeModal="other">{modals}</ModalRoot>);
-    act(jest.runAllTimers);
-
-    // check if mask is present
-    expect(document.querySelector<HTMLElement>(`.${styles.mask}`)?.style.opacity).toBe('1');
-
-    // onClose is working
-    await clickFade();
-    expect(onClose).toHaveBeenCalledTimes(1);
-  });
-
-  it('disables native pull-to-refresh when modal is open', async () => {
-    const modals = [<ModalPage id="m" data-testid="m" key="m" />, <ModalPage id="other" key="o" />];
-
-    const component = render(<ModalRoot activeModal={null}>{modals}</ModalRoot>, {
-      baseElement: document.documentElement,
+    it('on esc click', async () => {
+      const onCloseRoot = jest.fn();
+      const h = render(
+        <ModalRoot onClose={onCloseRoot} activeModal="m">
+          <ModalPage id="m" data-testid="m" />
+        </ModalRoot>,
+      );
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('m')));
+      fireEvent.keyDown(h.getByTestId('m'), { key: 'Escape', code: 'Escape' });
+      expect(onCloseRoot).toHaveBeenCalledTimes(1);
     });
-    act(jest.runAllTimers);
-
-    expect(document.querySelector('.vkui--disable-overscroll-behavior')).toBeFalsy();
-
-    component.rerender(<ModalRoot activeModal="m">{modals}</ModalRoot>);
-    act(jest.runAllTimers);
-    await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('m')));
-
-    if (name === 'ModalRootTouch') {
-      expect(document.querySelector('.vkui--disable-overscroll-behavior')).toBeTruthy();
-    } else {
-      expect(document.querySelector('.vkui--disable-overscroll-behavior')).toBeFalsy();
-    }
-
-    component.rerender(<ModalRoot activeModal={null}>{modals}</ModalRoot>);
-    act(jest.runAllTimers);
-    await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('m')));
-
-    expect(document.querySelector('.vkui--disable-overscroll-behavior')).toBeFalsy();
   });
 
-  it('modalOverlayTestId for ModalRoot', () => {
-    render(
+  it('check modalOverlayTestId prop vs context priority', async () => {
+    const h = render(
       <ModalRoot activeModal="page" modalOverlayTestId="modal-mask">
-        <ModalPage id="page" />
+        <ModalPage id="page" data-testid="page" />
       </ModalRoot>,
     );
+    await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('page')));
     expect(screen.queryByTestId('modal-mask')).toBeTruthy();
+
+    h.rerender(
+      <ModalRoot activeModal="page" modalOverlayTestId="modal-mask">
+        <ModalPage id="page" data-testid="page" modalOverlayTestId="custom-mask" />
+      </ModalRoot>,
+    );
+    await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('page')));
+    expect(screen.queryByTestId('modal-mask')).toBeFalsy();
+    expect(screen.queryByTestId('custom-mask')).toBeTruthy();
   });
 
   describe('focus', () => {
@@ -251,29 +247,29 @@ describe.each([
       const component = render(<ModalRoot activeModal="modal-page">{modals}</ModalRoot>, {
         baseElement: document.documentElement,
       });
-      act(jest.runAllTimers);
       await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-page')));
-
+      act(jest.runOnlyPendingTimers);
       expect(modalPageRef.current).toHaveFocus();
 
       component.rerender(<ModalRoot activeModal="modal-card">{modals}</ModalRoot>);
-      act(jest.runAllTimers);
-      await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-card')));
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-page')));
+      await waitCSSTransitionEnd(component.getByTestId('modal-card'));
+      act(jest.runOnlyPendingTimers);
 
       expect(modalCardRef.current).toHaveFocus();
     });
 
-    it('should focus on controllable element instead modal if it is focused', () => {
-      render(<ModalRoot activeModal="modal-page-with-input">{modals}</ModalRoot>, {
+    it('should focus on controllable element instead modal if it is focused', async () => {
+      const h = render(<ModalRoot activeModal="modal-page-with-input">{modals}</ModalRoot>, {
         baseElement: document.documentElement,
       });
-      act(jest.runAllTimers);
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(h.getByTestId('modal-page-with-input')));
 
       expect(modalPageWithInputRef.current).not.toHaveFocus();
       expect(inputInnerModalPageRef.current).toHaveFocus();
     });
 
-    it('should focus on controllable element only (if it is focused)', () => {
+    it('should focus on controllable element only (if it is focused)', async () => {
       const component = render(
         <ModalRoot activeModal="modal-page" noFocusToDialog>
           {modals}
@@ -282,8 +278,7 @@ describe.each([
           baseElement: document.documentElement,
         },
       );
-      act(jest.runAllTimers);
-
+      await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-page')));
       expect(modalPageRef.current).not.toHaveFocus();
 
       component.rerender(
@@ -291,7 +286,9 @@ describe.each([
           {modals}
         </ModalRoot>,
       );
-      act(jest.runAllTimers);
+      await waitCSSTransitionEnd(
+        getFirstHTMLElementChild(component.getByTestId('modal-page-with-input')),
+      );
 
       expect(modalPageWithInputRef.current).not.toHaveFocus();
       expect(inputInnerModalPageRef.current).toHaveFocus();
@@ -302,378 +299,3 @@ describe.each([
 function getFirstHTMLElementChild(el: HTMLElement | null) {
   return el && el.firstElementChild instanceof HTMLElement ? el.firstElementChild : null;
 }
-
-describe(ModalRootTouch, () => {
-  describe('check correct update height', () => {
-    const updateHeightSetup = async ({
-      content,
-      defaultModalContentClientHeight,
-      defaultContentInScrollHeight,
-    }: {
-      content: React.ReactElement;
-      defaultModalContentClientHeight: number;
-      defaultContentInScrollHeight: number;
-    }) => {
-      let modalContentClientHeight = defaultModalContentClientHeight;
-      let contentInScrollHeight = defaultContentInScrollHeight;
-      let innerElementTransform = '';
-
-      const Fixture = () => {
-        return (
-          <ModalRootTouch activeModal="modal-page">
-            <ModalPage
-              id="modal-page"
-              data-testid="modal-page"
-              key="1"
-              getRootRef={(element) => {
-                if (!element) {
-                  return;
-                }
-                jest
-                  .spyOn((element.firstElementChild! as HTMLElement).style, 'transform', 'set')
-                  .mockImplementation((newTransform) => (innerElementTransform = newTransform));
-                jest
-                  .spyOn(element, 'offsetHeight', 'get')
-                  .mockImplementation(() => modalContentClientHeight);
-              }}
-              getModalContentRef={(element) => {
-                if (!element) {
-                  return;
-                }
-                jest
-                  .spyOn(element, 'clientHeight', 'get')
-                  .mockImplementation(() => modalContentClientHeight);
-                jest
-                  .spyOn(element.firstElementChild!, 'scrollHeight', 'get')
-                  .mockImplementation(() => contentInScrollHeight);
-              }}
-            >
-              {content}
-            </ModalPage>
-          </ModalRootTouch>
-        );
-      };
-
-      const component = render(<Fixture />, {
-        baseElement: document.documentElement,
-      });
-      act(jest.runAllTimers);
-      await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-page')));
-
-      return {
-        component,
-        set modalContentClientHeight(height: number) {
-          modalContentClientHeight = height;
-        },
-        set contentInScrollHeight(height: number) {
-          contentInScrollHeight = height;
-        },
-        get innerElementTransform() {
-          return innerElementTransform;
-        },
-      };
-    };
-
-    it('should update modal height without expandable', async () => {
-      const ModalPageContent = withModalRootContext(({ updateModalHeight }) => {
-        return (
-          <div>
-            <Button onClick={updateModalHeight} data-testid="update-height">
-              Обновить
-            </Button>
-          </div>
-        );
-      });
-
-      const mockedData = await updateHeightSetup({
-        content: <ModalPageContent />,
-        defaultContentInScrollHeight: 700,
-        defaultModalContentClientHeight: 800,
-      });
-
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 12.5%, 0)');
-
-      mockedData.modalContentClientHeight = 1000;
-      mockedData.contentInScrollHeight = 700;
-
-      fireEvent.click(mockedData.component.getByTestId('update-height'));
-      act(jest.runAllTimers);
-
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 30%, 0)');
-    });
-
-    it('should update modal height with expandable', async () => {
-      const ModalPageContent = withModalRootContext(({ updateModalHeight }) => {
-        return (
-          <div>
-            <Button onClick={updateModalHeight} data-testid="update-height">
-              Обновить
-            </Button>
-          </div>
-        );
-      });
-
-      const mockedData = await updateHeightSetup({
-        content: <ModalPageContent />,
-        defaultModalContentClientHeight: 600,
-        defaultContentInScrollHeight: 800,
-      });
-
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 25%, 0)');
-
-      mockedData.modalContentClientHeight = 700;
-      mockedData.contentInScrollHeight = 1000;
-
-      fireEvent.click(mockedData.component.getByTestId('update-height'));
-      act(jest.runAllTimers);
-
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 25%, 0)');
-    });
-  });
-
-  describe('touch move events check to modal page', () => {
-    const touchMoveSetup = async ({
-      onClose,
-      settlingHeight,
-      modalPageHeight = 664,
-      modalPageContentClientHeight,
-      contentScrollHeight,
-    }: {
-      onClose: VoidFunction;
-      settlingHeight?: number;
-      modalPageHeight?: number;
-      modalPageContentClientHeight: number;
-      contentScrollHeight: number;
-    }) => {
-      let innerElementTransform = '';
-
-      Object.defineProperty(window, 'innerHeight', {
-        writable: true,
-        configurable: true,
-        value: 720,
-      });
-
-      const Fixture = () => {
-        return (
-          <ModalRootTouch activeModal="modal-page">
-            <ModalPage
-              id="modal-page"
-              data-testid="modal-page"
-              key="1"
-              settlingHeight={settlingHeight}
-              onClose={onClose}
-              getRootRef={(element) => {
-                if (!element) {
-                  return;
-                }
-                jest
-                  .spyOn((element.firstElementChild as HTMLDivElement).style, 'transform', 'set')
-                  .mockImplementation((newTransform) => (innerElementTransform = newTransform));
-                jest
-                  .spyOn(element, 'offsetHeight', 'get')
-                  .mockImplementation(() => modalPageHeight);
-              }}
-              getModalContentRef={(element) => {
-                if (!element) {
-                  return;
-                }
-                jest
-                  .spyOn(element, 'clientHeight', 'get')
-                  .mockImplementation(() => modalPageContentClientHeight);
-                jest
-                  .spyOn(element.firstElementChild!, 'scrollHeight', 'get')
-                  .mockImplementation(() => contentScrollHeight);
-              }}
-            >
-              <div></div>
-            </ModalPage>
-          </ModalRootTouch>
-        );
-      };
-
-      const component = render(<Fixture />, {
-        baseElement: document.documentElement,
-      });
-
-      const header = component.container.getElementsByClassName(modalPageStyles.header)[0];
-      act(jest.runAllTimers);
-      await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-page')));
-
-      return {
-        component,
-        get header() {
-          return header;
-        },
-        get innerElementTransform() {
-          return innerElementTransform;
-        },
-      };
-    };
-
-    it('should hide modal page by touch', async () => {
-      const date = mockDate();
-
-      const onClose = jest.fn();
-
-      const mockedData = await touchMoveSetup({
-        onClose,
-        modalPageContentClientHeight: 608,
-        contentScrollHeight: 1291,
-      });
-      fireEvent.mouseDown(mockedData.header, {
-        clientY: 250,
-      });
-      fireEvent.mouseMove(mockedData.header, {
-        clientY: 350,
-      });
-      date.next();
-      fireEvent.mouseUp(mockedData.header, {
-        client: 350,
-      });
-
-      expect(onClose).toHaveBeenCalledTimes(1);
-    });
-
-    it('should expand and then collapse modal page by touch', async () => {
-      const date = mockDate();
-
-      const onClose = jest.fn();
-
-      const mockedData = await touchMoveSetup({
-        onClose,
-        modalPageContentClientHeight: 608,
-        contentScrollHeight: 1291,
-      });
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 25%, 0)');
-      fireEvent.mouseDown(mockedData.header, {
-        clientY: 250,
-      });
-      fireEvent.mouseMove(mockedData.header, {
-        clientY: 190,
-      });
-      date.next();
-      fireEvent.mouseUp(mockedData.header, {
-        client: 190,
-      });
-      act(jest.runAllTimers);
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 0%, 0)');
-
-      fireEvent.mouseDown(mockedData.header, {
-        clientY: 95,
-      });
-      fireEvent.mouseMove(mockedData.header, {
-        clientY: 180,
-      });
-      date.next();
-      fireEvent.mouseUp(mockedData.header, {
-        client: 180,
-      });
-      act(jest.runAllTimers);
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 25%, 0)');
-
-      expect(onClose).toHaveBeenCalledTimes(0);
-    });
-
-    it('should close modal page when settlingHeight 100 by touch', async () => {
-      const date = mockDate();
-
-      const onClose = jest.fn();
-
-      const mockedData = await touchMoveSetup({
-        onClose,
-        settlingHeight: 100,
-        modalPageContentClientHeight: 600,
-        contentScrollHeight: 1200,
-      });
-
-      expect(mockedData.innerElementTransform).toBe('translate3d(0, 0%, 0)');
-      fireEvent.mouseDown(mockedData.header, {
-        clientY: 95,
-      });
-      fireEvent.mouseMove(mockedData.header, {
-        clientY: 250,
-      });
-      date.next();
-      fireEvent.mouseUp(mockedData.header, {
-        client: 250,
-      });
-      act(jest.runAllTimers);
-      expect(onClose).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('modal card touch move events', () => {
-    const touchMoveSetup = async ({ onClose }: { onClose: VoidFunction }) => {
-      let content: HTMLDivElement;
-      let transform = '';
-      Object.defineProperty(window, 'innerHeight', {
-        writable: true,
-        configurable: true,
-        value: 720,
-      });
-      const Fixture = () => {
-        return (
-          <ModalRootTouch activeModal="modal-card">
-            <ModalCard
-              id="modal-card"
-              data-testid="modal-card"
-              key="1"
-              onClose={onClose}
-              getRootRef={(element) => {
-                if (!element) {
-                  return;
-                }
-                content = element.firstElementChild as HTMLDivElement;
-                jest.spyOn(content, 'offsetHeight', 'get').mockImplementation(() => 320);
-                jest
-                  .spyOn(content.style, 'transform', 'set')
-                  .mockImplementation((newTransform) => (transform = newTransform));
-              }}
-            >
-              <div></div>
-            </ModalCard>
-          </ModalRootTouch>
-        );
-      };
-
-      const component = render(<Fixture />, {
-        baseElement: document.documentElement,
-      });
-      act(jest.runAllTimers);
-      await waitCSSTransitionEnd(getFirstHTMLElementChild(component.getByTestId('modal-card')));
-
-      return {
-        component,
-        get transform() {
-          return transform;
-        },
-        get content() {
-          return content;
-        },
-      };
-    };
-
-    it('should close modal card by touch', async () => {
-      const date = mockDate();
-      const onClose = jest.fn();
-      const mockedData = await touchMoveSetup({
-        onClose,
-      });
-      expect(mockedData.transform).toBe('translate3d(0, 0%, 0)');
-      fireEvent.mouseDown(mockedData.content, {
-        clientY: 400,
-      });
-      fireEvent.mouseMove(mockedData.content, {
-        clientY: 500,
-      });
-      act(jest.runAllTimers);
-      date.next();
-      expect(mockedData.transform).toBe('translate3d(0, 31.25%, 0)');
-      fireEvent.mouseUp(mockedData.content, {
-        clientY: 500,
-      });
-      act(jest.runAllTimers);
-      expect(onClose).toHaveBeenCalledTimes(1);
-    });
-  });
-});
diff --git a/packages/vkui/src/components/ModalRoot/ModalRoot.tsx b/packages/vkui/src/components/ModalRoot/ModalRoot.tsx
index dd7717f69ca..c60e3908b3a 100644
--- a/packages/vkui/src/components/ModalRoot/ModalRoot.tsx
+++ b/packages/vkui/src/components/ModalRoot/ModalRoot.tsx
@@ -1,727 +1,62 @@
 'use client';
 
 import * as React from 'react';
-import { classNames } from '@vkontakte/vkjs';
-import { clamp } from '../../helpers/math';
-import { withContext } from '../../hoc/withContext';
-import { withPlatform } from '../../hoc/withPlatform';
-import { type DOMProps, withDOM } from '../../lib/dom';
-import { getNavId } from '../../lib/getNavId';
-import { rubber } from '../../lib/touch';
+import { noop } from '@vkontakte/vkjs';
 import { warnOnce } from '../../lib/warnOnce';
-import { ConfigProviderContext } from '../ConfigProvider/ConfigProviderContext';
-import { FocusTrap } from '../FocusTrap/FocusTrap';
-import { type CustomTouchEvent, Touch } from '../Touch/Touch';
-import TouchRootContext from '../Touch/TouchContext';
-import { ModalRootContext, type ModalRootContextInterface } from './ModalRootContext';
-import { MODAL_PAGE_DEFAULT_PERCENT_HEIGHT } from './constants';
-import type { ModalRootWithDOMProps, ModalsStateEntry, TranslateRange } from './types';
-import { type ModalTransitionProps, withModalManager } from './useModalManager';
-import styles from './ModalRoot.module.css';
+import { ModalRootContext } from './ModalRootContext';
+import type { ModalRootProps } from './types';
 
 const warn = warnOnce('ModalRoot');
 
-function numberInRange(number: number, range: TranslateRange | undefined) {
-  if (!range) {
-    return false;
-  }
-  return number >= range[0] && number <= range[1];
-}
-
-function rangeTranslate(number: number) {
-  return clamp(number, 0, 98);
-}
-
-interface ModalRootState {
-  touchDown?: boolean;
-  dragging?: boolean;
-  modalOpenedLog: string[];
-}
-
-class ModalRootTouchComponent extends React.Component<
-  ModalRootWithDOMProps & DOMProps & ModalTransitionProps,
-  ModalRootState
-> {
-  constructor(props: ModalRootWithDOMProps & ModalTransitionProps) {
-    super(props);
-    this.state = {
-      touchDown: false,
-      dragging: false,
-      modalOpenedLog: [],
-    };
-
-    this.maskElementRef = React.createRef();
-
-    this.modalRootContext = {
-      updateModalHeight: this.updateModalHeight,
-      registerModal: ({ id, ...data }) => Object.assign(this.props.getModalState(id) ?? {}, data),
-      onClose: () => this.props.onExit(),
-      isInsideModal: true,
-    };
-
-    this.frameIds = {};
-  }
-
-  private readonly maskElementRef: React.RefObject<HTMLDivElement>;
-  private readonly viewportRef = React.createRef<HTMLDivElement>();
-  private maskAnimationFrame: number | undefined = undefined;
-  private readonly modalRootContext: ModalRootContextInterface;
-  private readonly frameIds: {
-    [index: string]: number;
-  };
-  private restoreFocusTo: HTMLElement | undefined | null = undefined;
-
-  get timeout(): number {
-    return this.props.platform === 'ios' ? 400 : 320;
-  }
-
-  get document(): Document {
-    return this.props.document as Document;
-  }
-
-  get window(): Window {
-    return this.props.window as Window;
-  }
-
-  getModals() {
-    return React.Children.toArray(this.props.children) as React.ReactElement[];
-  }
-
-  componentDidMount() {
-    // Отслеживаем изменение размеров viewport
-    this.window?.addEventListener('resize', this.updateModalHeight, false);
-  }
-
-  componentWillUnmount() {
-    this.toggleDocumentScrolling(true);
-    this.window.removeEventListener('resize', this.updateModalHeight, false);
-  }
-
-  componentDidUpdate(prevProps: ModalRootWithDOMProps & ModalTransitionProps) {
-    // transition phase 2: animate exiting modal
-    if (this.props.exitingModal && this.props.exitingModal !== prevProps.exitingModal) {
-      this.closeModal(this.props.exitingModal);
-    }
-
-    // transition phase 3: animate entering modal
-    if (this.props.enteringModal && this.props.enteringModal !== prevProps.enteringModal) {
-      const enteringState = this.props.getModalState(this.props.enteringModal);
-      this.props.onEnter();
-      this.waitTransitionFinish(enteringState, () => {
-        if (enteringState) {
-          if (enteringState.innerElement) {
-            enteringState.innerElement.style.transitionDelay = '';
-          }
-          this.onEntered(enteringState);
-        }
-      });
-
-      if (enteringState?.innerElement) {
-        enteringState.innerElement.style.transitionDelay = this.props.delayEnter
-          ? `${this.timeout}ms`
-          : '';
-        this.animateTranslate(enteringState, enteringState.translateY);
-        this.setMaskOpacity(enteringState, 1);
-      }
-    }
-
-    // focus restoration
-    if (this.props.activeModal && !prevProps.activeModal) {
-      this.restoreFocusTo = this.document.activeElement as HTMLElement;
-    }
-    if (!this.props.activeModal && !this.props.exitingModal && this.restoreFocusTo) {
-      this.restoreFocusTo.focus();
-      this.restoreFocusTo = null;
-    }
-
-    this.toggleDocumentScrolling(!this.props.activeModal && !this.props.exitingModal);
-  }
-
-  /* Отключает скролл документа */
-  toggleDocumentScrolling(enabled: boolean) {
-    if (enabled) {
-      // восстанавливаем значение overscroll behavior
-      // eslint-disable-next-line no-restricted-properties
-      this.document.documentElement.classList.remove('vkui--disable-overscroll-behavior');
-    } else {
-      // отключаем нативный pull-to-refresh при открытом модальном окне
-      // чтобы он не срабатывал при закрытии модалки смахиванием вниз
-      // eslint-disable-next-line no-restricted-properties
-      this.document.documentElement.classList.add('vkui--disable-overscroll-behavior');
-    }
-  }
-
-  checkPageContentHeight() {
-    const modalState = this.props.getModalState(this.props.activeModal);
-
-    if (modalState?.type === 'page' && modalState?.modalElement) {
-      const prevModalState = { ...modalState };
-      initPageModal(modalState);
-      const currentModalState = { ...modalState };
-
-      let needAnimate = false;
-
-      if (prevModalState.expandable === currentModalState.expandable) {
-        if (prevModalState.translateYFrom !== currentModalState.translateYFrom) {
-          needAnimate = true;
-        }
-      } else {
-        needAnimate = true;
-      }
-
-      if (needAnimate) {
-        this.animateTranslate(modalState, modalState.translateY);
-      }
-    }
-  }
-
-  updateModalHeight = () => {
-    const modalState = this.props.getModalState(this.props.activeModal);
-
-    if (modalState && modalState.type === 'page') {
-      if (this.props.enteringModal) {
-        this.waitTransitionFinish(modalState, () => {
-          requestAnimationFrame(() => this.checkPageContentHeight());
-        });
-      } else {
-        requestAnimationFrame(() => this.checkPageContentHeight());
-      }
-    }
-  };
-
-  onEntered({ id, modalElement }: ModalsStateEntry) {
-    if (
-      !this.props.noFocusToDialog &&
-      modalElement &&
-      !modalElement.contains(this.document.activeElement)
-    ) {
-      modalElement.focus();
-    }
-
-    this.props.onEntered(id);
-  }
-
-  closeModal(id: string) {
-    // Сбрасываем состояния, которые могут помешать закрытию модального окна
-    this.setState({ touchDown: false });
-
-    const prevModalState = this.props.getModalState(id);
-
-    if (!prevModalState) {
-      id && warn(`closeActiveModal: модальное окно (страница) ${id} не существует`, 'error');
-      return;
-    }
-    if (!this.state.modalOpenedLog.length) {
-      this.setState((prevState) => ({
-        modalOpenedLog: [...prevState.modalOpenedLog, id],
-      }));
-    }
-    const nextModalState = this.props.getModalState(this.props.activeModal);
-    const nextIsPage = !!nextModalState && nextModalState.type === 'page';
-
-    const prevIsPage = !!prevModalState && prevModalState.type === 'page';
-    this.waitTransitionFinish(prevModalState, () => this.props.onExited(id));
-    const exitTranslate =
-      prevIsPage &&
-      nextIsPage &&
-      (prevModalState.translateY ?? 0) <= (nextModalState?.translateYFrom ?? 0) &&
-      !this.props.isBack
-        ? (nextModalState?.translateYFrom ?? 0) + 10
-        : 100;
-    this.animateTranslate(prevModalState, exitTranslate);
-
-    if (!nextModalState) {
-      // NOTE: was only for clean exit
-      this.setMaskOpacity(prevModalState, 0);
-      this.setState({ modalOpenedLog: [] });
-      prevModalState.translateY = undefined;
-      prevModalState.expandable = undefined;
-    } else if (nextModalState.id && !this.state.modalOpenedLog.includes(nextModalState.id)) {
-      nextModalState.translateY = undefined;
-      this.setState((prevState) => ({
-        modalOpenedLog: [...prevState.modalOpenedLog, nextModalState.id!],
-      }));
-    }
-  }
-
-  onTouchMove = (e: CustomTouchEvent) => {
-    if (this.props.exitingModal) {
-      return;
-    }
-    const modalState = this.props.getModalState(this.props.activeModal);
-    if (!modalState) {
-      return;
-    }
-
-    if (modalState.type === 'page') {
-      return this.onPageTouchMove(e, modalState);
-    }
-
-    if (modalState.type === 'card') {
-      return this.onCardTouchMove(e, modalState);
-    }
-  };
-
-  onPageTouchMove(event: CustomTouchEvent, modalState: ModalsStateEntry) {
-    const { shiftY, originalEvent } = event;
-    const target = originalEvent.target as HTMLElement;
-
-    if (!event.isY) {
-      if (this.viewportRef.current?.contains(target)) {
-        originalEvent.preventDefault();
-      }
-      return;
-    }
-
-    if (!modalState.innerElement?.contains(target)) {
-      return originalEvent.preventDefault();
-    }
-
-    originalEvent.stopPropagation();
-
-    const { expandable, contentScrolled, collapsed, expanded } = modalState;
-
-    if (!this.state.touchDown) {
-      modalState.touchStartContentScrollTop = modalState.contentElement?.scrollTop ?? 0;
-      this.setState({ touchDown: true });
-    }
-
-    if (contentScrolled) {
-      return;
-    }
-
-    if (modalState.touchMovePositive === null) {
-      modalState.touchMovePositive = shiftY > 0;
-    }
-
-    if (
-      !modalState.expandable ||
-      collapsed ||
-      (expanded && modalState.touchMovePositive && modalState.touchStartContentScrollTop === 0) ||
-      modalState.headerElement?.contains(target)
-    ) {
-      originalEvent.preventDefault();
-
-      if ((!expandable && shiftY < 0) || !this.window) {
-        return;
-      }
-
-      !this.state.dragging && this.setState({ dragging: true });
-
-      const shiftYPercent = (shiftY / this.window.innerHeight) * 100;
-      const shiftYCurrent = rubber(shiftYPercent, 72, 0.8, this.props.platform !== 'ios');
-
-      modalState.touchShiftYPercent = shiftYPercent;
-      modalState.translateYCurrent = rangeTranslate((modalState.translateY ?? 0) + shiftYCurrent);
-
-      this.animateTranslate(modalState, modalState.translateYCurrent);
-      this.setMaskOpacity(modalState);
-    }
-  }
-
-  onCardTouchMove(event: CustomTouchEvent, modalState: ModalsStateEntry) {
-    const { originalEvent, shiftY } = event;
-    const target = originalEvent.target as HTMLElement;
-    if (modalState.innerElement?.contains(target)) {
-      if (!this.state.touchDown) {
-        this.setState({ touchDown: true, dragging: true });
-      }
-
-      const shiftYPercent = (shiftY / modalState.innerElement.offsetHeight) * 100;
-      const shiftYCurrent = rubber(shiftYPercent, 72, 1.2, this.props.platform !== 'ios');
-
-      modalState.touchShiftYPercent = shiftYPercent;
-      modalState.translateYCurrent = Math.max(0, (modalState.translateY ?? 0) + shiftYCurrent);
-
-      this.animateTranslate(modalState, modalState.translateYCurrent);
-      this.setMaskOpacity(modalState);
-    }
-  }
-
-  onTouchEnd = (e: CustomTouchEvent) => {
-    const modalState = this.props.getModalState(this.props.activeModal);
-
-    if (modalState?.type === 'page') {
-      return this.onPageTouchEnd(e, modalState);
-    }
-
-    if (modalState?.type === 'card') {
-      return this.onCardTouchEnd(e, modalState);
-    }
-  };
-
-  onPageTouchEnd(event: CustomTouchEvent, modalState: ModalsStateEntry) {
-    const { startY, shiftY } = event;
-
-    modalState.contentScrolled = false;
-    modalState.touchMovePositive = null;
-
-    let setStateCallback;
-
-    if (this.state.dragging && this.window) {
-      const shiftYEndPercent = ((startY + shiftY) / this.window.innerHeight) * 100;
-
-      let translateY = modalState.translateYCurrent ?? 0;
-      const expectTranslateY =
-        (translateY / event.duration) *
-        240 *
-        0.6 *
-        ((modalState.touchShiftYPercent ?? 0) < 0 ? -1 : 1);
-      translateY = rangeTranslate(translateY + expectTranslateY);
-
-      if (modalState.settlingHeight !== 100) {
-        if (numberInRange(translateY, modalState.expandedRange)) {
-          translateY = modalState.expandedRange?.[0] ?? 0;
-        } else if (numberInRange(translateY, modalState.collapsedRange)) {
-          translateY = modalState.translateYFrom ?? 0;
-        } else if (numberInRange(translateY, modalState.hiddenRange)) {
-          translateY = modalState.preventClose ? modalState.translateYFrom ?? 0 : 100;
-        } else {
-          translateY = modalState.translateYFrom ?? 0;
-        }
-      } else {
-        if (numberInRange(translateY, [0, 25])) {
-          translateY = 0;
-        } else {
-          translateY = modalState.preventClose ? modalState.translateYFrom ?? 0 : 100;
-        }
-      }
-
-      if (translateY !== 100 && shiftYEndPercent >= 75 && !modalState.preventClose) {
-        translateY = 100;
-      }
-
-      modalState.translateY = translateY;
-      modalState.translateYCurrent = translateY;
-      modalState.collapsed = numberInRange(translateY, modalState.collapsedRange);
-      modalState.expanded = translateY === 0;
-      modalState.hidden = translateY === 100;
-
-      if (modalState.hidden) {
-        this.props.onExit();
-      }
-
-      setStateCallback = () => {
-        if (!modalState.hidden) {
-          this.animateTranslate(modalState, modalState.translateY);
-        }
-
-        this.setMaskOpacity(modalState);
-      };
-    }
-
-    this.setState(
-      {
-        touchDown: false,
-        dragging: false,
-      },
-      setStateCallback,
-    );
-  }
-
-  onCardTouchEnd({ duration }: CustomTouchEvent, modalState: ModalsStateEntry) {
-    let setStateCallback;
-
-    if (this.state.dragging) {
-      let translateY = modalState.translateYCurrent ?? 0;
-
-      const expectTranslateY =
-        (translateY / duration) * 240 * 0.6 * ((modalState.touchShiftYPercent ?? 0) < 0 ? -1 : 1);
-      translateY = Math.max(0, translateY + expectTranslateY);
-
-      if (translateY >= 30) {
-        translateY = 100;
-      } else {
-        translateY = 0;
-      }
-
-      modalState.translateY = translateY;
-      modalState.hidden = translateY === 100;
-
-      if (modalState.hidden) {
-        this.props.onExit();
-      }
-
-      setStateCallback = () => {
-        if (!modalState.hidden) {
-          this.animateTranslate(modalState, modalState.translateY);
-        }
-
-        this.setMaskOpacity(modalState);
-      };
-    }
-
-    this.setState(
-      {
-        touchDown: false,
-        dragging: false,
-      },
-      setStateCallback,
-    );
-  }
-
-  onScroll = (e: React.SyntheticEvent) => {
-    const activeModal = this.props.activeModal;
-
-    const target = e.target as HTMLElement;
-
-    if (!activeModal) {
-      return;
-    }
-    const modalState = this.props.getModalState(activeModal);
-    if (modalState?.type === 'page' && modalState?.contentElement?.contains(target)) {
-      modalState.contentScrolled = true;
-
-      if (modalState.contentScrollStopTimeout) {
-        clearTimeout(modalState.contentScrollStopTimeout);
-      }
-
-      modalState.contentScrollStopTimeout = setTimeout(() => {
-        if (modalState.contentScrolled) {
-          modalState.contentScrolled = false;
-        }
-      }, 250);
-    }
-  };
-
-  waitTransitionFinish(modalState: ModalsStateEntry | undefined, eventHandler: () => void) {
-    const el = modalState ? modalState.innerElement : null;
-    if (el) {
-      el.addEventListener('transitionend', eventHandler, { once: true });
-    } else {
-      setTimeout(eventHandler, this.timeout);
-    }
-  }
-
-  /**
-   * Анимирует сдвиг модалки
-   *
-   * @param {ModalsStateEntry} modalState
-   * @param {number} percent Процент сдвига: 0 – полностью открыта, 100 – полностью закрыта
-   */
-  animateTranslate(modalState: ModalsStateEntry, percent: number | undefined) {
-    const frameId = `animateTranslateFrame${modalState.id}`;
-
-    cancelAnimationFrame(this.frameIds[frameId]);
-
-    this.frameIds[frameId] = requestAnimationFrame(() => {
-      if (!modalState.innerElement) {
-        return;
-      }
-      modalState.innerElement.style.transform = `translate3d(0, ${percent}%, 0)`;
-    });
-  }
-
-  /* Устанавливает прозрачность для полупрозрачной подложки */
-  setMaskOpacity(modalState: ModalsStateEntry, forceOpacity: number | null = null) {
-    if (forceOpacity === null && this.props.history?.[0] !== modalState.id) {
-      return;
-    }
-    if (this.maskAnimationFrame) {
-      cancelAnimationFrame(this.maskAnimationFrame);
-    }
-    this.maskAnimationFrame = requestAnimationFrame(() => {
-      if (this.maskElementRef.current) {
-        const { translateY = 0, translateYCurrent = 0 } = modalState;
-
-        const opacity =
-          forceOpacity === null
-            ? 1 - (translateYCurrent - translateY) / (100 - translateY) || 0
-            : forceOpacity;
-        this.maskElementRef.current.style.opacity = clamp(opacity, 0, 100).toString();
-        this.maskElementRef.current.style.transitionDelay =
-          opacity && this.props.delayEnter ? `${this.timeout}ms` : '';
-      }
-    });
-  }
-
-  render() {
-    const { activeModal, exitingModal, enteringModal, modalOverlayTestId } = this.props;
-    const { touchDown, dragging } = this.state;
-
-    if (!activeModal && !exitingModal) {
-      return null;
-    }
-
-    return (
-      <TouchRootContext.Provider value={true}>
-        <ModalRootContext.Provider value={this.modalRootContext}>
-          <Touch
-            className={classNames(
-              styles.host,
-              this.props.configProvider?.hasCustomPanelHeaderAfter &&
-                styles.hasCustomPanelHeaderAfterSlot,
-              touchDown && classNames(styles.touched, 'vkuiInternalModalRoot--touched'),
-              !!(enteringModal || exitingModal) &&
-                classNames(styles.switching, 'vkuiInternalModalRoot--switching'),
-            )}
-            onMove={this.onTouchMove}
-            onEnd={this.onTouchEnd}
-            onScroll={this.onScroll}
-          >
-            <div
-              data-testid={modalOverlayTestId}
-              className={styles.mask}
-              onClick={this.props.onExit}
-              ref={this.maskElementRef}
-            />
-            <div className={styles.viewport} ref={this.viewportRef}>
-              {this.getModals().map((Modal) => {
-                const modalId = getNavId(Modal.props, warn);
-                const _modalState = this.props.getModalState(modalId);
-                if ((modalId !== activeModal && modalId !== exitingModal) || !_modalState) {
-                  return null;
-                }
-                const modalState = { ..._modalState };
-
-                const isPage = modalState.type === 'page';
-                const key = `modal-${modalId}`;
-
-                return (
-                  <FocusTrap
-                    key={key}
-                    onClose={this.props.onExit}
-                    timeout={this.timeout}
-                    className={classNames(
-                      styles.modal,
-
-                      dragging && 'vkuiInternalModalRoot__modal--dragging',
-
-                      isPage && modalState.expandable && 'vkuiInternalModalRoot__modal--expandable',
-                      isPage && modalState.collapsed && 'vkuiInternalModalRoot__modal--collapsed',
-                    )}
-                    autoFocus={false}
-                    restoreFocus={false}
-                  >
-                    {Modal}
-                  </FocusTrap>
-                );
-              })}
-            </div>
-          </Touch>
-        </ModalRootContext.Provider>
-      </TouchRootContext.Provider>
-    );
-  }
-}
-
-export const ModalRootTouch: React.FC<ModalRootWithDOMProps> = withContext(
-  withPlatform(
-    withDOM<ModalRootWithDOMProps>(withModalManager(initModal)(ModalRootTouchComponent)),
-  ),
-  ConfigProviderContext,
-  'configProvider',
-);
-
 /**
- * Инициализирует модалку перед анимацией открытия
+ * @see https://vkcom.github.io/VKUI/#/ModalRoot
  */
-function initModal(modalState: ModalsStateEntry) {
-  switch (modalState.type) {
-    case 'page':
-      modalState.settlingHeight = modalState.settlingHeight || MODAL_PAGE_DEFAULT_PERCENT_HEIGHT;
-      return initPageModal(modalState);
-    case 'card':
-      return initCardModal(modalState);
-    default:
-      process.env.NODE_ENV === 'development' &&
-        warn(`initActiveModal: modalState.type="${modalState.type}" не поддерживается`, 'error');
-  }
-}
-
-function initPageModal(modalState: ModalsStateEntry) {
-  const { contentElement, bottomInset } = modalState;
-  const contentElementHeight = calculateModalContentHeight(
-    contentElement?.firstElementChild as HTMLElement,
-    modalState.expandable,
+export const ModalRoot = ({
+  activeModal,
+  children,
+  modalOverlayTestId,
+  noFocusToDialog,
+  onOpen,
+  onOpened,
+  onClose,
+  onClosed,
+}: ModalRootProps): React.ReactNode => {
+  return (
+    <ModalRootContext.Provider
+      value={{
+        isInsideModal: true,
+
+        // base props
+        activeModal,
+        modalOverlayTestId,
+        noFocusToDialog,
+
+        // callbacks
+        onOpen: onOpen || noop,
+        onOpened: onOpened || noop,
+        onClose: onClose || noop,
+        onClosed: onClosed || noop,
+
+        // TODO [>=8] Удалить метод
+        updateModalHeight:
+          /* istanbul ignore next: deprecated */
+          process.env.NODE_ENV === 'development'
+            ? () => {
+                warn('Метод updateModalHeight() устарел и будет удалён в VKUI v8');
+              }
+            : noop,
+
+        // TODO [>=8] Удалить метод
+        registerModal:
+          /* istanbul ignore next: deprecated */
+          process.env.NODE_ENV === 'development'
+            ? () => {
+                warn('Метод registerModal() устарел и будет удалён в VKUI v8');
+              }
+            : noop,
+      }}
+    >
+      {children}
+    </ModalRootContext.Provider>
   );
-  const bottomInsetHeight = bottomInset?.offsetHeight || 0;
-  const contentHeight = contentElementHeight + bottomInsetHeight;
-  let prevTranslateY = modalState.translateY;
-  let prevExpandable = modalState.expandable;
-
-  modalState.expandable =
-    contentHeight > (contentElement?.clientHeight ?? 0) || modalState.settlingHeight === 100;
-
-  let collapsed = false;
-  let expanded = false;
-  let translateYFrom;
-  let translateY;
-  let expandedRange: TranslateRange;
-  let collapsedRange: TranslateRange | undefined;
-  let hiddenRange: TranslateRange;
-
-  const hasCollapsedState = Boolean(modalState.expandable && modalState.settlingHeight !== 100);
-  if (modalState.expandable) {
-    translateYFrom = 100 - (modalState.settlingHeight ?? 0);
-
-    const shiftHalf = translateYFrom / 2;
-    const visiblePart = 100 - translateYFrom;
-
-    expandedRange = [0, shiftHalf];
-    collapsedRange = hasCollapsedState ? [shiftHalf, translateYFrom + visiblePart / 4] : undefined;
-    hiddenRange = [translateYFrom + visiblePart / 4, 100];
-
-    collapsed = hasCollapsedState && translateYFrom > 0;
-    expanded = translateYFrom <= 0;
-    translateY = translateYFrom;
-  } else {
-    const headerHeight = modalState.headerElement?.offsetHeight ?? 0;
-    const height = contentHeight + headerHeight;
-
-    translateYFrom =
-      100 - (height / (modalState.innerElement?.parentElement?.offsetHeight ?? 0)) * 100;
-    translateY = translateYFrom;
-
-    expandedRange = [translateY, translateY + 25];
-    collapsedRange = undefined;
-    hiddenRange = [translateY + 25, translateY + 100];
-  }
-
-  // Свойство expandable может измениться из-за высоты контента, в таком случае на всю высоту не разворачиваем
-  const shouldExpand = prevExpandable && modalState.expandable;
-  // Если модалка может открываться на весь экран, и новый сдвиг больше предыдущего, то откроем её на весь экран
-  if ((shouldExpand && translateY > (prevTranslateY ?? 100)) || modalState.settlingHeight === 100) {
-    translateY = 0;
-  }
-
-  // Если модалка уже раскрыта обновляем состояния
-  if (translateY === 0) {
-    expanded = true;
-    collapsed = false;
-  }
-
-  modalState.expandedRange = expandedRange;
-  modalState.collapsedRange = collapsedRange;
-  modalState.hiddenRange = hiddenRange;
-  modalState.translateY = translateY;
-  modalState.translateYFrom = translateYFrom;
-  modalState.collapsed = collapsed;
-  modalState.expanded = expanded;
-}
-
-function initCardModal(modalState: ModalsStateEntry) {
-  modalState.translateY = 0;
-}
-
-function calculateModalContentHeight(
-  element: HTMLElement,
-  isExpandable: ModalsStateEntry['expandable'],
-) {
-  if (!isExpandable) {
-    return element.scrollHeight;
-  }
-
-  /*
-   * В режиме expandable мы назначаем контейнеру контента высоту 100%, что не даёт
-   * получить реальную высоту контента.
-   * Поэтому мы пересчитываем высоту, временно устанавливая height: auto;
-   * */
-  const currentHeightStyle = element.style.height;
-  element.style.height = 'auto';
-
-  const elementHeight = element.scrollHeight;
-  element.style.height = currentHeightStyle;
-
-  return elementHeight;
-}
+};
diff --git a/packages/vkui/src/components/ModalRoot/ModalRootAdaptive.test.tsx b/packages/vkui/src/components/ModalRoot/ModalRootAdaptive.test.tsx
deleted file mode 100644
index 689c6b8d888..00000000000
--- a/packages/vkui/src/components/ModalRoot/ModalRootAdaptive.test.tsx
+++ /dev/null
@@ -1,41 +0,0 @@
-import { render, screen } from '@testing-library/react';
-import { ModalRoot } from './ModalRootAdaptive';
-
-let isDesktop = true;
-jest.mock('../../hooks/useAdaptivityWithJSMediaQueries', () => ({
-  useAdaptivityWithJSMediaQueries: () => ({
-    isDesktop,
-  }),
-}));
-
-jest.mock('./ModalRootDesktop', () => ({
-  ModalRootDesktop: () => {
-    return <div data-testid="ModalRootDesktop"></div>;
-  },
-}));
-
-jest.mock('./ModalRoot', () => ({
-  ModalRootTouch: () => {
-    return <div data-testid="ModalRootTouch"></div>;
-  },
-}));
-
-describe(ModalRoot, () => {
-  it('check use correct component to render modal root', () => {
-    isDesktop = true;
-    const { rerender } = render(
-      <ModalRoot activeModal="1">
-        <></>
-      </ModalRoot>,
-    );
-    expect(screen.getByTestId('ModalRootDesktop')).toBeInTheDocument();
-
-    isDesktop = false;
-    rerender(
-      <ModalRoot activeModal="1">
-        <></>
-      </ModalRoot>,
-    );
-    expect(screen.getByTestId('ModalRootTouch')).toBeInTheDocument();
-  });
-});
diff --git a/packages/vkui/src/components/ModalRoot/ModalRootAdaptive.tsx b/packages/vkui/src/components/ModalRoot/ModalRootAdaptive.tsx
deleted file mode 100644
index 53533c2a59f..00000000000
--- a/packages/vkui/src/components/ModalRoot/ModalRootAdaptive.tsx
+++ /dev/null
@@ -1,21 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { useAdaptivityWithJSMediaQueries } from '../../hooks/useAdaptivityWithJSMediaQueries';
-import { useScrollLock } from '../AppRoot/ScrollContext';
-import { ModalRootTouch } from './ModalRoot';
-import { ModalRootDesktop } from './ModalRootDesktop';
-import type { ModalRootProps } from './types';
-
-/**
- * @see https://vkcom.github.io/VKUI/#/ModalRoot
- */
-export const ModalRoot = (props: ModalRootProps): React.ReactNode => {
-  const { isDesktop } = useAdaptivityWithJSMediaQueries();
-
-  useScrollLock(!!props.activeModal);
-
-  const RootComponent = isDesktop ? ModalRootDesktop : ModalRootTouch;
-
-  return <RootComponent {...props} />;
-};
diff --git a/packages/vkui/src/components/ModalRoot/ModalRootContext.tsx b/packages/vkui/src/components/ModalRoot/ModalRootContext.tsx
index 0a52c061714..91d34bd0542 100644
--- a/packages/vkui/src/components/ModalRoot/ModalRootContext.tsx
+++ b/packages/vkui/src/components/ModalRoot/ModalRootContext.tsx
@@ -1,54 +1,14 @@
 import * as React from 'react';
-import { useIsomorphicLayoutEffect } from '../../lib/useIsomorphicLayoutEffect';
-import type { ModalElements, ModalsStateEntry, ModalType } from './types';
-
-export type ModalRegistryEntry = ModalElements & Required<Pick<ModalsStateEntry, 'type' | 'id'>>;
-type ModalRefs = { [k in keyof ModalElements]: (e: ModalElements[k]) => void };
-
-export interface ModalRootContextInterface {
-  updateModalHeight: VoidFunction;
-  registerModal: (data: ModalRegistryEntry) => void;
-  onClose?: VoidFunction;
-  isInsideModal: boolean;
-}
+import { noop } from '@vkontakte/vkjs';
+import type { ModalRootContextInterface } from './types';
 
 export const ModalRootContext: React.Context<ModalRootContextInterface> =
   React.createContext<ModalRootContextInterface>({
-    updateModalHeight: () => undefined,
-    registerModal: () => undefined,
+    onOpen: noop,
+    onOpened: noop,
+    onClose: noop,
+    onClosed: noop,
+    updateModalHeight: noop,
+    registerModal: noop,
     isInsideModal: false,
   });
-
-/**
- * All referenced elements must be static
- */
-export function useModalRegistry(
-  id: string | undefined,
-  type: ModalType,
-): {
-  refs: Required<ModalRefs>;
-} {
-  const modalContext = React.useContext(ModalRootContext);
-  const elements = React.useRef<ModalElements>({}).current;
-  useIsomorphicLayoutEffect(() => {
-    if (id !== undefined) {
-      modalContext.registerModal({ ...elements, type, id });
-      // unset refs on  unmount to prevent leak
-      const reset = Object.keys(elements).reduce<ModalRegistryEntry>(
-        (acc, k) => ({ ...acc, [k]: null }),
-        { type, id },
-      );
-      return () => modalContext.registerModal(reset);
-    }
-    return undefined;
-  }, []);
-
-  const refs = React.useRef<Required<ModalRefs>>({
-    modalElement: (e) => (elements.modalElement = e),
-    innerElement: (e) => (elements.innerElement = e),
-    headerElement: (e) => (elements.headerElement = e),
-    contentElement: (e) => (elements.contentElement = e),
-    bottomInset: (e) => (elements.bottomInset = e),
-  }).current;
-  return { refs };
-}
diff --git a/packages/vkui/src/components/ModalRoot/ModalRootDesktop.tsx b/packages/vkui/src/components/ModalRoot/ModalRootDesktop.tsx
deleted file mode 100644
index 98a743477d5..00000000000
--- a/packages/vkui/src/components/ModalRoot/ModalRootDesktop.tsx
+++ /dev/null
@@ -1,243 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { classNames, noop } from '@vkontakte/vkjs';
-import { clamp } from '../../helpers/math';
-import { useObjectMemo } from '../../hooks/useObjectMemo';
-import { usePrevious } from '../../hooks/usePrevious';
-import { useWaitTransitionFinish } from '../../hooks/useWaitTransitionFinish';
-import { useDOM } from '../../lib/dom';
-import { getNavId } from '../../lib/getNavId';
-import { warnOnce } from '../../lib/warnOnce';
-import { useConfigProvider } from '../ConfigProvider/ConfigProviderContext';
-import { FocusTrap } from '../FocusTrap/FocusTrap';
-import { ModalRootContext, type ModalRootContextInterface } from './ModalRootContext';
-import type { ModalRootWithDOMProps, ModalsStateEntry } from './types';
-import { useModalManager } from './useModalManager';
-import styles from './ModalRoot.module.css';
-
-const warn = warnOnce('ModalRoot');
-
-export const ModalRootDesktop = ({
-  activeModal: activeModalProp,
-  children,
-  noFocusToDialog = false,
-  onOpen,
-  onOpened,
-  onClose,
-  onClosed,
-  modalOverlayTestId,
-}: ModalRootWithDOMProps): React.ReactNode => {
-  const maskElementRef = React.useRef<HTMLDivElement>(null);
-  const maskAnimationFrame = React.useRef<number | undefined>(undefined);
-  const restoreFocusTo = React.useRef<HTMLElement | undefined>(undefined);
-
-  const { document } = useDOM();
-  const { hasCustomPanelHeaderAfter, platform } = useConfigProvider();
-  const {
-    activeModal,
-    exitingModal,
-    onExit,
-    getModalState,
-    enteringModal,
-    onEnter,
-    onEntered: onEnteredProp,
-    onExited,
-    history,
-    delayEnter,
-  } = useModalManager(activeModalProp, children, onOpen, onOpened, onClose, onClosed, noop);
-
-  const waitTransitionFinish = useWaitTransitionFinish();
-  const prevProps = usePrevious({
-    exitingModal,
-    enteringModal,
-    activeModal,
-  });
-  const modalRootContext: ModalRootContextInterface = useObjectMemo({
-    updateModalHeight: () => undefined,
-    registerModal: ({ id, ...data }) => Object.assign(getModalState(id) ?? {}, data),
-    onClose: onExit,
-    isInsideModal: true,
-  });
-
-  const timeout = platform === 'ios' ? 400 : 320;
-  const modals = React.Children.toArray(children) as React.ReactElement[];
-
-  /* Анимирует сдвиг модального окна */
-  const animateModalOpacity = (modalState: ModalsStateEntry | undefined, display: boolean) => {
-    if (modalState?.innerElement) {
-      modalState.innerElement.style.transition = '';
-      modalState.innerElement.style.transitionDelay = display && delayEnter ? `${timeout}ms` : '';
-      modalState.innerElement.style.opacity = display ? '1' : '0';
-    }
-  };
-
-  /* Устанавливает прозрачность для полупрозрачной подложки */
-  const setMaskOpacity = (modalState: ModalsStateEntry, forceOpacity: number | null = null) => {
-    if (forceOpacity === null && history?.[0] !== modalState.id) {
-      return;
-    }
-
-    if (maskAnimationFrame.current) {
-      cancelAnimationFrame(maskAnimationFrame.current);
-    }
-    maskAnimationFrame.current = requestAnimationFrame(() => {
-      if (maskElementRef.current) {
-        const { translateY = 0, translateYCurrent = 0 } = modalState;
-
-        const opacity =
-          forceOpacity === null
-            ? 1 - (translateYCurrent - translateY) / (100 - translateY) || 0
-            : forceOpacity;
-        maskElementRef.current.style.opacity = clamp(opacity, 0, 100).toString();
-      }
-    });
-  };
-
-  const onEntered = ({ id, modalElement }: ModalsStateEntry) => {
-    if (!noFocusToDialog && modalElement && !modalElement.contains(document!.activeElement)) {
-      modalElement.focus();
-    }
-
-    onEnteredProp(id);
-  };
-
-  const openModal = () => {
-    if (!enteringModal || !prevProps) {
-      return;
-    }
-
-    const enteringState = getModalState(enteringModal);
-    onEnter();
-
-    // Анимация открытия модального окна
-    if (!prevProps.exitingModal) {
-      requestAnimationFrame(() => {
-        if (enteringModal === enteringModal && enteringState) {
-          waitTransitionFinish(enteringState.innerElement, () => onEntered(enteringState), timeout);
-          animateModalOpacity(enteringState, true);
-          setMaskOpacity(enteringState, 1);
-        }
-      });
-
-      return;
-    }
-
-    // Переход между модальными окнами без анимации
-    requestAnimationFrame(() => {
-      if (enteringState?.innerElement) {
-        enteringState.innerElement.style.transition = 'none';
-        enteringState.innerElement.style.opacity = '1';
-        setMaskOpacity(enteringState, 1);
-      }
-    });
-
-    if (enteringState) {
-      onEntered(enteringState);
-    }
-  };
-
-  const closeModal = (id: string) => {
-    const prevModalState = getModalState(id);
-    if (!prevModalState) {
-      return;
-    }
-
-    // Анимация закрытия модального окна
-    if (!activeModal) {
-      requestAnimationFrame(() => {
-        waitTransitionFinish(
-          prevModalState?.innerElement,
-          (event) => {
-            // Исключаем дочерние элементы
-            if (event && event.target === prevModalState?.innerElement) {
-              onExited(id);
-            } else if (!event) {
-              // Вызвался по тайм-ауту
-              onExited(id);
-            }
-          },
-          timeout,
-        );
-        animateModalOpacity(prevModalState, false);
-        setMaskOpacity(prevModalState, 0);
-      });
-
-      return;
-    }
-
-    // Переход между модальными окнами без анимации
-    onExited(id);
-  };
-
-  React.useEffect(() => {
-    if (!prevProps) {
-      return;
-    }
-
-    // transition phase 2: animate exiting modal
-    if (exitingModal && exitingModal !== prevProps.exitingModal) {
-      closeModal(exitingModal);
-    }
-
-    // transition phase 3: animate entering modal
-    if (enteringModal && enteringModal !== prevProps.enteringModal) {
-      openModal();
-    }
-
-    // focus restoration
-    if (activeModal && !prevProps.activeModal) {
-      restoreFocusTo.current = (document?.activeElement ?? undefined) as HTMLElement | undefined;
-    }
-    if (!activeModal && !exitingModal && restoreFocusTo.current) {
-      restoreFocusTo.current.focus();
-      restoreFocusTo.current = undefined;
-    }
-  });
-
-  if (!activeModal && !exitingModal) {
-    return null;
-  }
-
-  return (
-    <ModalRootContext.Provider value={modalRootContext}>
-      <div
-        className={classNames(
-          styles.host,
-          hasCustomPanelHeaderAfter && styles.hasCustomPanelHeaderAfterSlot,
-          styles.desktop,
-        )}
-      >
-        <div
-          data-testid={modalOverlayTestId}
-          className={styles.mask}
-          ref={maskElementRef}
-          onClick={onExit}
-        />
-        <div className={styles.viewport}>
-          {modals.map((Modal: React.ReactElement) => {
-            const modalId = getNavId(Modal.props, warn);
-            if (modalId !== activeModal && modalId !== exitingModal) {
-              return null;
-            }
-
-            const key = `modal-${modalId}`;
-
-            return (
-              <FocusTrap
-                autoFocus={false}
-                restoreFocus={false}
-                onClose={onExit}
-                timeout={timeout}
-                key={key}
-                className={styles.modal}
-              >
-                {Modal}
-              </FocusTrap>
-            );
-          })}
-        </div>
-      </div>
-    </ModalRootContext.Provider>
-  );
-};
diff --git a/packages/vkui/src/components/ModalRoot/Readme.md b/packages/vkui/src/components/ModalRoot/Readme.md
index 20945bbd68c..0866ea75f61 100644
--- a/packages/vkui/src/components/ModalRoot/Readme.md
+++ b/packages/vkui/src/components/ModalRoot/Readme.md
@@ -62,7 +62,7 @@ const MODAL_CARD_ABOUT = 'say-about';
 const MODAL_CARD_NOTIFICATIONS = 'notifications';
 const MODAL_CARD_CHAT_INVITE = 'chat-invite';
 
-const DynamicModalPage = ({ updateModalHeight, onClose, ...props }) => {
+const DynamicModalPage = ({ onClose, ...props }) => {
   const platform = usePlatform();
   const { sizeX } = useAdaptivityConditionalRender();
   const [expanded, setExpanded] = React.useState(false);
@@ -103,10 +103,10 @@ const DynamicModalPage = ({ updateModalHeight, onClose, ...props }) => {
 const App = () => {
   const { sizeX } = useAdaptivityConditionalRender();
   const { isDesktop } = useAdaptivityWithJSMediaQueries();
-  const [activeModal, setActiveModal] = useState(null);
-  const [modalHistory, setModalHistory] = useState([]);
-  const [randomUser] = useState(() => getRandomUser());
-  const [users] = useState(() =>
+  const [activeModal, setActiveModal] = React.useState(null);
+  const [modalHistory, setModalHistory] = React.useState([]);
+  const [randomUser] = React.useState(() => getRandomUser());
+  const [users] = React.useState(() =>
     'k'
       .repeat(25)
       .split('')
@@ -572,81 +572,10 @@ const App = () => {
 
 Используйте параметр `height`.
 Высоту можно задать как числом (`height={300}`) так и в проценах (`height={'80%'}`).
-Работает и для мобильной версии и для декстопной.
+Работает и для мобильной версии и для десктопной.
 В мобильной версии при появлении модального окна на высоту по умолчанию также влияет значение `settlingHeight`.
 Чтобы отключить его влияние достаточно задать `settlingHeight={100}`.
 
-### Я указал `dynamicContentHeight` у `ModalPage`, но высота модальной страницы не меняется
-
-Если содержимое вашей модальной страницы вынесено в отдельный компонент, и при смене контента не обновляется высота, используйте хук `useModalRootContext` и вызывайте `updateModalHeight` после действий, которые могут привести к смене высоты содержимого.
-
-`src/App.js`
-
-```jsx static
-import SelectModal from './SelectModal';
-
-const App = () => {
-  const [activeModal, setActiveModal] = React.useState('select');
-
-  const modal = (
-    <ModalRoot activeModal={activeModal}>
-      <ModalPage id="select" dynamicContentHeight>
-        <SelectModal />
-      </ModalPage>
-    </ModalRoot>
-  );
-
-  return (
-    <SplitLayout modal={modal}>
-      <SplitCol>
-        <View activePanel="main">
-          <Panel id="main">...</Panel>
-        </View>
-      </SplitCol>
-    </SplitLayout>
-  );
-};
-```
-
-`src/SelectModal.js`
-
-```jsx static
-import { useModalRootContext } from '@vkontakte/vkui';
-
-export const SelectModal = () => {
-  const [items, setItems] = React.useState([]);
-  const [isLoading, setIsLoading] = React.useState(true);
-  const { updateModalHeight } = useModalRootContext();
-
-  const fetchItems = () => {
-    fetch('')
-      .then((r) => r.json())
-      .then((items) => {
-        setItems(items);
-        setIsLoading(false);
-      });
-  };
-
-  React.useEffect(fetchItems, []);
-
-  // После установки стейта и перерисовки компонента SelectModal сообщим ModalRoot об изменениях
-  React.useEffect(updateModalHeight, [items.length]);
-
-  return (
-    <div className="SelectModal">
-      {isLoading && <Spinner />}
-      {!isLoading && (
-        <Group>
-          {items.map((item) => (
-            <Cell key={item.id}>{item.title}</Cell>
-          ))}
-        </Group>
-      )}
-    </div>
-  );
-};
-```
-
 ### В мобильной версии при параметре `autoFocus` у контрола ломается поведение карточки
 
 К сожалению, из-за особенностей React, `autoFocus` ломает CSS анимацию.
@@ -658,7 +587,7 @@ export const SelectModal = () => {
 
 ```jsx static
 const App = () => {
-  const inputRef = useRef(null);
+  const inputRef = React.useRef(null);
 
   const handleOpen = React.useCallback((id) => {
     if (id === 'modal-with-auto-focus' && inputRef.current) {
@@ -684,7 +613,7 @@ const App = () => {
 
 ```jsx static
 const App = () => {
-  const inputRef = useRef(null);
+  const inputRef = React.useRef(null);
 
   const handleOpen = React.useCallback(() => {
     if (inputRef.current) {
@@ -705,8 +634,8 @@ const App = () => {
 
 ```jsx { "props": { "layout": false, "adaptivity": true } }
 const Example = () => {
-  const firstInputRef = useRef(null);
-  const secondInputRef = useRef(null);
+  const firstInputRef = React.useRef(null);
+  const secondInputRef = React.useRef(null);
   const [activeModal, setActiveModal] = React.useState(false);
 
   const handleOpenOfModalRoot = React.useCallback((id) => {
diff --git a/packages/vkui/src/components/ModalRoot/constants.ts b/packages/vkui/src/components/ModalRoot/constants.ts
deleted file mode 100644
index 882fe0827b5..00000000000
--- a/packages/vkui/src/components/ModalRoot/constants.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const MODAL_PAGE_DEFAULT_PERCENT_HEIGHT = 75;
diff --git a/packages/vkui/src/components/ModalRoot/types.ts b/packages/vkui/src/components/ModalRoot/types.ts
index 9cbef48943b..3ee78668343 100644
--- a/packages/vkui/src/components/ModalRoot/types.ts
+++ b/packages/vkui/src/components/ModalRoot/types.ts
@@ -1,13 +1,16 @@
-import type { DOMContextInterface } from '../../lib/dom';
-import type { HasPlatform } from '../../types';
-import type { ConfigProviderContextInterface } from '../ConfigProvider/ConfigProviderContext';
-
+/**
+ * @deprecated
+ */
 export type ModalType = 'page' | 'card';
 
+/**
+ * @deprecated
+ */
 export type TranslateRange = [number, number];
 
-export type ModalsState = { [index: string]: ModalsStateEntry };
-
+/**
+ * @deprecated
+ */
 export interface ModalElements {
   modalElement?: HTMLElement | null;
   innerElement?: HTMLElement | null;
@@ -16,6 +19,9 @@ export interface ModalElements {
   bottomInset?: HTMLElement | null;
 }
 
+/**
+ * @deprecated
+ */
 export interface ModalsStateEntry extends ModalElements {
   id: string | null;
   /**
@@ -72,44 +78,63 @@ export interface ModalsStateEntry extends ModalElements {
   preventClose?: boolean;
 }
 
-export interface ModalRootProps {
+type ModalRootBaseProps = {
   activeModal?: string | null;
-  children: React.ReactElement | Iterable<React.ReactElement>;
 
+  /**
+   * `data-testid` для маски
+   */
+  modalOverlayTestId?: string;
+
+  /**
+   * Отключает фокус на контейнер диалогового окна при открытии.
+   */
+  noFocusToDialog?: boolean;
+};
+
+type ModalRootCallbacks = {
   /**
    * Будет вызвано при начале открытия активной модалки с её id
    */
-  onOpen?: (modalId: string) => void;
+  onOpen: (modalId: string) => void;
 
   /**
    * Будет вызвано при окончательном открытии активной модалки с её id
    */
-  onOpened?: (modalId: string) => void;
+  onOpened: (modalId: string) => void;
 
   /**
    * Будет вызвано при начале закрытия активной модалки с её id
    */
-  onClose?: (modalId: string) => void;
+  onClose: (modalId: string) => void;
 
   /**
    * Будет вызвано при окончательном закрытии активной модалки с её id
    */
-  onClosed?: (modalId: string) => void;
+  onClosed: (modalId: string) => void;
+};
+
+export interface ModalRootProps extends ModalRootBaseProps, Partial<ModalRootCallbacks> {
+  children: React.ReactElement | Iterable<React.ReactElement>;
+}
 
+export interface ModalRootContextInterface extends ModalRootBaseProps, ModalRootCallbacks {
   /**
-   * `data-testid` для маски
+   * Обозначает, в контексте ли модального окна мы сейчас.
    */
-  modalOverlayTestId?: string;
+  isInsideModal: boolean;
 
   /**
-   * Отключает фокус на контейнер диалогового окна при открытии.
+   * С **VKUI v7** задача с обновлением высоты контента при `dynamicContentHeight` решается через CSS.
+   *
+   * @deprecated будет удалён в **VKUI v8**
    */
-  noFocusToDialog?: boolean;
-}
+  updateModalHeight: VoidFunction;
 
-export interface ModalRootWithDOMProps extends HasPlatform, ModalRootProps, DOMContextInterface {
   /**
-   * @ignore
+   * С **VKUI v7** регистрация модальных окон больше не требуется.
+   *
+   * @deprecated будет удалён в **VKUI v8**
    */
-  configProvider?: ConfigProviderContextInterface;
+  registerModal: (data: ModalElements & Required<Pick<ModalsStateEntry, 'type' | 'id'>>) => void;
 }
diff --git a/packages/vkui/src/components/ModalRoot/useModalManager.test.tsx b/packages/vkui/src/components/ModalRoot/useModalManager.test.tsx
deleted file mode 100644
index 8c01a61b815..00000000000
--- a/packages/vkui/src/components/ModalRoot/useModalManager.test.tsx
+++ /dev/null
@@ -1,302 +0,0 @@
-import * as React from 'react';
-import { act } from 'react';
-import { renderHook } from '@testing-library/react';
-import { noop } from '@vkontakte/vkjs';
-import { modalTransitionReducer, useModalManager } from './useModalManager';
-
-const MockModal = (p: any) => <div {...p} />;
-
-describe(useModalManager, () => {
-  describe('manages multi-phase transition', () => {
-    const modals = [<MockModal id="m1" key="m1" />, <MockModal id="m2" key="m2" />];
-    it('can enter on mount', () => {
-      const handle = renderHook(({ id }) => useModalManager(id, modals), {
-        initialProps: { id: 'm1' },
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm1',
-        enteringModal: 'm1',
-        exitingModal: null,
-        delayEnter: false,
-      });
-      act(() => {
-        handle.result.current.onEntered('m1');
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm1',
-        enteringModal: null,
-        exitingModal: null,
-      });
-    });
-    it('can enter on update', () => {
-      const handle = renderHook(({ id }) => useModalManager(id, modals), {
-        initialProps: { id: null as string | null },
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: null,
-        enteringModal: null,
-        exitingModal: null,
-      });
-      handle.rerender({ id: 'm1' });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm1',
-        enteringModal: 'm1',
-        exitingModal: null,
-        delayEnter: false,
-      });
-
-      act(() => {
-        handle.result.current.onEntered('m1');
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm1',
-        enteringModal: null,
-        exitingModal: null,
-      });
-    });
-    const flushMount = (initId: string | null = null) => {
-      const handle = renderHook(({ id }) => useModalManager(id, modals), {
-        initialProps: { id: initId },
-      });
-      act(() => {
-        handle.result.current.onEntered(initId);
-      });
-      return handle;
-    };
-    it('can exit', () => {
-      const handle = flushMount('m1');
-      handle.rerender({ id: null });
-      expect(handle.result.current).toMatchObject({
-        activeModal: null,
-        enteringModal: null,
-        exitingModal: 'm1',
-      });
-      act(() => {
-        handle.result.current.onExited('m1');
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: null,
-        enteringModal: null,
-        exitingModal: null,
-      });
-    });
-    it.each([
-      ['card', 'card', true],
-      ['page', 'page', false],
-    ] as const)('transitions %s -> %s with delay=%s', (t1, t2, delayEnter) => {
-      const handle = flushMount('m1');
-      handle.result.current.getModalState('m1')!.type = t1;
-      handle.result.current.getModalState('m2')!.type = t2;
-      handle.rerender({ id: 'm2' });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm2',
-        enteringModal: 'm2',
-        exitingModal: 'm1',
-        delayEnter,
-      });
-      act(() => {
-        handle.result.current.onExited('m1');
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm2',
-        enteringModal: 'm2',
-        exitingModal: null,
-      });
-      act(() => {
-        handle.result.current.onEntered('m2');
-      });
-      expect(handle.result.current).toMatchObject({
-        activeModal: 'm2',
-        enteringModal: null,
-        exitingModal: null,
-      });
-    });
-  });
-
-  describe('maintains transition history', () => {
-    it('initializes with activeModal', () => {
-      const handle = renderHook(() => useModalManager('m1', <MockModal id="m1" />, noop, noop));
-      expect(handle.result.current.history).toEqual(['m1']);
-    });
-    it('initializes empty if activeModal=null', () => {
-      const handle = renderHook(() => useModalManager(null, []));
-      expect(handle.result.current.history).toEqual([]);
-    });
-    it('Handles transition forward', () => {
-      const { history, isBack } = modalTransitionReducer(
-        {
-          history: [],
-        },
-        { type: 'setActive', id: 'm1' },
-      );
-      expect(history).toEqual(['m1']);
-      expect(isBack).toBe(false);
-    });
-    it('Handles transition back', () => {
-      const { history, isBack } = modalTransitionReducer(
-        {
-          history: ['m1', 'm2', 'm3'],
-        },
-        { type: 'setActive', id: 'm2' },
-      );
-      expect(history).toEqual(['m1', 'm2']);
-      expect(isBack).toBe(true);
-    });
-    it('resets on activeModal=null', () => {
-      const { history, isBack } = modalTransitionReducer(
-        {
-          history: ['m1', 'm2', 'm3'],
-        },
-        { type: 'setActive', id: null },
-      );
-      expect(history).toEqual([]);
-      expect(isBack).toBe(false);
-    });
-  });
-
-  describe('ignores missing modal', () => {
-    it('on init', () => {
-      const handle = renderHook(() => useModalManager('m1', []));
-      expect(handle.result.current.activeModal).toEqual(null);
-      expect(handle.result.current.history).toEqual([]);
-    });
-    it('on update', () => {
-      const handle = renderHook(({ id }) => useModalManager(id, []), {
-        initialProps: { id: null as string | null },
-      });
-      handle.rerender({ id: 'm1' });
-      expect(handle.result.current.activeModal).toEqual(null);
-    });
-  });
-
-  it('handles dynamic modals', () => {
-    // const handle = renderHook(({ id = "m1", children = [] }) =>
-    //   useModalManager(id, children, noop)
-    // );
-    // handle.rerender({ children: <MockModal id="m2" /> });
-
-    const handle = renderHook(({ id, children }) => useModalManager(id, children), {
-      initialProps: {
-        id: 'm1' as string | null,
-        children: [] as React.ReactNode | undefined,
-      },
-    });
-    handle.rerender({
-      children: <MockModal id="m2" />,
-      id: 'm1',
-    });
-    expect(handle.result.current.getModalState('m2')).toBeTruthy();
-  });
-
-  describe('open phase', () => {
-    it('calls active modal onOpen', () => {
-      const onOpenOfComponent = jest.fn();
-      const onOpenOfArgument = jest.fn();
-      const handle = renderHook(() =>
-        useModalManager('m1', <MockModal id="m1" onOpen={onOpenOfComponent} />, onOpenOfArgument),
-      );
-      handle.result.current.onEnter();
-      expect(onOpenOfComponent).toHaveBeenCalledTimes(1);
-      expect(onOpenOfArgument).toHaveBeenCalledTimes(0);
-    });
-    it('calls own onOpen if missing in modal props', () => {
-      const onOpen = jest.fn();
-      const handle = renderHook(() => useModalManager('m1', <MockModal id="m1" />, onOpen));
-      handle.result.current.onEnter();
-      expect(onOpen).toHaveBeenCalledTimes(1);
-    });
-    it('calls active modal onOpened', () => {
-      const onOpenedOfComponent = jest.fn();
-      const onOpenedOfArgument = jest.fn();
-      const handle = renderHook(() =>
-        useModalManager(
-          'm1',
-          <MockModal id="m1" onOpened={onOpenedOfComponent} settlingHeight={100} />,
-          noop,
-          onOpenedOfArgument,
-        ),
-      );
-      act(() => {
-        handle.result.current.onEntered('m1');
-      });
-      expect(onOpenedOfComponent).toHaveBeenCalledTimes(1);
-      expect(onOpenedOfArgument).toHaveBeenCalledTimes(0);
-    });
-    it('calls own onOpened if missing in modal props', () => {
-      const onOpened = jest.fn();
-      const handle = renderHook(() => useModalManager('m1', <MockModal id="m1" />, noop, onOpened));
-      act(() => {
-        handle.result.current.onEntered('m1');
-      });
-      expect(onOpened).toHaveBeenCalledTimes(1);
-    });
-
-    it('should show error when activeModal does not exist', () => {
-      process.env.NODE_ENV = 'development';
-      const error = jest.spyOn(console, 'error').mockImplementation(noop);
-      renderHook(() => useModalManager('m2', <MockModal id="m1" />, noop));
-      expect(error).toHaveBeenCalledWith(
-        '%c[VKUI/ModalRoot] Переход невозможен - модальное окно (страница) m2 не существует',
-        undefined,
-      );
-      error.mockClear();
-      process.env.NODE_ENV = 'test';
-    });
-  });
-
-  describe('exit phase', () => {
-    it('calls active modal onClose', () => {
-      const onCloseOfComponent = jest.fn();
-      const onCloseOfArgument = jest.fn();
-      const handle = renderHook(() =>
-        useModalManager(
-          'm1',
-          <MockModal id="m1" onClose={onCloseOfComponent} />,
-          noop,
-          noop,
-          onCloseOfArgument,
-        ),
-      );
-      handle.result.current.onExit();
-      expect(onCloseOfComponent).toHaveBeenCalledTimes(1);
-      expect(onCloseOfArgument).toHaveBeenCalledTimes(0);
-    });
-    it('calls own onClose if missing in modal props', () => {
-      const onClose = jest.fn();
-      const handle = renderHook(() =>
-        useModalManager('m1', <MockModal id="m1" />, noop, noop, onClose),
-      );
-      handle.result.current.onExit();
-      expect(onClose).toHaveBeenCalledTimes(1);
-    });
-    it('calls active modal onClosed', () => {
-      const onClosedOfComponent = jest.fn();
-      const onClosedOfArgument = jest.fn();
-      const handle = renderHook(() =>
-        useModalManager(
-          'm1',
-          <MockModal id="m1" onClosed={onClosedOfComponent} />,
-          noop,
-          noop,
-          noop,
-          onClosedOfArgument,
-        ),
-      );
-      act(() => {
-        handle.result.current.onExited('m1');
-      });
-      expect(onClosedOfComponent).toHaveBeenCalledTimes(1);
-      expect(onClosedOfArgument).toHaveBeenCalledTimes(0);
-    });
-    it('calls own onClosed if missing in modal props', () => {
-      const onClosed = jest.fn();
-      const handle = renderHook(() =>
-        useModalManager('m1', <MockModal id="m1" />, noop, noop, noop, onClosed),
-      );
-      act(() => {
-        handle.result.current.onExited('m1');
-      });
-      expect(onClosed).toHaveBeenCalledTimes(1);
-    });
-  });
-});
diff --git a/packages/vkui/src/components/ModalRoot/useModalManager.tsx b/packages/vkui/src/components/ModalRoot/useModalManager.tsx
index 41c79fcb7cc..311028bbcf2 100644
--- a/packages/vkui/src/components/ModalRoot/useModalManager.tsx
+++ b/packages/vkui/src/components/ModalRoot/useModalManager.tsx
@@ -1,244 +1,89 @@
-'use client';
-
-import * as React from 'react';
-import { isFunction, noop } from '@vkontakte/vkjs';
-import { getNavId } from '../../lib/getNavId';
+import { useContext, useState } from 'react';
 import { useIsomorphicLayoutEffect } from '../../lib/useIsomorphicLayoutEffect';
-import { warnOnce } from '../../lib/warnOnce';
-import type { HasChildren } from '../../types';
-import type { ModalsState, ModalsStateEntry } from './types';
-
-interface ModalTransitionState {
-  activeModal?: string | null;
-  enteringModal?: string | null;
-  exitingModal?: string | null;
-  history?: string[];
-  isBack?: boolean | null;
-}
-
-export interface ModalTransitionProps extends ModalTransitionState {
-  onEnter: VoidFunction;
-  onEntered: (id: string | null) => void;
-  onExit: VoidFunction;
-  onExited: (id: string | null) => void;
-  getModalState: (id: string | undefined | null) => ModalsStateEntry | undefined;
-  delayEnter: boolean;
-}
-
-function getModals(children: React.ReactNode | React.ReactNode[]) {
-  return React.Children.toArray(children) as React.ReactElement[];
+import { ModalRootContext } from './ModalRootContext';
+
+export interface UseModalManager {
+  id: string;
+  open: boolean;
+  keepMounted: boolean;
+  modalOverlayTestId?: string;
+  disableAutoFocus?: boolean;
+  onOpen?: (...args: any[]) => any;
+  onOpened?: (...args: any[]) => any;
+  onClose?: (...args: any[]) => any;
+  onClosed?: (...args: any[]) => any;
 }
 
-const warn = warnOnce('ModalRoot');
-
-export function modalTransitionReducer(
-  state: ModalTransitionState,
-  action: {
-    type: 'setActive' | 'entered' | 'exited' | 'inited';
-    id: string | null;
-  },
-): ModalTransitionState {
-  if (action.type === 'setActive' && action.id !== state.activeModal) {
-    const nextModal = action.id;
-    // preserve exiting modal if switching mid-transition
-    const prevModal = state.exitingModal || state.activeModal;
-    let history = state.history ? [...state.history] : [];
-    const isBack = Boolean(nextModal && history.includes(nextModal));
-
-    if (nextModal === null) {
-      history = [];
-    } else if (isBack) {
-      history = history.splice(0, history.indexOf(nextModal) + 1);
-    } else {
-      history.push(nextModal);
-    }
-
-    return {
-      activeModal: nextModal,
-      // not entering yet
-      enteringModal: null,
-      exitingModal: prevModal,
-      history,
-      isBack,
-    };
-  }
-  if (action.type === 'entered' && action.id === state.enteringModal) {
-    return { ...state, enteringModal: null };
-  }
-  if (action.type === 'exited' && action.id === state.exitingModal) {
-    return { ...state, exitingModal: null };
-  }
-  if (action.type === 'inited' && action.id === state.activeModal) {
-    return { ...state, enteringModal: action.id };
-  }
-  return state;
+export interface UseModalManagerResolvedProps {
+  open: boolean;
+  modalOverlayTestId?: string;
+  disableAutoFocus?: boolean;
+  onOpen?: (...args: any[]) => any;
+  onOpened?: (...args: any[]) => any;
+  onClose?: (...args: any[]) => any;
+  onClosed?: (...args: any[]) => any;
 }
 
-/**
- * Реализует переход модалок. При смене activeModal m1 -> m2:
- * 1. activeModal: m1, exitingModal: null, enteringModal: null, триггер перехода
- * 2. activeModal: m2, exitingModal: m1, enteringModal: null, рендерим m2 чтобы прошел init, начинаем анимацию выхода
- * одновременный переход между ModalPage:
- *   3a. activeModal: m2, exitingModal: m1, enteringModal: m2
- *   4a. exitingModal и enteringModal переходят в null в порядке завершения анимации
- * ИЛИ дожидаемся скрытия ModalCard
- *   3b. activeModal: m2, exitingModal: null, enteringModal: m2
- *   4b. enteringModal переходит в null после завершения анимации
- * 5. activeModal: m2, exitingModal: null, enteringModal: null, переход закончен
- */
-export function useModalManager(
-  activeModal: string | null | undefined,
-  children: React.ReactNode | React.ReactNode[],
-  onOpen: (id: string) => void = noop,
-  onOpened: (id: string) => void = noop,
-  onClose: (id: string) => void = noop,
-  onClosed: (id: string) => void = noop,
-  initModal: (state: ModalsStateEntry) => void = noop,
-): ModalTransitionProps {
-  const modalsState = React.useRef<ModalsState>({}).current;
-  getModals(children).forEach((Modal) => {
-    const modalProps = Modal.props;
-    const id = getNavId(modalProps, warn);
-    const state: ModalsStateEntry = (id !== undefined && modalsState[id]) || {
-      id: id ?? null,
-    };
-
-    state.onOpen = Modal.props.onOpen;
-    state.onOpened = Modal.props.onOpened;
-    state.onClose = Modal.props.onClose;
-    state.onClosed = Modal.props.onClosed;
-    state.preventClose = Modal.props.preventClose;
-    // ModalPage props
-    if (typeof modalProps.settlingHeight === 'number') {
-      state.settlingHeight = modalProps.settlingHeight;
-    }
-
-    if (state.id !== null) {
-      modalsState[state.id] = state;
-    }
-  });
-
-  const isMissing = activeModal && !modalsState[activeModal];
-  const safeActiveModal = isMissing ? null : activeModal;
-  const [transitionState, dispatchTransition] = React.useReducer(modalTransitionReducer, {
-    activeModal: safeActiveModal,
-    enteringModal: null,
-    exitingModal: null,
-    history: safeActiveModal ? [safeActiveModal] : [],
-    isBack: false,
-  });
-
-  // Map props to state, render activeModal for init
-  useIsomorphicLayoutEffect(() => {
-    // ignore non-existent activeModal
-    if (process.env.NODE_ENV === 'development' && isMissing) {
-      warn(`Переход невозможен - модальное окно (страница) ${activeModal} не существует`, 'error');
-    }
-    dispatchTransition({ type: 'setActive', id: safeActiveModal ?? null });
-  }, [activeModal]);
-
-  // Init activeModal & set enteringModal
-  useIsomorphicLayoutEffect(() => {
-    if (transitionState.activeModal) {
-      initModal(modalsState[transitionState.activeModal]);
-      dispatchTransition({ type: 'inited', id: transitionState.activeModal });
-    }
-  }, [transitionState.activeModal]);
-
-  const isCard = (id: string | null | undefined) => id != null && modalsState[id]?.type === 'card';
-  const onEntered = React.useCallback(
-    (id: string | null) => {
-      if (id) {
-        const modalState = modalsState[id];
-
-        if (isFunction(modalState.onOpened)) {
-          modalState.onOpened();
-        } else if (isFunction(onOpened)) {
-          onOpened(id);
-        }
+export const useModalManager = ({
+  id,
+  open,
+  keepMounted,
+  modalOverlayTestId,
+  disableAutoFocus,
+  onOpen: onOpenProp,
+  onOpened: onOpenedProp,
+  onClose: onCloseProp,
+  onClosed: onClosedProp,
+}: UseModalManager):
+  | { unmounted: true }
+  | ({ unmounted: false } & UseModalManagerResolvedProps) => {
+  const context = useContext(ModalRootContext);
+  const opened = context.isInsideModal ? context.activeModal === id : open;
+  const [unmounted, setUnmounted] = useState(keepMounted ? false : !opened);
+
+  useIsomorphicLayoutEffect(
+    function unsetUnmounted() {
+      if (!keepMounted && opened) {
+        setUnmounted((prev) => (prev ? false : prev));
       }
-
-      dispatchTransition({ type: 'entered', id });
-    },
-    [modalsState, onOpened],
-  );
-  const onExited = React.useCallback(
-    (id: string | null) => {
-      if (id) {
-        const modalState = modalsState[id];
-
-        if (isFunction(modalState.onClosed)) {
-          modalState.onClosed();
-        } else if (isFunction(onClosed)) {
-          onClosed(id);
-        }
-      }
-
-      dispatchTransition({ type: 'exited', id });
     },
-    [modalsState, onClosed],
-  );
-  const delayEnter = Boolean(
-    transitionState.exitingModal && (isCard(activeModal) || isCard(transitionState.exitingModal)),
-  );
-  const getModalState = React.useCallback(
-    (id: string | undefined | null) => (id ? modalsState[id] : undefined),
-    [modalsState],
+    [opened, keepMounted],
   );
 
-  function onEnter() {
-    const modalState = transitionState.activeModal && modalsState[transitionState.activeModal];
-    if (modalState) {
-      if (isFunction(modalState.onOpen)) {
-        modalState.onOpen();
-      } else if (isFunction(onOpen) && modalState.id) {
-        onOpen(modalState.id);
-      }
-    }
-  }
-
-  function onExit() {
-    const modalState = transitionState.activeModal && modalsState[transitionState.activeModal];
-    if (modalState && !modalState.preventClose) {
-      if (isFunction(modalState.onClose)) {
-        modalState.onClose();
-      } else if (isFunction(onClose) && modalState.id) {
-        onClose(modalState.id);
-      }
-    }
+  if (unmounted) {
+    return { unmounted: true };
   }
 
   return {
-    onEnter,
-    onEntered,
-    onExit,
-    onExited,
-    ...transitionState,
-    delayEnter,
-    getModalState,
-  };
-}
-
-type WithModalManager<Props extends ModalTransitionProps> = HasChildren &
-  Omit<Props, keyof ModalTransitionProps> & {
-    activeModal?: string | null;
-  };
+    unmounted: false,
+    open: opened,
+    modalOverlayTestId: modalOverlayTestId || context.modalOverlayTestId,
+    disableAutoFocus: disableAutoFocus || context.noFocusToDialog,
+    onOpen:
+      onOpenProp ||
+      function fallbackOnOpenToContext() {
+        context.onOpen(id);
+      },
+    onOpened:
+      onOpenedProp ||
+      function fallbackOnOpenedToContext() {
+        context.onOpened(id);
+      },
+    onClose:
+      onCloseProp ||
+      function fallbackOnCloseByContext() {
+        context.onClose(id);
+      },
+    onClosed: function onClosed(...args: any[]) {
+      if (!keepMounted) {
+        setUnmounted(true);
+      }
 
-export function withModalManager(initModal: (a: ModalsStateEntry) => void = noop) {
-  return function <Props extends ModalTransitionProps>(
-    Wrapped: React.ComponentType<Props>,
-  ): React.ComponentType<WithModalManager<Props>> {
-    return function WithModalManager(props) {
-      const transitionManager = useModalManager(
-        props.activeModal,
-        props.children,
-        (props as any).onOpen,
-        (props as any).onOpened,
-        (props as any).onClose,
-        (props as any).onClosed,
-        initModal,
-      );
-      return <Wrapped {...(props as any)} {...transitionManager} />;
-    };
+      if (onClosedProp) {
+        onClosedProp(...args);
+      } else {
+        context.onClosed(id);
+      }
+    },
   };
-}
+};
diff --git a/packages/vkui/src/components/ModalRoot/useModalRootContext.tsx b/packages/vkui/src/components/ModalRoot/useModalRootContext.tsx
index 9dbbcb505a8..e76b6b72f8c 100644
--- a/packages/vkui/src/components/ModalRoot/useModalRootContext.tsx
+++ b/packages/vkui/src/components/ModalRoot/useModalRootContext.tsx
@@ -1,5 +1,6 @@
 import * as React from 'react';
-import { ModalRootContext, type ModalRootContextInterface } from './ModalRootContext';
+import { ModalRootContext } from './ModalRootContext';
+import type { ModalRootContextInterface } from './types';
 
 export const useModalRootContext = (): ModalRootContextInterface =>
   React.useContext(ModalRootContext);
diff --git a/packages/vkui/src/components/ModalRoot/withModalRootContext.test.tsx b/packages/vkui/src/components/ModalRoot/withModalRootContext.test.tsx
index bdaf5c98516..5027b974727 100644
--- a/packages/vkui/src/components/ModalRoot/withModalRootContext.test.tsx
+++ b/packages/vkui/src/components/ModalRoot/withModalRootContext.test.tsx
@@ -20,6 +20,10 @@ describe(withModalRootContext, () => {
       <ModalRootContext.Provider
         value={{
           isInsideModal: false,
+          onOpen: noop,
+          onOpened: noop,
+          onClose: noop,
+          onClosed: noop,
           updateModalHeight: updateModalHeight,
           registerModal: noop,
         }}
diff --git a/packages/vkui/src/components/ModalRoot/withModalRootContext.tsx b/packages/vkui/src/components/ModalRoot/withModalRootContext.tsx
index 67170443c46..911982a197a 100644
--- a/packages/vkui/src/components/ModalRoot/withModalRootContext.tsx
+++ b/packages/vkui/src/components/ModalRoot/withModalRootContext.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import * as React from 'react';
-import type { ModalRootContextInterface } from './ModalRootContext';
+import type { ModalRootContextInterface } from './types';
 import { useModalRootContext } from './useModalRootContext';
 
 type PickedProps = Pick<ModalRootContextInterface, 'updateModalHeight'>;
diff --git a/packages/vkui/src/components/SplitLayout/SplitLayout.stories.tsx b/packages/vkui/src/components/SplitLayout/SplitLayout.stories.tsx
index a17021db755..a0fa888356f 100644
--- a/packages/vkui/src/components/SplitLayout/SplitLayout.stories.tsx
+++ b/packages/vkui/src/components/SplitLayout/SplitLayout.stories.tsx
@@ -16,7 +16,7 @@ import { CellButton } from '../CellButton/CellButton';
 import { Group } from '../Group/Group';
 import { ModalPage } from '../ModalPage/ModalPage';
 import { ModalPageHeader } from '../ModalPageHeader/ModalPageHeader';
-import { ModalRoot } from '../ModalRoot/ModalRootAdaptive';
+import { ModalRoot } from '../ModalRoot/ModalRoot';
 import { Panel } from '../Panel/Panel';
 import { PanelHeader } from '../PanelHeader/PanelHeader';
 import { Placeholder } from '../Placeholder/Placeholder';
diff --git a/packages/vkui/src/helpers/range.ts b/packages/vkui/src/helpers/range.ts
index 715a2febfba..982c67f1c25 100644
--- a/packages/vkui/src/helpers/range.ts
+++ b/packages/vkui/src/helpers/range.ts
@@ -24,3 +24,7 @@ export function rangeIncrement(from: number, to: number, step = 1): number[] {
 
   return range(from, to, step);
 }
+
+export function inRange(number: number, from: number, to: number) {
+  return number >= from && number <= to;
+}
diff --git a/packages/vkui/src/hooks/useKeyboard.ts b/packages/vkui/src/hooks/useKeyboard.ts
deleted file mode 100644
index 363b6d050f0..00000000000
--- a/packages/vkui/src/hooks/useKeyboard.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import * as React from 'react';
-import { useDOM } from '../lib/dom';
-import { useGlobalEventListener } from './useGlobalEventListener';
-
-interface SoftwareKeyboardState {
-  isOpened: boolean;
-}
-
-/**
- Проверяет, закрыла ли клавиатура часть экрана, 24% подошло к большинству устройств
- Работает на iOS и Android, где софт-клавиатура ресайзит viewport в браузерах
- */
-export function getPreciseKeyboardState(window: any): boolean {
-  const {
-    innerHeight,
-    screen: { availHeight },
-  } = window;
-
-  const coveredViewportPercentage = Math.round((1 - innerHeight / availHeight) * 100);
-  return coveredViewportPercentage > 24;
-}
-
-const eventOptions = {
-  passive: true,
-  capture: false,
-};
-
-export function useKeyboard(): SoftwareKeyboardState {
-  const { document } = useDOM();
-
-  const [isOpened, setIsOpened] = React.useState(false);
-
-  const onFocus = React.useCallback(
-    (event: FocusEvent | true) => {
-      const isOpened =
-        (event === true || event.type === 'focusin') &&
-        (document?.activeElement?.tagName === 'INPUT' ||
-          document?.activeElement?.tagName === 'TEXTAREA');
-      setIsOpened(isOpened);
-    },
-    [document?.activeElement?.tagName],
-  );
-
-  /**
-   У полей с autoFocus не отлавливаются события focus, для этого вызываем вручную,
-   чтобы иметь хоть какое-то понимание происходящего.
-   */
-  React.useEffect(() => {
-    onFocus(true);
-  }, [onFocus]);
-
-  useGlobalEventListener(document, 'focusout', onFocus, eventOptions);
-  useGlobalEventListener(document, 'focusin', onFocus, eventOptions);
-
-  return { isOpened };
-}
diff --git a/packages/vkui/src/hooks/useVirtualKeyboardState.ts b/packages/vkui/src/hooks/useVirtualKeyboardState.ts
new file mode 100644
index 00000000000..042ddb8f637
--- /dev/null
+++ b/packages/vkui/src/hooks/useVirtualKeyboardState.ts
@@ -0,0 +1,170 @@
+import { useEffect, useRef, useState } from 'react';
+import { debounce, throttle } from '@vkontakte/vkjs';
+import { clamp } from '../helpers/math';
+import {
+  getVisualViewport,
+  isHTMLContentEditableElement,
+  useDOM,
+  type VisualViewport,
+} from '../lib/dom';
+
+type KeyboardOpened = boolean;
+
+type SafeAreaBottomInset = number;
+
+export type VirtualKeyboardState = [KeyboardOpened, SafeAreaBottomInset];
+
+/**
+ * > см. [Неудобно работать с клавиатурой в ModalPage на iOS #3792](https://github.com/VKCOM/VKUI/discussions/3792)
+ *
+ * Для реализации модальных окон для тач-устройств, мы вынуждены отслеживать открытие виртуальной
+ * клавиатуры. По состоянию `opened` компоненты должны временно блокировать дальнейшее взаимодействие
+ * с ними. Например, отключить закрытие по свайпу, чтобы не мешать пользователю работать с полями
+ * ввода.
+ *
+ * Помимо этого в **Safari** и в **Chrome Android** нам нужно отслеживать прокрутку области видимости
+ * пользователем, т.к. в упомянутых браузерах, виртуальная клавиатура поднимает контент вверх
+ * не изменяя её высоту. Из-за этого появляется возможность прокручивать `window`, что визуально
+ * выглядит плохо. В хуке мы ловим фокус на поле ввода и далее, если это тач-устройство, то
+ * отлавливаем события прокрутки на `window`, чтобы сохранять текущую её позицию через `scrollTo(x, y)`.
+ *
+ * **Troubleshooting**
+ *
+ * - В **Safari** и в **Chrome Android** шапка будет выдвигаться вверх – хаки с выставлением `offsetTop`
+ *   из `VisualViewport` порождают reflow/repaint и прыгания контента.
+ *
+ * **Полезные ссылки**
+ *
+ * - [The Eccentric Ways of iOS Safari with the Keyboard](https://web.archive.org/web/20240920081850/https://blog.opendigerati.com/the-eccentric-ways-of-ios-safari-with-the-keyboard-b5aa3f34228d?gi=5411141a13e0)
+ * - [Dealing with the visual viewport](https://web.archive.org/web/20240920082109/https://rdavis.io/articles/dealing-with-the-visual-viewport)
+ * - [How to get the document height in iOS Safari when the on-screen keyboard is open](https://web.archive.org/web/20240920082743/https://martijnhols.nl/gists/how-to-get-document-height-ios-safari-osk)
+ */
+export function useVirtualKeyboardState(enabled = true): VirtualKeyboardState {
+  const { window, document } = useDOM();
+
+  const [focusedEl, setFocusedEl] = useState<Element | null>(null);
+  const [keyboardOpened, setKeyboardOpened] = useState<KeyboardOpened>(false);
+  const [safeAreaBottomInset, setSafeAreaBottomInset] = useState<SafeAreaBottomInset>(0);
+
+  const prevVisualViewportRef = useRef<VisualViewport | null>(null);
+
+  useEffect(
+    function handleFocusedEl() {
+      if (!enabled || !window || !document) {
+        return;
+      }
+
+      const handleFocus = (event: FocusEvent | true) => {
+        const activeElement = event === true ? document.activeElement : (event.target as Element);
+
+        if (isHTMLContentEditableElement(activeElement)) {
+          const patchedEvent = event === true ? { type: 'focusin' } : event;
+          switch (patchedEvent.type) {
+            case 'focusin':
+              prevVisualViewportRef.current = getVisualViewport(window);
+              setFocusedEl(activeElement);
+              break;
+            case 'focusout':
+              prevVisualViewportRef.current = null;
+              setKeyboardOpened(false);
+              setSafeAreaBottomInset(0);
+              setFocusedEl(null);
+              break;
+          }
+        }
+      };
+
+      /**
+       * У полей с autoFocus не отлавливаются события `focus`, для этого вызываем обработчик
+       * вручную, чтобы иметь хоть какое-то понимание происходящего.
+       */
+      handleFocus(true);
+
+      const eventOptions = { passive: true, capture: false };
+      document.addEventListener('focusin', handleFocus, eventOptions);
+      document.addEventListener('focusout', handleFocus, eventOptions);
+
+      return () => {
+        prevVisualViewportRef.current = null;
+        document.removeEventListener('focusin', handleFocus, eventOptions);
+        document.removeEventListener('focusout', handleFocus, eventOptions);
+      };
+    },
+    [enabled, window, document],
+  );
+
+  useEffect(
+    function handleVirtualKeyboardOpened() {
+      if (!focusedEl || !window) {
+        return;
+      }
+
+      let preventFirstSafeAreaBottomInsetCalc = true;
+      const handleResize = debounce(() => {
+        if (prevVisualViewportRef.current === null) {
+          return;
+        }
+
+        const nextVisualViewport = getVisualViewport(window);
+
+        const { offsetTop: prevOffsetTop, height: prevHeight } = prevVisualViewportRef.current;
+        const { offsetTop: nextOffsetTop, height: nextHeight } = nextVisualViewport;
+        if (prevOffsetTop !== nextOffsetTop || prevHeight !== nextHeight) {
+          setKeyboardOpened(true);
+          setSafeAreaBottomInset(
+            preventFirstSafeAreaBottomInsetCalc ? 0 : clamp(prevHeight - nextHeight, 0, 50),
+          );
+          preventFirstSafeAreaBottomInsetCalc = false;
+          prevVisualViewportRef.current = nextVisualViewport;
+
+          requestAnimationFrame(function preserveFocusedElIntoViewSchedule() {
+            if ('scrollIntoViewIfNeeded' in focusedEl) {
+              // @ts-expect-error: TS18046 не стандартный метод https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoViewIfNeeded
+              focusedEl.scrollIntoViewIfNeeded(false);
+            } else {
+              focusedEl.scrollIntoView({ block: 'nearest', behavior: 'instant' });
+            }
+          });
+        }
+      }, 100);
+
+      if (window.visualViewport) {
+        window.visualViewport.addEventListener('resize', handleResize);
+      } else {
+        window.addEventListener('resize', handleResize);
+      }
+
+      return function dispose() {
+        if (window.visualViewport) {
+          window.visualViewport?.removeEventListener('resize', handleResize);
+        } else {
+          window.removeEventListener('resize', handleResize);
+        }
+      };
+    },
+    [focusedEl, window],
+  );
+
+  useEffect(
+    function preventWindowScrollIfKeyboardOpened() {
+      if (!keyboardOpened || !window) {
+        return;
+      }
+
+      const prevent = throttle(() => {
+        if (prevVisualViewportRef.current) {
+          window.scrollTo(0, prevVisualViewportRef.current.offsetTop);
+        }
+      }, 100);
+
+      window.addEventListener('scroll', prevent, { passive: true });
+
+      return function dispose() {
+        window.removeEventListener('scroll', prevent);
+      };
+    },
+    [keyboardOpened, window],
+  );
+
+  return [keyboardOpened, safeAreaBottomInset];
+}
diff --git a/packages/vkui/src/index.ts b/packages/vkui/src/index.ts
index bdcc764c41f..bf96ac09b91 100644
--- a/packages/vkui/src/index.ts
+++ b/packages/vkui/src/index.ts
@@ -140,10 +140,12 @@ export type {
 /**
  * Modals
  */
-export { ModalRoot } from './components/ModalRoot/ModalRootAdaptive';
+export { ModalRoot } from './components/ModalRoot/ModalRoot';
 export type { ModalRootProps } from './components/ModalRoot/types';
 export { withModalRootContext } from './components/ModalRoot/withModalRootContext';
 export { ModalRootContext } from './components/ModalRoot/ModalRootContext';
+export { ModalPageFooter } from './components/ModalPageFooter/ModalPageFooter';
+export { ModalPageContent } from './components/ModalPageContent/ModalPageContent';
 export { ModalPage } from './components/ModalPage/ModalPage';
 export type { ModalPageProps } from './components/ModalPage/ModalPage';
 export { ModalPageHeader } from './components/ModalPageHeader/ModalPageHeader';
diff --git a/packages/vkui/src/lib/adaptivity/functions.ts b/packages/vkui/src/lib/adaptivity/functions.ts
index af99fdf8e05..8b8e416dea1 100644
--- a/packages/vkui/src/lib/adaptivity/functions.ts
+++ b/packages/vkui/src/lib/adaptivity/functions.ts
@@ -1,6 +1,7 @@
 import type { Exact } from '../../types';
+import { getWindow } from '../dom';
 import { type PlatformType } from '../platform';
-import { BREAKPOINTS } from './breakpoints';
+import { BREAKPOINTS, MEDIA_QUERIES } from './breakpoints';
 import {
   type SizeTypeValues,
   VIEW_WIDTH_TO_CSS_BREAKPOINT_MAP,
@@ -138,6 +139,12 @@ export function tryToCheckIsDesktop(
   return (widthIsLikeDesktop && otherParametersIsLikeDesktop) || IS_VKCOM_CRUTCH;
 }
 
+export function isSmallTablePlus(el: HTMLElement) {
+  const win = getWindow(el);
+  // eslint-disable-next-line no-restricted-properties
+  return win ? win.matchMedia(MEDIA_QUERIES.SMALL_TABLET_PLUS).matches : false;
+}
+
 /**
  * Конвертирует `viewWidth` в CSS брейкпоинты (см. тесты для наглядности).
  *
diff --git a/packages/vkui/src/lib/animation/index.ts b/packages/vkui/src/lib/animation/index.ts
index 4771fc3414c..8984767822b 100644
--- a/packages/vkui/src/lib/animation/index.ts
+++ b/packages/vkui/src/lib/animation/index.ts
@@ -1,4 +1,9 @@
-export { useCSSKeyframesAnimationController } from './useCSSKeyframesAnimationController';
+export {
+  type AnimationState,
+  type AnimationHandlers,
+  type UseCSSAnimationControllerCallback,
+  useCSSKeyframesAnimationController,
+} from './useCSSKeyframesAnimationController';
 export { REDUCE_MOTION_MEDIA_QUERY, useReducedMotion } from './useReducedMotion';
 export { rubberbandIfOutOfBounds } from './rubberbandIfOutOfBounds';
 export { animationFadeClassNames } from './fades';
diff --git a/packages/vkui/src/lib/dom.tsx b/packages/vkui/src/lib/dom.tsx
index b17bc5e1d76..89d8043ab51 100644
--- a/packages/vkui/src/lib/dom.tsx
+++ b/packages/vkui/src/lib/dom.tsx
@@ -15,6 +15,7 @@ export {
   getNodeScroll,
   isHTMLElement,
   isElement,
+  getParentNode,
 } from '@vkontakte/vkui-floating-ui/utils/dom';
 
 export { canUseDOM, canUseEventListeners, onDOMLoaded } from '@vkontakte/vkjs';
@@ -260,3 +261,57 @@ export const initializeBrowserGesturePreventionEffect = (window: Window): VoidFu
     window.removeEventListener('touchmove', handleWindowTouchMove, options);
   };
 };
+
+export const hasSelectionWithRangeType = (node: unknown) => {
+  const selection = getWindow(node).getSelection();
+  return selection ? selection.type === 'Range' : false;
+};
+
+export const isHTMLContentEditableElement = (
+  el: Element | null,
+): el is HTMLInputElement | HTMLTextAreaElement | HTMLElement => {
+  if (el === null) {
+    return false;
+  }
+
+  if (el.tagName === 'INPUT') {
+    // @ts-expect-error: TS2339 за счёт `tagName` удовлетворяемся, что это `HTMLInputElement`
+    return el.type === 'text' || el.type === 'number' || el.type === 'search';
+  }
+
+  return (
+    el.tagName === 'TEXTAREA' ||
+    // eslint-disable-next-line no-restricted-properties
+    el.closest('[contenteditable=true]') !== null
+  );
+};
+
+export type VisualViewport = {
+  offsetTop: number;
+  offsetLeft: number;
+  width: number;
+  height: number;
+};
+
+/**
+ * Фоллбек `visualViewport` для **Safari 12**.
+ */
+export function getVisualViewport(win: Window): VisualViewport {
+  const result: VisualViewport = { offsetTop: 0, offsetLeft: 0, width: 0, height: 0 };
+  if (win.visualViewport) {
+    const { offsetTop, offsetLeft, width, height } = win.visualViewport;
+    result.offsetTop = Math.round(offsetTop);
+    result.offsetLeft = offsetLeft;
+    result.width = width;
+    result.height = Math.round(height);
+
+    return result;
+  }
+
+  // TODO[Safari@>=13] Удалить фоллбек
+  result.offsetTop = win.pageYOffset;
+  result.offsetLeft = win.pageXOffset;
+  result.width = win.innerWidth; // note: вызывает reflow в отличии от visualViewport
+  result.height = win.innerHeight; // note: вызывает reflow в отличии от visualViewport
+  return result;
+}
diff --git a/packages/vkui/src/lib/sheet/constants.ts b/packages/vkui/src/lib/sheet/constants.ts
new file mode 100644
index 00000000000..e6dc92b2dcc
--- /dev/null
+++ b/packages/vkui/src/lib/sheet/constants.ts
@@ -0,0 +1,32 @@
+/** @public */
+export const BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE_KEY = 'data-vkui-block-sheet-behavior';
+
+/** @public */
+export const BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE = {
+  [BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE_KEY]: true,
+};
+
+/** @private */
+export const DRAG_THRESHOLDS = {
+  DISTANCE_FOR_MOVING_START: 12 as const,
+  VELOCITY: 500 as const,
+};
+
+/** @private */
+export const SNAP_POINT_SAFE_RANGE = {
+  LOWER: 25 as const,
+  HIGHEST: 90 as const,
+};
+
+/** @private */
+export const SNAP_POINT_DETENTS = {
+  MIN: 0 as const,
+  MEDIUM: 50 as const,
+  LARGE: 100 as const,
+};
+
+/** @private */
+export const DYNAMIC_SNAP_POINT_DATA = {
+  IDLE_POINT_VALUE: 0 as const,
+  COMPUTED_INDEX: 1 as const,
+};
diff --git a/packages/vkui/src/lib/sheet/controllers/BottomSheetController.ts b/packages/vkui/src/lib/sheet/controllers/BottomSheetController.ts
new file mode 100644
index 00000000000..5d7a2d5fbcb
--- /dev/null
+++ b/packages/vkui/src/lib/sheet/controllers/BottomSheetController.ts
@@ -0,0 +1,331 @@
+import { noop } from '@vkontakte/vkjs';
+import { clamp } from '../../../helpers/math';
+import { inRange } from '../../../helpers/range';
+import { rubberbandIfOutOfBounds } from '../../animation';
+import { hasSelectionWithRangeType } from '../../dom';
+import { UIPanGestureRecognizer } from '../../touch/UIPanGestureRecognizer';
+import {
+  BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE_KEY,
+  DRAG_THRESHOLDS,
+  DYNAMIC_SNAP_POINT_DATA,
+  SNAP_POINT_DETENTS,
+  SNAP_POINT_SAFE_RANGE,
+} from '../constants';
+import type { CSSTransitionController } from './CSSTransitionController';
+
+export type SnapPointDetents = [number, number] | [number, number, number];
+
+export type BottomSheetControllerSnapPointData = {
+  unit: '%' | 'px';
+  currentSnapPoint: number;
+  snapPointDetents: SnapPointDetents;
+};
+
+export type BottomSheetControllerOptions = {
+  sheetScrollEl: HTMLElement | null;
+  sheetTransitionController: CSSTransitionController<string>;
+  backdropTransitionController: CSSTransitionController | null;
+  onDismiss: VoidFunction;
+};
+
+export class BottomSheetController {
+  static parseInitialSnapPoint(
+    initialSnapPoint: 'auto' | number = SNAP_POINT_DETENTS.MEDIUM,
+  ): BottomSheetControllerSnapPointData {
+    if (initialSnapPoint === 'auto') {
+      return {
+        unit: 'px',
+        currentSnapPoint: DYNAMIC_SNAP_POINT_DATA.IDLE_POINT_VALUE,
+        snapPointDetents: [SNAP_POINT_DETENTS.MIN, DYNAMIC_SNAP_POINT_DATA.IDLE_POINT_VALUE],
+      };
+    }
+
+    const currentSnapPoint = Math.min(
+      Math.max(initialSnapPoint, SNAP_POINT_SAFE_RANGE.LOWER),
+      SNAP_POINT_DETENTS.LARGE,
+    );
+
+    return {
+      unit: '%',
+      currentSnapPoint,
+      snapPointDetents: inRange(
+        currentSnapPoint,
+        SNAP_POINT_SAFE_RANGE.LOWER,
+        SNAP_POINT_SAFE_RANGE.HIGHEST,
+      )
+        ? [SNAP_POINT_DETENTS.MIN, currentSnapPoint, SNAP_POINT_DETENTS.LARGE]
+        : [SNAP_POINT_DETENTS.MIN, currentSnapPoint],
+    };
+  }
+
+  constructor(
+    private readonly sheetEl: HTMLElement,
+    {
+      sheetScrollEl,
+      sheetTransitionController,
+      backdropTransitionController,
+      onDismiss,
+    }: BottomSheetControllerOptions,
+  ) {
+    this.onDismiss = onDismiss;
+    this.panGestureRecognizer = new UIPanGestureRecognizer();
+    this.sheetScrollEl = sheetScrollEl;
+    this.sheetTransitionController = sheetTransitionController;
+    this.backdropTransitionController = backdropTransitionController;
+  }
+
+  init(initialSnapPoint?: number | 'auto') {
+    this.isInitialized = true;
+
+    const { unit, currentSnapPoint, snapPointDetents } =
+      BottomSheetController.parseInitialSnapPoint(initialSnapPoint);
+
+    this.unit = unit;
+    this.currentSnapPoint = currentSnapPoint;
+    this.snapPointDetents = snapPointDetents;
+  }
+
+  destroy() {
+    this.isInitialized = false;
+    this.pannedEl = null;
+    this.sheetTransitionController.cleanup();
+    this.backdropTransitionController?.cleanup();
+
+    this.disableScrollBouncingDispose();
+    this.disableScrollBouncingDispose = noop;
+  }
+
+  panStart(event: UIEvent) {
+    if (
+      !this.isInitialized ||
+      this.panState !== 'idle' ||
+      event.defaultPrevented ||
+      hasSelectionWithRangeType(event.target)
+    ) {
+      return;
+    }
+
+    this.panState = 'start';
+    this.pannedEl = event.target as HTMLElement;
+    this.panGestureRecognizer.setStartCoords(event);
+  }
+
+  panMove(event: UIEvent) {
+    switch (this.panState) {
+      case 'start':
+        this.panGestureRecognizer.setInitialTimeOnce();
+        this.panGestureRecognizer.setEndCoords(event);
+
+        if (
+          event.defaultPrevented ||
+          this.shouldBePreventedIfPanGestureDistanceIsNotAsExpected() ||
+          this.shouldBePreventedIfPanGestureDirectionIsNotVertical() ||
+          // Может быть `null` если нажали на Shadow DOM.
+          this.pannedEl === null ||
+          this.shouldBePreventedIfPannedElIsExternal(this.pannedEl) ||
+          this.shouldBePreventedByDataAttribute(this.pannedEl) ||
+          this.shouldBePreventedIfIsScrolled(this.pannedEl)
+        ) {
+          return;
+        }
+
+        this.panState = 'moving';
+        this.panGestureRecognizer.setStartCoords(event);
+
+        this.disableScrollBouncingDispose = BottomSheetController.disableScrollBouncing(
+          this.sheetScrollEl,
+        );
+        this.sheetHeight = this.sheetEl.offsetHeight;
+
+        if (this.isDynamicSnapPoint) {
+          this.currentSnapPoint = this.sheetHeight;
+          this.snapPointDetents[DYNAMIC_SNAP_POINT_DATA.COMPUTED_INDEX] = this.sheetHeight;
+        }
+        break;
+      case 'moving':
+        if (event.cancelable) {
+          event.preventDefault();
+        }
+
+        this.panGestureRecognizer.setEndCoords(event);
+
+        const { y1, y2 } = this.panGestureRecognizer;
+
+        this.nextSnapPoint = rubberbandIfOutOfBounds(
+          this.currentSnapPoint - ((y2 - y1) / this.sheetHeight) * this.currentSnapPoint,
+          SNAP_POINT_DETENTS.MIN,
+          this.isDynamicSnapPoint ? this.sheetHeight : SNAP_POINT_DETENTS.LARGE,
+        );
+
+        this.calculateSnapPoint(this.nextSnapPoint, true);
+        break;
+    }
+  }
+
+  panEnd() {
+    switch (this.panState) {
+      case 'moving':
+        this.currentSnapPoint = this.getSnapPointTo(this.nextSnapPoint);
+        this.calculateSnapPoint(this.currentSnapPoint);
+        break;
+    }
+
+    this.panState = 'idle';
+    this.panGestureRecognizer.reset();
+
+    this.disableScrollBouncingDispose();
+    this.disableScrollBouncingDispose = noop;
+  }
+
+  private isInitialized = false;
+  private panState: 'idle' | 'start' | 'moving' = 'idle';
+  private pannedEl: HTMLElement | null = null;
+  private sheetHeight = 0;
+  private rafId: number | null = null;
+  private currentSnapPoint = 0;
+  private nextSnapPoint = 0;
+  private snapPointDetents: SnapPointDetents = [0, 0];
+  private unit: 'px' | '%' = '%';
+  private get isDynamicSnapPoint() {
+    return this.unit === 'px';
+  }
+  private disableScrollBouncingDispose = noop;
+  private readonly sheetScrollEl: HTMLElement | null;
+  private readonly sheetTransitionController: CSSTransitionController<string>;
+  private readonly backdropTransitionController: CSSTransitionController | null;
+  private readonly panGestureRecognizer: UIPanGestureRecognizer;
+  private readonly onDismiss: VoidFunction;
+
+  private calculateSnapPoint(nextSnapPoint: number, immediately = false) {
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+    }
+
+    if (nextSnapPoint <= SNAP_POINT_DETENTS.MIN) {
+      this.sheetTransitionController.enableTransition();
+      this.backdropTransitionController?.enableTransition();
+      this.onDismiss();
+      return;
+    }
+
+    const backdropOpacity = clamp(
+      this.isDynamicSnapPoint
+        ? nextSnapPoint / this.sheetHeight
+        : (nextSnapPoint * 2) / SNAP_POINT_DETENTS.LARGE,
+      0,
+      1,
+    );
+
+    this.rafId = requestAnimationFrame(() => {
+      if (immediately) {
+        this.backdropTransitionController?.disableTransition().set(backdropOpacity);
+        this.sheetTransitionController.disableTransition().set(`${nextSnapPoint}${this.unit}`);
+        return;
+      }
+
+      if (this.isDynamicSnapPoint) {
+        this.sheetTransitionController.cleanupOnTransitionEnd();
+      }
+
+      this.backdropTransitionController?.unset();
+      this.sheetTransitionController.enableTransition().set(`${this.currentSnapPoint}${this.unit}`);
+    });
+  }
+
+  private getSnapPointTo(nextSnapPoint: number) {
+    const closestSnapPoint = BottomSheetController.getClosestSnapPoint(
+      this.snapPointDetents,
+      nextSnapPoint,
+    );
+    if (closestSnapPoint !== this.currentSnapPoint) {
+      return closestSnapPoint;
+    }
+
+    const panDirection = this.panGestureRecognizer.direction();
+    if (panDirection.axis !== 'y' || panDirection.direction === null) {
+      return this.currentSnapPoint;
+    }
+
+    const velocity = this.panGestureRecognizer.velocity();
+    if (Math.abs(velocity.y) < DRAG_THRESHOLDS.VELOCITY) {
+      return this.currentSnapPoint;
+    }
+
+    const closestSnapPointByDirection = BottomSheetController.getClosestSnapPointByDirection(
+      this.snapPointDetents,
+      closestSnapPoint,
+      panDirection.direction,
+    );
+
+    return closestSnapPointByDirection;
+  }
+
+  private shouldBePreventedIfPanGestureDistanceIsNotAsExpected() {
+    return this.panGestureRecognizer.distance() < DRAG_THRESHOLDS.DISTANCE_FOR_MOVING_START;
+  }
+
+  private shouldBePreventedIfPanGestureDirectionIsNotVertical() {
+    return this.panGestureRecognizer.direction().axis === 'x';
+  }
+
+  private shouldBePreventedIfPannedElIsExternal(pannedEl: HTMLElement) {
+    return !this.sheetEl.contains(pannedEl);
+  }
+
+  private shouldBePreventedByDataAttribute(pannedEl: HTMLElement) {
+    // eslint-disable-next-line no-restricted-properties
+    return pannedEl.closest(`[${BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE_KEY}=true]`);
+  }
+
+  private shouldBePreventedIfIsScrolled(pannedEl: HTMLElement) {
+    if (this.sheetScrollEl === null || !this.sheetScrollEl.contains(pannedEl)) {
+      return false;
+    }
+
+    if (this.sheetScrollEl.scrollTop === 0) {
+      const panDirection = this.panGestureRecognizer.direction();
+      return panDirection.direction === -1;
+    }
+
+    return true;
+  }
+
+  private static disableScrollBouncing(node: HTMLElement | null) {
+    if (node === null) {
+      return noop;
+    }
+    node.style.setProperty('overflow', 'hidden');
+    return function dispose() {
+      node.style.removeProperty('overflow');
+    };
+  }
+
+  private static getClosestSnapPointByDirection(
+    snapPointDetents: SnapPointDetents,
+    currentY: number,
+    direction: -1 | 1,
+  ): number {
+    const foundIndex = snapPointDetents.findIndex((i) => i === currentY);
+    switch (direction) {
+      case -1:
+        return snapPointDetents[foundIndex + 1] ?? snapPointDetents[snapPointDetents.length - 1];
+      case 1:
+        return snapPointDetents[foundIndex - 1] ?? snapPointDetents[0];
+    }
+  }
+
+  private static getClosestSnapPoint(snapPointDetents: SnapPointDetents, currentY: number) {
+    let closest = snapPointDetents[0];
+    let minDifference = Math.abs(snapPointDetents[0] - currentY);
+
+    for (let i = 1; i < snapPointDetents.length; i += 1) {
+      const difference = Math.abs(snapPointDetents[i] - currentY);
+      if (difference < minDifference) {
+        closest = snapPointDetents[i];
+        minDifference = difference;
+      }
+    }
+
+    return closest;
+  }
+}
diff --git a/packages/vkui/src/lib/sheet/controllers/CSSTransitionController.ts b/packages/vkui/src/lib/sheet/controllers/CSSTransitionController.ts
new file mode 100644
index 00000000000..c0e23304e7c
--- /dev/null
+++ b/packages/vkui/src/lib/sheet/controllers/CSSTransitionController.ts
@@ -0,0 +1,51 @@
+export type CSSTransitionControllerUnit = 'px' | '%' | '';
+
+export class CSSTransitionController<V extends number | string = number> {
+  constructor(
+    public readonly el: HTMLElement,
+    public readonly property: string,
+  ) {}
+
+  set(to: V) {
+    this.el.style.setProperty(this.property, `${to}`);
+    return this;
+  }
+
+  unset(from?: V) {
+    if (from !== undefined) {
+      this.el.addEventListener('transitionend', this.handleTransitionEnd, { once: true });
+      this.enableTransition();
+      this.el.style.setProperty(this.property, `${from}`);
+      return this;
+    }
+
+    return this.cleanup();
+  }
+
+  enableTransition() {
+    this.el.style.removeProperty('transition');
+    return this;
+  }
+
+  disableTransition() {
+    this.el.style.setProperty('transition', 'none');
+    return this;
+  }
+
+  cleanup() {
+    this.el.removeEventListener('transitionend', this.handleTransitionEnd);
+    this.el.style.removeProperty('transition');
+    this.el.style.removeProperty(this.property);
+    return this;
+  }
+
+  cleanupOnTransitionEnd() {
+    this.el.addEventListener('transitionend', this.handleTransitionEnd, { once: true });
+    return this;
+  }
+
+  private readonly handleTransitionEnd = () => {
+    this.cleanup();
+    return this;
+  };
+}
diff --git a/packages/vkui/src/lib/sheet/index.ts b/packages/vkui/src/lib/sheet/index.ts
new file mode 100644
index 00000000000..954301a4a28
--- /dev/null
+++ b/packages/vkui/src/lib/sheet/index.ts
@@ -0,0 +1,10 @@
+export {
+  BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE_KEY,
+  BLOCK_SHEET_BEHAVIOR_DATA_ATTRIBUTE,
+} from './constants';
+export {
+  type UseBottomSheetOptions,
+  type UseBottomSheetHandlers,
+  type UseBottomSheetResult,
+  useBottomSheet,
+} from './useBottomSheet';
diff --git a/packages/vkui/src/lib/sheet/useBottomSheet.ts b/packages/vkui/src/lib/sheet/useBottomSheet.ts
new file mode 100644
index 00000000000..c8d9b17e2e5
--- /dev/null
+++ b/packages/vkui/src/lib/sheet/useBottomSheet.ts
@@ -0,0 +1,143 @@
+'use client';
+
+import {
+  type CSSProperties,
+  type Dispatch,
+  type SetStateAction,
+  type UIEvent,
+  type UIEventHandler,
+  useMemo,
+  useState,
+} from 'react';
+import { noop } from '@vkontakte/vkjs';
+import { useStableCallback } from '../../hooks/useStableCallback';
+import { useIsomorphicLayoutEffect } from '../useIsomorphicLayoutEffect';
+import { BottomSheetController } from './controllers/BottomSheetController';
+import { CSSTransitionController } from './controllers/CSSTransitionController';
+
+export type UseBottomSheetOptions = {
+  sheetCSSProperty: string;
+  backdropCSSProperty: string;
+  initialSnapPoint?: number | 'auto';
+  blocked?: boolean;
+  onDismiss?: VoidFunction;
+};
+
+export type UseBottomSheetHandlers = {
+  onTouchStart: UIEventHandler<HTMLElement>;
+  onTouchMove: UIEventHandler<HTMLElement>;
+  onTouchEnd: UIEventHandler<HTMLElement>;
+  onMouseDown: UIEventHandler<HTMLElement>;
+  onMouseMove: UIEventHandler<HTMLElement>;
+  onMouseUp: UIEventHandler<HTMLElement>;
+  onMouseLeave: UIEventHandler<HTMLElement>;
+};
+
+export type UseBottomSheetResult = [
+  {
+    initialStyle?: CSSProperties;
+    setSheetEl: Dispatch<SetStateAction<HTMLElement | null>>;
+    setSheetScrollEl: Dispatch<SetStateAction<HTMLElement | null>>;
+    setBackdropEl: Dispatch<SetStateAction<HTMLElement | null>>;
+  },
+  UseBottomSheetHandlers | undefined,
+];
+
+export const useBottomSheet = (
+  enabled: boolean,
+  {
+    blocked,
+    initialSnapPoint,
+    sheetCSSProperty,
+    backdropCSSProperty,
+    onDismiss: onDismissProp,
+  }: UseBottomSheetOptions,
+): UseBottomSheetResult => {
+  const [sheetScrollEl, setSheetScrollEl] = useState<HTMLElement | null>(null);
+  const [sheetEl, setSheetEl] = useState<HTMLElement | null>(null);
+  const [backdropEl, setBackdropEl] = useState<HTMLElement | null>(null);
+
+  const initialStyle = useMemo<CSSProperties | undefined>(() => {
+    if (!enabled) {
+      return;
+    }
+
+    const { unit, currentSnapPoint } =
+      BottomSheetController.parseInitialSnapPoint(initialSnapPoint);
+
+    return unit === '%' ? { [sheetCSSProperty]: `${currentSnapPoint}${unit}` } : undefined;
+  }, [enabled, initialSnapPoint, sheetCSSProperty]);
+
+  const onDismiss = useStableCallback(onDismissProp || noop);
+  const bsController = useMemo<BottomSheetController | null>(() => {
+    if (!enabled || sheetEl === null) {
+      return null;
+    }
+
+    return new BottomSheetController(sheetEl, {
+      sheetScrollEl: sheetScrollEl || null,
+      sheetTransitionController: new CSSTransitionController<string>(sheetEl, sheetCSSProperty),
+      backdropTransitionController: backdropEl
+        ? new CSSTransitionController(backdropEl, backdropCSSProperty)
+        : null,
+      onDismiss,
+    });
+  }, [
+    enabled,
+    sheetEl,
+    sheetCSSProperty,
+    sheetScrollEl,
+    backdropEl,
+    backdropCSSProperty,
+    onDismiss,
+  ]);
+
+  const onPanStart = function onPanStart(event: UIEvent<HTMLElement>) {
+    if (!blocked) {
+      bsController!.panStart(event.nativeEvent);
+    }
+  };
+
+  const onPanMove = function onPanMove(event: UIEvent<HTMLElement>) {
+    bsController!.panMove(event.nativeEvent);
+  };
+
+  const onPanEnd = function onPanEnd() {
+    bsController!.panEnd();
+  };
+
+  useIsomorphicLayoutEffect(
+    function init() {
+      if (bsController) {
+        bsController.init(initialSnapPoint);
+      }
+
+      return function destroy() {
+        if (bsController) {
+          bsController.destroy();
+        }
+      };
+    },
+    [initialSnapPoint, bsController],
+  );
+
+  return [
+    {
+      initialStyle,
+      setSheetEl,
+      setSheetScrollEl,
+      setBackdropEl,
+    },
+    bsController !== null
+      ? {
+          onTouchStart: onPanStart,
+          onTouchMove: onPanMove,
+          onTouchEnd: onPanEnd,
+          onMouseDown: onPanStart,
+          onMouseMove: onPanMove,
+          onMouseUp: onPanEnd,
+          onMouseLeave: onPanEnd,
+        }
+      : undefined,
+  ];
+};
diff --git a/packages/vkui/src/lib/touch/UIPanGestureRecognizer.ts b/packages/vkui/src/lib/touch/UIPanGestureRecognizer.ts
index 2c4bee1277e..5ef72184dd8 100644
--- a/packages/vkui/src/lib/touch/UIPanGestureRecognizer.ts
+++ b/packages/vkui/src/lib/touch/UIPanGestureRecognizer.ts
@@ -1,6 +1,8 @@
 import { getFirstTouchEventData } from '../dom';
 
-export type VCoords = { x: number; y: number };
+export type Direction = { axis: 'x' | 'y'; direction: -1 | 1 | null };
+
+export type Coords = { x: number; y: number };
 
 const DEFAULT_INITIAL_TIME = 0;
 const MILLISECONDS = 1000;
@@ -35,10 +37,7 @@ export class UIPanGestureRecognizer {
     this.y2 = clientY;
   }
 
-  delta(): {
-    x: number;
-    y: number;
-  } {
+  delta(): Coords {
     return {
       x: this.x2 - this.x1,
       y: this.y2 - this.y1,
@@ -50,10 +49,7 @@ export class UIPanGestureRecognizer {
     return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
   }
 
-  velocity(): {
-    x: number;
-    y: number;
-  } {
+  velocity(): Coords {
     const deltaTime = (Date.now() - this.initialTime) / MILLISECONDS;
 
     if (deltaTime <= 0) {
@@ -72,6 +68,13 @@ export class UIPanGestureRecognizer {
     return degrees < 0 ? 360 + degrees : degrees;
   }
 
+  direction(): Direction {
+    const { x, y } = this.delta();
+    return Math.abs(x) > Math.abs(y)
+      ? { axis: 'x', direction: x > 0 ? 1 : x < 0 ? -1 : null }
+      : { axis: 'y', direction: y > 0 ? 1 : y < 0 ? -1 : null };
+  }
+
   reset(): void {
     this.initialTime = DEFAULT_INITIAL_TIME;
     this.x1 = this.y1 = 0;
diff --git a/packages/vkui/src/lib/touch/index.ts b/packages/vkui/src/lib/touch/index.ts
index edb0340c982..036ffd824da 100644
--- a/packages/vkui/src/lib/touch/index.ts
+++ b/packages/vkui/src/lib/touch/index.ts
@@ -1,5 +1,8 @@
 export type * from './functions';
 export { getSupportedEvents, coordX, coordY, touchEnabled, rubber } from './functions';
 
-export type { VCoords } from './UIPanGestureRecognizer';
+export type {
+  Direction as UIPanGestureRecognizerDirection,
+  Coords as UIPanGestureRecognizerCoords,
+} from './UIPanGestureRecognizer';
 export { UIPanGestureRecognizer } from './UIPanGestureRecognizer';
diff --git a/packages/vkui/src/storybook/ModalWrapper.tsx b/packages/vkui/src/storybook/ModalWrapper.tsx
index c042bb727a9..519280dcbc1 100644
--- a/packages/vkui/src/storybook/ModalWrapper.tsx
+++ b/packages/vkui/src/storybook/ModalWrapper.tsx
@@ -2,7 +2,7 @@
 
 import * as React from 'react';
 import { Button } from '../components/Button/Button';
-import { ModalRoot } from '../components/ModalRoot/ModalRootAdaptive';
+import { ModalRoot } from '../components/ModalRoot/ModalRoot';
 import { Placeholder } from '../components/Placeholder/Placeholder';
 import { SplitCol } from '../components/SplitCol/SplitCol';
 import { SplitLayout } from '../components/SplitLayout/SplitLayout';
@@ -12,7 +12,7 @@ export const ModalWrapper = ({
   modalId,
 }: {
   children: React.ReactElement | Iterable<React.ReactElement>;
-  modalId: string;
+  modalId: string | null;
 }) => {
   const [activeModal, setActiveModal] = React.useState<string | null>(modalId);
 
diff --git a/styleguide/config.js b/styleguide/config.js
index 77d1962ece6..5e169ae1f01 100644
--- a/styleguide/config.js
+++ b/styleguide/config.js
@@ -202,7 +202,7 @@ const baseConfig = {
         {
           name: 'Modals',
           components: () => [
-            `../${VKUI_PACKAGE.PATHS.COMPONENTS_DIR}/ModalRoot/ModalRootAdaptive.tsx`,
+            `../${VKUI_PACKAGE.PATHS.COMPONENTS_DIR}/ModalRoot/ModalRoot.tsx`,
             `../${VKUI_PACKAGE.PATHS.COMPONENTS_DIR}/ModalPage/ModalPage.tsx`,
             `../${VKUI_PACKAGE.PATHS.COMPONENTS_DIR}/ModalPageHeader/ModalPageHeader.tsx`,
             `../${VKUI_PACKAGE.PATHS.COMPONENTS_DIR}/ModalCard/ModalCard.tsx`,