@jini-ai/admin 0.4.1 → 0.4.3

package/dist/playground/react/hooks/Canvas.hooks.d.ts

@@ -1,4 +1,4 @@
-import type { TabViewProps } from '../../../react/bind-react.js';
+import type { TabViewProps } from '../../../core/react/bind-react.js';
 export declare function useCanvas({ permissions }: TabViewProps, _optional?: {}): {
     denied: boolean;
     registerCanvas: (node: HTMLDivElement | null) => void | undefined;

package/dist/playground/react/hooks/Canvas.hooks.js

@@ -1,5 +1,5 @@
 import { useCallback } from 'react';
-import { useController } from '../../../react/use-controller.js';
+import { useController } from '../../../core/react/use-controller.js';
 import { createPlaygroundController } from '../../controllers/playground.controller.js';
 import { canMountPlayground } from '../../rules.js';
 import { usePlaygroundPorts } from './PlaygroundPorts.hooks.js';

package/dist/playground/react/hooks/PlaygroundPage.hooks.d.ts

@@ -1,4 +1,4 @@
-import type { ModulePageProps } from '../../../react/bind-react.js';
+import type { ModulePageProps } from '../../../core/react/bind-react.js';
 export declare function usePlaygroundPage(props: ModulePageProps, _optional?: {}): {
     denied: boolean;
     ActiveTab: import("react").LazyExoticComponent<import("react").ComponentType<import("../../../react/bind-react.js").TabViewProps>> | undefined;

package/dist/playground/react/index.js

@@ -1,4 +1,4 @@
-import { bindReact } from '../../react/bind-react.js';
+import { bindReact } from '../../core/react/bind-react.js';
 import { playgroundModule } from '../playground.module.js';
 import { PlaygroundPortsContext } from './hooks/PlaygroundPorts.hooks.js';
 export { usePlaygroundPorts } from './hooks/PlaygroundPorts.hooks.js';

package/dist/playground/react/pages/PlaygroundPage.d.ts

@@ -1,4 +1,4 @@
-import type { ModulePageProps } from '../../../react/bind-react.js';
+import type { ModulePageProps } from '../../../core/react/bind-react.js';
 export declare function PlaygroundPage(props: ModulePageProps, _optional?: {}): import("react").JSX.Element;
 export default PlaygroundPage;
 //# sourceMappingURL=PlaygroundPage.d.ts.map

package/dist/playground/react/tabs/CanvasTab.d.ts

@@ -1,4 +1,4 @@
-import type { TabViewProps } from '../../../react/bind-react.js';
+import type { TabViewProps } from '../../../core/react/bind-react.js';
 export declare function CanvasTab(props: TabViewProps, _optional?: {}): import("react").JSX.Element;
 export default CanvasTab;
 //# sourceMappingURL=CanvasTab.d.ts.map

package/dist/react/bind-react.d.ts

@@ -1,46 +1,2 @@
-import type { ComponentType, ReactNode, LazyExoticComponent, Context as ReactContext } from 'react';
-import type { AdminInstance, AdminModule, ScopedPorts } from '../core/module/types.js';
-export interface TabViewProps {
-    readonly params: Readonly<Record<string, unknown>>;
-    readonly permissions?: readonly string[];
-}
-export interface ModulePageProps {
-    readonly tabs: Readonly<Record<string, LazyExoticComponent<ComponentType<TabViewProps>>>>;
-    readonly description: ReturnType<AdminInstance['describe']>['pages'][number];
-    readonly requestedTab?: string;
-    readonly onTabChange?: (required: {
-        tab: string;
-    }, optional?: Record<string, never>) => void;
-}
-type Loader<P> = () => Promise<{
-    default: ComponentType<P>;
-}>;
-export type ReactViews<M extends AdminModule> = {
-    readonly [P in keyof M['pages']]: {
-        readonly page: Loader<ModulePageProps>;
-        readonly tabs: {
-            readonly [T in keyof M['pages'][P]['tabs']]: Loader<TabViewProps>;
-        };
-    };
-};
-/** Every page and tab is lazy. The only port context is private to this binding;
- * a sibling module can never read another module's dependencies through a global locator. */
-export declare function bindReact<const M extends AdminModule>({ module, views }: {
-    module: M;
-    views: ReactViews<M>;
-}, { context }?: {
-    context?: ReactContext<ScopedPorts<M> | null>;
-}): {
-    module: M;
-    pages: { [P in keyof M["pages"]]: {
-        Page: LazyExoticComponent<ComponentType<ModulePageProps>>;
-        tabs: { [T in keyof M["pages"][P]["tabs"]]: LazyExoticComponent<ComponentType<TabViewProps>>; };
-    }; };
-    Provider: ({ admin, children }: {
-        admin: AdminInstance;
-        children: ReactNode;
-    }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<ScopedPorts<M> | null>>;
-    usePorts: (_required?: Record<string, never>, _optional?: Record<string, never>) => ScopedPorts<M>;
-};
-export {};
+export * from '../core/react/bind-react.js';
 //# sourceMappingURL=bind-react.d.ts.map

package/dist/react/bind-react.js

@@ -1,28 +1,3 @@
-import { createContext, createElement, lazy, useContext } from 'react';
-import { AdminConfigError } from '../core/module/create-admin.js';
-/** Every page and tab is lazy. The only port context is private to this binding;
- * a sibling module can never read another module's dependencies through a global locator. */
-export function bindReact({ module, views }, { context } = {}) {
-    const Context = context ?? createContext(null);
-    const pages = Object.fromEntries(Object.entries(views).map(([id, raw]) => {
-        const view = raw;
-        return [
-            id,
-            {
-                Page: lazy(view.page),
-                tabs: Object.fromEntries(Object.entries(view.tabs).map(([tab, load]) => [tab, lazy(load)])),
-            },
-        ];
-    }));
-    function usePorts(_required = {}, _optional = {}) {
-        const ports = useContext(Context);
-        if (!ports)
-            throw new AdminConfigError({ issues: [`React scope unavailable: ${module.id}`] });
-        return ports;
-    }
-    function Provider({ admin, children }, _optional = {}) {
-        return createElement(Context.Provider, { value: admin.scope({ module }) }, children);
-    }
-    return { module, pages, Provider, usePorts };
-}
+// Compatibility path; the shared implementation lives in core.
+export * from '../core/react/bind-react.js';
 //# sourceMappingURL=bind-react.js.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.d.ts

@@ -1,4 +1,4 @@
-import { type ReactNode } from 'react';
+import type { ReactNode } from 'react';
 import { type ConfirmTone } from '../../types.js';
 import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
 /**
@@ -10,8 +10,8 @@ import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
  * overlay + backdrop idiom: that shape hand-rolls focus trapping, Escape handling, and a backdrop
  * element, all of which the browser's own top layer gives a real `<dialog>` for free, including
  * correct stacking above everything else on the page without a chosen `z-index`. The `showModal`/
- * `close` calls themselves, and the jsdom fallback they need, live in `ConfirmDialog.hooks.tsx` —
- * see that file's doc comment.
+ * `close` calls themselves, and the jsdom fallback they need, are delegated by
+ * `ConfirmDialog.hooks.tsx` to UI-kit's native hook — see that adapter's doc comment.
  *
  * Unstyled, like everything in this layer: the `.confirm-dialog` / `.btn-secondary` /
  * `.btn-danger` / `.btn-warning` class names are emitted for the host stylesheet to define.
@@ -51,7 +51,7 @@ import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
  * Labels state both the action and its consequence tier, derived from this component's own
  * three-tier `ConfirmTone` vocabulary rather than reparsed from `title`/`body`: `body` is arbitrary
  * `ReactNode` (a caller can pass JSX), not guaranteed to be a string at all, so it cannot be safely
- * folded into agent-facing text — see {@link confirmDialogConsequencePhrase}.
+ * folded into agent-facing text — the shared UI-kit confirmation planner owns those phrases.
  */
 export interface ConfirmDialogProps {
     open: boolean;
@@ -90,6 +90,23 @@ export interface ConfirmDialogProps {
      *  effect without `agentHandle`. @default true */
     agentMayConfirm?: boolean;
 }
+/**
+ * UI-kit's confirmation planner owns the sub-handle segments appended to the caller's base:
+ * literals chosen by the mechanism, never host data. Neither needs sanitizing, unlike
+ * `RowMenu`'s per-item keys (see this file's "Agent handles" contract).
+ *
+ * Its plain-language consequence phrase is keyed off the dialog's three-tier `ConfirmTone`
+ * vocabulary (`"default"` / `"warning"` / `"danger"`, documented in `../../types.js`), rather
+ * than reparsed from `title` or `body`, which cannot safely supply agent-facing consequence text.
+ * The confirm label names the action (`confirmLabel`), target (`title`) and declared consequence;
+ * the planner does not parse `body` to decide whether an action is safe.
+ *
+ * The cancel label's consequence is a guarantee of the contract (cancelling never calls
+ * `onConfirm`), rather than something read off `tone`, so it needs no tone input at all.
+ * Agent attributes retain the shape used by `RowMenu`'s local `rowMenuAgentProps`; injecting
+ * admin's attribute port into the shared owner preserves that shape and handle validation
+ * without keeping a second local implementation. No base handle means no agent attributes.
+ */
 /**
  * Controlled modal confirm — renders the `<dialog>` markup and delegates its open/close and focus
  * lifecycle to {@link useConfirmDialog} (injectable via the `useDialog` prop, defaulted to the real
@@ -99,5 +116,5 @@ export interface ConfirmDialogProps {
  * is no browser-assigned "default button" for Enter to reach for at all; confirm can only ever fire
  * from an explicit click or explicit Tab-then-Enter onto it.
  */
-export declare function ConfirmDialog({ useDialog, agentHandle: baseHandle, agentMayConfirm, ...props }: ConfirmDialogProps): import("react").JSX.Element;
+export declare function ConfirmDialog({ useDialog, agentHandle: baseHandle, agentMayConfirm, ...props }: ConfirmDialogProps, _optional?: Record<string, never>): import("react").JSX.Element;
 //# sourceMappingURL=ConfirmDialog.d.ts.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.d.ts

@@ -78,10 +78,10 @@ export declare function useConfirmDialogCancelLabel(_requiredArgs: Record<string
     readonly explicit?: string | undefined;
 }): string;
 /**
- * Owns the `<dialog>` element's open/close lifecycle and focus management for `ConfirmDialog`.
+ * Adapts UI-kit's `<dialog>` element open/close lifecycle and focus management for `ConfirmDialog`.
  *
  * The caller keeps `ConfirmDialog` mounted and toggles `open` — it is never conditionally rendered
- * by its parent — so the effect below has a stable `<dialog>` element to call `showModal()`/
+ * by its parent — so the shared native hook has a stable `<dialog>` element to call `showModal()`/
  * `close()` on and to restore focus through when it closes.
  *
  * Focus moves to the *cancel* action on open, not confirm — an operator whose first keystroke after

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useId, useMemo, useRef, } from 'react';
+import { createContext, useContext, useMemo, useRef, } from 'react';
+import { useNativeDialog } from '@jini-ai/ui-kit/react/native';
 /** Empty object, not `undefined` — {@link useConfirmDialogCancelLabel} can always read `cancelLabel`
  *  off it without an extra null check, whether or not a provider is mounted. */
 const ConfirmDialogDefaultsContext = createContext({});
@@ -41,10 +42,10 @@ export function useConfirmDialogCancelLabel(_requiredArgs, { explicit } = {}) {
     return explicit ?? cancelLabel ?? DEFAULT_CANCEL_LABEL;
 }
 /**
- * Owns the `<dialog>` element's open/close lifecycle and focus management for `ConfirmDialog`.
+ * Adapts UI-kit's `<dialog>` element open/close lifecycle and focus management for `ConfirmDialog`.
  *
  * The caller keeps `ConfirmDialog` mounted and toggles `open` — it is never conditionally rendered
- * by its parent — so the effect below has a stable `<dialog>` element to call `showModal()`/
+ * by its parent — so the shared native hook has a stable `<dialog>` element to call `showModal()`/
  * `close()` on and to restore focus through when it closes.
  *
  * Focus moves to the *cancel* action on open, not confirm — an operator whose first keystroke after
@@ -60,63 +61,24 @@ export function useConfirmDialog({ open, onCancel, document }, { pending } = {})
     // in document order regardless of which dialog is actually open — a screen reader announcing
     // "Delete role?" while the operator is about to confirm "Delete policy?", on a destructive
     // action. `useId()` gives every mounted instance its own id for free.
-    const titleId = useId();
-    const dialogRef = useRef(null);
-    const cancelRef = useRef(null);
     // Captured at the moment `open` flips true, before focus moves into the dialog — the element that
     // had focus then is, by construction, whatever triggered this dialog (a `RowMenu` item's
     // "Delete", a plain trigger button, …). Restored on close rather than left wherever the browser's
     // own modal-focus algorithm happened to land (its default without this is `<body>`, which drops a
     // keyboard user back to the top of the page).
-    const triggerRef = useRef(null);
-    useEffect(() => {
-        const dialog = dialogRef.current;
-        if (!dialog)
-            return;
-        if (open) {
-            triggerRef.current = document.activeElement;
-            if (typeof dialog.showModal === 'function') {
-                if (!dialog.open)
-                    dialog.showModal();
-            }
-            else {
-                dialog.setAttribute('open', '');
-            }
-            cancelRef.current?.focus();
-        }
-        else {
-            if (typeof dialog.close === 'function') {
-                if (dialog.open)
-                    dialog.close();
-            }
-            else {
-                dialog.removeAttribute('open');
-            }
-            if (triggerRef.current instanceof HTMLElement)
-                triggerRef.current.focus();
-        }
-    }, [open, document]);
-    function handleNativeCancel(e) {
-        // Fires on Escape while a real `showModal()`-opened dialog has focus. Always prevented: the
-        // effect above is the single source of truth for open/closed (driven by `open`), so
-        // letting the browser close the element on its own would desync DOM state from React state.
-        // Escape still closes the dialog — it just does so by routing through `onCancel`, same as a
-        // Cancel-button click, so the caller's `open` state (and therefore this same effect) is what
-        // actually calls `dialog.close()`.
-        e.preventDefault();
-        if (pending)
-            return;
-        onCancel();
-    }
-    function handleBackdropClick(e) {
-        // A `<dialog>` element's own box is sized to its content, not the viewport — a click that lands
-        // on the `<dialog>` element itself (as opposed to one of its children) is therefore a click on
-        // the backdrop area outside that content box.
-        if (pending)
-            return;
-        if (e.target === dialogRef.current)
-            onCancel();
-    }
+    // Fires on Escape while a real `showModal()`-opened dialog has focus. Always prevented: the
+    // shared native hook is the single source of truth for open/closed (driven by `open`), so
+    // letting the browser close the element on its own would desync DOM state from React state.
+    // Escape still closes the dialog — it just does so by routing through `onCancel`, same as a
+    // Cancel-button click, so the caller's `open` state (and therefore this same effect) is what
+    // actually calls `dialog.close()`.
+    // A `<dialog>` element's own box is sized to its content, not the viewport — a click that lands
+    // on the `<dialog>` element itself (as opposed to one of its children) is therefore a click on
+    // the backdrop area outside that content box.
+    const cancelRef = useRef(null);
+    const vm = useNativeDialog({ open, title: '', onClose: () => onCancel(), ...(pending === undefined ? {} : { pending }) }, { document, initialFocus: () => cancelRef.current?.focus() });
+    const titleId = vm.titleId, dialogRef = vm.props.ref;
+    const handleNativeCancel = vm.props.onCancel, handleBackdropClick = vm.props.onClick;
     return { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick };
 }
 //# sourceMappingURL=ConfirmDialog.hooks.js.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.js

@@ -1,72 +1,25 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import {} from 'react';
 import { agentHandle } from '@jini-ai/agentic';
+import { useConfirmController } from '@jini-ai/ui-kit/react';
 import { resolveTone, toneClassName } from '../../types.js';
 import { useConfirmDialog, useConfirmDialogCancelLabel } from './ConfirmDialog.hooks.js';
-/** Sub-handle segments appended to the caller's base — literals this component chooses itself,
- *  never host data (see this file's "Agent handles" doc comment for why that means neither needs
- *  sanitizing, unlike `RowMenu`'s per-item keys). */
-const CONFIRM_HANDLE_ACTION = 'confirm';
-const CANCEL_HANDLE_ACTION = 'cancel';
 /**
- * Plain-language phrase for what confirming actually changes, keyed off the dialog's own
- * three-tier `ConfirmTone` vocabulary (`"default"` / `"warning"` / `"danger"`, documented in
- * `../../types.js`) rather than reparsed from `title` or `body` — see this file's doc comment for
- * why those cannot be safely folded into agent-facing text.
+ * UI-kit's confirmation planner owns the sub-handle segments appended to the caller's base:
+ * literals chosen by the mechanism, never host data. Neither needs sanitizing, unlike
+ * `RowMenu`'s per-item keys (see this file's "Agent handles" contract).
  *
- * @param tone - The dialog's resolved tone (see `resolveTone`).
- * @returns The tier's consequence phrase, or `undefined` for `"default"`, which declares no tier.
- * @complexity O(1).
- */
-function confirmDialogConsequencePhrase(tone) {
-    if (tone === 'danger')
-        return 'cannot be undone';
-    if (tone === 'warning')
-        return 'changes access, but is reversible';
-    return undefined;
-}
-/**
- * The confirm action's agent-facing label: what it does (`confirmLabel`), what it applies to
- * (`title`), and — when the tone declares one — its consequence tier.
- *
- * @param confirmLabel - The button's own visible text, e.g. `"Delete"`.
- * @param title - The dialog's title, e.g. `"Delete role?"`.
- * @param tone - The dialog's resolved tone.
- * @returns A label an agent can use to judge whether confirming is safe, without having read
- *   `body` (which this function never receives — see this file's doc comment for why).
- * @complexity O(1).
- */
-function confirmDialogConfirmLabel(confirmLabel, title, tone) {
-    const consequence = confirmDialogConsequencePhrase(tone);
-    return consequence === undefined ? `${confirmLabel} — ${title}` : `${confirmLabel} — ${title}; ${consequence}`;
-}
-/**
- * The cancel action's agent-facing label. Unlike {@link confirmDialogConfirmLabel}, its consequence
- * is a guarantee of this component's own contract (cancelling never calls `onConfirm`) rather than
- * something read off `tone`, so it needs no tone input at all.
- *
- * @param cancelLabel - The button's own visible text, already defaulted by the caller.
- * @param title - The dialog's title, e.g. `"Delete role?"`.
- * @returns A label stating that this action leaves the titled action unconfirmed.
- * @complexity O(1).
- */
-function confirmDialogCancelLabel(cancelLabel, title) {
-    return `${cancelLabel} — leaves "${title}" unconfirmed; no action taken`;
-}
-/**
- * Builds the `data-agent-*` attribute props for one of this dialog's two actions, or nothing at
- * all when the dialog published no base handle — same shape as `RowMenu.tsx`'s local
- * `rowMenuAgentProps`, kept local and unexported here since only this one component needs it.
+ * Its plain-language consequence phrase is keyed off the dialog's three-tier `ConfirmTone`
+ * vocabulary (`"default"` / `"warning"` / `"danger"`, documented in `../../types.js`), rather
+ * than reparsed from `title` or `body`, which cannot safely supply agent-facing consequence text.
+ * The confirm label names the action (`confirmLabel`), target (`title`) and declared consequence;
+ * the planner does not parse `body` to decide whether an action is safe.
  *
- * @param base - The dialog's own handle from the caller, or `undefined` when it published none.
- * @param action - Which action this is — see {@link CONFIRM_HANDLE_ACTION}/{@link CANCEL_HANDLE_ACTION}.
- * @param options - Role and this action's already-composed label.
- * @returns Spreadable attribute props, or `{}` when `base` is `undefined`.
- * @complexity O(1).
+ * The cancel label's consequence is a guarantee of the contract (cancelling never calls
+ * `onConfirm`), rather than something read off `tone`, so it needs no tone input at all.
+ * Agent attributes retain the shape used by `RowMenu`'s local `rowMenuAgentProps`; injecting
+ * admin's attribute port into the shared owner preserves that shape and handle validation
+ * without keeping a second local implementation. No base handle means no agent attributes.
  */
-function confirmDialogAgentProps(base, action, options) {
-    return base === undefined ? {} : agentHandle({ handle: `${base}-${action}` }, options);
-}
 /**
  * Controlled modal confirm — renders the `<dialog>` markup and delegates its open/close and focus
  * lifecycle to {@link useConfirmDialog} (injectable via the `useDialog` prop, defaulted to the real
@@ -76,16 +29,26 @@ function confirmDialogAgentProps(base, action, options) {
  * is no browser-assigned "default button" for Enter to reach for at all; confirm can only ever fire
  * from an explicit click or explicit Tab-then-Enter onto it.
  */
-export function ConfirmDialog({ useDialog = useConfirmDialog, agentHandle: baseHandle, agentMayConfirm = true, ...props }) {
-    const { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick } = useDialog({ open: props.open, onCancel: props.onCancel, document }, { pending: props.pending });
+export function ConfirmDialog({ useDialog = useConfirmDialog, agentHandle: baseHandle, agentMayConfirm = true, ...props }, _optional = {}) {
     const tone = resolveTone({}, props);
     const cancelLabel = useConfirmDialogCancelLabel({}, { explicit: props.cancelLabel });
-    return (_jsxs("dialog", { ref: dialogRef, className: "confirm-dialog", "aria-labelledby": titleId, onCancel: handleNativeCancel, onClick: handleBackdropClick, children: [_jsx("h2", { id: titleId, children: props.title }), _jsx("div", { className: "confirm-dialog-body", children: props.body }), _jsxs("div", { className: "confirm-dialog-actions", children: [_jsx("button", { ref: cancelRef, type: "button", className: "btn-secondary", disabled: props.pending, onClick: props.onCancel, ...confirmDialogAgentProps(baseHandle, CANCEL_HANDLE_ACTION, {
-                            role: 'button',
-                            label: confirmDialogCancelLabel(cancelLabel, props.title),
-                        }), children: cancelLabel }), _jsx("button", { type: "button", className: toneClassName({ tone }), disabled: props.pending, onClick: () => props.onConfirm(), ...confirmDialogAgentProps(agentMayConfirm ? baseHandle : undefined, CONFIRM_HANDLE_ACTION, {
-                            role: 'button',
-                            label: confirmDialogConfirmLabel(props.confirmLabel, props.title, tone),
-                        }), children: props.confirmLabel })] })] }));
+    const controller = useConfirmController({
+        open: props.open, title: props.title, body: props.body, confirmLabel: props.confirmLabel,
+        cancelLabel, tone, agentMayConfirm,
+        ...(baseHandle === undefined ? {} : { agentHandle: baseHandle }),
+        ...(props.pending === undefined ? {} : { pending: props.pending }),
+        onConfirm: () => props.onConfirm(), onCancel: () => props.onCancel(),
+    }, {
+        // UI-kit names selects separately; agentic publishes them as fields and still owns handle validation.
+        agent: ((required, optional = {}) => agentHandle(required, {
+            ...(optional.role === undefined ? {} : { role: optional.role === 'select' ? 'field' : optional.role }),
+            ...(optional.label === undefined ? {} : { label: optional.label }),
+        })),
+    });
+    const { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick } = useDialog({ open: props.open, onCancel: () => { controller.requestDismiss({ reason: 'close' }); }, document }, { pending: controller.pending });
+    // Keep admin's concise accessible names; the shared planner still supplies consequence-aware agent labels.
+    const { 'aria-label': _cancelName, ...cancelAttrs } = controller.cancel.attrs ?? {};
+    const { 'aria-label': _confirmName, ...confirmAttrs } = controller.confirm.attrs ?? {};
+    return (_jsxs("dialog", { ref: dialogRef, className: "confirm-dialog", "aria-labelledby": titleId, onCancel: handleNativeCancel, onClick: handleBackdropClick, children: [_jsx("h2", { id: titleId, children: props.title }), _jsxs("div", { className: "confirm-dialog-body", children: [props.body, controller.error] }), _jsxs("div", { className: "confirm-dialog-actions", children: [_jsx("button", { ref: cancelRef, type: "button", className: "btn-secondary", disabled: controller.pending, onClick: () => controller.cancel.onPress?.({}), ...cancelAttrs, children: cancelLabel }), _jsx("button", { type: "button", className: toneClassName({ tone }), disabled: controller.pending, onClick: () => controller.confirm.onPress?.({}), ...confirmAttrs, children: props.confirmLabel })] })] }));
 }
 //# sourceMappingURL=ConfirmDialog.js.map

package/dist/react/components/RowMenu/RowMenu.hooks.d.ts

@@ -1,4 +1,4 @@
-import { type KeyboardEvent } from 'react';
+import { type KeyboardEvent, type RefObject } from 'react';
 /**
  * @file `RowMenu`'s open/close state, viewport-aware positioning, and keyboard/focus behavior,
  * split out of the component so it can be swapped for a fake via the `useRowMenu` prop on
@@ -9,6 +9,25 @@ interface Position {
     left: number;
     placement: 'below' | 'above';
 }
+type RowMenuWindow = Pick<Window, 'innerHeight' | 'innerWidth' | 'addEventListener' | 'removeEventListener'>;
+type RowMenuDocument = Pick<Document, 'addEventListener' | 'removeEventListener'>;
+/** What `useRowMenu` hands `RowMenu` — and the shape an injected `useRowMenu` fake must return. */
+export interface RowMenuState {
+    readonly open: boolean;
+    readonly position: Position | null;
+    readonly triggerRef: RefObject<HTMLButtonElement | null>;
+    /** A callback ref from the real hook (see {@link trackOpenMenu}; `null` while closed), or a host
+     *  hook's ref object. Spelled out rather than React's `Ref`, whose callback form carries a brand
+     *  that fails to match across two installed `@types/react` copies (Jini's vs a host app's). */
+    readonly menuRef: RefObject<HTMLDivElement | null> | ((menu: HTMLDivElement | null) => void) | null;
+    readonly itemRefs: RefObject<Array<HTMLButtonElement | null>>;
+    readonly onTriggerClick: () => void;
+    readonly onTriggerKeyDown: (event: KeyboardEvent<HTMLButtonElement>) => void;
+    readonly onMenuKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
+    readonly selectItem: (item: {
+        readonly onSelect: () => void;
+    }) => void;
+}
 /**
  * Owns `RowMenu`'s open/close state, positioning, and keyboard/focus behavior.
  *
@@ -17,20 +36,8 @@ interface Position {
  */
 export declare function useRowMenu({ itemCount, window, document }: {
     readonly itemCount: number;
-    readonly window: Pick<Window, 'innerHeight' | 'innerWidth' | 'addEventListener' | 'removeEventListener'>;
-    readonly document: Pick<Document, 'addEventListener' | 'removeEventListener'>;
-}): {
-    open: boolean;
-    position: Position | null;
-    triggerRef: import("react").RefObject<HTMLButtonElement | null>;
-    menuRef: import("react").RefObject<HTMLDivElement | null>;
-    itemRefs: import("react").RefObject<(HTMLButtonElement | null)[]>;
-    onTriggerClick: () => void;
-    onTriggerKeyDown: (e: KeyboardEvent<HTMLButtonElement>) => void;
-    onMenuKeyDown: (e: KeyboardEvent<HTMLDivElement>) => void;
-    selectItem: ({ onSelect }: {
-        readonly onSelect: () => void;
-    }) => void;
-};
+    readonly window: RowMenuWindow;
+    readonly document: RowMenuDocument;
+}): RowMenuState;
 export {};
 //# sourceMappingURL=RowMenu.hooks.d.ts.map