@moldable-ai/ui 0.2.18 → 0.2.19

package/dist/components/chat/model-effort-ultra-effects.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const TRACK_PARTICLES = [
+    [6, 72, 3, -4, 2.1, -0.8, 0.72],
+    [9, 35, -2, 4, 2.8, -1.9, 0.48],
+    [18, 58, 4, -3, 1.9, -0.4, 0.82],
+    [29, 26, -3, 5, 3.1, -2.4, 0.56],
+    [38, 70, 2, -5, 2.5, -1.1, 0.68],
+    [46, 43, -4, 3, 2.9, -2.2, 0.9],
+    [55, 72, 3, -4, 2.2, -1.6, 0.58],
+    [63, 31, -2, 5, 3.2, -0.7, 0.72],
+    [71, 61, 4, -3, 2.4, -1.8, 0.48],
+    [78, 27, -3, 4, 2.7, -2.5, 0.86],
+    [84, 70, 2, -5, 2, -0.6, 0.62],
+    [89, 43, -4, 3, 3, -2.1, 0.9],
+    [93, 67, 3, -4, 2.3, -1.3, 0.7],
+    [96, 32, -2, 5, 2.8, -0.2, 0.54],
+];
+const BURST_PARTICLES = [
+    [-32, -3],
+    [-28, -17],
+    [-19, -29],
+    [-5, -34],
+    [10, -32],
+    [24, -24],
+    [32, -11],
+    [35, 4],
+    [29, 19],
+    [18, 30],
+    [3, 35],
+    [-12, 32],
+    [-25, 24],
+    [-34, 11],
+    [20, -7],
+    [-16, 9],
+];
+export function UltraRangeEffects({ reveal }) {
+    return (_jsxs("span", { "aria-hidden": "true", className: "model-effort-ultra-fill", "data-reveal": reveal, children: [_jsx("span", { className: "model-effort-ultra-field" }), _jsx("span", { className: "model-effort-ultra-particles", children: TRACK_PARTICLES.map(([left, top, driftX, driftY, duration, delay, opacity], index) => (_jsx("span", { className: "model-effort-ultra-particle", style: {
+                        left: `${left}%`,
+                        top: `${top}%`,
+                        '--particle-drift-x': `${driftX}px`,
+                        '--particle-drift-y': `${driftY}px`,
+                        '--particle-opacity': opacity,
+                        animationDuration: `${duration}s`,
+                        animationDelay: `${delay}s`,
+                    } }, index))) })] }));
+}
+export function UltraThumbBurst() {
+    return (_jsx("span", { "aria-hidden": "true", className: "model-effort-ultra-burst", children: BURST_PARTICLES.map(([x, y], index) => (_jsx("span", { className: "model-effort-ultra-burst-particle", style: {
+                '--burst-x': `${x}px`,
+                '--burst-y': `${y}px`,
+                animationDelay: `${(index % 4) * 12}ms`,
+                backgroundColor: index % 3 === 0
+                    ? 'var(--model-effort-blue)'
+                    : 'var(--model-effort-purple)',
+            } }, index))) }));
+}

package/dist/components/hardware/bluetooth-panel-helpers.d.ts

@@ -0,0 +1,9 @@
+export type BluetoothSubscriptionCleanup = () => Promise<void>;
+/**
+ * Stops every active observer before returning. Successful entries are removed,
+ * while failed entries stay registered so the caller can retry cleanup.
+ */
+export declare function cleanupBluetoothSubscriptions(subscriptions: Map<string, BluetoothSubscriptionCleanup>): Promise<void>;
+/** Parses a compact or separator-delimited hexadecimal Bluetooth value. */
+export declare function parseBluetoothHexBytes(value: string): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=bluetooth-panel-helpers.d.ts.map

package/dist/components/hardware/bluetooth-panel-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-panel-helpers.d.ts","sourceRoot":"","sources":["../../../src/components/hardware/bluetooth-panel-helpers.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;AAE9D;;;GAGG;AACH,wBAAsB,6BAA6B,CACjD,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,4BAA4B,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC,CAef;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAqB7E"}

package/dist/components/hardware/bluetooth-panel-helpers.js

@@ -0,0 +1,37 @@
+/**
+ * Stops every active observer before returning. Successful entries are removed,
+ * while failed entries stay registered so the caller can retry cleanup.
+ */
+export async function cleanupBluetoothSubscriptions(subscriptions) {
+    const failures = [];
+    await Promise.all([...subscriptions].map(async ([key, stop]) => {
+        try {
+            await stop();
+            if (subscriptions.get(key) === stop)
+                subscriptions.delete(key);
+        }
+        catch (cause) {
+            failures.push(cause);
+        }
+    }));
+    if (failures.length > 0)
+        throw failures[0];
+}
+/** Parses a compact or separator-delimited hexadecimal Bluetooth value. */
+export function parseBluetoothHexBytes(value) {
+    const normalized = value
+        .trim()
+        .replace(/0x/gi, '')
+        .replace(/[\s,:-]+/g, '');
+    if (normalized.length === 0) {
+        throw new TypeError('Enter at least one hexadecimal byte.');
+    }
+    if (normalized.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(normalized)) {
+        throw new TypeError('Use complete hexadecimal bytes, such as 01 A0 FF.');
+    }
+    const bytes = new Uint8Array(new ArrayBuffer(normalized.length / 2));
+    for (let index = 0; index < bytes.length; index++) {
+        bytes[index] = Number.parseInt(normalized.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+}

package/dist/components/hardware/bluetooth-panel.d.ts

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import { type MoldableBluetoothConnection, type MoldableBluetoothDevice, type MoldableBluetoothRemoteGATTCharacteristic, type MoldableNativeBluetoothDevice } from '../../lib/native-hardware';
+export type MoldableBluetoothStatus = 'idle' | 'requesting' | 'connecting' | 'connected' | 'error';
+export interface MoldableBluetoothCharacteristicInfo {
+    serviceUuid: string;
+    uuid: string;
+    /** Property names when the runtime exposes them; empty when unknown. */
+    properties: string[];
+    /** Web Bluetooth handle; null on the desktop bridge (UUIDs drive I/O). */
+    characteristic: MoldableBluetoothRemoteGATTCharacteristic | null;
+}
+export interface MoldableBluetoothServiceInfo {
+    uuid: string;
+    characteristics: MoldableBluetoothCharacteristicInfo[];
+}
+export interface UseMoldableBluetoothOptions {
+    onValue?: (characteristic: MoldableBluetoothCharacteristicInfo, value: DataView) => void;
+}
+/**
+ * Bluetooth LE state machine behind `BluetoothPanel`. Handles both transports
+ * returned by `requestMoldableBluetoothWithFallback`: Web Bluetooth (GATT
+ * connection + service discovery) and the desktop bridge (UUID-addressed I/O
+ * on an already-connected device).
+ */
+export declare function useMoldableBluetooth(options?: UseMoldableBluetoothOptions): {
+    status: MoldableBluetoothStatus;
+    device: MoldableBluetoothDevice | MoldableNativeBluetoothDevice | null;
+    connection: MoldableBluetoothConnection | null;
+    disconnecting: boolean;
+    services: MoldableBluetoothServiceInfo[];
+    subscribedUuids: string[];
+    error: Error | null;
+    entries: import("./stream-log").StreamLogEntry[];
+    request: (serviceUuid?: string) => Promise<void>;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    read: (characteristic: MoldableBluetoothCharacteristicInfo) => Promise<void>;
+    subscribe: (characteristic: MoldableBluetoothCharacteristicInfo) => Promise<void>;
+    unsubscribe: (characteristic: MoldableBluetoothCharacteristicInfo) => Promise<void>;
+    write: (characteristic: MoldableBluetoothCharacteristicInfo, bytes: BufferSource) => Promise<void>;
+    writeHex: (characteristic: MoldableBluetoothCharacteristicInfo, value: string) => Promise<void>;
+    clearEntries: () => void;
+};
+export interface BluetoothPanelProps extends React.ComponentProps<'div'> {
+    /** Prefill and scope scanning/discovery to one GATT service UUID. */
+    serviceUuid?: string;
+    onValue?: (characteristic: MoldableBluetoothCharacteristicInfo, value: DataView) => void;
+}
+/**
+ * Bluetooth LE panel: scan (optionally scoped to a service UUID), connect,
+ * browse discovered characteristics, and read, write, or subscribe to values
+ * with a live hex log.
+ */
+declare function BluetoothPanel({ className, serviceUuid, onValue, ...props }: BluetoothPanelProps): import("react/jsx-runtime").JSX.Element;
+export { BluetoothPanel };
+//# sourceMappingURL=bluetooth-panel.d.ts.map

package/dist/components/hardware/bluetooth-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-panel.d.ts","sourceRoot":"","sources":["../../../src/components/hardware/bluetooth-panel.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,yCAAyC,EAG9C,KAAK,6BAA6B,EAQnC,MAAM,2BAA2B,CAAA;AAqBlC,MAAM,MAAM,uBAAuB,GAC/B,MAAM,GACN,YAAY,GACZ,YAAY,GACZ,WAAW,GACX,OAAO,CAAA;AAgDX,MAAM,WAAW,mCAAmC;IAClD,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,wEAAwE;IACxE,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,0EAA0E;IAC1E,cAAc,EAAE,yCAAyC,GAAG,IAAI,CAAA;CACjE;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe,EAAE,mCAAmC,EAAE,CAAA;CACvD;AA+ED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,CACR,cAAc,EAAE,mCAAmC,EACnD,KAAK,EAAE,QAAQ,KACZ,IAAI,CAAA;CACV;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,2BAAgC;;;;;;;;;4BAkJlB,MAAM;;;2BAiDJ,mCAAmC;gCA0BnC,mCAAmC;kCAqCnC,mCAAmC;4BAqBxC,mCAAmC,SAC5C,YAAY;+BAmCH,mCAAmC,SAC5C,MAAM;;EAsClB;AAED,MAAM,WAAW,mBAAoB,SAAQ,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC;IACtE,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,CACR,cAAc,EAAE,mCAAmC,EACnD,KAAK,EAAE,QAAQ,KACZ,IAAI,CAAA;CACV;AAED;;;;GAIG;AACH,iBAAS,cAAc,CAAC,EACtB,SAAS,EACT,WAAW,EACX,OAAO,EACP,GAAG,KAAK,EACT,EAAE,mBAAmB,2CAiPrB;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}

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

@@ -0,0 +1,470 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Binary, Bluetooth } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { NativeHardwareBridgeError, connectMoldableBluetoothDevice, isMoldableBluetoothSupported, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, requestMoldableBluetoothWithFallback, writeMoldableBluetoothValue, } from '../../lib/native-hardware';
+import { Button } from '../ui/button';
+import { Input } from '../ui/input';
+import { Spinner } from '../ui/spinner';
+import { cleanupBluetoothSubscriptions, parseBluetoothHexBytes, } from './bluetooth-panel-helpers';
+import { CapabilityBadge } from './capability-badge';
+import { DeviceList, DeviceListEmpty, DeviceListItem } from './device-list';
+import { HardwarePanel, HardwarePanelAction, HardwarePanelContent, HardwarePanelHeader, HardwarePanelIcon, HardwarePanelTitle, } from './hardware-panel';
+import { LiveIndicator } from './live-indicator';
+import { StreamLog, useStreamLog } from './stream-log';
+const HEX_DUMP_MAX_BYTES = 32;
+const BLUETOOTH_BASE_UUID_SUFFIX = '-0000-1000-8000-00805f9b34fb';
+function toError(cause) {
+    return cause instanceof Error ? cause : new Error(String(cause));
+}
+function isDismissedChooser(cause) {
+    return (cause instanceof NativeHardwareBridgeError &&
+        (cause.code === 'cancelled' || cause.code === 'aborted'));
+}
+function asBytes(data) {
+    return data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function viewBytes(view) {
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function formatHexDump(bytes) {
+    if (bytes.byteLength === 0)
+        return '(empty)';
+    const shown = Array.from(bytes.subarray(0, HEX_DUMP_MAX_BYTES))
+        .map((byte) => byte.toString(16).padStart(2, '0').toUpperCase())
+        .join(' ');
+    const hidden = bytes.byteLength - HEX_DUMP_MAX_BYTES;
+    return hidden > 0 ? `${shown} +${hidden} more` : shown;
+}
+/** `0x2A19` for SIG-assigned UUIDs, middle-truncated hex for vendor ones. */
+function shortUuid(uuid) {
+    const value = uuid.toLowerCase();
+    if (value.startsWith('0000') && value.endsWith(BLUETOOTH_BASE_UUID_SUFFIX)) {
+        return `0x${value.slice(4, 8).toUpperCase()}`;
+    }
+    return value.length > 13 ? `${value.slice(0, 8)}…${value.slice(-4)}` : value;
+}
+function middleTruncate(uuid) {
+    return uuid.length > 22 ? `${uuid.slice(0, 13)}…${uuid.slice(-8)}` : uuid;
+}
+function characteristicKey(characteristic) {
+    return `${characteristic.serviceUuid}/${characteristic.uuid}`;
+}
+/** Web Bluetooth exposes `properties`; the structural type keeps it optional. */
+function describeProperties(characteristic) {
+    const flags = characteristic
+        .properties;
+    if (!flags)
+        return [];
+    const names = [];
+    if (flags.read)
+        names.push('read');
+    if (flags.write || flags.writeWithoutResponse)
+        names.push('write');
+    if (flags.notify)
+        names.push('notify');
+    if (flags.indicate)
+        names.push('indicate');
+    return names;
+}
+function requireWebCharacteristic(characteristic) {
+    if (!characteristic.characteristic) {
+        throw new Error('This characteristic has no Web Bluetooth handle.');
+    }
+    return characteristic.characteristic;
+}
+function observeGattDisconnect(transport, listener) {
+    if (transport.kind === 'web-bluetooth') {
+        transport.device.addEventListener('gattserverdisconnected', listener);
+        return () => transport.device.removeEventListener('gattserverdisconnected', listener);
+    }
+    transport.device.addEventListener('gattserverdisconnected', listener);
+    return () => transport.device.removeEventListener('gattserverdisconnected', listener);
+}
+async function discoverWebServices(connection, serviceUuid) {
+    const services = serviceUuid
+        ? [await connection.getPrimaryService(serviceUuid)]
+        : await connection.server.getPrimaryServices();
+    return Promise.all(services.map(async (service) => {
+        const characteristics = await service
+            .getCharacteristics()
+            .catch(() => []);
+        return {
+            uuid: service.uuid,
+            characteristics: characteristics.map((characteristic) => ({
+                serviceUuid: service.uuid,
+                uuid: characteristic.uuid,
+                properties: describeProperties(characteristic),
+                characteristic,
+            })),
+        };
+    }));
+}
+/**
+ * Bluetooth LE state machine behind `BluetoothPanel`. Handles both transports
+ * returned by `requestMoldableBluetoothWithFallback`: Web Bluetooth (GATT
+ * connection + service discovery) and the desktop bridge (UUID-addressed I/O
+ * on an already-connected device).
+ */
+export function useMoldableBluetooth(options = {}) {
+    const [status, setStatus] = useState('idle');
+    const [device, setDevice] = useState(null);
+    const [connection, setConnection] = useState(null);
+    const [services, setServices] = useState([]);
+    const [subscribedUuids, setSubscribedUuids] = useState([]);
+    const [disconnecting, setDisconnecting] = useState(false);
+    const [error, setError] = useState(null);
+    const { entries, append, clear } = useStreamLog();
+    const generationRef = useRef(0);
+    const transportRef = useRef(null);
+    const connectionRef = useRef(null);
+    const requestedServiceRef = useRef(undefined);
+    const subscriptionsRef = useRef(new Map());
+    const detachDeviceRef = useRef(null);
+    const disconnectingRef = useRef(false);
+    const unmountedRef = useRef(false);
+    const onValueRef = useRef(options.onValue);
+    onValueRef.current = options.onValue;
+    const reset = useCallback(async (bestEffort = false) => {
+        generationRef.current++;
+        const wasDisconnecting = disconnectingRef.current;
+        disconnectingRef.current = true;
+        try {
+            try {
+                await cleanupBluetoothSubscriptions(subscriptionsRef.current);
+            }
+            catch (cause) {
+                if (!unmountedRef.current) {
+                    setSubscribedUuids([...subscriptionsRef.current.keys()]);
+                }
+                if (!bestEffort)
+                    throw cause;
+            }
+            const transport = transportRef.current;
+            try {
+                if (transport?.kind === 'desktop-bridge') {
+                    await transport.device.disconnect();
+                }
+                else {
+                    connectionRef.current?.disconnect();
+                }
+            }
+            catch (cause) {
+                if (!bestEffort)
+                    throw cause;
+            }
+            detachDeviceRef.current?.();
+            detachDeviceRef.current = null;
+            transportRef.current = null;
+            connectionRef.current = null;
+            requestedServiceRef.current = undefined;
+            subscriptionsRef.current.clear();
+            if (!unmountedRef.current) {
+                setSubscribedUuids([]);
+                setDevice(null);
+                setConnection(null);
+                setServices([]);
+            }
+        }
+        finally {
+            disconnectingRef.current = wasDisconnecting;
+        }
+    }, []);
+    const disconnect = useCallback(async () => {
+        setDisconnecting(true);
+        setError(null);
+        try {
+            await reset();
+            setStatus('idle');
+        }
+        catch (cause) {
+            setError(toError(cause));
+        }
+        finally {
+            setDisconnecting(false);
+        }
+    }, [reset]);
+    const handleDisconnected = useCallback(() => {
+        if (disconnectingRef.current)
+            return;
+        void reset(true).then(() => {
+            if (unmountedRef.current)
+                return;
+            setStatus('idle');
+            append({ direction: 'info', data: 'Device disconnected' });
+        });
+    }, [append, reset]);
+    const handleDisconnectedRef = useRef(handleDisconnected);
+    handleDisconnectedRef.current = handleDisconnected;
+    const appendValue = useCallback((characteristic, value) => {
+        append({
+            direction: 'in',
+            data: `${shortUuid(characteristic.uuid)} ${formatHexDump(viewBytes(value))}`,
+        });
+        onValueRef.current?.(characteristic, value);
+    }, [append]);
+    const connect = useCallback(async () => {
+        const transport = transportRef.current;
+        if (!transport)
+            return;
+        const generation = generationRef.current;
+        setStatus('connecting');
+        setError(null);
+        try {
+            let discovered;
+            if (transport.kind === 'web-bluetooth') {
+                const nextConnection = await connectMoldableBluetoothDevice(transport.device);
+                if (generationRef.current !== generation) {
+                    nextConnection.disconnect();
+                    return;
+                }
+                connectionRef.current = nextConnection;
+                setConnection(nextConnection);
+                discovered = await discoverWebServices(nextConnection, requestedServiceRef.current);
+            }
+            else {
+                discovered = (await transport.device.getServices()).map((service) => ({
+                    uuid: service.uuid,
+                    characteristics: service.characteristicUuids.map((uuid) => ({
+                        serviceUuid: service.uuid,
+                        uuid,
+                        properties: [],
+                        characteristic: null,
+                    })),
+                }));
+            }
+            if (generationRef.current !== generation)
+                return;
+            setServices(discovered);
+            setStatus('connected');
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+            setStatus('error');
+        }
+    }, []);
+    const request = useCallback(async (serviceUuid) => {
+        setError(null);
+        try {
+            await reset();
+            const generation = generationRef.current;
+            const trimmed = serviceUuid?.trim() || undefined;
+            requestedServiceRef.current = trimmed;
+            setStatus('requesting');
+            if (!trimmed && !isMoldableBluetoothSupported()) {
+                throw new Error('The desktop Bluetooth chooser needs a service UUID to scan.');
+            }
+            const transport = await requestMoldableBluetoothWithFallback(trimmed
+                ? {
+                    filters: [{ services: [trimmed] }],
+                    optionalServices: [trimmed],
+                }
+                : { acceptAllDevices: true });
+            if (generationRef.current !== generation) {
+                if (transport.kind === 'desktop-bridge') {
+                    await transport.device.disconnect().catch(() => undefined);
+                }
+                else {
+                    transport.device.gatt?.disconnect();
+                }
+                return;
+            }
+            transportRef.current = transport;
+            setDevice(transport.device);
+            detachDeviceRef.current = observeGattDisconnect(transport, () => {
+                handleDisconnectedRef.current();
+            });
+            await connect();
+        }
+        catch (cause) {
+            if (isDismissedChooser(cause)) {
+                setStatus('idle');
+                return;
+            }
+            if (unmountedRef.current)
+                return;
+            setError(toError(cause));
+            setStatus(transportRef.current ? 'connected' : 'error');
+        }
+    }, [connect, reset]);
+    const read = useCallback(async (characteristic) => {
+        const transport = transportRef.current;
+        if (!transport)
+            return;
+        const generation = generationRef.current;
+        setError(null);
+        try {
+            const value = transport.kind === 'desktop-bridge'
+                ? await transport.device.read(characteristic.serviceUuid, characteristic.uuid)
+                : await readMoldableBluetoothValue(requireWebCharacteristic(characteristic));
+            if (generationRef.current !== generation)
+                return;
+            appendValue(characteristic, value);
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+        }
+    }, [appendValue]);
+    const subscribe = useCallback(async (characteristic) => {
+        const transport = transportRef.current;
+        const key = characteristicKey(characteristic);
+        if (!transport || subscriptionsRef.current.has(key))
+            return;
+        const generation = generationRef.current;
+        setError(null);
+        try {
+            let stop;
+            if (transport.kind === 'desktop-bridge') {
+                stop = await transport.device.observe(characteristic.serviceUuid, characteristic.uuid, (value) => appendValue(characteristic, value));
+            }
+            else {
+                const target = requireWebCharacteristic(characteristic);
+                stop = await observeMoldableBluetoothNotifications(target, () => {
+                    if (target.value)
+                        appendValue(characteristic, target.value);
+                });
+            }
+            if (generationRef.current !== generation) {
+                await stop().catch(() => undefined);
+                return;
+            }
+            subscriptionsRef.current.set(key, stop);
+            setSubscribedUuids((previous) => previous.includes(key) ? previous : [...previous, key]);
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+        }
+    }, [appendValue]);
+    const unsubscribe = useCallback(async (characteristic) => {
+        const key = characteristicKey(characteristic);
+        const stop = subscriptionsRef.current.get(key);
+        if (!stop)
+            return;
+        setError(null);
+        try {
+            await stop();
+            if (subscriptionsRef.current.get(key) !== stop)
+                return;
+            subscriptionsRef.current.delete(key);
+            setSubscribedUuids((previous) => previous.filter((value) => value !== key));
+        }
+        catch (cause) {
+            setError(toError(cause));
+        }
+    }, []);
+    const write = useCallback(async (characteristic, bytes) => {
+        const transport = transportRef.current;
+        if (!transport)
+            return;
+        const generation = generationRef.current;
+        setError(null);
+        try {
+            if (transport.kind === 'desktop-bridge') {
+                await transport.device.write(characteristic.serviceUuid, characteristic.uuid, bytes);
+            }
+            else {
+                await writeMoldableBluetoothValue(requireWebCharacteristic(characteristic), bytes, 'automatic');
+            }
+            if (generationRef.current !== generation)
+                return;
+            append({
+                direction: 'out',
+                data: `${shortUuid(characteristic.uuid)} ${formatHexDump(asBytes(bytes))}`,
+            });
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+        }
+    }, [append]);
+    const writeHex = useCallback(async (characteristic, value) => {
+        try {
+            await write(characteristic, parseBluetoothHexBytes(value));
+        }
+        catch (cause) {
+            setError(toError(cause));
+        }
+    }, [write]);
+    useEffect(() => {
+        unmountedRef.current = false;
+        return () => {
+            unmountedRef.current = true;
+            void reset(true);
+        };
+    }, [reset]);
+    return {
+        status,
+        device,
+        connection,
+        disconnecting,
+        services,
+        subscribedUuids,
+        error,
+        entries,
+        request,
+        connect,
+        disconnect,
+        read,
+        subscribe,
+        unsubscribe,
+        write,
+        writeHex,
+        clearEntries: clear,
+    };
+}
+/**
+ * Bluetooth LE panel: scan (optionally scoped to a service UUID), connect,
+ * browse discovered characteristics, and read, write, or subscribe to values
+ * with a live hex log.
+ */
+function BluetoothPanel({ className, serviceUuid, onValue, ...props }) {
+    const bluetooth = useMoldableBluetooth({ onValue });
+    const [uuidInput, setUuidInput] = useState(serviceUuid ?? '');
+    const [writeValues, setWriteValues] = useState({});
+    const connected = bluetooth.status === 'connected';
+    const busy = bluetooth.status === 'requesting' || bluetooth.status === 'connecting';
+    const deviceName = bluetooth.device?.name || 'BLE device';
+    return (_jsxs(HardwarePanel, { "data-slot": "bluetooth-panel", "data-status": bluetooth.status, className: className, ...props, children: [_jsxs(HardwarePanelHeader, { children: [_jsx(HardwarePanelIcon, { children: _jsx(Bluetooth, {}) }), _jsx(HardwarePanelTitle, { children: "Bluetooth LE" }), _jsx(CapabilityBadge, { capability: "bluetooth" }), _jsx(HardwarePanelAction, { children: connected ? (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground inline-flex max-w-40 items-center rounded-full border px-2 py-0.5 text-[11px] font-medium", children: _jsx("span", { className: "truncate", children: deviceName }) }), _jsx(LiveIndicator, {}), _jsxs(Button, { size: "sm", variant: "outline", disabled: bluetooth.disconnecting, onClick: () => void bluetooth.disconnect(), children: [bluetooth.disconnecting ? _jsx(Spinner, {}) : null, bluetooth.disconnecting ? 'Disconnecting…' : 'Disconnect'] })] })) : (_jsxs(_Fragment, { children: [_jsx(Input, { value: uuidInput, onChange: (event) => setUuidInput(event.target.value), onKeyDown: (event) => {
+                                        if (event.key === 'Enter' && !busy) {
+                                            void bluetooth.request(uuidInput);
+                                        }
+                                    }, placeholder: "Service UUID (optional)", "aria-label": "Service UUID", disabled: busy, className: "h-8 w-44 font-mono text-xs md:text-xs" }), _jsxs(Button, { size: "sm", disabled: busy, onClick: () => void bluetooth.request(uuidInput), children: [busy ? _jsx(Spinner, {}) : null, bluetooth.status === 'requesting'
+                                            ? 'Scanning…'
+                                            : bluetooth.status === 'connecting'
+                                                ? 'Connecting…'
+                                                : 'Scan'] })] })) })] }), _jsx(HardwarePanelContent, { children: connected ? (_jsxs("div", { className: "animate-in fade-in space-y-4 duration-300 motion-reduce:animate-none", children: [bluetooth.services.length === 0 ? (_jsx(DeviceList, { children: _jsx(DeviceListEmpty, { icon: _jsx(Bluetooth, {}), children: "No GATT services discovered" }) })) : (bluetooth.services.map((service) => (_jsxs("section", { "data-slot": "bluetooth-service", className: "space-y-1.5", children: [_jsx("div", { className: "text-muted-foreground font-mono text-[10px] font-medium uppercase tracking-wider", children: middleTruncate(service.uuid) }), _jsx(DeviceList, { children: service.characteristics.length === 0 ? (_jsx(DeviceListEmpty, { children: "No characteristics" })) : (service.characteristics.map((characteristic) => {
+                                        const key = characteristicKey(characteristic);
+                                        const subscribed = bluetooth.subscribedUuids.includes(key);
+                                        const unknown = characteristic.properties.length === 0;
+                                        const canRead = unknown || characteristic.properties.includes('read');
+                                        const canWrite = unknown || characteristic.properties.includes('write');
+                                        const canNotify = unknown ||
+                                            characteristic.properties.includes('notify') ||
+                                            characteristic.properties.includes('indicate');
+                                        return (_jsx(DeviceListItem, { icon: _jsx(Binary, {}), name: _jsx("span", { className: "font-mono", children: shortUuid(characteristic.uuid) }), description: unknown
+                                                ? undefined
+                                                : characteristic.properties.join(' · '), action: _jsxs(_Fragment, { children: [canWrite ? (_jsxs(_Fragment, { children: [_jsx(Input, { value: writeValues[key] ?? '', onChange: (event) => setWriteValues((previous) => ({
+                                                                    ...previous,
+                                                                    [key]: event.target.value,
+                                                                })), onKeyDown: (event) => {
+                                                                    if (event.key === 'Enter') {
+                                                                        void bluetooth.writeHex(characteristic, writeValues[key] ?? '');
+                                                                    }
+                                                                }, placeholder: "01 A0 FF", "aria-label": `Hex value for ${shortUuid(characteristic.uuid)}`, className: "h-7 w-24 font-mono text-xs md:text-xs" }), _jsx(Button, { variant: "ghost", size: "xs", onClick: () => void bluetooth.writeHex(characteristic, writeValues[key] ?? ''), children: "Write" })] })) : null, canRead ? (_jsx(Button, { variant: "ghost", size: "xs", onClick: () => void bluetooth.read(characteristic), children: "Read" })) : null, canNotify ? (_jsx(Button, { variant: "outline", size: "xs", onClick: () => void (subscribed
+                                                            ? bluetooth.unsubscribe(characteristic)
+                                                            : bluetooth.subscribe(characteristic)), children: subscribed ? 'Stop' : 'Notify' })) : null] }) }, key));
+                                    })) })] }, service.uuid)))), bluetooth.error ? (_jsx("p", { className: "text-status-error text-xs", children: bluetooth.error.message })) : null, _jsx(StreamLog, { entries: bluetooth.entries, maxHeight: 200, emptyLabel: "Waiting for characteristic data" })] })) : (_jsx("div", { className: "animate-in fade-in flex flex-col items-center gap-3 py-6 text-center duration-300 motion-reduce:animate-none", children: busy ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { className: "text-muted-foreground" }), _jsx("p", { className: "text-muted-foreground text-xs", children: bluetooth.status === 'requesting'
+                                    ? 'Waiting for the device chooser…'
+                                    : 'Connecting to device…' })] })) : bluetooth.status === 'error' ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "text-sm font-medium", children: "Bluetooth request failed" }), _jsx("p", { className: "text-muted-foreground max-w-64 text-xs", children: bluetooth.error?.message ??
+                                    'The Bluetooth request could not complete.' })] })) : (_jsxs(_Fragment, { children: [_jsx("div", { className: "text-muted-foreground bg-background shadow-xs flex size-10 items-center justify-center rounded-lg border [&_svg]:size-5", children: _jsx(Bluetooth, {}) }), _jsx("p", { className: "text-sm font-medium", children: "Not connected" }), _jsx("p", { className: "text-muted-foreground text-xs", children: "Scan for a nearby BLE device." })] })) })) })] }));
+}
+export { BluetoothPanel };