@moldable-ai/ui 0.2.18 → 0.2.20

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

@@ -0,0 +1,105 @@
+import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } from './bridge';
+export function bluetoothError(error, operation) {
+    if (error instanceof NativeCapabilityBridgeError)
+        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 toNativeCapabilityBridgeError({
+        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 toNativeCapabilityBridgeError({
+            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-capabilities/bluetooth-native-fallback.d.ts

@@ -0,0 +1,33 @@
+import type { MoldableBluetoothDevice, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types';
+import { type NativeCapabilityBridgeOptions } 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?: NativeCapabilityBridgeOptions): Promise<MoldableNativeBluetoothService[]>;
+    read(serviceUuid: string, characteristicUuid: string, options?: NativeCapabilityBridgeOptions): Promise<DataView>;
+    write(serviceUuid: string, characteristicUuid: string, data: BufferSource, options?: NativeCapabilityBridgeOptions & {
+        withResponse?: boolean;
+    }): Promise<void>;
+    observe(serviceUuid: string, characteristicUuid: string, listener: (value: DataView) => void, options?: NativeCapabilityBridgeOptions): Promise<() => Promise<void>>;
+    disconnect(options?: NativeCapabilityBridgeOptions): 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?: NativeCapabilityBridgeOptions): Promise<MoldableBluetoothTransport>;
+//# sourceMappingURL=bluetooth-native-fallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-native-fallback.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/bluetooth-native-fallback.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,uBAAuB,EACvB,qCAAqC,EACtC,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,KAAK,6BAA6B,EAEnC,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,6BAA6B,GACtC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAA;IAC5C,IAAI,CACF,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAC1B,OAAO,CAAC,EAAE,6BAA6B,GACtC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACpB,KAAK,CACH,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAC1B,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,6BAA6B,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,GACnE,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,6BAA6B,GACtC,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/B,UAAU,CAAC,OAAO,CAAC,EAAE,6BAA6B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACnE;AA2PD;;;GAGG;AACH,wBAAsB,oCAAoC,CACxD,OAAO,EAAE,qCAAqC,EAC9C,aAAa,GAAE,6BAAkC,GAChD,OAAO,CAAC,0BAA0B,CAAC,CAsCrC"}

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

@@ -0,0 +1,214 @@
+import { isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+import { callNativeCapabilityBridge, } 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 callNativeCapabilityBridge({ 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 callNativeCapabilityBridge({
+        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-capabilities/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-capabilities/bluetooth-types.d.ts.map

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

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

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

package/dist/lib/native-capabilities/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-capabilities/bluetooth.d.ts.map

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

package/dist/lib/native-capabilities/bluetooth.js

@@ -0,0 +1,4 @@
+export { getMoldableBluetoothAvailability, isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+export { connectMoldableBluetoothDevice, MoldableBluetoothConnection, } from './bluetooth-connection';
+export { getMoldableBluetoothCharacteristic, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, writeMoldableBluetoothValue, } from './bluetooth-gatt';
+export { requestMoldableBluetoothWithFallback } from './bluetooth-native-fallback';

package/dist/lib/native-capabilities/bridge.d.ts

@@ -0,0 +1,23 @@
+import { type NativeCapabilityErrorCode, type NativeCapabilityErrorPayload, type NativeCapabilityManifest } from './types';
+export declare const NATIVE_CAPABILITY_CANCEL_REQUEST_TYPE: "moldable:native-capabilities-cancel";
+export interface NativeCapabilityBridgeOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare class NativeCapabilityBridgeError extends Error {
+    readonly code: NativeCapabilityErrorCode;
+    readonly details?: unknown;
+    readonly retryable?: boolean;
+    constructor(error: NativeCapabilityErrorPayload);
+}
+export declare function toNativeCapabilityBridgeError(value: unknown, fallbackMessage?: string): NativeCapabilityBridgeError;
+/** Resolve only desktop-owned parent origins; unknown embedders fail closed. */
+export declare function resolveNativeCapabilityParentOrigin(referrer: string, immediateAncestorOrigin?: string, currentOrigin?: string, allowDevelopmentOrigin?: boolean): string | null;
+export declare function callNativeCapabilityBridge<TResult>(request: {
+    type: string;
+    [key: string]: unknown;
+}, responseType: string, options?: NativeCapabilityBridgeOptions): Promise<TResult>;
+export declare function getNativeCapabilities(options?: NativeCapabilityBridgeOptions): Promise<NativeCapabilityManifest>;
+/** Public app-author API for querying the host's native capability manifest. */
+export declare const getMoldableNativeCapabilities: typeof getNativeCapabilities;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/lib/native-capabilities/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/bridge.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EACjC,KAAK,wBAAwB,EAC9B,MAAM,SAAS,CAAA;AAGhB,eAAO,MAAM,qCAAqC,EAChD,qCAA8C,CAAA;AAchD,MAAM,WAAW,6BAA6B;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAA;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;gBAEhB,KAAK,EAAE,4BAA4B;CAOhD;AAiBD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,EACd,eAAe,SAAsC,GACpD,2BAA2B,CAW7B;AA6FD,gFAAgF;AAChF,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,MAAM,EAChB,uBAAuB,SAAgC,EACvD,aAAa,SAAyB,EACtC,sBAAsB,UAAmC,GACxD,MAAM,GAAG,IAAI,CAoBf;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAChD,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EACjD,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,OAAO,CAAC,CAqIlB;AAED,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,wBAAwB,CAAC,CAiBnC;AAED,gFAAgF;AAChF,eAAO,MAAM,6BAA6B,8BAAwB,CAAA"}