@oxyhq/bloom 0.31.0 → 0.32.0

package/lib/commonjs/alert-dialog/AlertDialog.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createAlertDialog = createAlertDialog;
 var _react = _interopRequireWildcard(require("react"));
+var _context = require("../dialog/context.js");
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /**
@@ -24,6 +25,19 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  * imperative `confirm()` helper + `<AlertDialogHost />` to trigger a confirm
  * from an event handler without owning visible state.
  *
+ * Control mode — IMPERATIVE, not controlled. `AlertDialog` keeps its public
+ * *controlled* API (`visible` boolean + `onClose`) but internally bridges it
+ * onto the Dialog's imperative `useDialogControl()` handle, so `confirm()`
+ * drives `<Dialog>` through the EXACT uncontrolled/imperative internals
+ * Mention's `ConfirmPrompt` uses. That is the code path that actually plays the
+ * exit animation on dismiss: imperative `close()` sets `isClosing`, runs the
+ * exit animation, and fires `onClose` only once it settles. The controlled path
+ * instead fires `onClose` synchronously — and because `<AlertDialogHost />`
+ * resolves + drops the queue entry inside `onClose`, the surface would then
+ * unmount instantly, skipping the exit animation entirely. Bridging to
+ * imperative mode eliminates that fork so `confirm()` and Mention's
+ * `ConfirmPrompt` are pixel/timing identical.
+ *
  * The centered card uses the Dialog default `maxWidth` (480px) for full visual
  * parity with the shared confirm surface.
  */
@@ -39,31 +53,62 @@ function createAlertDialog(Dialog) {
     onCancel,
     destructive = false,
     hideCancel = false,
-    dismissible = false,
+    dismissible = true,
     cardStyle,
     testID
   }) {
-    // Confirm resolves + closes SYNCHRONOUSLY, in this order, and must NOT go
-    // through the Dialog's auto-close (`shouldCloseOnPress: false`). In
-    // controlled mode `close()` fires `onClose` FIRST, and the `confirm()` host
-    // wires `onClose` to resolve the promise as *cancelled* (`false`). Running
-    // `onConfirm` (resolve `true`, which removes the queue entry) before
-    // `onClose` (now a no-op for that entry) is what makes the confirm button
-    // resolve `true`.
-    const handleConfirm = (0, _react.useCallback)(() => {
-      onConfirm?.();
+    const control = (0, _context.useDialogControl)();
+
+    // Bridge the public *controlled* `visible` prop onto the Dialog's
+    // imperative open/close. Opening on mount straight from an effect (no
+    // `setTimeout`) mirrors bloom's own `AutoMountedDialog` (which backs
+    // `alert()`) — the canonical fresh-mount imperative-open pattern:
+    // `<AlertDialogHost />` mounts a FRESH `AlertDialog` per confirm
+    // (`key={id}`) with the final content already committed, so there is no
+    // stale-content window to defer past and the entry animation curve stays
+    // identical to Mention's. `control` is referentially stable (memoised on
+    // its id), so this effect only re-runs when `visible` actually flips. When
+    // a direct consumer flips `visible` to `false`, we imperatively `close()`
+    // so the exit animation still plays.
+    const closingFromPropRef = (0, _react.useRef)(false);
+    (0, _react.useEffect)(() => {
+      if (visible) {
+        control.open();
+        return;
+      }
+      closingFromPropRef.current = true;
+      control.close();
+    }, [visible, control]);
+
+    // The Dialog fires `onClose` after the exit animation settles (imperative
+    // mode). Forward ONLY user-initiated dismissals (backdrop / Escape / cancel)
+    // to the consumer — a consumer-initiated close (they flipped `visible` to
+    // `false`) must not re-enter `onClose`, preserving the previous controlled
+    // semantics where a programmatic close does not fire `onClose`.
+    const handleClose = (0, _react.useCallback)(() => {
+      if (closingFromPropRef.current) {
+        closingFromPropRef.current = false;
+        return;
+      }
       onClose();
-    }, [onConfirm, onClose]);
+    }, [onClose]);
+
+    // Confirm/cancel map onto the Dialog's declarative action row. Both keep the
+    // default `shouldCloseOnPress` (true): the button runs the exit animation
+    // FIRST, then invokes `onPress` as a close-completion callback — so
+    // `onConfirm` resolves the `confirm()` promise as the surface animates out,
+    // exactly like Mention. `onConfirm` (resolve `true`, drains the entry) runs
+    // just BEFORE the Dialog's own post-close `onClose` (→ `handleClose` →
+    // resolve `false`, now a no-op for the drained entry), which is what makes
+    // the confirm button win the double-resolution guard.
     const actions = [{
       label: confirmLabel,
-      onPress: handleConfirm,
-      color: destructive ? 'destructive' : 'default',
-      shouldCloseOnPress: false
+      onPress: onConfirm,
+      color: destructive ? 'destructive' : 'default'
     }];
     if (!hideCancel) {
-      // The `cancel` color auto-dismisses via the Dialog's `close()`, which in
-      // controlled mode fires `onClose` (the host resolves `false`). `onCancel`
-      // runs after the surface finishes closing.
+      // The `cancel` color auto-dismisses via the Dialog's `close()` (exit
+      // animation), then runs `onCancel` as a close-completion callback.
       actions.push({
         label: cancelLabel,
         onPress: onCancel,
@@ -71,11 +116,14 @@ function createAlertDialog(Dialog) {
       });
     }
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(Dialog, {
-      open: visible,
-      onClose: onClose,
+      control: control,
+      onClose: handleClose,
       placement: "center"
-      // Alert dialogs are blocking by default — the backdrop / Escape only
-      // dismiss when the caller opts in via `dismissible`.
+      // Alert dialogs dismiss on backdrop / Escape by default (matching the
+      // shared Dialog default and Mention's `ConfirmPrompt`). A backdrop /
+      // Escape dismissal can only ever resolve the confirm as cancelled
+      // (`false`), never the destructive action — callers that need a truly
+      // blocking confirm opt out with `dismissible={false}`.
       ,
       dismissOnBackdrop: dismissible,
       title: title,

package/lib/commonjs/alert-dialog/AlertDialog.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","_interopRequireWildcard","require","_jsxRuntime","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","createAlertDialog","Dialog","AlertDialogComponent","AlertDialog","visible","onClose","title","description","confirmLabel","cancelLabel","onConfirm","onCancel","destructive","hideCancel","dismissible","cardStyle","testID","handleConfirm","useCallback","actions","label","onPress","color","shouldCloseOnPress","push","jsx","open","placement","dismissOnBackdrop","style","memo","displayName"],"sourceRoot":"../../../src","sources":["alert-dialog/AlertDialog.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_react","_interopRequireWildcard","require","_context","_jsxRuntime","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","createAlertDialog","Dialog","AlertDialogComponent","AlertDialog","visible","onClose","title","description","confirmLabel","cancelLabel","onConfirm","onCancel","destructive","hideCancel","dismissible","cardStyle","testID","control","useDialogControl","closingFromPropRef","useRef","useEffect","open","current","close","handleClose","useCallback","actions","label","onPress","color","push","jsx","placement","dismissOnBackdrop","style","memo","displayName"],"sourceRoot":"../../../src","sources":["alert-dialog/AlertDialog.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/alert-dialog/AlertDialog.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import React, { memo, useCallback } from 'react';
+import React, { memo, useCallback, useEffect, useRef } from 'react';
+import { useDialogControl } from "../dialog/context.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Build the `AlertDialog` component bound to a platform `Dialog`.
@@ -19,6 +20,19 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * imperative `confirm()` helper + `<AlertDialogHost />` to trigger a confirm
  * from an event handler without owning visible state.
  *
+ * Control mode — IMPERATIVE, not controlled. `AlertDialog` keeps its public
+ * *controlled* API (`visible` boolean + `onClose`) but internally bridges it
+ * onto the Dialog's imperative `useDialogControl()` handle, so `confirm()`
+ * drives `<Dialog>` through the EXACT uncontrolled/imperative internals
+ * Mention's `ConfirmPrompt` uses. That is the code path that actually plays the
+ * exit animation on dismiss: imperative `close()` sets `isClosing`, runs the
+ * exit animation, and fires `onClose` only once it settles. The controlled path
+ * instead fires `onClose` synchronously — and because `<AlertDialogHost />`
+ * resolves + drops the queue entry inside `onClose`, the surface would then
+ * unmount instantly, skipping the exit animation entirely. Bridging to
+ * imperative mode eliminates that fork so `confirm()` and Mention's
+ * `ConfirmPrompt` are pixel/timing identical.
+ *
  * The centered card uses the Dialog default `maxWidth` (480px) for full visual
  * parity with the shared confirm surface.
  */
@@ -34,31 +48,62 @@ export function createAlertDialog(Dialog) {
     onCancel,
     destructive = false,
     hideCancel = false,
-    dismissible = false,
+    dismissible = true,
     cardStyle,
     testID
   }) {
-    // Confirm resolves + closes SYNCHRONOUSLY, in this order, and must NOT go
-    // through the Dialog's auto-close (`shouldCloseOnPress: false`). In
-    // controlled mode `close()` fires `onClose` FIRST, and the `confirm()` host
-    // wires `onClose` to resolve the promise as *cancelled* (`false`). Running
-    // `onConfirm` (resolve `true`, which removes the queue entry) before
-    // `onClose` (now a no-op for that entry) is what makes the confirm button
-    // resolve `true`.
-    const handleConfirm = useCallback(() => {
-      onConfirm?.();
+    const control = useDialogControl();
+
+    // Bridge the public *controlled* `visible` prop onto the Dialog's
+    // imperative open/close. Opening on mount straight from an effect (no
+    // `setTimeout`) mirrors bloom's own `AutoMountedDialog` (which backs
+    // `alert()`) — the canonical fresh-mount imperative-open pattern:
+    // `<AlertDialogHost />` mounts a FRESH `AlertDialog` per confirm
+    // (`key={id}`) with the final content already committed, so there is no
+    // stale-content window to defer past and the entry animation curve stays
+    // identical to Mention's. `control` is referentially stable (memoised on
+    // its id), so this effect only re-runs when `visible` actually flips. When
+    // a direct consumer flips `visible` to `false`, we imperatively `close()`
+    // so the exit animation still plays.
+    const closingFromPropRef = useRef(false);
+    useEffect(() => {
+      if (visible) {
+        control.open();
+        return;
+      }
+      closingFromPropRef.current = true;
+      control.close();
+    }, [visible, control]);
+
+    // The Dialog fires `onClose` after the exit animation settles (imperative
+    // mode). Forward ONLY user-initiated dismissals (backdrop / Escape / cancel)
+    // to the consumer — a consumer-initiated close (they flipped `visible` to
+    // `false`) must not re-enter `onClose`, preserving the previous controlled
+    // semantics where a programmatic close does not fire `onClose`.
+    const handleClose = useCallback(() => {
+      if (closingFromPropRef.current) {
+        closingFromPropRef.current = false;
+        return;
+      }
       onClose();
-    }, [onConfirm, onClose]);
+    }, [onClose]);
+
+    // Confirm/cancel map onto the Dialog's declarative action row. Both keep the
+    // default `shouldCloseOnPress` (true): the button runs the exit animation
+    // FIRST, then invokes `onPress` as a close-completion callback — so
+    // `onConfirm` resolves the `confirm()` promise as the surface animates out,
+    // exactly like Mention. `onConfirm` (resolve `true`, drains the entry) runs
+    // just BEFORE the Dialog's own post-close `onClose` (→ `handleClose` →
+    // resolve `false`, now a no-op for the drained entry), which is what makes
+    // the confirm button win the double-resolution guard.
     const actions = [{
       label: confirmLabel,
-      onPress: handleConfirm,
-      color: destructive ? 'destructive' : 'default',
-      shouldCloseOnPress: false
+      onPress: onConfirm,
+      color: destructive ? 'destructive' : 'default'
     }];
     if (!hideCancel) {
-      // The `cancel` color auto-dismisses via the Dialog's `close()`, which in
-      // controlled mode fires `onClose` (the host resolves `false`). `onCancel`
-      // runs after the surface finishes closing.
+      // The `cancel` color auto-dismisses via the Dialog's `close()` (exit
+      // animation), then runs `onCancel` as a close-completion callback.
       actions.push({
         label: cancelLabel,
         onPress: onCancel,
@@ -66,11 +111,14 @@ export function createAlertDialog(Dialog) {
       });
     }
     return /*#__PURE__*/_jsx(Dialog, {
-      open: visible,
-      onClose: onClose,
+      control: control,
+      onClose: handleClose,
       placement: "center"
-      // Alert dialogs are blocking by default — the backdrop / Escape only
-      // dismiss when the caller opts in via `dismissible`.
+      // Alert dialogs dismiss on backdrop / Escape by default (matching the
+      // shared Dialog default and Mention's `ConfirmPrompt`). A backdrop /
+      // Escape dismissal can only ever resolve the confirm as cancelled
+      // (`false`), never the destructive action — callers that need a truly
+      // blocking confirm opt out with `dismissible={false}`.
       ,
       dismissOnBackdrop: dismissible,
       title: title,

package/lib/module/alert-dialog/AlertDialog.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","memo","useCallback","jsx","_jsx","createAlertDialog","Dialog","AlertDialogComponent","AlertDialog","visible","onClose","title","description","confirmLabel","cancelLabel","onConfirm","onCancel","destructive","hideCancel","dismissible","cardStyle","testID","handleConfirm","actions","label","onPress","color","shouldCloseOnPress","push","open","placement","dismissOnBackdrop","style","displayName"],"sourceRoot":"../../../src","sources":["alert-dialog/AlertDialog.tsx"],"mappings":";;AAAA,OAAOA,KAAK,IAAIC,IAAI,EAAEC,WAAW,QAAQ,OAAO;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAOjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAACC,MAAuB,EAAE;EACzD,MAAMC,oBAAoB,GAAG,SAASC,WAAWA,CAAC;IAChDC,OAAO;IACPC,OAAO;IACPC,KAAK;IACLC,WAAW;IACXC,YAAY,GAAG,SAAS;IACxBC,WAAW,GAAG,QAAQ;IACtBC,SAAS;IACTC,QAAQ;IACRC,WAAW,GAAG,KAAK;IACnBC,UAAU,GAAG,KAAK;IAClBC,WAAW,GAAG,KAAK;IACnBC,SAAS;IACTC;EACgB,CAAC,EAAE;IACnB;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMC,aAAa,GAAGpB,WAAW,CAAC,MAAM;MACtCa,SAAS,GAAG,CAAC;MACbL,OAAO,CAAC,CAAC;IACX,CAAC,EAAE,CAACK,SAAS,EAAEL,OAAO,CAAC,CAAC;IAExB,MAAMa,OAAuB,GAAG,CAC9B;MACEC,KAAK,EAAEX,YAAY;MACnBY,OAAO,EAAEH,aAAa;MACtBI,KAAK,EAAET,WAAW,GAAG,aAAa,GAAG,SAAS;MAC9CU,kBAAkB,EAAE;IACtB,CAAC,CACF;IACD,IAAI,CAACT,UAAU,EAAE;MACf;MACA;MACA;MACAK,OAAO,CAACK,IAAI,CAAC;QACXJ,KAAK,EAAEV,WAAW;QAClBW,OAAO,EAAET,QAAQ;QACjBU,KAAK,EAAE;MACT,CAAC,CAAC;IACJ;IAEA,oBACEtB,IAAA,CAACE,MAAM;MACLuB,IAAI,EAAEpB,OAAQ;MACdC,OAAO,EAAEA,OAAQ;MACjBoB,SAAS,EAAC;MACV;MACA;MAAA;MACAC,iBAAiB,EAAEZ,WAAY;MAC/BR,KAAK,EAAEA,KAAM;MACbC,WAAW,EAAEA,WAAY;MACzBW,OAAO,EAAEA,OAAQ;MACjBC,KAAK,EAAEb,KAAM;MACbqB,KAAK,EAAEZ,SAAU;MACjBC,MAAM,EAAEA;IAAO,CAChB,CAAC;EAEN,CAAC;EAED,MAAMb,WAAW,gBAAGP,IAAI,CAACM,oBAAoB,CAAC;EAC9CC,WAAW,CAACyB,WAAW,GAAG,aAAa;EACvC,OAAOzB,WAAW;AACpB","ignoreList":[]}
+{"version":3,"names":["React","memo","useCallback","useEffect","useRef","useDialogControl","jsx","_jsx","createAlertDialog","Dialog","AlertDialogComponent","AlertDialog","visible","onClose","title","description","confirmLabel","cancelLabel","onConfirm","onCancel","destructive","hideCancel","dismissible","cardStyle","testID","control","closingFromPropRef","open","current","close","handleClose","actions","label","onPress","color","push","placement","dismissOnBackdrop","style","displayName"],"sourceRoot":"../../../src","sources":["alert-dialog/AlertDialog.tsx"],"mappings":";;AAAA,OAAOA,KAAK,IAAIC,IAAI,EAAEC,WAAW,EAAEC,SAAS,EAAEC,MAAM,QAAQ,OAAO;AAGnE,SAASC,gBAAgB,QAAQ,sBAAmB;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAKrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAACC,MAAuB,EAAE;EACzD,MAAMC,oBAAoB,GAAG,SAASC,WAAWA,CAAC;IAChDC,OAAO;IACPC,OAAO;IACPC,KAAK;IACLC,WAAW;IACXC,YAAY,GAAG,SAAS;IACxBC,WAAW,GAAG,QAAQ;IACtBC,SAAS;IACTC,QAAQ;IACRC,WAAW,GAAG,KAAK;IACnBC,UAAU,GAAG,KAAK;IAClBC,WAAW,GAAG,IAAI;IAClBC,SAAS;IACTC;EACgB,CAAC,EAAE;IACnB,MAAMC,OAAO,GAAGpB,gBAAgB,CAAC,CAAC;;IAElC;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMqB,kBAAkB,GAAGtB,MAAM,CAAC,KAAK,CAAC;IACxCD,SAAS,CAAC,MAAM;MACd,IAAIS,OAAO,EAAE;QACXa,OAAO,CAACE,IAAI,CAAC,CAAC;QACd;MACF;MACAD,kBAAkB,CAACE,OAAO,GAAG,IAAI;MACjCH,OAAO,CAACI,KAAK,CAAC,CAAC;IACjB,CAAC,EAAE,CAACjB,OAAO,EAAEa,OAAO,CAAC,CAAC;;IAEtB;IACA;IACA;IACA;IACA;IACA,MAAMK,WAAW,GAAG5B,WAAW,CAAC,MAAM;MACpC,IAAIwB,kBAAkB,CAACE,OAAO,EAAE;QAC9BF,kBAAkB,CAACE,OAAO,GAAG,KAAK;QAClC;MACF;MACAf,OAAO,CAAC,CAAC;IACX,CAAC,EAAE,CAACA,OAAO,CAAC,CAAC;;IAEb;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMkB,OAAuB,GAAG,CAC9B;MACEC,KAAK,EAAEhB,YAAY;MACnBiB,OAAO,EAAEf,SAAS;MAClBgB,KAAK,EAAEd,WAAW,GAAG,aAAa,GAAG;IACvC,CAAC,CACF;IACD,IAAI,CAACC,UAAU,EAAE;MACf;MACA;MACAU,OAAO,CAACI,IAAI,CAAC;QACXH,KAAK,EAAEf,WAAW;QAClBgB,OAAO,EAAEd,QAAQ;QACjBe,KAAK,EAAE;MACT,CAAC,CAAC;IACJ;IAEA,oBACE3B,IAAA,CAACE,MAAM;MACLgB,OAAO,EAAEA,OAAQ;MACjBZ,OAAO,EAAEiB,WAAY;MACrBM,SAAS,EAAC;MACV;MACA;MACA;MACA;MACA;MAAA;MACAC,iBAAiB,EAAEf,WAAY;MAC/BR,KAAK,EAAEA,KAAM;MACbC,WAAW,EAAEA,WAAY;MACzBgB,OAAO,EAAEA,OAAQ;MACjBC,KAAK,EAAElB,KAAM;MACbwB,KAAK,EAAEf,SAAU;MACjBC,MAAM,EAAEA;IAAO,CAChB,CAAC;EAEN,CAAC;EAED,MAAMb,WAAW,gBAAGV,IAAI,CAACS,oBAAoB,CAAC;EAC9CC,WAAW,CAAC4B,WAAW,GAAG,aAAa;EACvC,OAAO5B,WAAW;AACpB","ignoreList":[]}

package/lib/typescript/commonjs/alert-dialog/AlertDialog.d.ts

@@ -19,6 +19,19 @@ type DialogComponent = React.ComponentType<DialogProps>;
  * imperative `confirm()` helper + `<AlertDialogHost />` to trigger a confirm
  * from an event handler without owning visible state.
  *
+ * Control mode — IMPERATIVE, not controlled. `AlertDialog` keeps its public
+ * *controlled* API (`visible` boolean + `onClose`) but internally bridges it
+ * onto the Dialog's imperative `useDialogControl()` handle, so `confirm()`
+ * drives `<Dialog>` through the EXACT uncontrolled/imperative internals
+ * Mention's `ConfirmPrompt` uses. That is the code path that actually plays the
+ * exit animation on dismiss: imperative `close()` sets `isClosing`, runs the
+ * exit animation, and fires `onClose` only once it settles. The controlled path
+ * instead fires `onClose` synchronously — and because `<AlertDialogHost />`
+ * resolves + drops the queue entry inside `onClose`, the surface would then
+ * unmount instantly, skipping the exit animation entirely. Bridging to
+ * imperative mode eliminates that fork so `confirm()` and Mention's
+ * `ConfirmPrompt` are pixel/timing identical.
+ *
  * The centered card uses the Dialog default `maxWidth` (480px) for full visual
  * parity with the shared confirm surface.
  */

package/lib/typescript/commonjs/alert-dialog/AlertDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertDialog.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/AlertDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAEjD,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,KAAK,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,kLAepD,gBAAgB,8CAqDpB;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"AlertDialog.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/AlertDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AAEpE,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,WAAW,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,KAAK,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,kLAepD,gBAAgB,8CAsFpB;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/lib/typescript/commonjs/alert-dialog/types.d.ts

@@ -25,8 +25,10 @@ export interface AlertDialogProps {
     /** Render only the confirm button (no cancel). Defaults to `false`. */
     hideCancel?: boolean;
     /**
-     * Tap-outside / Escape dismisses. Defaults to `false` — alert dialogs are
-     * usually blocking until answered.
+     * Tap-outside / Escape dismisses. Defaults to `true` — matching the shared
+     * `Dialog` default and Mention's `ConfirmPrompt`. A backdrop / Escape
+     * dismissal always resolves the confirm as cancelled (`false`), so it is
+     * safe by default; pass `false` for a truly blocking confirm.
      */
     dismissible?: boolean;
     cardStyle?: StyleProp<ViewStyle>;
@@ -39,6 +41,10 @@ export interface ConfirmOptions {
     cancelLabel?: string;
     destructive?: boolean;
     hideCancel?: boolean;
+    /**
+     * Tap-outside / Escape dismisses (resolving `false`). Defaults to `true`;
+     * pass `false` for a blocking confirm that must be answered by a button.
+     */
     dismissible?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/alert-dialog/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB"}

package/lib/typescript/module/alert-dialog/AlertDialog.d.ts

@@ -19,6 +19,19 @@ type DialogComponent = React.ComponentType<DialogProps>;
  * imperative `confirm()` helper + `<AlertDialogHost />` to trigger a confirm
  * from an event handler without owning visible state.
  *
+ * Control mode — IMPERATIVE, not controlled. `AlertDialog` keeps its public
+ * *controlled* API (`visible` boolean + `onClose`) but internally bridges it
+ * onto the Dialog's imperative `useDialogControl()` handle, so `confirm()`
+ * drives `<Dialog>` through the EXACT uncontrolled/imperative internals
+ * Mention's `ConfirmPrompt` uses. That is the code path that actually plays the
+ * exit animation on dismiss: imperative `close()` sets `isClosing`, runs the
+ * exit animation, and fires `onClose` only once it settles. The controlled path
+ * instead fires `onClose` synchronously — and because `<AlertDialogHost />`
+ * resolves + drops the queue entry inside `onClose`, the surface would then
+ * unmount instantly, skipping the exit animation entirely. Bridging to
+ * imperative mode eliminates that fork so `confirm()` and Mention's
+ * `ConfirmPrompt` are pixel/timing identical.
+ *
  * The centered card uses the Dialog default `maxWidth` (480px) for full visual
  * parity with the shared confirm surface.
  */

package/lib/typescript/module/alert-dialog/AlertDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertDialog.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/AlertDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAEjD,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,KAAK,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,kLAepD,gBAAgB,8CAqDpB;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"AlertDialog.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/AlertDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AAEpE,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,WAAW,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,KAAK,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,kLAepD,gBAAgB,8CAsFpB;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/lib/typescript/module/alert-dialog/types.d.ts

@@ -25,8 +25,10 @@ export interface AlertDialogProps {
     /** Render only the confirm button (no cancel). Defaults to `false`. */
     hideCancel?: boolean;
     /**
-     * Tap-outside / Escape dismisses. Defaults to `false` — alert dialogs are
-     * usually blocking until answered.
+     * Tap-outside / Escape dismisses. Defaults to `true` — matching the shared
+     * `Dialog` default and Mention's `ConfirmPrompt`. A backdrop / Escape
+     * dismissal always resolves the confirm as cancelled (`false`), so it is
+     * safe by default; pass `false` for a truly blocking confirm.
      */
     dismissible?: boolean;
     cardStyle?: StyleProp<ViewStyle>;
@@ -39,6 +41,10 @@ export interface ConfirmOptions {
     cancelLabel?: string;
     destructive?: boolean;
     hideCancel?: boolean;
+    /**
+     * Tap-outside / Escape dismisses (resolving `false`). Defaults to `true`;
+     * pass `false` for a blocking confirm that must be answered by a button.
+     */
     dismissible?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/alert-dialog/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/alert-dialog/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/bloom",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Bloom UI — Oxy ecosystem component library for React Native + Expo + Web",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/src/__tests__/AlertDialog.test.tsx

@@ -2,7 +2,10 @@ import React, { useState } from 'react';
 import { act, fireEvent, render } from '@testing-library/react-native';
 
 import { AlertDialog, AlertDialogHost, confirm } from '../alert-dialog';
+import { createAlertDialog } from '../alert-dialog/AlertDialog';
+import { createAlertDialogHost } from '../alert-dialog/AlertDialogHost';
 import { getConfirmQueue, resolveConfirm } from '../alert-dialog/confirm-store';
+import type { DialogProps } from '../dialog';
 import { BloomThemeProvider } from '../theme/BloomThemeProvider';
 
 function renderWithTheme(ui: React.ReactElement) {
@@ -209,4 +212,73 @@ describe('AlertDialog (built on Dialog)', () => {
       await expect(result).resolves.toBe(true);
     });
   });
+
+  // Finding 1 (control-mode) + Finding 2 (backdrop-dismiss default). These pin
+  // the two behavioural fixes at the prop boundary between `AlertDialog` and the
+  // underlying `Dialog`, using a prop-capturing mock `Dialog` so the assertions
+  // are deterministic and platform-agnostic.
+  describe('control-mode bridge + dismiss defaults', () => {
+    function captureDialogProps() {
+      const captured: { props?: DialogProps } = {};
+      const MockDialog = (props: DialogProps) => {
+        captured.props = props;
+        return null;
+      };
+      return { captured, MockDialog };
+    }
+
+    it('drives the underlying Dialog imperatively (control), never the controlled `open` prop', () => {
+      const { captured, MockDialog } = captureDialogProps();
+      const TestAlertDialog = createAlertDialog(MockDialog);
+      renderWithTheme(<TestAlertDialog visible onClose={() => {}} title="Delete?" />);
+      // The whole point of the fix: `confirm()` must take the Dialog's
+      // imperative/uncontrolled branch (the one that plays the exit animation),
+      // so an imperative `control` handle is passed and the controlled `open`
+      // boolean — which would take the other branch — is never set.
+      expect(captured.props?.control).toBeDefined();
+      expect(captured.props?.open).toBeUndefined();
+    });
+
+    it('defaults dismissOnBackdrop to true (backdrop / Escape dismiss by default)', () => {
+      const { captured, MockDialog } = captureDialogProps();
+      const TestAlertDialog = createAlertDialog(MockDialog);
+      renderWithTheme(<TestAlertDialog visible onClose={() => {}} title="Delete?" />);
+      // Matches the shared Dialog default + Mention's ConfirmPrompt.
+      expect(captured.props?.dismissOnBackdrop).toBe(true);
+    });
+
+    it('still supports an opt-in blocking confirm via dismissible={false}', () => {
+      const { captured, MockDialog } = captureDialogProps();
+      const TestAlertDialog = createAlertDialog(MockDialog);
+      renderWithTheme(
+        <TestAlertDialog visible onClose={() => {}} title="Delete?" dismissible={false} />,
+      );
+      expect(captured.props?.dismissOnBackdrop).toBe(false);
+    });
+
+    it('resolves false when dismissed via backdrop / Escape (Dialog onClose) with no button press', async () => {
+      // Backdrop tap and Escape both route through the Dialog's `onClose`. Now
+      // that dismissOnBackdrop defaults true, that path is reachable by default
+      // and must resolve the confirm as cancelled (false) and drain the queue —
+      // never trigger the (potentially destructive) confirm action.
+      const captured: { onClose?: () => void } = {};
+      const MockDialog = (props: DialogProps) => {
+        captured.onClose = props.onClose;
+        return null;
+      };
+      const Host = createAlertDialogHost(createAlertDialog(MockDialog));
+      renderWithTheme(<Host />);
+      let result!: Promise<boolean>;
+      act(() => {
+        result = confirm({ title: 'Discard unsaved changes?' });
+      });
+      act(() => {
+        // Simulate the backdrop / Escape dismissal the real Dialog fires after
+        // its exit animation settles.
+        captured.onClose?.();
+      });
+      await expect(result).resolves.toBe(false);
+      expect(getConfirmQueue()).toHaveLength(0);
+    });
+  });
 });

package/src/alert-dialog/AlertDialog.tsx

@@ -1,6 +1,7 @@
-import React, { memo, useCallback } from 'react';
+import React, { memo, useCallback, useEffect, useRef } from 'react';
 
 import type { DialogAction, DialogProps } from '../dialog';
+import { useDialogControl } from '../dialog/context';
 import type { AlertDialogProps } from './types';
 
 type DialogComponent = React.ComponentType<DialogProps>;
@@ -22,6 +23,19 @@ type DialogComponent = React.ComponentType<DialogProps>;
  * imperative `confirm()` helper + `<AlertDialogHost />` to trigger a confirm
  * from an event handler without owning visible state.
  *
+ * Control mode — IMPERATIVE, not controlled. `AlertDialog` keeps its public
+ * *controlled* API (`visible` boolean + `onClose`) but internally bridges it
+ * onto the Dialog's imperative `useDialogControl()` handle, so `confirm()`
+ * drives `<Dialog>` through the EXACT uncontrolled/imperative internals
+ * Mention's `ConfirmPrompt` uses. That is the code path that actually plays the
+ * exit animation on dismiss: imperative `close()` sets `isClosing`, runs the
+ * exit animation, and fires `onClose` only once it settles. The controlled path
+ * instead fires `onClose` synchronously — and because `<AlertDialogHost />`
+ * resolves + drops the queue entry inside `onClose`, the surface would then
+ * unmount instantly, skipping the exit animation entirely. Bridging to
+ * imperative mode eliminates that fork so `confirm()` and Mention's
+ * `ConfirmPrompt` are pixel/timing identical.
+ *
  * The centered card uses the Dialog default `maxWidth` (480px) for full visual
  * parity with the shared confirm surface.
  */
@@ -37,34 +51,64 @@ export function createAlertDialog(Dialog: DialogComponent) {
     onCancel,
     destructive = false,
     hideCancel = false,
-    dismissible = false,
+    dismissible = true,
     cardStyle,
     testID,
   }: AlertDialogProps) {
-    // Confirm resolves + closes SYNCHRONOUSLY, in this order, and must NOT go
-    // through the Dialog's auto-close (`shouldCloseOnPress: false`). In
-    // controlled mode `close()` fires `onClose` FIRST, and the `confirm()` host
-    // wires `onClose` to resolve the promise as *cancelled* (`false`). Running
-    // `onConfirm` (resolve `true`, which removes the queue entry) before
-    // `onClose` (now a no-op for that entry) is what makes the confirm button
-    // resolve `true`.
-    const handleConfirm = useCallback(() => {
-      onConfirm?.();
+    const control = useDialogControl();
+
+    // Bridge the public *controlled* `visible` prop onto the Dialog's
+    // imperative open/close. Opening on mount straight from an effect (no
+    // `setTimeout`) mirrors bloom's own `AutoMountedDialog` (which backs
+    // `alert()`) — the canonical fresh-mount imperative-open pattern:
+    // `<AlertDialogHost />` mounts a FRESH `AlertDialog` per confirm
+    // (`key={id}`) with the final content already committed, so there is no
+    // stale-content window to defer past and the entry animation curve stays
+    // identical to Mention's. `control` is referentially stable (memoised on
+    // its id), so this effect only re-runs when `visible` actually flips. When
+    // a direct consumer flips `visible` to `false`, we imperatively `close()`
+    // so the exit animation still plays.
+    const closingFromPropRef = useRef(false);
+    useEffect(() => {
+      if (visible) {
+        control.open();
+        return;
+      }
+      closingFromPropRef.current = true;
+      control.close();
+    }, [visible, control]);
+
+    // The Dialog fires `onClose` after the exit animation settles (imperative
+    // mode). Forward ONLY user-initiated dismissals (backdrop / Escape / cancel)
+    // to the consumer — a consumer-initiated close (they flipped `visible` to
+    // `false`) must not re-enter `onClose`, preserving the previous controlled
+    // semantics where a programmatic close does not fire `onClose`.
+    const handleClose = useCallback(() => {
+      if (closingFromPropRef.current) {
+        closingFromPropRef.current = false;
+        return;
+      }
       onClose();
-    }, [onConfirm, onClose]);
+    }, [onClose]);
 
+    // Confirm/cancel map onto the Dialog's declarative action row. Both keep the
+    // default `shouldCloseOnPress` (true): the button runs the exit animation
+    // FIRST, then invokes `onPress` as a close-completion callback — so
+    // `onConfirm` resolves the `confirm()` promise as the surface animates out,
+    // exactly like Mention. `onConfirm` (resolve `true`, drains the entry) runs
+    // just BEFORE the Dialog's own post-close `onClose` (→ `handleClose` →
+    // resolve `false`, now a no-op for the drained entry), which is what makes
+    // the confirm button win the double-resolution guard.
     const actions: DialogAction[] = [
       {
         label: confirmLabel,
-        onPress: handleConfirm,
+        onPress: onConfirm,
         color: destructive ? 'destructive' : 'default',
-        shouldCloseOnPress: false,
       },
     ];
     if (!hideCancel) {
-      // The `cancel` color auto-dismisses via the Dialog's `close()`, which in
-      // controlled mode fires `onClose` (the host resolves `false`). `onCancel`
-      // runs after the surface finishes closing.
+      // The `cancel` color auto-dismisses via the Dialog's `close()` (exit
+      // animation), then runs `onCancel` as a close-completion callback.
       actions.push({
         label: cancelLabel,
         onPress: onCancel,
@@ -74,11 +118,14 @@ export function createAlertDialog(Dialog: DialogComponent) {
 
     return (
       <Dialog
-        open={visible}
-        onClose={onClose}
+        control={control}
+        onClose={handleClose}
         placement="center"
-        // Alert dialogs are blocking by default — the backdrop / Escape only
-        // dismiss when the caller opts in via `dismissible`.
+        // Alert dialogs dismiss on backdrop / Escape by default (matching the
+        // shared Dialog default and Mention's `ConfirmPrompt`). A backdrop /
+        // Escape dismissal can only ever resolve the confirm as cancelled
+        // (`false`), never the destructive action — callers that need a truly
+        // blocking confirm opt out with `dismissible={false}`.
         dismissOnBackdrop={dismissible}
         title={title}
         description={description}

package/src/alert-dialog/types.ts

@@ -27,8 +27,10 @@ export interface AlertDialogProps {
   /** Render only the confirm button (no cancel). Defaults to `false`. */
   hideCancel?: boolean;
   /**
-   * Tap-outside / Escape dismisses. Defaults to `false` — alert dialogs are
-   * usually blocking until answered.
+   * Tap-outside / Escape dismisses. Defaults to `true` — matching the shared
+   * `Dialog` default and Mention's `ConfirmPrompt`. A backdrop / Escape
+   * dismissal always resolves the confirm as cancelled (`false`), so it is
+   * safe by default; pass `false` for a truly blocking confirm.
    */
   dismissible?: boolean;
   cardStyle?: StyleProp<ViewStyle>;
@@ -42,5 +44,9 @@ export interface ConfirmOptions {
   cancelLabel?: string;
   destructive?: boolean;
   hideCancel?: boolean;
+  /**
+   * Tap-outside / Escape dismisses (resolving `false`). Defaults to `true`;
+   * pass `false` for a blocking confirm that must be answered by a button.
+   */
   dismissible?: boolean;
 }