@okyrychenko-dev/react-modal-manager 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-09-14
+
+### Added
+
+- Allow modal definitions whose input is `void` or `undefined` to be opened without an input argument through the modal manager, registered definitions, and typed registries.
+- Add verified React 18 and React 19 compatibility, including Strict Mode and independent-root coverage.
+- Add tested SSR, hydration, and Next.js App Router/React Server Components guidance.
+- Add compile-checked adoption examples, packed-package contract checks, lifecycle benchmarks, and reproducible competitive package checks.
+- Add automated pnpm-based CI and provenance-enabled npm release workflows.
+
+### Changed
+
+- Move modal lifecycle ownership entirely into each `ModalProvider`, with React observing the lifecycle state directly.
+- Simplify imperative modal access: pass a typed registry directly to `ModalProvider`; external registry calls route to the most recently mounted matching provider and fall back when it unmounts.
+- Remove Zustand from the public installation contract. React is now the only peer dependency; `@okyrychenko-dev/type-utils` is the sole runtime dependency.
+- Migrate repository development, validation, package inspection, and release workflows from npm to pnpm.
+- Expand the README with provider-scope, lifecycle, registry, SSR/RSC, custom-renderer, accessibility, adoption, and troubleshooting guidance.
+
+### Fixed
+
+- Preserve provider lifecycle state during React Strict Mode effect replay.
+- Preserve registry routing across nested providers, adjacent providers, and independent React roots.
+- Make lifecycle Storybook examples repeatable after modal settlement.
+
+[0.2.0]: https://github.com/okyrychenko-dev/react-modal-manager/compare/v0.1.0...v0.2.0

package/README.md

@@ -35,42 +35,51 @@ const app = (
 
 ## Why This Library
 
-- **Typed results, not `any`.** `open<TInput, TResult>(def, input)` returns a `Promise<TResult>`. Both sides of the call are checked.
-- **Per-provider isolation.** Each `ModalProvider` owns its own Zustand store — no global singleton, so subtrees and tests never leak modal state into each other.
-- **Open from non-React code.** A typed registry (or controller) lets event buses, command palettes, and action maps open modals while keeping full inference.
-- **UI-agnostic core.** A single `renderer` boundary lets you plug in portals, overlays, animations, or any design system. The core never prescribes DOM or styling.
+- **Typed results, not `any`.** `open<TInput, TResult>(def, input)` returns a `Promise<TResult>`. Both sides of the call are checked, and inputless modals can omit the argument.
+- **Per-provider isolation.** Each `ModalProvider` owns an independent lifecycle whose authoritative state React observes directly — no global lifecycle singleton, so subtrees and tests never leak modal state into each other.
+- **Open from non-React code.** A typed registry lets event buses, command palettes, and action maps open modals while keeping full inference.
+- **UI-agnostic core.** A single `renderer` seam lets you plug in portals, overlays, animations, or any design system. The core never prescribes DOM or styling.
 - **Built-in `confirm()`** with a typed, discriminated-union result — useful from day one, replaceable when you need your own design.
 - **Promise-shaped lifecycle.** Dismissals reject with `ModalDismissError`; exit animations are supported through `closeDelayMs` + an `"open" | "closing"` status.
 
-### Compared to `nice-modal-react`
+### Compared to [`@ebay/nice-modal-react`](https://github.com/eBay/nice-modal-react)
 
-| | `react-modal-manager` | `nice-modal-react` |
-| --- | --- | --- |
-| Result typing | `Promise<TResult>`, fully inferred | result is effectively `unknown` / `any` |
-| State scope | isolated per `ModalProvider` | single global singleton |
-| Open from anywhere | typed registry / controller (LIFO provider stack) | global `NiceModal.show(id)` |
-| Built-in confirm | typed `ConfirmModalResult` | none |
-| UI coupling | UI-agnostic `renderer` boundary | you render it yourself |
-| Concepts to first modal | 1 (`confirm`) — or define → register → open for custom modals | 1 (`show`) |
+Revalidated **2026-09-13** for this package's **0.2.0** release line (through `3a98aa8`) and the current stable [`@ebay/nice-modal-react` 1.2.13](https://www.npmjs.com/package/@ebay/nice-modal-react/v/1.2.13). “Verified behavior” below means an executable public-surface check; “architecture” describes source structure and is not itself a consumer guarantee.
 
-**Honest trade-off:** there is no "show a modal by string id from literally anywhere" without importing a typed `ModalDefinition` or a registry. That is the deliberate price of end-to-end type safety, not a missing feature.
+| Area | `react-modal-manager` | `nice-modal-react` | Evidence kind |
+| --- | --- | --- | --- |
+| Input and result typing | A definition or registry key couples input to `Promise<TResult>` | Component props are inferred; `show()` result is caller-selected and handlers expose `Promise<unknown>` | Verified declarations: [local packed-consumer fixture](scripts/package-consumer.typecheck.ts), [Nice Modal 1.2.13 declarations](https://unpkg.com/@ebay/nice-modal-react@1.2.13/lib/esm/index.d.ts) |
+| Lifecycle correctness | Per-instance handles; resolve, reject, and dismiss settle once; optional closing phase precedes removal | Promise-based `show`; separate `hide` and `remove`; UI-library helpers connect removal to exit callbacks | Verified local behavior: [lifecycle tests](src/lifecycle/__tests__/modalLifecycle.test.ts); documented competitor behavior: [Nice Modal usage and helpers](https://github.com/eBay/nice-modal-react/tree/1.2.13#usage) |
+| Provider isolation | Nested, adjacent, and independent roots own isolated lifecycle state | Each provider creates reducer state, while imperative dispatch, registrations, and promise callbacks are module-level | Verified local behavior: [root tests](src/provider/__tests__/ModalProvider.roots.test.tsx); competitor architecture: [1.2.13 source](https://github.com/eBay/nice-modal-react/blob/1.2.13/src/index.tsx) |
+| React compatibility | Declares React 18 and 19 and runs the same root/Strict Mode suite against both | Declares React and React DOM `>16.8.0`; the published package was developed with React 17 | Verified local matrix: [CI](.github/workflows/ci.yml); published competitor metadata: [package manifest](https://unpkg.com/@ebay/nice-modal-react@1.2.13/package.json) |
+| SSR and RSC | Provider server rendering, separate-request isolation, and hydration are tested; RSC usage has a compiled Client Component example | No SSR, hydration, or React Server Components contract is documented in the 1.2.13 README | Verified local behavior: [SSR tests](src/provider/__tests__/ModalProvider.ssr.test.tsx) and [RSC-style fixture](examples/next-app-router-provider.typecheck.tsx); competitor documentation: [1.2.13 README](https://github.com/eBay/nice-modal-react/tree/1.2.13) |
+| Imperative access | A typed registry opens outside React after being bound to a provider; keys, input, and results are inferred | `NiceModal.show(component, props)` or a registered string id can be called directly after a provider establishes the module-level dispatch | Verified local behavior: [registry tests](src/registry/__tests__/createModalRegistry.test.tsx); documented competitor behavior: [component and id APIs](https://github.com/eBay/nice-modal-react/tree/1.2.13#using-your-modal-component) |
+| Rendering independence | Lifecycle renders modal definitions through a replaceable wrapper; no portal, overlay, CSS, or design-system dependency | Supplies no dialog markup and wraps consumer components; includes helpers for Ant Design, MUI, and React Bootstrap lifecycles | Public interfaces: [local renderer types](src/types/modal.ts), [Nice Modal helpers](https://unpkg.com/@ebay/nice-modal-react@1.2.13/lib/esm/index.d.ts) |
+| Accessibility composition | Built-in confirmation provides dialog semantics, initial focus, focus trapping, and safe destructive focus; custom modals/renderers remain consumer-owned | Accessibility belongs entirely to the consumer’s chosen modal component or UI library | Verified local behavior: [confirmation tests](src/confirm/__tests__/ConfirmModal.test.tsx); documented competitor scope: [“not a React modal component”](https://github.com/eBay/nice-modal-react/tree/1.2.13#nice-modal) |
+| First-use ergonomics | `confirm()` is the shortest path; custom flows define a modal and open it directly or through a registry | `show(component, props)` is the shortest path; string access adds `register(id, component)` | Documented public APIs: [this README](#quick-start), [Nice Modal usage](https://github.com/eBay/nice-modal-react/tree/1.2.13#usage) |
+| Package cost | Recorded minimal `createModal` consumer: **2,058 B / 1,044 B gzip**; React is the only peer and `type-utils` the only runtime dependency | Reproduced minimal named-`show` consumer: **758 B / 473 B gzip**; zero runtime dependencies, with React and React DOM as peers | Reproduce with [`package:check`](scripts/check-packed-package.mjs) and [`competitive:check`](scripts/check-competitive-package.mjs). The entry points differ, so these are package-cost observations, not a universal size ranking. |
+| Performance | Optimized-build raw samples and summaries cover mount, unmount, open/render, settlement, delayed removal, stacking, and registry routing | No like-for-like run was made against the competitor | Reproducible local evidence: [`benchmark:lifecycle`](scripts/benchmark-lifecycle.mjs). No performance winner is claimed. |
+| Maintenance status | 0.2.0 is the release line evaluated in this repository | 1.2.13 was published 2023-10-03; it remains the npm `latest` release on the evaluation date | Release evidence: [local manifest](package.json), [npm version](https://www.npmjs.com/package/@ebay/nice-modal-react/v/1.2.13), [GitHub release](https://github.com/eBay/nice-modal-react/releases/tag/1.2.13) |
+
+The main trade-off is deliberate: this package does not provide unchecked `show("any-string")` routing. Imperative callers import a typed definition or use a typed registry, and a registry must be bound to a mounted provider. Nice Modal’s global component/id calls require less setup and can be more convenient when that trade-off is acceptable. Conversely, this package’s provider ownership, result inference, SSR behavior, and built-in confirmation are explicit tested contracts rather than conclusions drawn only from implementation structure.
 
 ## Installation
 
 ```bash
-npm install @okyrychenko-dev/react-modal-manager zustand
+npm install @okyrychenko-dev/react-modal-manager
 # or
-yarn add @okyrychenko-dev/react-modal-manager zustand
+yarn add @okyrychenko-dev/react-modal-manager
 # or
-pnpm add @okyrychenko-dev/react-modal-manager zustand
+pnpm add @okyrychenko-dev/react-modal-manager
 ```
 
 Peer dependencies:
 
 - [React](https://react.dev/) `^18.0.0 || ^19.0.0`
-- [Zustand](https://zustand-demo.pmnd.rs/) `^5.0.0`
 
-There are **no runtime dependencies** beyond these peers — the provider-scoped store is built into the package.
+Modal lifecycle state is provider-owned and observed directly by React. There is no global lifecycle singleton.
+
+The package also installs its small runtime guard dependency automatically; React is the only peer dependency consumers provide.
 
 ## Quick Start
 
@@ -110,6 +119,20 @@ function ReportsPage() {
 }
 ```
 
+## Adoption Path
+
+Start with the smallest API that solves the current problem, then add the next capability only when the application needs it:
+
+1. Use [`confirm()`](#confirmation-modals) for a typed yes/no decision.
+2. Define a [typed custom modal](#typed-modal-flow) when the flow needs application-specific input, UI, or results.
+3. Keep the returned [modal handle](#typed-modal-flow) when the caller must identify or dismiss that exact instance.
+4. Add a [typed registry](#typed-modal-registry) for commands that originate outside React.
+5. Supply a [custom renderer](#custom-renderer) for overlays, portals, design-system shells, and exit animations.
+6. Split independent application areas into [provider scopes](#provider-scope).
+7. Follow the [Next.js App Router guidance](#nextjs-app-router-ssr) for SSR and React Server Components.
+
+The complete path is compile-checked as a package consumer in [`examples/adoption-paths.typecheck.tsx`](examples/adoption-paths.typecheck.tsx). The client boundary used by a server layout is checked separately in [`examples/next-app-router-provider.typecheck.tsx`](examples/next-app-router-provider.typecheck.tsx). Interactive equivalents live in Storybook under `Components/confirmModal`, `Context/ModalProvider`, and `Components/ModalViewport`.
+
 ## Type Safety
 
 This is where the library earns its place. Define a modal once and every call site is checked end to end.
@@ -122,9 +145,16 @@ interface RenameInput {
   currentName: string;
 }
 
-type RenameResult =
-  | { status: "renamed"; name: string }
-  | { status: "cancelled" };
+interface RenameSucceededResult {
+  status: "renamed";
+  name: string;
+}
+
+interface RenameCancelledResult {
+  status: "cancelled";
+}
+
+type RenameResult = RenameSucceededResult | RenameCancelledResult;
 
 function RenameModal({ close, input }: ModalComponentProps<RenameInput, RenameResult>) {
   // `input` is RenameInput. `close` only accepts a RenameResult.
@@ -221,6 +251,16 @@ const result = await handle;
 
 The handle's `dismiss()` stays bound to the provider that opened the modal.
 
+For a modal that needs no input, declare its input as `void` and omit the second argument:
+
+```tsx
+const infoModal = createModal<void, void>({ component: InfoModal });
+
+await modal.open(infoModal);
+```
+
+Modals with any other input type still require an input argument.
+
 ## Typed Modal Registry
 
 Use `createModalRegistry()` when code needs to open modals by a stable key while keeping typed input and result contracts. This suits command palettes, event buses, action maps, and configuration-driven flows. Pass the registry straight to `ModalProvider` — there is no controller to wire up.
@@ -262,6 +302,32 @@ export async function renameFromAction(reportId: string, currentName: string) {
 
 The registry key is type-checked, and TypeScript infers the required input and the returned result from the modal registered under that key. `modals.open` from outside the React tree targets the most recently mounted `ModalProvider` bound to that registry (providers form a LIFO stack and fall back on unmount).
 
+Before a provider binds the registry, `modals.isReady()` is `false` and registry operations throw. Binding happens in a client effect, so a registry is intentionally unbound during server rendering.
+
+## Provider Scope
+
+Each `ModalProvider` owns an independent lifecycle. `useModalManager()` always targets the nearest provider, so adjacent or nested application areas can keep their modal state, renderers, and teardown behavior isolated. A handle remains bound to the provider that created it, even when another provider opens the same modal definition.
+
+Use a separate registry for each strictly isolated scope. Binding the same registry to multiple providers is a deliberate routing mechanism instead: external calls target the most recently mounted binding and fall back to the previous binding when it unmounts.
+
+```tsx
+const accountModals = createModalRegistry({ rename: renameReportModal });
+const workspaceModals = createModalRegistry({ rename: renameReportModal });
+
+function App() {
+  return (
+    <>
+      <ModalProvider registry={accountModals} renderer={AccountModalRenderer}>
+        <AccountSettings />
+      </ModalProvider>
+      <ModalProvider registry={workspaceModals} renderer={WorkspaceModalRenderer}>
+        <Workspace />
+      </ModalProvider>
+    </>
+  );
+}
+```
+
 ## Confirmation Modals
 
 `modal.confirm()` (and `registry.confirm()`) opens the built-in confirmation modal and resolves to a typed, discriminated-union result.
@@ -283,7 +349,7 @@ if (result.confirmed) {
 The bundled `confirmModal` is an **accessible, unstyled reference implementation**:
 
 - `role="dialog"` with `aria-modal="true"`, `aria-labelledby` (title) and `aria-describedby` (description)
-- the confirm button receives focus on open (the cancel button for `variant: "danger"`, so a stray Enter never confirms a destructive action), and focus returns to the trigger on close
+- the confirm button receives focus on open (the cancel button for `variant: "danger"`, so a stray Enter never confirms a destructive action), and focus returns to the previously focused element when the modal is removed
 - `Tab` / `Shift+Tab` are trapped within the dialog
 - `Escape` dismisses it (unless `dismissible: false`)
 
@@ -313,13 +379,13 @@ function App() {
 }
 ```
 
-The core prescribes no DOM structure, focus management, or styling — adapters provide those while reusing the same lifecycle API. When `closeDelayMs` is greater than `0`, resolved or dismissed instances move from `modal.status === "open"` to `modal.status === "closing"` before removal, giving exit animations time to run.
+The core prescribes no DOM structure, focus management, or styling — renderers provide those while reusing the same modal manager interface. When `closeDelayMs` is greater than `0`, resolved, dismissed, or rejected instances move from `modal.status === "open"` to `modal.status === "closing"` before removal, giving exit animations time to run. A value of `0` or less removes the instance immediately. Updating the prop changes the removal delay used by later settlements in that provider.
 
 ## Recipes
 
 ### Next.js App Router (SSR)
 
-The store is created lazily **per provider** (`useState(createModalStore)`) and lives in React context, so there is no module-level singleton and no shared state across requests — it is safe for the App Router and React Server Components. The provider uses hooks, so it must run in a Client Component. Wrap it once and render that wrapper from your server layout.
+The lifecycle is created lazily **per provider**, lives in React context, and exposes its state directly to React through external-store observation. It owns opening, settlement, dismissal, delayed removal, and disposal. Server rendering reads a stable empty snapshot, and there is no module-level singleton or shared state across requests. The provider uses hooks, so it must run in a Client Component. Wrap it once and render that wrapper from your server layout.
 
 ```tsx
 // app/providers/modal-provider.tsx
@@ -350,6 +416,8 @@ export default function RootLayout({ children }: { children: React.ReactNode })
 
 Modal components and any component calling `useModalManager()` must also be Client Components (`"use client"`).
 
+Opening modal work while React is rendering on the server is unsupported. The server snapshot is intentionally empty: open modals from event handlers, effects, command handlers, or other client-side code after hydration. A registry likewise remains unbound until its provider's client effect runs, so check `registry.isReady()` before dispatching startup commands from outside React.
+
 ### Tailwind CSS
 
 Provide the overlay and centering through the `renderer`, and style modal components with Tailwind utilities.
@@ -374,18 +442,31 @@ function TailwindRenderer({ children, modal }: ModalRendererProps) {
 </ModalProvider>;
 ```
 
-### shadcn/ui
+### shadcn/ui (Radix)
 
-Use a shadcn `Dialog` as the renderer shell, so every opened modal is wrapped in the design system's overlay and animations while your modal components stay focused on content.
+Use the current [Radix-based shadcn `Dialog`](https://ui.shadcn.com/docs/components/radix/dialog) as a controlled renderer shell, so every opened modal is wrapped in the design system's overlay and animations. Route `onOpenChange(false)` back to the modal manager so Escape, outside interaction, and shadcn's generated close button dismiss the correct instance.
 
 ```tsx
+import {
+  type ModalRendererProps,
+  useModalManager,
+} from "@okyrychenko-dev/react-modal-manager";
 import { Dialog, DialogContent } from "@/components/ui/dialog";
-import type { ModalRendererProps } from "@okyrychenko-dev/react-modal-manager";
 
 function ShadcnRenderer({ children, modal }: ModalRendererProps) {
-  // `open` stays true while mounted; the library removes the instance after closeDelayMs.
+  const modalManager = useModalManager();
+
+  function handleOpenChange(open: boolean) {
+    if (!open && modal.status === "open") {
+      modalManager.dismiss(modal.instanceId);
+    }
+  }
+
   return (
-    <Dialog open={modal.status === "open"}>
+    <Dialog
+      open={modal.status === "open"}
+      onOpenChange={handleOpenChange}
+    >
       <DialogContent>{children}</DialogContent>
     </Dialog>
   );
@@ -396,7 +477,11 @@ function ShadcnRenderer({ children, modal }: ModalRendererProps) {
 </ModalProvider>;
 ```
 
-You can also build a fully custom confirm modal on shadcn's `AlertDialog` and pass it via the `confirmModal` prop — see below.
+This provider-wide renderer is for content-only custom modals. Each modal rendered inside `DialogContent` must compose shadcn's `DialogHeader`, `DialogTitle`, and, when useful, `DialogDescription`; otherwise Radix cannot establish the accessible title/description relationship.
+
+Do not use the built-in confirmation modal with this renderer: it already owns its dialog semantics, so wrapping it in `DialogContent` would create nested dialogs and omit Radix's required `DialogTitle`. If this provider calls `confirm()`, pass a content-only custom `confirmModal` that composes `DialogHeader`, `DialogTitle`, and `DialogDescription` inside this existing shell. Do not nest another `Dialog` or `AlertDialog` in it.
+
+Match `closeDelayMs` to your generated component's exit-animation duration. The example uses 200 ms, matching the current [Radix-based component's `duration-200`](https://github.com/shadcn-ui/ui/blob/main/apps/v4/registry/new-york-v4/ui/dialog.tsx).
 
 ### React Hook Form inside a modal
 
@@ -472,6 +557,7 @@ Type exports:
 - `ModalId`
 - `ModalInstanceId`
 - `ModalInstanceStatus`
+- `ModalOpenArgs`
 - `ModalManager`
 - `ModalOptions`
 - `ModalProviderProps`
@@ -497,7 +583,7 @@ Creates an isolated modal manager for a React subtree and renders active modals.
 - `renderer?: ModalRenderer` — Optional wrapper for each rendered modal instance
 - `confirmModal?: ModalDefinition<ConfirmModalParams, ConfirmModalResult>` — Optional custom confirm modal implementation
 - `registry?: ModalRegistry` — Optional typed modal registry bound to this provider while it is mounted
-- `closeDelayMs?: number` — Delay before removing a closing modal from the store. Defaults to `0`
+- `closeDelayMs?: number` — Delay before removing a closing lifecycle instance. Values of `0` or less remove immediately. Defaults to `0`; prop updates apply to later settlements
 
 ### `useModalManager()`
 
@@ -505,7 +591,7 @@ Returns the modal manager from the nearest `ModalProvider`.
 
 **Returns:**
 
-- `open(modal, input): ModalHandle<TResult>`
+- `open(modal, ...args: ModalOpenArgs<TInput>): ModalHandle<TResult>`
 - `confirm(params): Promise<ConfirmModalResult>`
 - `dismiss(instanceId, reason?): void`
 - `closeAll(reason?): void`
@@ -516,16 +602,18 @@ Creates a typed modal definition.
 
 **Options:**
 
-- `id?: string` — Optional stable modal definition id. An internal debug id is generated when omitted
+- `id?: string` — Optional stable modal definition id. A unique definition id is generated when omitted
 - `component: ModalComponent<TInput, TResult>` — React component that receives typed input and completion callbacks
 
+For a modal declared with `TInput = void` (or `undefined`), omit the input argument: `modal.open(infoModal)`. Modals with any other input type still require it.
+
 ### `createModalRegistry(definitions)`
 
 Creates a typed registry for opening modals by key. Bind it directly with `<ModalProvider registry={registry}>`.
 
 **Returns:**
 
-- `open(key, input): ModalHandle<TResult>`
+- `open(key, ...args: ModalOpenArgs<TInput>): ModalHandle<TResult>` — input is optional only when the registered modal uses `void` or `undefined`
 - `confirm(params): Promise<ConfirmModalResult>`
 - `dismiss(instanceId, reason?): void`
 - `closeAll(reason?): void`
@@ -535,17 +623,17 @@ Creates a typed registry for opening modals by key. Bind it directly with `<Moda
 
 Props passed to custom modal components.
 
-- `input: TInput` — Input supplied to `modal.open()`
+- `input: ModalOpenArgs<TInput>[0]` — Input supplied to `modal.open()`; `undefined` when a `void` input is omitted
 - `instanceId: string` — Runtime modal instance id
-- `close(result: TResult): void` — Resolve the modal promise and remove the instance
-- `dismiss(reason?): void` — Reject with `ModalDismissError` and remove the instance
-- `reject(error): void` — Reject with an error and remove the instance
+- `close(result: TResult): void` — Resolve the modal promise and begin closing the instance
+- `dismiss(reason?): void` — Reject with `ModalDismissError` and begin closing the instance
+- `reject(error): void` — Reject with an error and begin closing the instance
 
-When `closeDelayMs` is configured, `close`, `dismiss`, and `reject` settle the promise immediately, mark the modal as `"closing"`, and remove it after the delay.
+When `closeDelayMs` is greater than `0`, `close`, `dismiss`, and `reject` settle the promise immediately, mark the modal as `"closing"`, and remove it after the delay. A value of `0` or less removes the instance immediately after settlement.
 
 ### `ModalRendererProps`
 
-Props passed to the `renderer` boundary.
+Props passed to the `renderer` seam.
 
 - `children: ReactNode` — Rendered modal component
 - `modal.definitionId: string` — Stable modal definition id
@@ -567,14 +655,16 @@ Opens the built-in (or provided) confirmation modal.
 
 **Returns:**
 
+`ConfirmModalResult` is a discriminated union. Its structure is shown with named branches below so the successful and cancelled paths remain explicit; only `ConfirmModalResult` is exported from the package root.
+
 ```ts
-export type ConfirmationModalRejectReason = "cancel" | "dismiss";
+type ConfirmationModalRejectReason = "cancel" | "dismiss";
 
-export interface ConfirmationModalConfirmedResult {
+interface ConfirmationModalConfirmedResult {
   confirmed: true;
 }
 
-export interface ConfirmationModalRejectedResult {
+interface ConfirmationModalRejectedResult {
   confirmed: false;
   reason: ConfirmationModalRejectReason;
 }
@@ -613,11 +703,15 @@ react-action-guard-dialog
 ## Development
 
 ```bash
-npm install
-npm run typecheck
-npm run lint
-npm run test:run
-npm run build
+pnpm install --frozen-lockfile
+pnpm run typecheck
+pnpm run lint
+pnpm run format:check
+pnpm run test:run
+pnpm run test:coverage
+pnpm run build
+pnpm run build-storybook
+pnpm pack --pack-destination /tmp/react-modal-manager-pack
 ```
 
 ## License