@moldable-ai/ui 0.2.18 → 0.2.19

package/dist/components/hardware/usb-panel.js

@@ -0,0 +1,363 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RefreshCw, RotateCcw, Trash2, Usb } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { NativeHardwareBridgeError, clearMoldableUsbHalt, closeMoldableUsbDevice, forgetMoldableUsbDevice, getMoldableUsbDevices, openMoldableUsbDevice, readMoldableUsbControlTransfer, readMoldableUsbEndpoint, requestMoldableUsbDevice, resetMoldableUsbDevice, writeMoldableUsbControlTransfer, writeMoldableUsbEndpoint, } from '../../lib/native-hardware';
+import { Button } from '../ui/button';
+import { Input } from '../ui/input';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from '../ui/select';
+import { Spinner } from '../ui/spinner';
+import { CapabilityBadge } from './capability-badge';
+import { formatHexBytes, parseHexBytes, parseIntegerInput, } from './device-io-controls';
+import { DeviceList, DeviceListEmpty, DeviceListItem } from './device-list';
+import { HardwarePanel, HardwarePanelAction, HardwarePanelContent, HardwarePanelFooter, HardwarePanelHeader, HardwarePanelIcon, HardwarePanelTitle, } from './hardware-panel';
+import { Readout, ReadoutItem } from './readout';
+function toError(cause) {
+    return cause instanceof Error ? cause : new Error(String(cause));
+}
+function formatHexId(value) {
+    return `0x${value.toString(16).padStart(4, '0')}`;
+}
+function usbDeviceDescriptionId(device) {
+    return [
+        device.vendorId,
+        device.productId,
+        device.serialNumber ?? '',
+        device.productName ?? '',
+    ].join(':');
+}
+/**
+ * USB state machine behind `UsbDevicePanel`: granted-device enumeration,
+ * chooser requests, minimal-claim open/close tracking. Use directly to build
+ * custom USB UI on the same best-effort error handling.
+ */
+export function useMoldableUsb(options = {}) {
+    const [devices, setDevices] = useState([]);
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    const [openDeviceIds, setOpenDeviceIds] = useState([]);
+    const [nativeDeviceChoices, setNativeDeviceChoices] = useState([]);
+    const openDevicesRef = useRef(new Map());
+    const idsRef = useRef(new WeakMap());
+    const idCounterRef = useRef(0);
+    const pendingSelectionRef = useRef(null);
+    const generationRef = useRef(0);
+    const unmountedRef = useRef(false);
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const deviceId = useCallback((device) => {
+        let id = idsRef.current.get(device);
+        if (!id) {
+            id = `usb-${++idCounterRef.current}`;
+            idsRef.current.set(device, id);
+        }
+        return id;
+    }, []);
+    const refresh = useCallback(async () => {
+        const generation = ++generationRef.current;
+        setStatus('loading');
+        setError(null);
+        try {
+            const known = await getMoldableUsbDevices();
+            if (generationRef.current !== generation)
+                return;
+            setDevices((previous) => [
+                ...known,
+                ...previous.filter((device) => openDevicesRef.current.has(deviceId(device)) &&
+                    !known.includes(device)),
+            ]);
+            setStatus('idle');
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            if (cause instanceof NativeHardwareBridgeError &&
+                cause.code === 'unsupported') {
+                // No WebUSB enumeration here (native fallback runtime). Devices
+                // granted through `request` stay listed; this is not an error.
+                setStatus('idle');
+                return;
+            }
+            setError(toError(cause));
+            setStatus('error');
+        }
+    }, [deviceId]);
+    const handleDisconnect = useCallback((device) => {
+        if (unmountedRef.current)
+            return;
+        const id = deviceId(device);
+        const record = openDevicesRef.current.get(id);
+        if (record) {
+            device.removeEventListener('disconnect', record.onDisconnect);
+        }
+        openDevicesRef.current.delete(id);
+        setOpenDeviceIds((previous) => previous.filter((existing) => existing !== id));
+        setDevices((previous) => previous.filter((existing) => existing !== device));
+    }, [deviceId]);
+    const chooseNativeDevice = useCallback((devices) => new Promise((resolve, reject) => {
+        pendingSelectionRef.current = { devices, resolve, reject };
+        setNativeDeviceChoices(devices);
+    }), []);
+    const selectNativeDevice = useCallback((device) => {
+        const pending = pendingSelectionRef.current;
+        if (!pending || !pending.devices.includes(device))
+            return;
+        pendingSelectionRef.current = null;
+        setNativeDeviceChoices([]);
+        pending.resolve(device);
+    }, []);
+    const cancelNativeSelection = useCallback(() => {
+        const pending = pendingSelectionRef.current;
+        if (!pending)
+            return;
+        pendingSelectionRef.current = null;
+        setNativeDeviceChoices([]);
+        pending.reject(new NativeHardwareBridgeError({
+            code: 'cancelled',
+            message: 'USB device selection was cancelled.',
+            retryable: true,
+        }));
+    }, []);
+    const request = useCallback(async (filters) => {
+        const generation = ++generationRef.current;
+        setStatus('requesting');
+        setError(null);
+        try {
+            const device = await requestMoldableUsbDevice({
+                filters: filters ?? optionsRef.current.filters ?? [],
+                selectNativeDevice: optionsRef.current.selectNativeDevice ?? chooseNativeDevice,
+            });
+            if (generationRef.current !== generation)
+                return;
+            setDevices((previous) => previous.includes(device) ? previous : [...previous, device]);
+            setStatus('idle');
+            return device;
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            if (cause instanceof NativeHardwareBridgeError &&
+                (cause.code === 'cancelled' || cause.code === 'aborted')) {
+                // The user dismissed the chooser; that is not an error state.
+                setStatus('idle');
+                return;
+            }
+            setError(toError(cause));
+            setStatus('error');
+        }
+    }, [chooseNativeDevice]);
+    const open = useCallback(async (device) => {
+        const id = deviceId(device);
+        if (openDevicesRef.current.has(id))
+            return;
+        try {
+            await openMoldableUsbDevice(device, optionsRef.current.openOptions);
+            if (unmountedRef.current) {
+                void closeMoldableUsbDevice(device, optionsRef.current.openOptions?.claimInterfaces).catch(() => undefined);
+                return;
+            }
+            const onDisconnect = () => handleDisconnect(device);
+            device.addEventListener('disconnect', onDisconnect, { once: true });
+            openDevicesRef.current.set(id, {
+                device,
+                onDisconnect,
+                releaseInterfaces: optionsRef.current.openOptions?.claimInterfaces ?? [],
+            });
+            setOpenDeviceIds((previous) => previous.includes(id) ? previous : [...previous, id]);
+            setError(null);
+            setStatus('idle');
+            optionsRef.current.onDeviceOpen?.(device);
+        }
+        catch (cause) {
+            if (unmountedRef.current)
+                return;
+            setError(toError(cause));
+            setStatus('error');
+        }
+    }, [deviceId, handleDisconnect]);
+    const close = useCallback(async (device) => {
+        const id = deviceId(device);
+        const record = openDevicesRef.current.get(id);
+        try {
+            await closeMoldableUsbDevice(device, record?.releaseInterfaces);
+            if (record) {
+                device.removeEventListener('disconnect', record.onDisconnect);
+            }
+            openDevicesRef.current.delete(id);
+            setOpenDeviceIds((previous) => previous.filter((existing) => existing !== id));
+            setError(null);
+            setStatus('idle');
+            return true;
+        }
+        catch (cause) {
+            if (record)
+                record.releaseInterfaces = [];
+            if (unmountedRef.current)
+                return false;
+            setError(toError(cause));
+            setStatus('error');
+            return false;
+        }
+    }, [deviceId]);
+    const runOperation = useCallback(async (operation) => {
+        setError(null);
+        try {
+            const result = await operation();
+            if (!unmountedRef.current)
+                setStatus('idle');
+            return result;
+        }
+        catch (cause) {
+            if (!unmountedRef.current) {
+                setError(toError(cause));
+                setStatus('error');
+            }
+            throw cause;
+        }
+    }, []);
+    const forget = useCallback(async (device) => {
+        const id = deviceId(device);
+        if ((openDevicesRef.current.has(id) || device.opened) &&
+            !(await close(device))) {
+            return false;
+        }
+        try {
+            await runOperation(() => forgetMoldableUsbDevice(device));
+            if (unmountedRef.current)
+                return false;
+            setDevices((previous) => previous.filter((known) => known !== device));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, [close, deviceId, runOperation]);
+    useEffect(() => {
+        unmountedRef.current = false;
+        void refresh();
+        const liveGeneration = generationRef;
+        const openDevices = openDevicesRef.current;
+        return () => {
+            unmountedRef.current = true;
+            liveGeneration.current++;
+            const pending = pendingSelectionRef.current;
+            pendingSelectionRef.current = null;
+            pending?.reject(new NativeHardwareBridgeError({
+                code: 'aborted',
+                message: 'USB device selection was interrupted.',
+                retryable: true,
+            }));
+            const stillOpen = [...openDevices.values()];
+            openDevices.clear();
+            for (const { device, onDisconnect, releaseInterfaces } of stillOpen) {
+                device.removeEventListener('disconnect', onDisconnect);
+                void closeMoldableUsbDevice(device, releaseInterfaces).catch(() => undefined);
+            }
+        };
+    }, [refresh]);
+    return {
+        devices,
+        status,
+        error,
+        openDeviceIds,
+        nativeDeviceChoices,
+        deviceId,
+        refresh,
+        request,
+        selectNativeDevice,
+        cancelNativeSelection,
+        open,
+        close,
+        forget,
+        readEndpoint: (device, endpoint, length) => runOperation(() => readMoldableUsbEndpoint(device, endpoint, length)),
+        writeEndpoint: (device, endpoint, data) => runOperation(() => writeMoldableUsbEndpoint(device, endpoint, data)),
+        readControl: (device, setup, length) => runOperation(() => readMoldableUsbControlTransfer(device, setup, length)),
+        writeControl: (device, setup, data) => runOperation(() => writeMoldableUsbControlTransfer(device, setup, data)),
+        clearHalt: (device, direction, endpoint) => runOperation(() => clearMoldableUsbHalt(device, direction, endpoint)),
+        reset: (device) => runOperation(() => resetMoldableUsbDevice(device)),
+    };
+}
+function UsbDeviceControls({ device, usb }) {
+    const [endpoint, setEndpoint] = useState('1');
+    const [length, setLength] = useState('64');
+    const [payload, setPayload] = useState('');
+    const [requestType, setRequestType] = useState('vendor');
+    const [recipient, setRecipient] = useState('device');
+    const [request, setRequest] = useState('0');
+    const [value, setValue] = useState('0');
+    const [index, setIndex] = useState('0');
+    const [result, setResult] = useState('Ready');
+    const [busy, setBusy] = useState(false);
+    const run = async (operation) => {
+        setBusy(true);
+        try {
+            setResult(await operation());
+        }
+        catch (cause) {
+            setResult(toError(cause).message);
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    const endpointNumber = () => parseIntegerInput(endpoint, 'Endpoint', 1, 15);
+    const transferLength = () => parseIntegerInput(length, 'Length', 1, 65_535);
+    const setup = () => ({
+        requestType,
+        recipient,
+        request: parseIntegerInput(request, 'Request', 0, 255),
+        value: parseIntegerInput(value, 'Value', 0, 65_535),
+        index: parseIntegerInput(index, 'Index', 0, 65_535),
+    });
+    return (_jsxs("div", { "data-slot": "usb-device-controls", className: "bg-muted/30 mt-2 space-y-3 rounded-md border p-2.5", children: [_jsxs("div", { className: "grid gap-2 sm:grid-cols-3", children: [_jsx(Input, { "aria-label": "USB endpoint number", value: endpoint, onChange: (event) => setEndpoint(event.target.value), placeholder: "Endpoint", className: "h-8 font-mono text-xs" }), _jsx(Input, { "aria-label": "USB transfer length", value: length, onChange: (event) => setLength(event.target.value), placeholder: "Length", className: "h-8 font-mono text-xs" }), _jsx(Input, { "aria-label": "USB endpoint payload", value: payload, onChange: (event) => setPayload(event.target.value), placeholder: "Hex payload", className: "h-8 font-mono text-xs" })] }), _jsxs("div", { className: "flex flex-wrap gap-1.5", children: [_jsx(Button, { size: "xs", variant: "outline", disabled: busy, onClick: () => void run(async () => {
+                            const transfer = await usb.readEndpoint(device, endpointNumber(), transferLength());
+                            return `Endpoint IN · ${transfer.status} · ${formatHexBytes(transfer.data)}`;
+                        }), children: "Endpoint IN" }), _jsx(Button, { size: "xs", variant: "outline", disabled: busy, onClick: () => void run(async () => {
+                            const transfer = await usb.writeEndpoint(device, endpointNumber(), parseHexBytes(payload));
+                            return `Endpoint OUT · ${transfer.status} · ${transfer.bytesWritten ?? 0} bytes`;
+                        }), children: "Endpoint OUT" }), _jsx(Button, { size: "xs", variant: "ghost", disabled: busy, onClick: () => void run(async () => {
+                            await usb.clearHalt(device, 'in', endpointNumber());
+                            return 'IN halt cleared';
+                        }), children: "Clear IN halt" }), _jsx(Button, { size: "xs", variant: "ghost", disabled: busy, onClick: () => void run(async () => {
+                            await usb.clearHalt(device, 'out', endpointNumber());
+                            return 'OUT halt cleared';
+                        }), children: "Clear OUT halt" })] }), _jsxs("div", { className: "grid gap-2 sm:grid-cols-5", children: [_jsxs(Select, { value: requestType, onValueChange: (next) => setRequestType(next), children: [_jsx(SelectTrigger, { size: "sm", "aria-label": "USB control request type", children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsx(SelectItem, { value: "standard", children: "Standard" }), _jsx(SelectItem, { value: "class", children: "Class" }), _jsx(SelectItem, { value: "vendor", children: "Vendor" })] })] }), _jsxs(Select, { value: recipient, onValueChange: (next) => setRecipient(next), children: [_jsx(SelectTrigger, { size: "sm", "aria-label": "USB control recipient", children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsx(SelectItem, { value: "device", children: "Device" }), _jsx(SelectItem, { value: "interface", children: "Interface" }), _jsx(SelectItem, { value: "endpoint", children: "Endpoint" }), _jsx(SelectItem, { value: "other", children: "Other" })] })] }), [
+                        ['Request', request, setRequest],
+                        ['Value', value, setValue],
+                        ['Index', index, setIndex],
+                    ].map(([label, current, update]) => (_jsx(Input, { "aria-label": `USB control ${String(label).toLowerCase()}`, value: current, onChange: (event) => update(event.target.value), placeholder: label, className: "h-8 font-mono text-xs" }, label)))] }), _jsxs("div", { className: "flex flex-wrap items-center gap-1.5", children: [_jsx(Button, { size: "xs", variant: "outline", disabled: busy, onClick: () => void run(async () => {
+                            const transfer = await usb.readControl(device, setup(), transferLength());
+                            return `Control IN · ${transfer.status} · ${formatHexBytes(transfer.data)}`;
+                        }), children: "Control IN" }), _jsx(Button, { size: "xs", variant: "outline", disabled: busy, onClick: () => void run(async () => {
+                            const transfer = await usb.writeControl(device, setup(), parseHexBytes(payload));
+                            return `Control OUT · ${transfer.status} · ${transfer.bytesWritten ?? 0} bytes`;
+                        }), children: "Control OUT" }), _jsxs(Button, { size: "xs", variant: "ghost", disabled: busy, onClick: () => void run(async () => {
+                            await usb.reset(device);
+                            return 'Device reset';
+                        }), children: [_jsx(RotateCcw, {}), "Reset"] }), _jsx("span", { className: "text-muted-foreground ml-auto truncate font-mono text-[10px]", children: busy ? 'Working…' : result })] })] }));
+}
+/**
+ * USB device panel: request access, list granted devices, open/close each
+ * with minimal claims, and read out live device details while open.
+ */
+function UsbDevicePanel({ className, filters, selectNativeDevice, openOptions, onDeviceOpen, ...props }) {
+    const usb = useMoldableUsb({
+        filters,
+        selectNativeDevice,
+        openOptions,
+        onDeviceOpen,
+    });
+    const requesting = usb.status === 'requesting';
+    const loading = usb.status === 'loading';
+    return (_jsxs(HardwarePanel, { "data-slot": "usb-device-panel", "data-status": usb.status, className: className, ...props, children: [_jsxs(HardwarePanelHeader, { children: [_jsx(HardwarePanelIcon, { children: _jsx(Usb, {}) }), _jsx(HardwarePanelTitle, { children: "USB" }), _jsx(CapabilityBadge, { capability: "usb" }), _jsxs(HardwarePanelAction, { children: [_jsxs(Button, { size: "sm", disabled: requesting, onClick: () => void usb.request(), children: [requesting ? _jsx(Spinner, {}) : _jsx(Usb, {}), requesting ? 'Requesting…' : 'Request device'] }), _jsx(Button, { variant: "ghost", size: "icon-sm", "aria-label": "Refresh devices", disabled: loading || requesting, onClick: () => void usb.refresh(), children: _jsx(RefreshCw, { className: loading ? 'animate-spin motion-reduce:animate-none' : undefined }) })] })] }), _jsxs(HardwarePanelContent, { children: [usb.nativeDeviceChoices.length > 0 ? (_jsxs("div", { "data-slot": "usb-native-device-picker", className: "bg-muted/30 mb-4 space-y-2 rounded-lg border p-3", children: [_jsx("p", { className: "text-sm font-medium", children: "Choose a USB device" }), _jsx("p", { className: "text-muted-foreground text-xs", children: "More than one native device matched. Select the device explicitly." }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [usb.nativeDeviceChoices.map((device, index) => (_jsxs(Button, { size: "xs", variant: "outline", onClick: () => usb.selectNativeDevice(device), children: [device.productName || 'USB device', " \u00B7", ' ', formatHexId(device.vendorId), ":", formatHexId(device.productId)] }, `${usbDeviceDescriptionId(device)}:${index}`))), _jsx(Button, { size: "xs", variant: "ghost", onClick: usb.cancelNativeSelection, children: "Cancel" })] })] })) : null, _jsx(DeviceList, { children: usb.devices.length === 0 ? (_jsxs(DeviceListEmpty, { icon: _jsx(Usb, {}), children: [_jsx("span", { className: "font-medium", children: "No devices yet" }), _jsx("span", { className: "text-muted-foreground/70 text-xs", children: "Request access to a USB device to get started." })] })) : (usb.devices.map((device, index) => {
+                            const id = usb.deviceId(device);
+                            const open = usb.openDeviceIds.includes(id) || device.opened;
+                            return (_jsx(DeviceListItem, { icon: _jsx(Usb, {}), name: device.productName || 'USB device', description: `${formatHexId(device.vendorId)}:${formatHexId(device.productId)}` +
+                                    (device.manufacturerName
+                                        ? ` · ${device.manufacturerName}`
+                                        : ''), connected: open, action: _jsxs("div", { className: "flex items-center gap-1", children: [_jsx(Button, { size: "xs", variant: "outline", onClick: () => void (open ? usb.close(device) : usb.open(device)), children: open ? 'Close' : 'Open' }), _jsx(Button, { size: "icon-xs", variant: "ghost", "aria-label": `Forget ${device.productName || 'USB device'}`, onClick: () => void usb.forget(device), children: _jsx(Trash2, {}) })] }), children: open ? (_jsxs("div", { "data-slot": "usb-device-details", className: "animate-in fade-in slide-in-from-top-1 bg-muted/30 mt-2 rounded-md border p-2.5 duration-200 motion-reduce:animate-none", children: [_jsxs(Readout, { className: "gap-y-2 sm:grid-cols-4", children: [_jsx(ReadoutItem, { label: "Configuration", value: device.configuration?.configurationValue ?? null }), _jsx(ReadoutItem, { label: "Vendor ID", value: formatHexId(device.vendorId) }), _jsx(ReadoutItem, { label: "Product ID", value: formatHexId(device.productId) }), _jsx(ReadoutItem, { label: "Serial", value: device.serialNumber ?? null })] }), _jsx(UsbDeviceControls, { device: device, usb: usb })] })) : null }, `${id}:${index}`));
+                        })) })] }), _jsxs(HardwarePanelFooter, { children: [usb.error ? (_jsx("span", { className: "text-status-error truncate", children: usb.error.message })) : (_jsx("span", { className: "truncate", children: usb.devices.length === 0
+                            ? 'No devices authorized'
+                            : `${usb.devices.length} device${usb.devices.length === 1 ? '' : 's'} known` })), _jsxs("span", { className: "ml-auto shrink-0 font-mono tabular-nums", children: [usb.openDeviceIds.length, " open"] })] })] }));
+}
+export { UsbDevicePanel };

package/dist/components/hardware/use-capability.d.ts

@@ -0,0 +1,20 @@
+import { type NativeHardwareCapabilityDescriptor, type NativeHardwareCapabilityId, type NativeHardwareCapabilityManifest } from '../../lib/native-hardware';
+export type MoldableCapabilityStatus = 'checking' | 'supported' | 'partial' | 'unsupported' | 'unavailable';
+/**
+ * Loads the native capability manifest once per page and shares it across all
+ * hardware components. Pass `force` to bypass the cache (e.g. after a grant).
+ */
+export declare function loadMoldableCapabilities(force?: boolean): Promise<NativeHardwareCapabilityManifest>;
+export interface MoldableCapability {
+    status: MoldableCapabilityStatus;
+    descriptor: NativeHardwareCapabilityDescriptor | null;
+    manifest: NativeHardwareCapabilityManifest | null;
+    error: Error | null;
+    refresh: () => void;
+}
+/**
+ * Reads the support level for one native capability. `unavailable` means the
+ * manifest could not be loaded at all (typically: not running inside Moldable).
+ */
+export declare function useMoldableCapability(id: NativeHardwareCapabilityId): MoldableCapability;
+//# sourceMappingURL=use-capability.d.ts.map

package/dist/components/hardware/use-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-capability.d.ts","sourceRoot":"","sources":["../../../src/components/hardware/use-capability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,kCAAkC,EACvC,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EAEtC,MAAM,2BAA2B,CAAA;AAElC,MAAM,MAAM,wBAAwB,GAChC,UAAU,GACV,WAAW,GACX,SAAS,GACT,aAAa,GACb,aAAa,CAAA;AAIjB;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,UAAQ,GACZ,OAAO,CAAC,gCAAgC,CAAC,CAU3C;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,wBAAwB,CAAA;IAChC,UAAU,EAAE,kCAAkC,GAAG,IAAI,CAAA;IACrD,QAAQ,EAAE,gCAAgC,GAAG,IAAI,CAAA;IACjD,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,0BAA0B,GAC7B,kBAAkB,CA2CpB"}

package/dist/components/hardware/use-capability.js

@@ -0,0 +1,61 @@
+'use client';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { getMoldableNativeCapabilities, } from '../../lib/native-hardware';
+let manifestPromise = null;
+/**
+ * Loads the native capability manifest once per page and shares it across all
+ * hardware components. Pass `force` to bypass the cache (e.g. after a grant).
+ */
+export function loadMoldableCapabilities(force = false) {
+    if (force || !manifestPromise) {
+        manifestPromise = getMoldableNativeCapabilities().catch((error) => {
+            manifestPromise = null;
+            throw error;
+        });
+    }
+    return manifestPromise;
+}
+/**
+ * Reads the support level for one native capability. `unavailable` means the
+ * manifest could not be loaded at all (typically: not running inside Moldable).
+ */
+export function useMoldableCapability(id) {
+    const [manifest, setManifest] = useState(null);
+    const [error, setError] = useState(null);
+    const [checking, setChecking] = useState(true);
+    const generation = useRef(0);
+    const load = useCallback((force) => {
+        const current = ++generation.current;
+        setChecking(true);
+        setError(null);
+        loadMoldableCapabilities(force)
+            .then((value) => {
+            if (generation.current !== current)
+                return;
+            setManifest(value);
+            setChecking(false);
+        })
+            .catch((cause) => {
+            if (generation.current !== current)
+                return;
+            setManifest(null);
+            setError(cause instanceof Error ? cause : new Error(String(cause)));
+            setChecking(false);
+        });
+    }, []);
+    useEffect(() => {
+        load(false);
+        const liveGeneration = generation;
+        return () => {
+            liveGeneration.current++;
+        };
+    }, [load]);
+    const refresh = useCallback(() => load(true), [load]);
+    const descriptor = manifest ? manifest.capabilities[id] : null;
+    const status = checking
+        ? 'checking'
+        : descriptor
+            ? descriptor.support
+            : 'unavailable';
+    return { status, descriptor, manifest, error, refresh };
+}

package/dist/components/ui/input-group.d.ts

@@ -3,7 +3,7 @@ import { Button } from './button';
 import { type VariantProps } from 'class-variance-authority';
 declare function InputGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
 declare const inputGroupAddonVariants: (props?: ({
-    align?: "inline-end" | "inline-start" | "block-start" | "block-end" | null | undefined;
+    align?: "inline-end" | "inline-start" | "block-end" | "block-start" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<'div'> & VariantProps<typeof inputGroupAddonVariants>): import("react/jsx-runtime").JSX.Element;
 declare const inputGroupButtonVariants: (props?: ({

package/dist/components/ui/slider.d.ts

@@ -1,5 +1,8 @@
 import * as SliderPrimitive from '@radix-ui/react-slider';
 import * as React from 'react';
-declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function Slider({ className, defaultValue, value, min, max, rangeContent, thumbContent, ...props }: React.ComponentProps<typeof SliderPrimitive.Root> & {
+    rangeContent?: React.ReactNode;
+    thumbContent?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
 export { Slider };
 //# sourceMappingURL=slider.d.ts.map

package/dist/components/ui/slider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slider.d.ts","sourceRoot":"","sources":["../../../src/components/ui/slider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,eAAe,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,iBAAS,MAAM,CAAC,EACd,SAAS,EACT,YAAY,EACZ,KAAK,EACL,GAAO,EACP,GAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,eAAe,CAAC,IAAI,CAAC,2CA8CnD;AAED,OAAO,EAAE,MAAM,EAAE,CAAA"}
+{"version":3,"file":"slider.d.ts","sourceRoot":"","sources":["../../../src/components/ui/slider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,eAAe,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,iBAAS,MAAM,CAAC,EACd,SAAS,EACT,YAAY,EACZ,KAAK,EACL,GAAO,EACP,GAAS,EACT,YAAY,EACZ,YAAY,EACZ,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,eAAe,CAAC,IAAI,CAAC,GAAG;IACrD,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC9B,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC/B,2CAkDA;AAED,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/components/ui/slider.js

@@ -3,12 +3,12 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import * as SliderPrimitive from '@radix-ui/react-slider';
 import * as React from 'react';
 import { cn } from '../../lib/utils';
-function Slider({ className, defaultValue, value, min = 0, max = 100, ...props }) {
+function Slider({ className, defaultValue, value, min = 0, max = 100, rangeContent, thumbContent, ...props }) {
     const _values = React.useMemo(() => Array.isArray(value)
         ? value
         : Array.isArray(defaultValue)
             ? defaultValue
             : [min, max], [value, defaultValue, min, max]);
-    return (_jsxs(SliderPrimitive.Root, { "data-slot": "slider", defaultValue: defaultValue, value: value, min: min, max: max, className: cn('relative flex w-full touch-none select-none items-center data-[orientation=vertical]:h-full data-[orientation=vertical]:min-h-44 data-[orientation=vertical]:w-auto data-[orientation=vertical]:flex-col data-[disabled]:opacity-50', className), ...props, children: [_jsx(SliderPrimitive.Track, { "data-slot": "slider-track", className: cn('bg-muted relative grow overflow-hidden rounded-full data-[orientation=horizontal]:h-1.5 data-[orientation=vertical]:h-full data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-1.5'), children: _jsx(SliderPrimitive.Range, { "data-slot": "slider-range", className: cn('bg-primary absolute data-[orientation=horizontal]:h-full data-[orientation=vertical]:w-full') }) }), Array.from({ length: _values.length }, (_, index) => (_jsx(SliderPrimitive.Thumb, { "data-slot": "slider-thumb", className: "border-primary ring-ring/50 focus-visible:outline-hidden block size-4 shrink-0 rounded-full border bg-white shadow-sm transition-[color,box-shadow] hover:ring-4 focus-visible:ring-4 disabled:pointer-events-none disabled:opacity-50" }, index)))] }));
+    return (_jsxs(SliderPrimitive.Root, { "data-slot": "slider", defaultValue: defaultValue, value: value, min: min, max: max, className: cn('relative flex w-full touch-none select-none items-center data-[orientation=vertical]:h-full data-[orientation=vertical]:min-h-44 data-[orientation=vertical]:w-auto data-[orientation=vertical]:flex-col data-[disabled]:opacity-50', className), ...props, children: [_jsx(SliderPrimitive.Track, { "data-slot": "slider-track", className: cn('bg-muted relative grow overflow-hidden rounded-full data-[orientation=horizontal]:h-1.5 data-[orientation=vertical]:h-full data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-1.5'), children: _jsx(SliderPrimitive.Range, { "data-slot": "slider-range", className: cn('bg-primary absolute overflow-hidden rounded-full data-[orientation=horizontal]:h-full data-[orientation=vertical]:w-full'), children: rangeContent }) }), Array.from({ length: _values.length }, (_, index) => (_jsx(SliderPrimitive.Thumb, { "data-slot": "slider-thumb", className: "border-primary ring-ring/50 focus-visible:outline-hidden block size-4 shrink-0 rounded-full border bg-white shadow-sm transition-[color,box-shadow] hover:ring-4 focus-visible:ring-4 disabled:pointer-events-none disabled:opacity-50", children: thumbContent }, index)))] }));
 }
 export { Slider };

package/dist/index.d.ts

@@ -2,7 +2,9 @@ export { cn } from './lib/utils';
 export { ThemeProvider, useTheme, themeScript, type Theme } from './lib/theme';
 export { WorkspaceProvider, useWorkspace, WORKSPACE_HEADER, } from './lib/workspace';
 export { useMoldableCommands, useMoldableCommand, useMoldableAppCommands, useMoldableNavigationPop, useMoldableNavigationState, isInMoldable, sendToMoldable, pushMoldableNavigation, popMoldableNavigation, resetMoldableNavigation, downloadFile, publishMoldableArtifact, setMoldableWindowFullscreen, type AppCommand, type CommandAction, type CommandsResponse, type CommandMessage, type MoldableNavigationEntry, type MoldableNavigationPopMessage, type MoldableNavigationStateMessage, type DownloadFileOptions, type MoldableArtifactFile, type MoldableArtifactPublishOptions, type MoldableArtifactPublishResult, type MoldableWindowFullscreenMode, type MoldableWindowFullscreenOptions, type MoldableWindowFullscreenResult, type MoldableWindowFullscreenMessage, type MoldableWindowFullscreenResultMessage, } from './lib/commands';
+export * from './lib/native-hardware';
 export * from './components/ui';
+export * from './components/hardware';
 export { TODAY_KIND_RANK, TODAY_KIND_TTL_MS, makeTodayItem, type TodayItem, type TodayItemKind, type TodaySurface, type TodayAction, type TodayResponse, type ResumeState, type HydratedTodayItem, type HydratedResume, } from './lib/today';
 export { useIsMobile } from './hooks/use-mobile';
 export { Markdown } from './components/markdown';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AAG9E,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,EACZ,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACnC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,qCAAqC,GAC3C,MAAM,gBAAgB,CAAA;AAGvB,cAAc,iBAAiB,CAAA;AAG/B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EACL,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGnD,OAAO,EACL,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,iCAAiC,CAAA;AAGxC,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAGrE,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AAG9E,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,EACZ,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACnC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,qCAAqC,GAC3C,MAAM,gBAAgB,CAAA;AAGvB,cAAc,uBAAuB,CAAA;AAGrC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,uBAAuB,CAAA;AAGrC,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EACL,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGnD,OAAO,EACL,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,iCAAiC,CAAA;AAGxC,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAGrE,cAAc,mBAAmB,CAAA"}

package/dist/index.js

@@ -6,8 +6,12 @@ export { ThemeProvider, useTheme, themeScript } from './lib/theme';
 export { WorkspaceProvider, useWorkspace, WORKSPACE_HEADER, } from './lib/workspace';
 // Export commands
 export { useMoldableCommands, useMoldableCommand, useMoldableAppCommands, useMoldableNavigationPop, useMoldableNavigationState, isInMoldable, sendToMoldable, pushMoldableNavigation, popMoldableNavigation, resetMoldableNavigation, downloadFile, publishMoldableArtifact, setMoldableWindowFullscreen, } from './lib/commands';
+// Export typed desktop/native hardware APIs
+export * from './lib/native-hardware';
 // Export UI components
 export * from './components/ui';
+// Export native hardware components (polished wrappers over lib/native-hardware)
+export * from './components/hardware';
 // Export Today contract
 export { TODAY_KIND_RANK, TODAY_KIND_TTL_MS, makeTodayItem, } from './lib/today';
 // Export hooks

package/dist/lib/native-hardware/bluetooth-access.d.ts

@@ -0,0 +1,14 @@
+import type { MoldableBluetoothAvailability, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRequestDeviceOptions, MoldableBluetoothRequestOptions } from './bluetooth-types';
+/** Checks only for the standards-based Web Bluetooth entry point. */
+export declare function isMoldableBluetoothSupported(): boolean;
+/**
+ * Returns adapter availability when the runtime exposes it. `unknown` means the
+ * API exists but cannot report adapter state, not that Bluetooth is available.
+ */
+export declare function getMoldableBluetoothAvailability(options?: MoldableBluetoothOperationOptions): Promise<MoldableBluetoothAvailability>;
+/**
+ * Opens the browser's device chooser. This must be called directly from a
+ * trusted user action; it never silently scans for or selects devices.
+ */
+export declare function requestMoldableBluetoothDevice(deviceOptions: MoldableBluetoothRequestDeviceOptions, options?: MoldableBluetoothRequestOptions): Promise<MoldableBluetoothDevice>;
+//# sourceMappingURL=bluetooth-access.d.ts.map

package/dist/lib/native-hardware/bluetooth-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-access.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-access.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,6BAA6B,EAC7B,uBAAuB,EACvB,iCAAiC,EACjC,qCAAqC,EACrC,+BAA+B,EAChC,MAAM,mBAAmB,CAAA;AAE1B,qEAAqE;AACrE,wBAAgB,4BAA4B,IAAI,OAAO,CAGtD;AAED;;;GAGG;AACH,wBAAsB,gCAAgC,CACpD,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,6BAA6B,CAAC,CAexC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,aAAa,EAAE,qCAAqC,EACpD,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,uBAAuB,CAAC,CAelC"}

package/dist/lib/native-hardware/bluetooth-access.js

@@ -0,0 +1,40 @@
+import { abortableBluetooth, assertBluetoothUserGesture, bluetoothError, getBluetoothAPI, getBluetoothNavigator, validateBluetoothRequestOptions, } from './bluetooth-internal';
+/** Checks only for the standards-based Web Bluetooth entry point. */
+export function isMoldableBluetoothSupported() {
+    const api = getBluetoothNavigator()?.bluetooth;
+    return Boolean(api && typeof api.requestDevice === 'function');
+}
+/**
+ * Returns adapter availability when the runtime exposes it. `unknown` means the
+ * API exists but cannot report adapter state, not that Bluetooth is available.
+ */
+export async function getMoldableBluetoothAvailability(options = {}) {
+    const operation = 'check Bluetooth availability';
+    const api = getBluetoothAPI(operation);
+    if (typeof api.getAvailability !== 'function')
+        return 'unknown';
+    try {
+        return (await abortableBluetooth(api.getAvailability(), options.signal, operation))
+            ? 'available'
+            : 'unavailable';
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}
+/**
+ * Opens the browser's device chooser. This must be called directly from a
+ * trusted user action; it never silently scans for or selects devices.
+ */
+export async function requestMoldableBluetoothDevice(deviceOptions, options = {}) {
+    const operation = 'request a Bluetooth device';
+    const api = getBluetoothAPI(operation);
+    validateBluetoothRequestOptions(deviceOptions);
+    assertBluetoothUserGesture();
+    try {
+        return await abortableBluetooth(api.requestDevice(deviceOptions), options.signal, operation, (device) => device.gatt?.disconnect());
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}

package/dist/lib/native-hardware/bluetooth-connection.d.ts

@@ -0,0 +1,19 @@
+import type { MoldableBluetoothConnectionOptions, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTServer, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID } from './bluetooth-types';
+export declare class MoldableBluetoothConnection {
+    readonly device: MoldableBluetoothDevice;
+    readonly server: MoldableBluetoothRemoteGATTServer;
+    private readonly abortSignal?;
+    private readonly disconnectListeners;
+    private isClosed;
+    constructor(device: MoldableBluetoothDevice, server: MoldableBluetoothRemoteGATTServer, options?: MoldableBluetoothConnectionOptions);
+    get connected(): boolean;
+    onDisconnected(listener: () => void, signal?: AbortSignal): () => void;
+    getPrimaryService(service: MoldableBluetoothUUID, options?: MoldableBluetoothOperationOptions): Promise<MoldableBluetoothRemoteGATTService>;
+    disconnect(): void;
+    private readonly handleAbort;
+    private readonly handleDisconnected;
+    private finish;
+}
+/** Connects a previously user-selected device and owns disconnect cleanup. */
+export declare function connectMoldableBluetoothDevice(device: MoldableBluetoothDevice, options?: MoldableBluetoothConnectionOptions): Promise<MoldableBluetoothConnection>;
+//# sourceMappingURL=bluetooth-connection.d.ts.map

package/dist/lib/native-hardware/bluetooth-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-connection.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-connection.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kCAAkC,EAClC,uBAAuB,EACvB,iCAAiC,EACjC,iCAAiC,EACjC,kCAAkC,EAClC,qBAAqB,EACtB,MAAM,mBAAmB,CAAA;AAE1B,qBAAa,2BAA2B;IACtC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAA;IACxC,QAAQ,CAAC,MAAM,EAAE,iCAAiC,CAAA;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAa;IAC1C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAwB;IAC5D,OAAO,CAAC,QAAQ,CAAQ;gBAGtB,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iCAAiC,EACzC,OAAO,GAAE,kCAAuC;IASlD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,IAAI;IAWhE,iBAAiB,CACrB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,kCAAkC,CAAC;IAmB9C,UAAU,IAAI,IAAI;IAMlB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0B;IACtD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA0B;IAE7D,OAAO,CAAC,MAAM;CAqBf;AAED,8EAA8E;AAC9E,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,uBAAuB,EAC/B,OAAO,GAAE,kCAAuC,GAC/C,OAAO,CAAC,2BAA2B,CAAC,CA0BtC"}