@jini-ai/ui-kit 0.0.0-stage → 0.1.1

package/dist/react/Kit.hooks.js

@@ -0,0 +1,87 @@
+import { useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, createElement } from 'react';
+import { createPortal } from 'react-dom';
+import { KitContext } from './context.js';
+import { createKit } from './kit.js';
+import { assertKitContract, KitConfigError } from '../needs.js';
+import { kitSpec } from '../kit.spec.js';
+import { createToastService } from '../toast.js';
+import { Toast } from './facade.js';
+let defaultValue;
+function getDefault() {
+    return defaultValue ??= { kit: createKit({}), agent: undefined, overlayContainer: null, toast: undefined, cancelLabel: 'Cancel', guard: 'fallback' };
+}
+export function useKit(_required = {}, _optional = {}) {
+    return useContext(KitContext) ?? getDefault();
+}
+export function useKitProvider(required, _optional = {}) {
+    const fallback = useMemo(() => createKit({}), []);
+    const kit = required.kit ?? fallback;
+    for (const requirement of required.needs ?? []) {
+        assertKitContract({ contract: requirement.contract });
+        const missing = requirement.components.filter(name => kitSpec[name]?.status !== 'implemented');
+        if (missing.length)
+            throw new KitConfigError({ issues: missing.map(name => `${requirement.id}: ${name} is not implemented`) });
+    }
+    const overlayContainer = useOverlayRoot({ supplied: required.overlayContainer });
+    const toast = useMemo(() => required.toast ?? createToastService({}), [required.toast]);
+    const activeServices = useRef(new Set());
+    useEffect(() => {
+        activeServices.current.add(toast);
+        return () => {
+            activeServices.current.delete(toast);
+            // StrictMode immediately replays effects using the same instance. Defer owned-service disposal
+            // by one microtask so the replay can reclaim it; replaced or unmounted instances still dispose.
+            queueMicrotask(() => { if (!required.toast && !activeServices.current.has(toast))
+                toast.dispose({}); });
+        };
+    }, [toast, required.toast]);
+    return useMemo(() => ({ kit, overlayContainer, toast, agent: required.agent,
+        cancelLabel: required.cancelLabel ?? 'Cancel', guard: required.guard ?? kit.guard }), [kit, overlayContainer, toast, required.agent, required.cancelLabel, required.guard]);
+}
+function useOverlayRoot(required) {
+    const [root, setRoot] = useState(required.supplied ?? null);
+    useEffect(() => {
+        if (required.supplied) {
+            setRoot(required.supplied);
+            return;
+        }
+        const element = document.createElement('div');
+        element.dataset.jiniPart = 'kit.overlay';
+        document.body.appendChild(element);
+        setRoot(element);
+        return () => { element.remove(); };
+    }, [required.supplied]);
+    return required.supplied ?? root;
+}
+export function useOverlayContainer(_required = {}, _optional = {}) {
+    return useKit({}).overlayContainer ?? (typeof document === 'undefined' ? null : document.body);
+}
+export function renderOverlay(required, _optional = {}) {
+    return required.container ? createPortal(required.children, required.container) : required.children;
+}
+export function useKitComponent(required, _optional = {}) {
+    const context = useKit({});
+    return context.kit.components[required.name];
+}
+export function useFacade(required, _optional = {}) {
+    const Component = useKitComponent({ name: required.name });
+    const attrs = { 'data-jini-part': required.name === 'Tabs' ? 'kit.tab' : kitSpec[required.name].parts[0], ...required.props.attrs };
+    return { Component, props: { ...required.props, attrs } };
+}
+export function useToast(_required = {}, _optional = {}) {
+    const service = useKit({}).toast;
+    if (!service)
+        throw new KitConfigError({ issues: ['useToast requires a KitProvider or an injected toast service'] });
+    return service;
+}
+export function useToastRegion(required, _optional = {}) {
+    const context = useKit({});
+    const service = required.service ?? context.toast;
+    if (!service)
+        throw new KitConfigError({ issues: ['ToastRegion requires a KitProvider or a service'] });
+    const messages = useSyncExternalStore(listener => service.subscribe({ listener }), () => service.snapshot({}), () => service.snapshot({}));
+    const children = messages.map(message => createElement(Toast, { key: message.id, message: message.message,
+        ...(message.tone ? { tone: message.tone } : {}), onDismiss: () => service.dismiss({ id: message.id }) }));
+    return { container: useOverlayContainer({}), attrs: { 'data-jini-part': 'kit.toast-region', ...required.attrs }, children };
+}
+//# sourceMappingURL=Kit.hooks.js.map

package/dist/react/KitProvider.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { KitProviderProps, ToastProps } from './types.js';
+import type { ToastService } from '../toast.js';
+export declare function KitProvider(props: KitProviderProps, _optional?: Record<string, never>): import("react").JSX.Element;
+export declare function Overlay(props: {
+    children: ReactNode;
+    container: HTMLElement | null;
+}, _optional?: Record<string, never>): ReactNode;
+export declare function ToastRegion(props: {
+    service?: ToastService;
+    attrs?: ToastProps['attrs'];
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=KitProvider.d.ts.map

package/dist/react/KitProvider.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { KitContext } from './context.js';
+import { useKitProvider, useToastRegion, renderOverlay } from './Kit.hooks.js';
+export function KitProvider(props, _optional = {}) {
+    const value = useKitProvider(props);
+    return _jsx(KitContext.Provider, { value: value, children: props.children });
+}
+export function Overlay(props, _optional = {}) {
+    return renderOverlay(props);
+}
+export function ToastRegion(props, _optional = {}) {
+    const vm = useToastRegion(props);
+    return _jsx(Overlay, { container: vm.container, children: _jsx("div", { ...vm.attrs, "aria-live": "polite", "aria-relevant": "additions removals", children: vm.children }) });
+}
+//# sourceMappingURL=KitProvider.js.map

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

@@ -0,0 +1,3 @@
+import type { ConfirmDialogProps } from '../types.js';
+export declare function ConfirmDialog(props: ConfirmDialogProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=ConfirmDialog.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { ConfirmController, ConfirmDialogProps } from '../types.js';
+export declare function useConfirmController(required: ConfirmDialogProps, _optional?: Record<string, never>): ConfirmController;
+export declare function useConfirmFacade(required: ConfirmDialogProps, _optional?: Record<string, never>): {
+    Component: import("react").ComponentType<import("../types.js").ConfirmViewProps>;
+    controller: ConfirmController;
+};
+//# sourceMappingURL=ConfirmDialog.hooks.d.ts.map

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

@@ -0,0 +1,101 @@
+import { createElement, useEffect, useId, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { createConfirmController, planConfirm } from '../../confirm.js';
+import { useKit, useOverlayContainer } from '../Kit.hooks.js';
+import { isDevelopment } from '../context.js';
+import { nativeKit } from '../native/index.js';
+import { inspectConfirm } from './guard.js';
+export function useConfirmController(required, _optional = {}) {
+    const context = useKit({}), titleId = useId(), frameId = useId(), consequenceId = useId(), cancelRef = useRef(null);
+    const boundaryRef = useRef(null), latest = useRef(required), mounted = useRef(false);
+    const [executing, setExecuting] = useState(false), [error, setError] = useState(false);
+    latest.current = required;
+    useEffect(() => { mounted.current = true; return () => { mounted.current = false; }; }, []);
+    const model = useMemo(() => createConfirmController({ read: () => latest.current,
+        onCancel: () => latest.current.onCancel({}), onConfirm: () => latest.current.onConfirm({}) }), []);
+    const pending = !!required.pending || executing;
+    const plan = planConfirm({ ...required, cancelLabel: required.cancelLabel ?? context.cancelLabel, pending });
+    function actionAttrs(part, spec, label) {
+        const attrs = spec && context.agent ? context.agent({ handle: spec.handle }, { role: spec.role, label: spec.label }) : {};
+        return Object.freeze({ ...attrs, 'data-jini-part': part, 'aria-label': label,
+            ...(required.actionAccessibleNames && plan.consequence ? { 'aria-describedby': consequenceId } : {}),
+            'aria-busy': pending, 'data-jini-state': pending ? 'pending' : 'ready' });
+    }
+    async function onPress() {
+        if (model.isExecuting({}) || !latest.current.open || latest.current.pending)
+            return;
+        setExecuting(true);
+        setError(false);
+        try {
+            await model.confirm({ actor: 'human' });
+        }
+        catch {
+            if (mounted.current)
+                setError(true);
+        }
+        finally {
+            if (mounted.current)
+                setExecuting(false);
+        }
+    }
+    return { className: required.className, open: required.open, pending, title: required.title, body: required.body, consequence: plan.consequence,
+        error: error ? createElement('p', { className: 'jini-notice jini-notice-error', role: 'alert' }, required.errorLabel ?? 'The action failed. Please try again.') : null,
+        frameAttrs: Object.freeze({ ...required.attrs, id: frameId, 'data-jini-part': 'confirm.dialog', role: 'alertdialog',
+            'aria-labelledby': titleId, 'aria-modal': true, 'aria-busy': pending }),
+        titleAttrs: { id: titleId, 'data-jini-part': 'confirm.title' },
+        consequenceAttrs: { id: consequenceId, 'data-jini-part': 'confirm.consequence' },
+        cancel: Object.freeze({ attrs: actionAttrs('confirm.cancel', plan.cancel, required.actionAccessibleNames?.cancel ?? plan.cancel?.label ?? `${plan.cancelLabel} — no action taken`),
+            ref: cancelRef, disabled: pending, variant: 'secondary', children: plan.cancelLabel,
+            onPress: () => { model.requestDismiss({ reason: 'cancel-button' }); } }),
+        confirm: Object.freeze({ attrs: actionAttrs('confirm.confirm', plan.confirm, required.actionAccessibleNames?.confirm ?? plan.confirmLabel), disabled: pending, pending,
+            variant: plan.confirmVariant, children: required.confirmLabel, onPress }),
+        boundaryRef, overlayContainer: useOverlayContainer({}), agentMayConfirm: required.agentMayConfirm !== false,
+        requestDismiss: model.requestDismiss,
+        focusInitial(_required, _optional = {}) { cancelRef.current?.focus(); },
+    };
+}
+export function useConfirmFacade(required, _optional = {}) {
+    const c = useConfirmController(required), context = useKit({}), [, refresh] = useState(0);
+    const initial = useRef(true), opener = useRef(null);
+    const failed = context.guard !== 'off' && context.kit.failed.has('ConfirmDialog');
+    const Component = failed ? nativeKit.ConfirmDialog : context.kit.components.ConfirmDialog;
+    // Insertion effects precede every child's layout effects (including showModal's focus move).
+    // Capturing in a parent layout effect instead captures Cancel and restores focus into a closed dialog.
+    useInsertionEffect(() => { if (c.open)
+        opener.current = document.activeElement; }, [c.open]);
+    useLayoutEffect(() => {
+        if (!c.open) {
+            initial.current = true;
+            // React restores selection between cleanup and layout setup; restore the trigger after that step.
+            if (opener.current instanceof HTMLElement && opener.current.isConnected)
+                opener.current.focus();
+            return;
+        }
+        c.focusInitial({});
+        return () => { if (opener.current instanceof HTMLElement && opener.current.isConnected)
+            opener.current.focus(); };
+    }, [c.open, Component]);
+    useEffect(() => {
+        if (!c.open || failed || context.guard === 'off' || !isDevelopment({}))
+            return;
+        if (!context.kit.overrides.includes('ConfirmDialog') && !context.kit.overrides.includes('Button'))
+            return;
+        // After the committed view's effects, including library portal/focus synchronization.
+        const timer = setTimeout(() => {
+            const reasons = inspectConfirm({ controller: c, checkFocus: initial.current });
+            initial.current = false;
+            if (!reasons.length)
+                return;
+            if (!context.kit.violations.some(v => v.component === 'ConfirmDialog' && v.reasons.join() === reasons.join())) {
+                context.kit.violations.push({ component: 'ConfirmDialog', reasons });
+                console.error(`@jini-ai/ui-kit ConfirmDialog conformance violation: ${reasons.join('; ')}`);
+            }
+            if (context.guard === 'fallback') {
+                context.kit.failed.add('ConfirmDialog');
+                refresh(value => value + 1);
+            }
+        }, 0);
+        return () => clearTimeout(timer);
+    }, [c.open, c.pending, c.agentMayConfirm, c.consequence, Component, context, failed]);
+    return { Component, controller: failed ? { ...c, nativeActions: true } : c };
+}
+//# sourceMappingURL=ConfirmDialog.hooks.js.map

package/dist/react/confirm/ConfirmDialog.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useConfirmFacade } from './ConfirmDialog.hooks.js';
+import { Overlay } from '../KitProvider.js';
+export function ConfirmDialog(props, _optional = {}) {
+    const vm = useConfirmFacade(props);
+    return _jsx(Overlay, { container: vm.controller.overlayContainer, children: _jsx("span", { ref: vm.controller.boundaryRef, className: "jini-overlay-boundary", children: _jsx(vm.Component, { controller: vm.controller }) }) });
+}
+//# sourceMappingURL=ConfirmDialog.js.map

package/dist/react/confirm/guard.d.ts

@@ -0,0 +1,7 @@
+import type { ConfirmController } from '../types.js';
+/** Checks real mounted DOM. jsdom cannot prove layout or browser top-layer behavior; those are browser scenarios. */
+export declare function inspectConfirm(required: {
+    controller: ConfirmController;
+    checkFocus: boolean;
+}, _optional?: Record<string, never>): string[];
+//# sourceMappingURL=guard.d.ts.map

package/dist/react/confirm/guard.js

@@ -0,0 +1,54 @@
+function visible(element) {
+    for (let current = element; current; current = current.parentElement) {
+        const style = getComputedStyle(current);
+        if (current.hidden || current.getAttribute('aria-hidden') === 'true' || style.display === 'none' || style.visibility === 'hidden' || style.visibility === 'collapse' || style.opacity === '0')
+            return false;
+    }
+    return true;
+}
+/** Checks real mounted DOM. jsdom cannot prove layout or browser top-layer behavior; those are browser scenarios. */
+export function inspectConfirm(required, _optional = {}) {
+    const c = required.controller, issues = [];
+    const frame = c.frameAttrs.id ? document.getElementById(c.frameAttrs.id) : null;
+    if (!frame)
+        return ['missing confirm frame'];
+    if (frame.dataset.jiniPart !== 'confirm.dialog' || frame.getAttribute('role') !== 'alertdialog')
+        issues.push('missing alertdialog semantics');
+    if (!c.overlayContainer?.contains(frame))
+        issues.push('frame outside overlay container');
+    if (frame.getAttribute('aria-labelledby') !== c.frameAttrs['aria-labelledby'])
+        issues.push('missing title association');
+    const cancel = frame.querySelector('[data-jini-part="confirm.cancel"]');
+    const confirm = frame.querySelector('[data-jini-part="confirm.confirm"]');
+    for (const [name, element, bag] of [['cancel', cancel, c.cancel], ['confirm', confirm, c.confirm]]) {
+        if (!element) {
+            issues.push(`missing ${name} action`);
+            continue;
+        }
+        if (!element.matches('button,input,[role="button"][tabindex]'))
+            issues.push(`${name} part is not on a focusable action`);
+        if (!visible(element))
+            issues.push(`${name} action hidden`);
+        for (const [key, value] of Object.entries(bag.attrs ?? {})) {
+            if (value !== undefined && element.getAttribute(key) !== String(value))
+                issues.push(`${name} did not forward ${key}`);
+        }
+        if (c.pending && !element.matches(':disabled') && element.getAttribute('aria-disabled') !== 'true')
+            issues.push(`${name} enabled while pending`);
+    }
+    if (!c.pending && required.checkFocus && cancel && document.activeElement !== cancel)
+        issues.push('initial focus is not cancel');
+    if (!c.agentMayConfirm && confirm && [confirm, ...confirm.querySelectorAll('*')].some(element => element.getAttributeNames().some(name => name.startsWith('data-agent-'))))
+        issues.push('human-only confirm published agent metadata');
+    if (c.consequence && confirm && !confirm.getAttribute('aria-label')?.includes(c.consequence)) {
+        // A concise action name still has to expose the real, visible consequence as its
+        // description. An override dropping the associated paragraph must fail the guard.
+        const description = c.consequenceAttrs?.id ? document.getElementById(c.consequenceAttrs.id) : null;
+        const describedIds = confirm.getAttribute('aria-describedby')?.split(/\s+/) ?? [];
+        if (!description || !frame.contains(description) || !visible(description) ||
+            !describedIds.includes(description.id) || !description.textContent?.includes(c.consequence))
+            issues.push('missing consequence label');
+    }
+    return issues;
+}
+//# sourceMappingURL=guard.js.map

package/dist/react/context.d.ts

@@ -0,0 +1,9 @@
+import { type Context } from 'react';
+import type { KitContextValue } from './types.js';
+export declare function isDevelopment(_required: Record<string, never>, _optional?: Record<string, never>): boolean;
+/** Sharing the context object (not just a token) makes independently bundled copies interoperable. */
+export declare function getSharedKitContext(required: {
+    version: string;
+}, _optional?: Record<string, never>): Context<KitContextValue | null>;
+export declare const KitContext: Context<KitContextValue | null>;
+//# sourceMappingURL=context.d.ts.map

package/dist/react/context.js

@@ -0,0 +1,24 @@
+import { createContext } from 'react';
+const CONTEXT_KEY = Symbol.for('@jini-ai/ui-kit/react/context@1');
+export function isDevelopment(_required, _optional = {}) {
+    // Keep the standard expression intact for bundlers to replace. A typeof-process shortcut would
+    // force development mode in browsers even after a production NODE_ENV substitution.
+    try {
+        return process.env.NODE_ENV !== 'production';
+    }
+    catch {
+        return true;
+    }
+}
+/** Sharing the context object (not just a token) makes independently bundled copies interoperable. */
+export function getSharedKitContext(required, _optional = {}) {
+    const shared = globalThis;
+    const slot = shared[CONTEXT_KEY] ??= { context: createContext(null), versions: new Set() };
+    if (isDevelopment({}) && slot.versions.size && !slot.versions.has(required.version)) {
+        console.warn(`@jini-ai/ui-kit version skew: ${[...slot.versions, required.version].join(', ')}; shared contract-major 1 context`);
+    }
+    slot.versions.add(required.version);
+    return slot.context;
+}
+export const KitContext = getSharedKitContext({ version: '0.1.0' });
+//# sourceMappingURL=context.js.map

package/dist/react/facade.d.ts

@@ -0,0 +1,37 @@
+export declare const Button: import("react").ForwardRefExoticComponent<Omit<import("./types.js").ButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const IconButton: import("react").ForwardRefExoticComponent<Omit<import("./types.js").IconButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const TextField: import("react").ForwardRefExoticComponent<Omit<import("./types.js").TextFieldProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const TextArea: import("react").ForwardRefExoticComponent<Omit<import("./types.js").TextAreaProps, "ref"> & import("react").RefAttributes<HTMLTextAreaElement>>;
+export declare const Select: import("react").ForwardRefExoticComponent<Omit<import("./types.js").SelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+export declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<import("./types.js").CheckboxProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const Switch: import("react").ForwardRefExoticComponent<Omit<import("./types.js").SwitchProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const Dialog: import("react").ForwardRefExoticComponent<Omit<import("./types.js").DialogProps, "ref"> & import("react").RefAttributes<HTMLDialogElement>>;
+export declare const Tabs: {
+    (props: import("./types.js").TabsProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").TabsProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Tabs";
+};
+export declare const Menu: {
+    (props: import("./types.js").MenuProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").MenuProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Menu";
+};
+export declare const Toast: {
+    (props: import("./types.js").ToastProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").ToastProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Toast";
+};
+export declare const Tooltip: {
+    (props: import("./types.js").TooltipProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").TooltipProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Tooltip";
+};
+export declare const Notice: {
+    (props: import("./types.js").NoticeProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").NoticeProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Notice";
+};
+export declare const Spinner: {
+    (props: import("./types.js").SpinnerProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").SpinnerProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Spinner";
+};
+export declare const Badge: {
+    (props: import("./types.js").BadgeProps, _optional?: Record<string, never>): import("react").ReactElement<import("./types.js").BadgeProps, string | import("react").JSXElementConstructor<any>>;
+    displayName: "Badge";
+};
+//# sourceMappingURL=facade.d.ts.map

package/dist/react/facade.js

@@ -0,0 +1,36 @@
+import { createElement, forwardRef } from 'react';
+import { useFacade, renderOverlay, useOverlayContainer } from './Kit.hooks.js';
+function control(required, _optional = {}) {
+    const Facade = forwardRef(function KitFacade(props, ref) {
+        const vm = useFacade({ name: required.name, props: { ...props, ref } });
+        const container = useOverlayContainer({});
+        const result = createElement(vm.Component, vm.props);
+        return required.name === 'Dialog' ? renderOverlay({ children: result, container }) : result;
+    });
+    Facade.displayName = required.name;
+    return Facade;
+}
+function view(required, _optional = {}) {
+    function Facade(props, _optional = {}) {
+        const vm = useFacade({ name: required.name, props });
+        return createElement(vm.Component, vm.props);
+    }
+    Facade.displayName = required.name;
+    return Facade;
+}
+export const Button = control({ name: 'Button' });
+export const IconButton = control({ name: 'IconButton' });
+export const TextField = control({ name: 'TextField' });
+export const TextArea = control({ name: 'TextArea' });
+export const Select = control({ name: 'Select' });
+export const Checkbox = control({ name: 'Checkbox' });
+export const Switch = control({ name: 'Switch' });
+export const Dialog = control({ name: 'Dialog' });
+export const Tabs = view({ name: 'Tabs' });
+export const Menu = view({ name: 'Menu' });
+export const Toast = view({ name: 'Toast' });
+export const Tooltip = view({ name: 'Tooltip' });
+export const Notice = view({ name: 'Notice' });
+export const Spinner = view({ name: 'Spinner' });
+export const Badge = view({ name: 'Badge' });
+//# sourceMappingURL=facade.js.map

package/dist/react/index.d.ts

@@ -0,0 +1,8 @@
+export { KitProvider, Overlay, ToastRegion } from './KitProvider.js';
+export { createKit, createStrictKit, extendKit, describeKit } from './kit.js';
+export { useKit, useKitComponent, useOverlayContainer, useToast } from './Kit.hooks.js';
+export { Button, IconButton, TextField, TextArea, Select, Checkbox, Switch, Dialog, Tabs, Menu, Toast, Tooltip, Notice, Spinner, Badge } from './facade.js';
+export { ConfirmDialog } from './confirm/ConfirmDialog.js';
+export { useConfirmController } from './confirm/ConfirmDialog.hooks.js';
+export type * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -0,0 +1,7 @@
+export { KitProvider, Overlay, ToastRegion } from './KitProvider.js';
+export { createKit, createStrictKit, extendKit, describeKit } from './kit.js';
+export { useKit, useKitComponent, useOverlayContainer, useToast } from './Kit.hooks.js';
+export { Button, IconButton, TextField, TextArea, Select, Checkbox, Switch, Dialog, Tabs, Menu, Toast, Tooltip, Notice, Spinner, Badge } from './facade.js';
+export { ConfirmDialog } from './confirm/ConfirmDialog.js';
+export { useConfirmController } from './confirm/ConfirmDialog.hooks.js';
+//# sourceMappingURL=index.js.map

package/dist/react/kit.d.ts

@@ -0,0 +1,35 @@
+import { type ImplementedComponentName } from '../kit.spec.js';
+import type { GuardMode, ReactKit, ResolvedKit } from './types.js';
+type KitOptions = {
+    id?: string;
+    contract?: string;
+    guard?: GuardMode;
+};
+export declare function createKit(required: {
+    components?: Partial<ReactKit>;
+}, optional?: KitOptions): ResolvedKit;
+export declare function createStrictKit(required: {
+    components: ReactKit;
+}, optional?: KitOptions): ResolvedKit;
+export declare function extendKit(required: {
+    base: ResolvedKit;
+    components: Partial<ReactKit>;
+}, optional?: KitOptions): ResolvedKit;
+export declare function describeKit(required: {
+    kit: ResolvedKit;
+}, _optional?: Record<string, never>): {
+    id: string;
+    contract: string;
+    coverage: {
+        component: ImplementedComponentName;
+        parts: readonly ["kit.button"] | readonly ["kit.icon-button"] | readonly ["kit.text-field", "kit.field-label"] | readonly ["kit.text-area", "kit.field-label"] | readonly ["kit.select", "kit.field-label"] | readonly ["kit.checkbox"] | readonly ["kit.switch"] | readonly ["kit.dialog", "kit.dialog-title", "kit.dialog-close", "kit.overlay"] | readonly ["confirm.dialog", "confirm.title", "confirm.body", "confirm.actions", "confirm.cancel", "confirm.confirm"] | readonly ["kit.tabs", "kit.tab", "kit.tab-panel"] | readonly ["kit.menu-trigger", "kit.menu", "kit.menu-item"] | readonly ["kit.toast", "kit.toast-dismiss", "kit.toast-region"] | readonly ["kit.tooltip-trigger", "kit.tooltip"] | readonly ["kit.notice"] | readonly ["kit.spinner"] | readonly ["kit.badge"];
+        source: "native" | "native-guard" | "override";
+    }[];
+    fallbacks: ImplementedComponentName[];
+    violations: {
+        reasons: string[];
+        component: ImplementedComponentName;
+    }[];
+};
+export {};
+//# sourceMappingURL=kit.d.ts.map

package/dist/react/kit.js

@@ -0,0 +1,44 @@
+import { KIT_CONTRACT, implementedComponents, kitSpec } from '../kit.spec.js';
+import { assertKitContract, KitConfigError } from '../needs.js';
+import { nativeKit } from './native/index.js';
+export function createKit(required, optional = {}) {
+    const contract = optional.contract ?? KIT_CONTRACT.version;
+    assertKitContract({ contract });
+    const overrides = implementedComponents.filter(name => required.components?.[name] !== undefined);
+    const issues = overrides.filter(name => {
+        // Runtime callers can bypass TypeScript; validate unknown rather than assuming ComponentType's callable shape.
+        const component = required.components[name];
+        if (typeof component === 'function')
+            return false;
+        if (typeof component !== 'object' || component === null || !('$$typeof' in component))
+            return true;
+        return ![Symbol.for('react.forward_ref'), Symbol.for('react.memo'), Symbol.for('react.lazy')].includes(component.$$typeof);
+    });
+    if (issues.length)
+        throw new KitConfigError({ issues: issues.map(name => `${name} is not a component`) });
+    const components = { ...nativeKit };
+    // Ignore explicit undefined rather than erasing a working native default.
+    for (const name of overrides)
+        Object.assign(components, { [name]: required.components[name] });
+    return Object.freeze({ id: optional.id ?? 'native', contract, components: Object.freeze(components),
+        overrides: Object.freeze(overrides), violations: [], failed: new Set(), guard: optional.guard ?? 'fallback' });
+}
+export function createStrictKit(required, optional = {}) {
+    const missing = implementedComponents.filter(name => required.components[name] === undefined);
+    if (missing.length)
+        throw new KitConfigError({ issues: missing.map(name => `missing ${name}`) });
+    return createKit(required, optional);
+}
+export function extendKit(required, optional = {}) {
+    const inherited = Object.fromEntries(required.base.overrides.map(name => [name, required.base.components[name]]));
+    return createKit({ components: { ...inherited, ...required.components } }, { id: optional.id ?? required.base.id, contract: optional.contract ?? required.base.contract, guard: optional.guard ?? required.base.guard });
+}
+export function describeKit(required, _optional = {}) {
+    const { kit } = required;
+    const coverage = implementedComponents.map(name => ({ component: name, parts: kitSpec[name].parts,
+        source: kit.failed.has(name) ? 'native-guard' : kit.overrides.includes(name) ? 'override' : 'native' }));
+    return { id: kit.id, contract: kit.contract, coverage,
+        fallbacks: coverage.filter(entry => entry.source !== 'override').map(entry => entry.component),
+        violations: kit.violations.map(violation => ({ ...violation, reasons: [...violation.reasons] })) };
+}
+//# sourceMappingURL=kit.js.map

package/dist/react/native/Controls.d.ts

@@ -0,0 +1,13 @@
+import type { ButtonProps, IconButtonProps, TextFieldProps, TextAreaProps, SelectProps, CheckboxProps, SwitchProps, ToastProps, NoticeProps, SpinnerProps, BadgeProps } from '../types.js';
+export declare const NativeButton: import("react").ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const NativeIconButton: import("react").ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const NativeTextField: import("react").ForwardRefExoticComponent<Omit<TextFieldProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const NativeTextArea: import("react").ForwardRefExoticComponent<Omit<TextAreaProps, "ref"> & import("react").RefAttributes<HTMLTextAreaElement>>;
+export declare const NativeSelect: import("react").ForwardRefExoticComponent<Omit<SelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+export declare const NativeCheckbox: import("react").ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const NativeSwitch: import("react").ForwardRefExoticComponent<Omit<SwitchProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare function NativeToast(props: ToastProps, _optional?: Record<string, never>): import("react").JSX.Element;
+export declare function NativeNotice(props: NoticeProps, _optional?: Record<string, never>): import("react").JSX.Element;
+export declare function NativeSpinner(props: SpinnerProps, _optional?: Record<string, never>): import("react").JSX.Element;
+export declare function NativeBadge(props: BadgeProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=Controls.d.ts.map