@moldable-ai/ui 0.2.18 → 0.2.20

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

@@ -0,0 +1,88 @@
+import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal';
+export class MoldableBluetoothConnection {
+    device;
+    server;
+    abortSignal;
+    disconnectListeners = new Set();
+    isClosed = false;
+    constructor(device, server, options = {}) {
+        this.device = device;
+        this.server = server;
+        this.abortSignal = options.signal;
+        device.addEventListener('gattserverdisconnected', this.handleDisconnected);
+        options.signal?.addEventListener('abort', this.handleAbort, { once: true });
+    }
+    get connected() {
+        return !this.isClosed && this.server.connected;
+    }
+    onDisconnected(listener, signal) {
+        if (signal?.aborted || this.isClosed)
+            return () => undefined;
+        this.disconnectListeners.add(listener);
+        const cleanup = () => {
+            this.disconnectListeners.delete(listener);
+            signal?.removeEventListener('abort', cleanup);
+        };
+        signal?.addEventListener('abort', cleanup, { once: true });
+        return cleanup;
+    }
+    async getPrimaryService(service, options = {}) {
+        const operation = `get Bluetooth service ${String(service)}`;
+        if (!this.connected) {
+            throw bluetoothError(new DOMException('Bluetooth device is disconnected', 'NetworkError'), operation);
+        }
+        try {
+            return await abortableBluetooth(this.server.getPrimaryService(service), options.signal, operation);
+        }
+        catch (error) {
+            throw bluetoothError(error, operation);
+        }
+    }
+    disconnect() {
+        if (this.isClosed)
+            return;
+        this.finish(false);
+        if (this.server.connected)
+            this.server.disconnect();
+    }
+    handleAbort = () => this.disconnect();
+    handleDisconnected = () => this.finish(true);
+    finish(notify) {
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        this.device.removeEventListener('gattserverdisconnected', this.handleDisconnected);
+        this.abortSignal?.removeEventListener('abort', this.handleAbort);
+        if (notify) {
+            const listeners = [...this.disconnectListeners];
+            this.disconnectListeners.clear();
+            for (const listener of listeners) {
+                try {
+                    listener();
+                }
+                catch {
+                    // A consumer callback must not prevent connection cleanup.
+                }
+            }
+        }
+        this.disconnectListeners.clear();
+    }
+}
+/** Connects a previously user-selected device and owns disconnect cleanup. */
+export async function connectMoldableBluetoothDevice(device, options = {}) {
+    const operation = `connect to Bluetooth device ${device.id}`;
+    if (!device.gatt) {
+        throw bluetoothError(new DOMException('Device does not expose a GATT server', 'NotSupportedError'), operation);
+    }
+    try {
+        const server = await abortableBluetooth(device.gatt.connect(), options.signal, operation, (lateServer) => lateServer.disconnect());
+        if (options.signal?.aborted) {
+            server.disconnect();
+            throw bluetoothAborted(operation);
+        }
+        return new MoldableBluetoothConnection(device, server, options);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTCharacteristic, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID, MoldableBluetoothWriteMode } from './bluetooth-types';
+export declare function getMoldableBluetoothCharacteristic(service: MoldableBluetoothRemoteGATTService, characteristic: MoldableBluetoothUUID, options?: MoldableBluetoothOperationOptions): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+export declare function readMoldableBluetoothValue(characteristic: MoldableBluetoothRemoteGATTCharacteristic, options?: MoldableBluetoothOperationOptions): Promise<DataView>;
+/** Starts notifications and returns async, idempotent subscription cleanup. */
+export declare function observeMoldableBluetoothNotifications(characteristic: MoldableBluetoothRemoteGATTCharacteristic, listener: (event: Event) => void, options?: MoldableBluetoothOperationOptions): Promise<() => Promise<void>>;
+export declare function writeMoldableBluetoothValue(characteristic: MoldableBluetoothRemoteGATTCharacteristic, value: BufferSource, mode?: MoldableBluetoothWriteMode, options?: MoldableBluetoothOperationOptions): Promise<void>;
+//# sourceMappingURL=bluetooth-gatt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-gatt.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-gatt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,iCAAiC,EACjC,yCAAyC,EACzC,kCAAkC,EAClC,qBAAqB,EACrB,0BAA0B,EAC3B,MAAM,mBAAmB,CAAA;AAE1B,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,kCAAkC,EAC3C,cAAc,EAAE,qBAAqB,EACrC,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,yCAAyC,CAAC,CAWpD;AAED,wBAAsB,0BAA0B,CAC9C,cAAc,EAAE,yCAAyC,EACzD,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,QAAQ,CAAC,CAWnB;AAED,+EAA+E;AAC/E,wBAAsB,qCAAqC,CACzD,cAAc,EAAE,yCAAyC,EACzD,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAmC9B;AAED,wBAAsB,2BAA2B,CAC/C,cAAc,EAAE,yCAAyC,EACzD,KAAK,EAAE,YAAY,EACnB,IAAI,GAAE,0BAAwC,EAC9C,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

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

@@ -0,0 +1,77 @@
+import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal';
+export async function getMoldableBluetoothCharacteristic(service, characteristic, options = {}) {
+    const operation = `get Bluetooth characteristic ${String(characteristic)}`;
+    try {
+        return await abortableBluetooth(service.getCharacteristic(characteristic), options.signal, operation);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}
+export async function readMoldableBluetoothValue(characteristic, options = {}) {
+    const operation = `read Bluetooth characteristic ${characteristic.uuid}`;
+    try {
+        return await abortableBluetooth(characteristic.readValue(), options.signal, operation);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}
+/** Starts notifications and returns async, idempotent subscription cleanup. */
+export async function observeMoldableBluetoothNotifications(characteristic, listener, options = {}) {
+    const operation = `observe Bluetooth characteristic ${characteristic.uuid}`;
+    try {
+        await abortableBluetooth(characteristic.startNotifications(), options.signal, operation, (lateCharacteristic) => {
+            void lateCharacteristic.stopNotifications();
+        });
+        if (options.signal?.aborted) {
+            await characteristic.stopNotifications();
+            throw bluetoothAborted(operation);
+        }
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+    let active = true;
+    const cleanup = async () => {
+        if (!active)
+            return;
+        active = false;
+        characteristic.removeEventListener('characteristicvaluechanged', listener);
+        options.signal?.removeEventListener('abort', onAbort);
+        try {
+            await characteristic.stopNotifications();
+        }
+        catch (error) {
+            throw bluetoothError(error, `stop ${operation}`);
+        }
+    };
+    const onAbort = () => void cleanup().catch(() => undefined);
+    characteristic.addEventListener('characteristicvaluechanged', listener);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    return cleanup;
+}
+export async function writeMoldableBluetoothValue(characteristic, value, mode = 'automatic', options = {}) {
+    const operation = `write Bluetooth characteristic ${characteristic.uuid}`;
+    let write;
+    if (mode === 'with-response') {
+        write = characteristic.writeValueWithResponse?.bind(characteristic);
+    }
+    else if (mode === 'without-response') {
+        write = characteristic.writeValueWithoutResponse?.bind(characteristic);
+    }
+    else {
+        write =
+            characteristic.writeValueWithResponse?.bind(characteristic) ??
+                characteristic.writeValue.bind(characteristic);
+    }
+    if (!write) {
+        throw bluetoothError(new DOMException(`Bluetooth write mode ${mode} is unavailable`, 'NotSupportedError'), operation);
+    }
+    try {
+        await abortableBluetooth(write(value), options.signal, operation);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { MoldableBluetoothAPI, MoldableBluetoothNavigator, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types';
+import { NativeHardwareBridgeError } from './bridge';
+export declare function bluetoothError(error: unknown, operation: string): NativeHardwareBridgeError;
+export declare function bluetoothAborted(operation: string): NativeHardwareBridgeError;
+export declare function getBluetoothNavigator(): MoldableBluetoothNavigator | undefined;
+export declare function getBluetoothAPI(operation: string): MoldableBluetoothAPI;
+export declare function assertBluetoothUserGesture(): void;
+export declare function validateBluetoothRequestOptions(options: MoldableBluetoothRequestDeviceOptions): void;
+export declare function abortableBluetooth<T>(promise: Promise<T>, signal: AbortSignal | undefined, operation: string, onLateResolution?: (value: T) => void): Promise<T>;
+//# sourceMappingURL=bluetooth-internal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-internal.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,qCAAqC,EACtC,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,yBAAyB,EAE1B,MAAM,UAAU,CAAA;AAGjB,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAChB,yBAAyB,CAsC3B;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,yBAAyB,CAK7E;AAED,wBAAgB,qBAAqB,IACjC,0BAA0B,GAC1B,SAAS,CAIZ;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB,CASvE;AAED,wBAAgB,0BAA0B,IAAI,IAAI,CAWjD;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,qCAAqC,GAC7C,IAAI,CAiBN;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GACpC,OAAO,CAAC,CAAC,CAAC,CA+BZ"}

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

@@ -0,0 +1,105 @@
+import { NativeHardwareBridgeError, toNativeHardwareBridgeError, } from './bridge';
+export function bluetoothError(error, operation) {
+    if (error instanceof NativeHardwareBridgeError)
+        return error;
+    const name = error instanceof DOMException ? error.name : undefined;
+    let code = 'host_error';
+    let retryable = false;
+    if (name === 'NotSupportedError')
+        code = 'unsupported';
+    else if (name === 'NotAllowedError' || name === 'SecurityError') {
+        code = 'permission_denied';
+    }
+    else if (name === 'AbortError')
+        code = 'aborted';
+    else if (name === 'NotFoundError')
+        code = 'cancelled';
+    else if (name === 'NetworkError' ||
+        name === 'InvalidStateError' ||
+        name === 'OperationError') {
+        code = 'unavailable';
+        retryable = true;
+    }
+    else if (error instanceof TypeError)
+        code = 'invalid_request';
+    const fallbackMessage = `Unable to ${operation}`;
+    return toNativeHardwareBridgeError({
+        code,
+        message: error instanceof Error
+            ? error.message || fallbackMessage
+            : fallbackMessage,
+        details: {
+            capability: 'bluetooth',
+            operation,
+            ...(name ? { cause: name } : {}),
+        },
+        retryable,
+    }, fallbackMessage);
+}
+export function bluetoothAborted(operation) {
+    return bluetoothError(new DOMException(`Bluetooth ${operation} was aborted`, 'AbortError'), operation);
+}
+export function getBluetoothNavigator() {
+    return typeof navigator === 'undefined'
+        ? undefined
+        : navigator;
+}
+export function getBluetoothAPI(operation) {
+    const api = getBluetoothNavigator()?.bluetooth;
+    if (!api || typeof api.requestDevice !== 'function') {
+        throw bluetoothError(new DOMException('Web Bluetooth is unavailable', 'NotSupportedError'), operation);
+    }
+    return api;
+}
+export function assertBluetoothUserGesture() {
+    const activation = getBluetoothNavigator()?.userActivation;
+    if (activation && !activation.isActive) {
+        throw toNativeHardwareBridgeError({
+            code: 'invalid_request',
+            message: 'Bluetooth device selection must be requested from a user-initiated action.',
+            details: { capability: 'bluetooth', cause: 'user_gesture_required' },
+            retryable: true,
+        });
+    }
+}
+export function validateBluetoothRequestOptions(options) {
+    const hasFilters = 'filters' in options && options.filters !== undefined;
+    const acceptsAll = options.acceptAllDevices === true;
+    if (hasFilters === acceptsAll) {
+        throw bluetoothError(new TypeError('Specify either a non-empty filters array or acceptAllDevices: true'), 'request a Bluetooth device');
+    }
+    if (hasFilters && options.filters.length === 0) {
+        throw bluetoothError(new TypeError('Bluetooth filters must not be empty'), 'request a Bluetooth device');
+    }
+}
+export function abortableBluetooth(promise, signal, operation, onLateResolution) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(bluetoothAborted(operation));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            reject(bluetoothAborted(operation));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            if (settled) {
+                onLateResolution?.(value);
+                return;
+            }
+            settled = true;
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+    });
+}

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

@@ -0,0 +1,33 @@
+import type { MoldableBluetoothDevice, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types';
+import { type NativeHardwareBridgeOptions } from './bridge';
+export type MoldableBluetoothTransport = {
+    kind: 'web-bluetooth';
+    device: MoldableBluetoothDevice;
+} | {
+    kind: 'desktop-bridge';
+    device: MoldableNativeBluetoothDevice;
+};
+export interface MoldableNativeBluetoothService {
+    uuid: string;
+    characteristicUuids: string[];
+}
+export interface MoldableNativeBluetoothDevice {
+    readonly id: string;
+    readonly name: string | null;
+    readonly connected: boolean;
+    addEventListener(type: 'gattserverdisconnected', listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: 'gattserverdisconnected', listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    getServices(options?: NativeHardwareBridgeOptions): Promise<MoldableNativeBluetoothService[]>;
+    read(serviceUuid: string, characteristicUuid: string, options?: NativeHardwareBridgeOptions): Promise<DataView>;
+    write(serviceUuid: string, characteristicUuid: string, data: BufferSource, options?: NativeHardwareBridgeOptions & {
+        withResponse?: boolean;
+    }): Promise<void>;
+    observe(serviceUuid: string, characteristicUuid: string, listener: (value: DataView) => void, options?: NativeHardwareBridgeOptions): Promise<() => Promise<void>>;
+    disconnect(options?: NativeHardwareBridgeOptions): Promise<void>;
+}
+/**
+ * Uses Web Bluetooth first, with a restrictive desktop BLE chooser fallback.
+ * The native branch mirrors physical disconnect and adapter-loss events.
+ */
+export declare function requestMoldableBluetoothWithFallback(options: MoldableBluetoothRequestDeviceOptions, bridgeOptions?: NativeHardwareBridgeOptions): Promise<MoldableBluetoothTransport>;
+//# sourceMappingURL=bluetooth-native-fallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-native-fallback.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-native-fallback.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,uBAAuB,EACvB,qCAAqC,EACtC,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AAMjB,MAAM,MAAM,0BAA0B,GAClC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,6BAA6B,CAAA;CAAE,CAAA;AAErE,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,mBAAmB,EAAE,MAAM,EAAE,CAAA;CAC9B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,gBAAgB,CACd,IAAI,EAAE,wBAAwB,EAC9B,QAAQ,EAAE,kCAAkC,EAC5C,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAA;IACP,mBAAmB,CACjB,IAAI,EAAE,wBAAwB,EAC9B,QAAQ,EAAE,kCAAkC,EAC5C,OAAO,CAAC,EAAE,OAAO,GAAG,oBAAoB,GACvC,IAAI,CAAA;IACP,WAAW,CACT,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAA;IAC5C,IAAI,CACF,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAC1B,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACpB,KAAK,CACH,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAC1B,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,2BAA2B,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,GACjE,OAAO,CAAC,IAAI,CAAC,CAAA;IAChB,OAAO,CACL,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAC1B,QAAQ,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,EACnC,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/B,UAAU,CAAC,OAAO,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjE;AA2PD;;;GAGG;AACH,wBAAsB,oCAAoC,CACxD,OAAO,EAAE,qCAAqC,EAC9C,aAAa,GAAE,2BAAgC,GAC9C,OAAO,CAAC,0BAA0B,CAAC,CAsCrC"}

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

@@ -0,0 +1,214 @@
+import { isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+import { callNativeHardwareBridge, } from './bridge';
+const REQUEST_TYPE = 'moldable:native-bluetooth';
+const RESULT_TYPE = 'moldable:native-bluetooth-result';
+const EVENT_TYPE = 'moldable:native-bluetooth-event';
+function isNativeConnectionResult(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const connection = value;
+    return (typeof connection.connectionId === 'string' &&
+        connection.connectionId.length > 0 &&
+        (connection.name === null || typeof connection.name === 'string'));
+}
+function uuid(value) {
+    if (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= 0 &&
+        value <= 0xffff) {
+        return value.toString(16).padStart(4, '0');
+    }
+    if (typeof value === 'string' && /^[0-9a-fA-F-]{4,64}$/.test(value))
+        return value.toLowerCase();
+    throw new TypeError('The native Bluetooth fallback requires numeric or UUID service identifiers.');
+}
+function dataBytes(source) {
+    const bytes = source instanceof ArrayBuffer
+        ? new Uint8Array(source)
+        : new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    if (bytes.byteLength > 512)
+        throw new TypeError('Bluetooth values are limited to 512 bytes.');
+    return Array.from(bytes);
+}
+function nativeRequest(connectionId, action, payload, options = {}) {
+    return callNativeHardwareBridge({ type: REQUEST_TYPE, action, connectionId, ...payload }, RESULT_TYPE, options);
+}
+function nativeDevice(connection) {
+    let disconnected = false;
+    const events = new EventTarget();
+    const activeSubscriptions = new Set();
+    const transitionDisconnected = () => {
+        if (disconnected)
+            return;
+        disconnected = true;
+        window.removeEventListener('message', onLifecycleMessage);
+        for (const cleanup of [...activeSubscriptions]) {
+            void cleanup().catch(() => undefined);
+        }
+        events.dispatchEvent(new Event('gattserverdisconnected'));
+    };
+    function onLifecycleMessage(event) {
+        if (event.source !== window.parent ||
+            typeof event.data !== 'object' ||
+            !event.data)
+            return;
+        const message = event.data;
+        if (message.type !== EVENT_TYPE ||
+            typeof message.event !== 'object' ||
+            !message.event)
+            return;
+        const value = message.event;
+        if (value.connectionId === connection.connectionId &&
+            (value.kind === 'disconnected' || value.kind === 'adapterUnavailable')) {
+            transitionDisconnected();
+        }
+    }
+    window.addEventListener('message', onLifecycleMessage);
+    const assertConnected = () => {
+        if (disconnected) {
+            throw new DOMException('The Bluetooth device is disconnected.', 'InvalidStateError');
+        }
+    };
+    return {
+        id: connection.connectionId,
+        name: connection.name,
+        get connected() {
+            return !disconnected;
+        },
+        addEventListener(type, listener, options) {
+            events.addEventListener(type, listener, options);
+        },
+        removeEventListener(type, listener, options) {
+            events.removeEventListener(type, listener, options);
+        },
+        async getServices(options) {
+            assertConnected();
+            return nativeRequest(connection.connectionId, 'getServices', {}, options);
+        },
+        async read(serviceUuid, characteristicUuid, options) {
+            assertConnected();
+            const data = await nativeRequest(connection.connectionId, 'read', {
+                serviceUuid: uuid(serviceUuid),
+                characteristicUuid: uuid(characteristicUuid),
+            }, options);
+            if (!Array.isArray(data) ||
+                !data.every((byte) => Number.isInteger(byte))) {
+                throw new TypeError('The desktop returned an invalid Bluetooth value.');
+            }
+            return new DataView(Uint8Array.from(data).buffer);
+        },
+        async write(serviceUuid, characteristicUuid, data, options) {
+            assertConnected();
+            await nativeRequest(connection.connectionId, 'write', {
+                serviceUuid: uuid(serviceUuid),
+                characteristicUuid: uuid(characteristicUuid),
+                data: dataBytes(data),
+                withResponse: options?.withResponse !== false,
+            }, options);
+        },
+        async observe(serviceUuid, characteristicUuid, listener, options) {
+            assertConnected();
+            const service = uuid(serviceUuid);
+            const characteristic = uuid(characteristicUuid);
+            const onMessage = (event) => {
+                if (event.source !== window.parent ||
+                    typeof event.data !== 'object' ||
+                    !event.data)
+                    return;
+                const message = event.data;
+                if (message.type !== EVENT_TYPE ||
+                    typeof message.event !== 'object' ||
+                    !message.event)
+                    return;
+                const value = message.event;
+                if (value.connectionId !== connection.connectionId ||
+                    value.kind !== 'notification' ||
+                    value.serviceUuid !== service ||
+                    value.characteristicUuid !== characteristic ||
+                    !Array.isArray(value.data))
+                    return;
+                if (!value.data.every((byte) => Number.isInteger(byte) &&
+                    Number(byte) >= 0 &&
+                    Number(byte) <= 255)) {
+                    return;
+                }
+                listener(new DataView(Uint8Array.from(value.data).buffer));
+            };
+            window.addEventListener('message', onMessage);
+            try {
+                await nativeRequest(connection.connectionId, 'subscribe', { serviceUuid: service, characteristicUuid: characteristic }, options);
+            }
+            catch (error) {
+                window.removeEventListener('message', onMessage);
+                throw error;
+            }
+            let cleanupPromise = null;
+            const cleanup = () => {
+                if (cleanupPromise)
+                    return cleanupPromise;
+                window.removeEventListener('message', onMessage);
+                options?.signal?.removeEventListener('abort', handleAbort);
+                activeSubscriptions.delete(cleanup);
+                cleanupPromise = disconnected
+                    ? Promise.resolve()
+                    : nativeRequest(connection.connectionId, 'unsubscribe', { serviceUuid: service, characteristicUuid: characteristic }, { timeoutMs: options?.timeoutMs }).then(() => undefined);
+                return cleanupPromise;
+            };
+            const handleAbort = () => void cleanup().catch(() => undefined);
+            activeSubscriptions.add(cleanup);
+            options?.signal?.addEventListener('abort', handleAbort, { once: true });
+            if (options?.signal?.aborted)
+                handleAbort();
+            return cleanup;
+        },
+        async disconnect(options) {
+            if (disconnected)
+                return;
+            window.removeEventListener('message', onLifecycleMessage);
+            const subscriptions = [...activeSubscriptions];
+            disconnected = true;
+            await Promise.allSettled(subscriptions.map((cleanup) => cleanup()));
+            try {
+                await nativeRequest(connection.connectionId, 'disconnect', {}, options);
+            }
+            finally {
+                events.dispatchEvent(new Event('gattserverdisconnected'));
+            }
+        },
+    };
+}
+/**
+ * Uses Web Bluetooth first, with a restrictive desktop BLE chooser fallback.
+ * The native branch mirrors physical disconnect and adapter-loss events.
+ */
+export async function requestMoldableBluetoothWithFallback(options, bridgeOptions = {}) {
+    if (isMoldableBluetoothSupported()) {
+        return {
+            kind: 'web-bluetooth',
+            device: await requestMoldableBluetoothDevice(options, bridgeOptions),
+        };
+    }
+    if (!('filters' in options) || !options.filters?.length) {
+        throw new TypeError('The native Bluetooth fallback does not allow acceptAllDevices.');
+    }
+    const filters = options.filters.map((filter) => {
+        if (filter.manufacturerData?.length || filter.serviceData?.length) {
+            throw new TypeError('The native Bluetooth fallback does not support data filters yet.');
+        }
+        return {
+            name: filter.name,
+            namePrefix: filter.namePrefix,
+            services: filter.services?.map(uuid),
+        };
+    });
+    const result = await callNativeHardwareBridge({
+        type: REQUEST_TYPE,
+        action: 'requestDevice',
+        filters,
+        optionalServices: options.optionalServices?.map(uuid) ?? [],
+    }, RESULT_TYPE, { timeoutMs: 120_000, ...bridgeOptions });
+    if (!isNativeConnectionResult(result)) {
+        throw new TypeError('The desktop returned an invalid Bluetooth device.');
+    }
+    return { kind: 'desktop-bridge', device: nativeDevice(result) };
+}

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

@@ -0,0 +1,85 @@
+/** Local structural Web Bluetooth types for runtimes whose DOM library omits them. */
+export type MoldableBluetoothUUID = string | number;
+export interface MoldableBluetoothDataFilter {
+    dataPrefix?: BufferSource;
+    mask?: BufferSource;
+}
+export interface MoldableBluetoothManufacturerDataFilter extends MoldableBluetoothDataFilter {
+    companyIdentifier: number;
+}
+export interface MoldableBluetoothServiceDataFilter extends MoldableBluetoothDataFilter {
+    service: MoldableBluetoothUUID;
+}
+export interface MoldableBluetoothLEScanFilter {
+    name?: string;
+    namePrefix?: string;
+    services?: MoldableBluetoothUUID[];
+    manufacturerData?: MoldableBluetoothManufacturerDataFilter[];
+    serviceData?: MoldableBluetoothServiceDataFilter[];
+}
+export type MoldableBluetoothRequestDeviceOptions = {
+    filters: MoldableBluetoothLEScanFilter[];
+    acceptAllDevices?: false;
+    optionalServices?: MoldableBluetoothUUID[];
+    optionalManufacturerData?: number[];
+} | {
+    filters?: never;
+    acceptAllDevices: true;
+    optionalServices?: MoldableBluetoothUUID[];
+    optionalManufacturerData?: number[];
+};
+export interface MoldableBluetoothRemoteGATTCharacteristic extends EventTarget {
+    readonly service: MoldableBluetoothRemoteGATTService;
+    readonly uuid: string;
+    readonly value?: DataView;
+    startNotifications(): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+    stopNotifications(): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+    readValue(): Promise<DataView>;
+    writeValue(value: BufferSource): Promise<void>;
+    writeValueWithResponse?(value: BufferSource): Promise<void>;
+    writeValueWithoutResponse?(value: BufferSource): Promise<void>;
+}
+export interface MoldableBluetoothRemoteGATTService {
+    readonly device: MoldableBluetoothDevice;
+    readonly isPrimary: boolean;
+    readonly uuid: string;
+    getCharacteristic(characteristic: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+    getCharacteristics(characteristic?: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTCharacteristic[]>;
+}
+export interface MoldableBluetoothRemoteGATTServer {
+    readonly connected: boolean;
+    readonly device: MoldableBluetoothDevice;
+    connect(): Promise<MoldableBluetoothRemoteGATTServer>;
+    disconnect(): void;
+    getPrimaryService(service: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTService>;
+    getPrimaryServices(service?: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTService[]>;
+}
+export interface MoldableBluetoothDeviceEventMap {
+    gattserverdisconnected: Event;
+}
+export interface MoldableBluetoothDevice extends EventTarget {
+    readonly id: string;
+    readonly name?: string;
+    readonly gatt?: MoldableBluetoothRemoteGATTServer;
+    addEventListener<K extends keyof MoldableBluetoothDeviceEventMap>(type: K, listener: (event: MoldableBluetoothDeviceEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MoldableBluetoothDeviceEventMap>(type: K, listener: (event: MoldableBluetoothDeviceEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+}
+export interface MoldableBluetoothAPI {
+    getAvailability?(): Promise<boolean>;
+    requestDevice(options: MoldableBluetoothRequestDeviceOptions): Promise<MoldableBluetoothDevice>;
+}
+export interface MoldableBluetoothNavigator extends Navigator {
+    bluetooth?: MoldableBluetoothAPI;
+}
+export type MoldableBluetoothAvailability = 'available' | 'unavailable' | 'unknown';
+export interface MoldableBluetoothRequestOptions {
+    signal?: AbortSignal;
+}
+export interface MoldableBluetoothConnectionOptions {
+    signal?: AbortSignal;
+}
+export interface MoldableBluetoothOperationOptions {
+    signal?: AbortSignal;
+}
+export type MoldableBluetoothWriteMode = 'with-response' | 'without-response' | 'automatic';
+//# sourceMappingURL=bluetooth-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-types.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+/** Local structural Web Bluetooth types for runtimes whose DOM library omits them. */
+export {};

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

@@ -0,0 +1,7 @@
+export { getMoldableBluetoothAvailability, isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+export { connectMoldableBluetoothDevice, MoldableBluetoothConnection, } from './bluetooth-connection';
+export { getMoldableBluetoothCharacteristic, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, writeMoldableBluetoothValue, } from './bluetooth-gatt';
+export type * from './bluetooth-types';
+export { requestMoldableBluetoothWithFallback } from './bluetooth-native-fallback';
+export type { MoldableBluetoothTransport, MoldableNativeBluetoothDevice, MoldableNativeBluetoothService, } from './bluetooth-native-fallback';
+//# sourceMappingURL=bluetooth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gCAAgC,EAChC,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,kCAAkC,EAClC,qCAAqC,EACrC,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,kBAAkB,CAAA;AACzB,mBAAmB,mBAAmB,CAAA;AACtC,OAAO,EAAE,oCAAoC,EAAE,MAAM,6BAA6B,CAAA;AAClF,YAAY,EACV,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,6BAA6B,CAAA"}