@moldable-ai/ui 0.2.18 → 0.2.19

package/dist/lib/native-hardware/hid-native.js

@@ -0,0 +1,229 @@
+import { NativeHardwareBridgeError } from './bridge';
+import { bytesFromNativeDeviceResult, bytesWrittenFromNativeDeviceResult, closeMoldableNativeDevice, executeMoldableNativeDeviceOperation, openMoldableNativeDevice, } from './native-device-io';
+import { NativeDeviceLifecycle, isNativeDeviceDisconnect, } from './native-device-lifecycle';
+export class NativeMoldableHidDevice extends EventTarget {
+    descriptor;
+    vendorId;
+    productId;
+    productName;
+    handle;
+    closing;
+    inputPump;
+    lifecycle = new NativeDeviceLifecycle();
+    constructor(descriptor) {
+        super();
+        this.descriptor = descriptor;
+        this.vendorId = descriptor.vendorId ?? 0;
+        this.productId = descriptor.productId ?? 0;
+        this.productName = descriptor.label;
+    }
+    get opened() {
+        return this.lifecycle.opened;
+    }
+    async open() {
+        if (this.closing)
+            await this.closing;
+        if (this.handle && this.lifecycle.disconnected)
+            await this.close();
+        if (this.opened)
+            return;
+        const result = await openMoldableNativeDevice('hid', this.descriptor.selector, {});
+        if (result.kind !== 'hid')
+            throw new Error('Native device kind mismatch.');
+        this.handle = result.handle;
+        this.lifecycle.didOpen();
+        this.startInputPump();
+    }
+    async close() {
+        if (this.closing)
+            return this.closing;
+        if (!this.handle)
+            return;
+        const handle = this.handle;
+        this.inputPump?.abort();
+        this.inputPump = undefined;
+        const closing = closeMoldableNativeDevice('hid', handle)
+            .then(() => {
+            if (this.handle === handle) {
+                this.handle = undefined;
+                this.lifecycle.didClose();
+            }
+        })
+            .catch((error) => {
+            if (this.handle === handle && !this.lifecycle.disconnected) {
+                this.startInputPump();
+            }
+            throw error;
+        })
+            .finally(() => {
+            if (this.closing === closing)
+                this.closing = undefined;
+        });
+        this.closing = closing;
+        return closing;
+    }
+    async forget() {
+        await this.close();
+    }
+    async sendReport(reportId, data) {
+        assertReportId(reportId);
+        const payload = asBytes(data);
+        const bytes = new Uint8Array(payload.byteLength + 1);
+        bytes[0] = reportId;
+        bytes.set(payload, 1);
+        const result = await this.execute({
+            action: 'write',
+            endpoint: null,
+            data: [...bytes],
+            timeoutMs: 10_000,
+            bulk: false,
+        });
+        if (bytesWrittenFromNativeDeviceResult(result) !== bytes.byteLength) {
+            throw new NativeHardwareBridgeError({
+                code: 'host_error',
+                message: 'The HID device accepted only part of the output report.',
+                retryable: true,
+            });
+        }
+    }
+    async sendFeatureReport(reportId, data) {
+        assertReportId(reportId);
+        await this.execute({
+            action: 'hidSendFeature',
+            reportId,
+            data: [...asBytes(data)],
+        });
+    }
+    async receiveFeatureReport(reportId) {
+        assertReportId(reportId);
+        const result = await this.execute({
+            action: 'hidReceiveFeature',
+            reportId,
+            length: 4096,
+        });
+        const bytes = bytesFromNativeDeviceResult(result);
+        return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    listen(listener, signal) {
+        if (signal?.aborted)
+            return () => undefined;
+        let active = true;
+        const handleReport = (event) => {
+            listener(event);
+        };
+        const stop = () => {
+            if (!active)
+                return;
+            active = false;
+            this.removeEventListener('inputreport', handleReport);
+            signal?.removeEventListener('abort', stop);
+        };
+        this.addEventListener('inputreport', handleReport);
+        signal?.addEventListener('abort', stop, { once: true });
+        return stop;
+    }
+    startInputPump() {
+        if (!this.handle || this.inputPump || this.lifecycle.disconnected)
+            return;
+        const controller = new AbortController();
+        this.inputPump = controller;
+        void this.readLoop(controller.signal).finally(() => {
+            if (this.inputPump === controller)
+                this.inputPump = undefined;
+        });
+    }
+    async readLoop(signal) {
+        while (!signal.aborted && this.handle) {
+            try {
+                const result = await this.execute({
+                    action: 'hidReadInput',
+                    length: 4096,
+                    timeoutMs: 500,
+                }, signal);
+                if (result.kind !== 'hidInput' ||
+                    !Number.isInteger(result.reportId) ||
+                    Number(result.reportId) < 0 ||
+                    Number(result.reportId) > 255) {
+                    throw new NativeHardwareBridgeError({
+                        code: 'invalid_response',
+                        message: 'Moldable returned an invalid HID input report.',
+                        details: result,
+                    });
+                }
+                const bytes = bytesFromNativeDeviceResult({
+                    kind: 'data',
+                    data: result.data,
+                });
+                if (bytes.length === 0)
+                    continue;
+                const event = new Event('inputreport');
+                Object.defineProperties(event, {
+                    device: { value: this },
+                    reportId: { value: Number(result.reportId) },
+                    data: {
+                        value: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+                    },
+                });
+                this.dispatchEvent(event);
+            }
+            catch (error) {
+                if (signal.aborted || !this.handle)
+                    return;
+                if (error instanceof NativeHardwareBridgeError &&
+                    error.code === 'timeout') {
+                    continue;
+                }
+                if (isNativeDeviceDisconnect(error)) {
+                    this.lifecycle.didDisconnect(this, error);
+                }
+                else {
+                    const event = new Event('error');
+                    Object.defineProperty(event, 'error', { value: error });
+                    this.dispatchEvent(event);
+                }
+                return;
+            }
+        }
+    }
+    async execute(operation, signal) {
+        if (!this.handle) {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_request',
+                message: 'HID device is not open.',
+            });
+        }
+        if (this.lifecycle.disconnected) {
+            throw new NativeHardwareBridgeError({
+                code: 'unavailable',
+                message: 'HID device is disconnected.',
+                retryable: true,
+            });
+        }
+        try {
+            return await executeMoldableNativeDeviceOperation('hid', this.handle, operation, { signal });
+        }
+        catch (error) {
+            if (isNativeDeviceDisconnect(error)) {
+                this.lifecycle.didDisconnect(this, error);
+            }
+            throw error;
+        }
+    }
+}
+export function isNativeMoldableHidDevice(device) {
+    return device instanceof NativeMoldableHidDevice;
+}
+function asBytes(data) {
+    return data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function assertReportId(reportId) {
+    if (!Number.isInteger(reportId) || reportId < 0 || reportId > 0xff) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_request',
+            message: 'HID reportId must be an integer between 0 and 255.',
+            retryable: false,
+        });
+    }
+}

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

@@ -0,0 +1,52 @@
+export interface MoldableHidOperationOptions {
+    signal?: AbortSignal;
+}
+export interface MoldableHidDeviceFilter {
+    vendorId?: number;
+    productId?: number;
+    usagePage?: number;
+    usage?: number;
+}
+export interface MoldableHidInputReportEvent extends Event {
+    readonly data: DataView;
+    readonly device: MoldableHidDevice;
+    readonly reportId: number;
+}
+/** Structural subset of the standard HIDDevice interface used by the helpers. */
+export interface MoldableHidDevice extends EventTarget {
+    readonly opened: boolean;
+    readonly vendorId: number;
+    readonly productId: number;
+    readonly productName: string;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    forget?(): Promise<void>;
+    sendReport(reportId: number, data: BufferSource): Promise<void>;
+    sendFeatureReport(reportId: number, data: BufferSource): Promise<void>;
+    receiveFeatureReport(reportId: number): Promise<DataView>;
+}
+export interface MoldableHidRequestOptions extends MoldableHidOperationOptions {
+    filters: readonly MoldableHidDeviceFilter[];
+    exclusionFilters?: readonly MoldableHidDeviceFilter[];
+}
+/** Returns true only when this WebView exposes the WebHID entry point. */
+export declare function isMoldableHidSupported(): boolean;
+/** Lists devices previously authorized through WebHID. */
+export declare function getMoldableHidDevices(): Promise<MoldableHidDevice[]>;
+/**
+ * Shows the browser's HID chooser. Call this directly from a user gesture.
+ * Aborting stops awaiting the result but cannot dismiss every browser chooser.
+ */
+export declare function requestMoldableHidDevices(options: MoldableHidRequestOptions): Promise<MoldableHidDevice[]>;
+export declare function openMoldableHidDevice(device: MoldableHidDevice): Promise<void>;
+export declare function closeMoldableHidDevice(device: MoldableHidDevice): Promise<void>;
+/** Revokes the saved permission when the runtime supports HIDDevice.forget(). */
+export declare function forgetMoldableHidDevice(device: MoldableHidDevice): Promise<void>;
+export declare function sendMoldableHidReport(device: MoldableHidDevice, reportId: number, data: BufferSource, options?: MoldableHidOperationOptions): Promise<void>;
+export declare function sendMoldableHidFeatureReport(device: MoldableHidDevice, reportId: number, data: BufferSource, options?: MoldableHidOperationOptions): Promise<void>;
+export declare function receiveMoldableHidFeatureReport(device: MoldableHidDevice, reportId: number, options?: MoldableHidOperationOptions): Promise<DataView>;
+/** Registers an input-report listener and returns an idempotent cleanup handle. */
+export declare function listenForMoldableHidInputReports(device: MoldableHidDevice, listener: (event: MoldableHidInputReportEvent) => void, options?: {
+    signal?: AbortSignal;
+}): () => void;
+//# sourceMappingURL=hid.d.ts.map

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

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

package/dist/lib/native-hardware/hid.js

@@ -0,0 +1,160 @@
+import { NativeHardwareBridgeError } from './bridge';
+import { awaitDeviceIoWithAbort, deviceIoError, unsupportedDeviceIoError, } from './device-io-errors';
+import { NativeMoldableHidDevice, isNativeMoldableHidDevice, } from './hid-native';
+import { listMoldableNativeDevices } from './native-device-io';
+function assertNativeHidFiltersSupported(filters) {
+    if (filters?.some((filter) => filter.usagePage !== undefined || filter.usage !== undefined)) {
+        throw new NativeHardwareBridgeError({
+            code: 'unsupported',
+            message: 'The native HID fallback cannot match usagePage or usage filters on this platform.',
+            retryable: false,
+        });
+    }
+}
+function hidApi() {
+    const api = typeof navigator === 'undefined'
+        ? undefined
+        : navigator.hid;
+    if (!api)
+        throw unsupportedDeviceIoError('hid');
+    return api;
+}
+/** Returns true only when this WebView exposes the WebHID entry point. */
+export function isMoldableHidSupported() {
+    return (typeof navigator !== 'undefined' && !!navigator.hid);
+}
+/** Lists devices previously authorized through WebHID. */
+export async function getMoldableHidDevices() {
+    if (!isMoldableHidSupported()) {
+        throw unsupportedDeviceIoError('hid');
+    }
+    try {
+        return await hidApi().getDevices();
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'enumerate', error);
+    }
+}
+/**
+ * Shows the browser's HID chooser. Call this directly from a user gesture.
+ * Aborting stops awaiting the result but cannot dismiss every browser chooser.
+ */
+export async function requestMoldableHidDevices(options) {
+    if (!isMoldableHidSupported()) {
+        assertNativeHidFiltersSupported(options.filters);
+        assertNativeHidFiltersSupported(options.exclusionFilters);
+        const descriptors = await listMoldableNativeDevices('hid', {
+            signal: options.signal,
+            filters: options.filters.map(({ vendorId, productId }) => ({
+                vendorId,
+                productId,
+            })),
+            ...(options.exclusionFilters
+                ? {
+                    exclusionFilters: options.exclusionFilters.map(({ vendorId, productId }) => ({ vendorId, productId })),
+                }
+                : {}),
+        });
+        return descriptors
+            .filter((descriptor) => options.filters.length === 0
+            ? true
+            : options.filters.some((filter) => (filter.vendorId === undefined ||
+                filter.vendorId === descriptor.vendorId) &&
+                (filter.productId === undefined ||
+                    filter.productId === descriptor.productId)))
+            .filter((descriptor) => !options.exclusionFilters?.some((filter) => (filter.vendorId === undefined ||
+            filter.vendorId === descriptor.vendorId) &&
+            (filter.productId === undefined ||
+                filter.productId === descriptor.productId)))
+            .map((descriptor) => new NativeMoldableHidDevice(descriptor));
+    }
+    try {
+        return await awaitDeviceIoWithAbort(hidApi().requestDevice({
+            filters: [...options.filters],
+            ...(options.exclusionFilters
+                ? { exclusionFilters: [...options.exclusionFilters] }
+                : {}),
+        }), 'hid', 'request', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'request', error);
+    }
+}
+export async function openMoldableHidDevice(device) {
+    if (device.opened)
+        return;
+    try {
+        await device.open();
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'open', error);
+    }
+}
+export async function closeMoldableHidDevice(device) {
+    if (!device.opened && !isNativeMoldableHidDevice(device))
+        return;
+    try {
+        await device.close();
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'close', error);
+    }
+}
+/** Revokes the saved permission when the runtime supports HIDDevice.forget(). */
+export async function forgetMoldableHidDevice(device) {
+    if (typeof device.forget !== 'function') {
+        throw unsupportedDeviceIoError('hid');
+    }
+    try {
+        await device.forget();
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'close', error);
+    }
+}
+export async function sendMoldableHidReport(device, reportId, data, options = {}) {
+    try {
+        await awaitDeviceIoWithAbort(device.sendReport(reportId, data), 'hid', 'write', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'write', error);
+    }
+}
+export async function sendMoldableHidFeatureReport(device, reportId, data, options = {}) {
+    try {
+        await awaitDeviceIoWithAbort(device.sendFeatureReport(reportId, data), 'hid', 'write', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'write', error);
+    }
+}
+export async function receiveMoldableHidFeatureReport(device, reportId, options = {}) {
+    try {
+        return await awaitDeviceIoWithAbort(device.receiveFeatureReport(reportId), 'hid', 'read', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('hid', 'read', error);
+    }
+}
+/** Registers an input-report listener and returns an idempotent cleanup handle. */
+export function listenForMoldableHidInputReports(device, listener, options = {}) {
+    if (isNativeMoldableHidDevice(device)) {
+        return device.listen(listener, options.signal);
+    }
+    if (options.signal?.aborted)
+        return () => undefined;
+    const handleReport = (event) => {
+        listener(event);
+    };
+    let active = true;
+    const cleanup = () => {
+        if (!active)
+            return;
+        active = false;
+        device.removeEventListener('inputreport', handleReport);
+        options.signal?.removeEventListener('abort', cleanup);
+    };
+    device.addEventListener('inputreport', handleReport);
+    options.signal?.addEventListener('abort', cleanup, { once: true });
+    return cleanup;
+}

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

@@ -0,0 +1,38 @@
+export { NativeHardwareBridgeError, getMoldableNativeCapabilities, toNativeHardwareBridgeError, } from './bridge';
+export type { NativeHardwareBridgeOptions } from './bridge';
+export { getNativeHardwareCapability, isNativeHardwareCapabilityDescriptor, isNativeHardwareCapabilityId, isNativeHardwareCapabilityManifest, supportsNativeHardwareCapability, } from './capabilities';
+export { readMoldableClipboardText, writeMoldableClipboardText, } from './clipboard';
+export { MoldableBluetoothConnection, connectMoldableBluetoothDevice, getMoldableBluetoothAvailability, getMoldableBluetoothCharacteristic, isMoldableBluetoothSupported, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, requestMoldableBluetoothDevice, requestMoldableBluetoothWithFallback, writeMoldableBluetoothValue, } from './bluetooth';
+export type { MoldableBluetoothAPI, MoldableBluetoothAvailability, MoldableBluetoothConnectionOptions, MoldableBluetoothDataFilter, MoldableBluetoothDevice, MoldableBluetoothDeviceEventMap, MoldableBluetoothLEScanFilter, MoldableBluetoothManufacturerDataFilter, MoldableBluetoothNavigator, MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTCharacteristic, MoldableBluetoothRemoteGATTServer, MoldableBluetoothRemoteGATTService, MoldableBluetoothRequestDeviceOptions, MoldableBluetoothRequestOptions, MoldableBluetoothServiceDataFilter, MoldableBluetoothTransport, MoldableBluetoothUUID, MoldableBluetoothWriteMode, MoldableNativeBluetoothDevice, MoldableNativeBluetoothService, } from './bluetooth';
+export { getMoldableDisplays } from './displays';
+export type { GetMoldableDisplaysOptions, MoldableDisplay, MoldableDisplayPosition, MoldableDisplaySize, MoldableDisplaysResult, } from './displays';
+export { areMoldableGlobalShortcutsSuspended, isMoldableGlobalShortcutRegistered, isMoldableGlobalShortcut, registerAllMoldableGlobalShortcuts, registerMoldableGlobalShortcut, setMoldableGlobalShortcutsSuspended, unregisterAllMoldableGlobalShortcuts, unregisterMoldableGlobalShortcut, } from './global-shortcuts';
+export type { MoldableGlobalShortcutEvent, MoldableGlobalShortcutHandler, MoldableGlobalShortcutRegistration, MoldableGlobalShortcutState, } from './global-shortcuts';
+export { getMoldableHapticAvailability, performMoldableHapticFeedback, } from './haptics';
+export type { MoldableHapticAvailability, MoldableHapticPattern, MoldableHapticResult, } from './haptics';
+export { closeMoldableHidDevice, forgetMoldableHidDevice, getMoldableHidDevices, isMoldableHidSupported, listenForMoldableHidInputReports, openMoldableHidDevice, receiveMoldableHidFeatureReport, requestMoldableHidDevices, sendMoldableHidFeatureReport, sendMoldableHidReport, } from './hid';
+export type { MoldableHidDevice, MoldableHidDeviceFilter, MoldableHidInputReportEvent, MoldableHidOperationOptions, MoldableHidRequestOptions, } from './hid';
+export { MOLDABLE_LOCATION_MAX_CACHE_AGE_MS, MOLDABLE_LOCATION_MAX_TIMEOUT_MS, MOLDABLE_LOCATION_MIN_TIMEOUT_MS, getMoldableCurrentPosition, getMoldableLocationAuthorizationStatus, } from './location';
+export type { MoldableLocationAuthorization, MoldableLocationAuthorizationState, MoldableLocationCoordinates, MoldableLocationOptions, MoldableLocationResult, } from './location';
+export { LOCAL_AUTHENTICATION_MAX_REASON_BYTES, authenticateMoldableLocalUser, getMoldableLocalAuthenticationAvailability, } from './local-authentication';
+export type { MoldableLocalAuthenticationAvailability, MoldableLocalAuthenticationMethod, MoldableLocalAuthenticationOptions, MoldableLocalAuthenticationOutcome, MoldableLocalAuthenticationPolicy, MoldableLocalAuthenticationResult, } from './local-authentication';
+export { enumerateMoldableMediaDevices, getMoldableCameraStream, getMoldableDisplayStream, getMoldableMicrophoneStream, stopMoldableMediaStream, } from './media';
+export { NATIVE_SYSTEM_AUDIO_MAX_REPLAY_FRAMES, NATIVE_SYSTEM_AUDIO_PERMISSION_REQUEST_TIMEOUT_MS, getMoldableSystemAudioCapabilities, getMoldableSystemAudioStatus, replayMoldableSystemAudioFrames, requestMoldableSystemAudioPermission, startMoldableSystemAudioCapture, stopMoldableSystemAudioCapture, subscribeMoldableSystemAudioEvents, } from './system-audio';
+export type { MoldableSystemAudioCapabilities, MoldableSystemAudioCapabilityResult, MoldableSystemAudioCaptureMode, MoldableSystemAudioEvent, MoldableSystemAudioEventListener, MoldableSystemAudioReplayOptions, MoldableSystemAudioSource, MoldableSystemAudioSourceState, MoldableSystemAudioStartOptions, MoldableSystemAudioStartResult, MoldableSystemAudioStatus, MoldableSystemAudioStopOptions, SubscribeMoldableSystemAudioEventsOptions, UnsubscribeMoldableSystemAudioEvents, } from './system-audio';
+export { NATIVE_MEDIA_PERMISSION_REQUEST_TIMEOUT_MS, getMoldableMediaPermissionDiagnostics, getMoldableMediaPermissionStatus, requestMoldableMediaPermission, } from './media-permissions';
+export type { MoldableMediaPermission, MoldableMediaPermissionDiagnostics, MoldableMediaPermissionState, MoldableMediaPermissionStatus, } from './media-permissions';
+export { getMoldableMIDIInputs, getMoldableMIDIOutputs, isMoldableMIDISupported, observeMoldableMIDIState, openMoldableMIDIInput, openMoldableMIDIOutput, requestMoldableMIDIAccess, requestMoldableMIDIWithFallback, } from './midi';
+export type { MoldableMIDIAccessOptions, MoldableMIDIConnectionOptions, MoldableMIDIInputConnection, MoldableMIDIOutputConnection, MoldableMIDITransport, MoldableNativeMIDIAccess, MoldableNativeMIDIPort, } from './midi';
+export { NATIVE_NOTIFICATION_MAX_BODY_LENGTH, NATIVE_NOTIFICATION_MAX_TAG_LENGTH, NATIVE_NOTIFICATION_MAX_TITLE_LENGTH, getMoldableNotificationPermission, requestMoldableNotificationPermission, sendMoldableNotification, } from './notifications';
+export type { MoldableNotificationOptions, MoldableNotificationPermission, MoldableNotificationPermissionResult, MoldableNotificationSendResult, } from './notifications';
+export { getMoldableCurrentThermalState, getMoldablePowerState, getMoldableSystemIdleState, getMoldableSystemIdleTime, isMoldableSleepBlockerStarted, isMoldablePowerSessionEvent, startMoldableSleepBlocker, stopMoldableSleepBlocker, watchMoldablePowerSession, } from './power-session';
+export type { MoldableBatteryState, MoldableBatteryStatus, MoldablePowerSessionEvent, MoldablePowerSource, MoldablePowerState, MoldableSleepBlocker, MoldableSleepBlockerType, MoldableSystemIdleResult, MoldableSystemIdleState, MoldableThermalState, StopWatchingMoldablePowerSession, WatchMoldablePowerSessionOptions, } from './power-session';
+export { SECURE_STORAGE_MAX_KEY_LENGTH, SECURE_STORAGE_MAX_VALUE_BYTES, deleteMoldableSecureValue, getMoldableSecureStorageDiagnostics, getMoldableSecureValue, listMoldableSecureValues, setMoldableSecureValue, } from './secure-storage';
+export type { MoldableSecureStorageDeleteResult, MoldableSecureStorageBackend, MoldableSecureStorageDiagnostics, MoldableSecureStorageEntryMetadata, MoldableSecureStorageListResult, MoldableSecureStorageSetResult, MoldableSecureStorageValueResult, } from './secure-storage';
+export { closeMoldableSerialPort, forgetMoldableSerialPort, getMoldableSerialPorts, getMoldableSerialSignals, isMoldableSerialSupported, openMoldableSerialPort, readMoldableSerialPort, requestMoldableSerialPort, setMoldableSerialSignals, writeMoldableSerialPort, } from './serial';
+export type { MoldableBluetoothServiceUuid, MoldableSerialInputSignals, MoldableSerialOpenOptions, MoldableSerialOperationOptions, MoldableSerialOutputSignals, MoldableSerialPort, MoldableSerialPortFilter, MoldableSerialPortInfo, MoldableSerialRequestOptions, } from './serial';
+export { NATIVE_HARDWARE_CAPABILITY_IDS, NATIVE_HARDWARE_MANIFEST_SCHEMA_VERSION, } from './types';
+export type { NativeHardwareCapabilityDescriptor, NativeHardwareCapabilityId, NativeHardwareCapabilityManifest, NativeHardwareErrorCode, NativeHardwareErrorPayload, NativeHardwarePermissionAuthority, NativeHardwarePermissionMetadata, NativeHardwarePermissionName, NativeHardwarePermissionRequest, NativeHardwarePlatform, NativeHardwareSupport, NativeHardwareTransportKind, NativeHardwareTransportMetadata, } from './types';
+export { clearMoldableUsbHalt, closeMoldableUsbDevice, forgetMoldableUsbDevice, getMoldableUsbDevices, isMoldableUsbSupported, openMoldableUsbDevice, readMoldableUsbControlTransfer, readMoldableUsbEndpoint, requestMoldableUsbDevice, resetMoldableUsbDevice, writeMoldableUsbControlTransfer, writeMoldableUsbEndpoint, } from './usb';
+export type { MoldableUsbConfiguration, MoldableUsbControlTransferParameters, MoldableUsbDevice, MoldableUsbDeviceFilter, MoldableUsbInTransferResult, MoldableUsbOpenOptions, MoldableUsbOperationOptions, MoldableUsbOutTransferResult, MoldableUsbRequestOptions, } from './usb';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAA;AAE3D,OAAO,EACL,2BAA2B,EAC3B,oCAAoC,EACpC,4BAA4B,EAC5B,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,gCAAgC,EAChC,kCAAkC,EAClC,4BAA4B,EAC5B,qCAAqC,EACrC,0BAA0B,EAC1B,8BAA8B,EAC9B,oCAAoC,EACpC,2BAA2B,GAC5B,MAAM,aAAa,CAAA;AACpB,YAAY,EACV,oBAAoB,EACpB,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,EAC3B,uBAAuB,EACvB,+BAA+B,EAC/B,6BAA6B,EAC7B,uCAAuC,EACvC,0BAA0B,EAC1B,iCAAiC,EACjC,yCAAyC,EACzC,iCAAiC,EACjC,kCAAkC,EAClC,qCAAqC,EACrC,+BAA+B,EAC/B,kCAAkC,EAClC,0BAA0B,EAC1B,qBAAqB,EACrB,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChD,YAAY,EACV,0BAA0B,EAC1B,eAAe,EACf,uBAAuB,EACvB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,mCAAmC,EACnC,kCAAkC,EAClC,wBAAwB,EACxB,kCAAkC,EAClC,8BAA8B,EAC9B,mCAAmC,EACnC,oCAAoC,EACpC,gCAAgC,GACjC,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EACV,2BAA2B,EAC3B,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,GAC5B,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,0BAA0B,EAC1B,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,gCAAgC,EAChC,qBAAqB,EACrB,+BAA+B,EAC/B,yBAAyB,EACzB,4BAA4B,EAC5B,qBAAqB,GACtB,MAAM,OAAO,CAAA;AACd,YAAY,EACV,iBAAiB,EACjB,uBAAuB,EACvB,2BAA2B,EAC3B,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,OAAO,CAAA;AAEd,OAAO,EACL,kCAAkC,EAClC,gCAAgC,EAChC,gCAAgC,EAChC,0BAA0B,EAC1B,sCAAsC,GACvC,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,EAC3B,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,qCAAqC,EACrC,6BAA6B,EAC7B,0CAA0C,GAC3C,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACV,uCAAuC,EACvC,iCAAiC,EACjC,kCAAkC,EAClC,kCAAkC,EAClC,iCAAiC,EACjC,iCAAiC,GAClC,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,qCAAqC,EACrC,iDAAiD,EACjD,kCAAkC,EAClC,4BAA4B,EAC5B,+BAA+B,EAC/B,oCAAoC,EACpC,+BAA+B,EAC/B,8BAA8B,EAC9B,kCAAkC,GACnC,MAAM,gBAAgB,CAAA;AACvB,YAAY,EACV,+BAA+B,EAC/B,mCAAmC,EACnC,8BAA8B,EAC9B,wBAAwB,EACxB,gCAAgC,EAChC,gCAAgC,EAChC,yBAAyB,EACzB,8BAA8B,EAC9B,+BAA+B,EAC/B,8BAA8B,EAC9B,yBAAyB,EACzB,8BAA8B,EAC9B,yCAAyC,EACzC,oCAAoC,GACrC,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,0CAA0C,EAC1C,qCAAqC,EACrC,gCAAgC,EAChC,8BAA8B,GAC/B,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EACV,uBAAuB,EACvB,kCAAkC,EAClC,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,EACzB,+BAA+B,GAChC,MAAM,QAAQ,CAAA;AACf,YAAY,EACV,yBAAyB,EACzB,6BAA6B,EAC7B,2BAA2B,EAC3B,4BAA4B,EAC5B,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,QAAQ,CAAA;AAEf,OAAO,EACL,mCAAmC,EACnC,kCAAkC,EAClC,oCAAoC,EACpC,iCAAiC,EACjC,qCAAqC,EACrC,wBAAwB,GACzB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,2BAA2B,EAC3B,8BAA8B,EAC9B,oCAAoC,EACpC,8BAA8B,GAC/B,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,EACrB,0BAA0B,EAC1B,yBAAyB,EACzB,6BAA6B,EAC7B,2BAA2B,EAC3B,yBAAyB,EACzB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,EAC9B,yBAAyB,EACzB,mCAAmC,EACnC,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EACV,iCAAiC,EACjC,4BAA4B,EAC5B,gCAAgC,EAChC,kCAAkC,EAClC,+BAA+B,EAC/B,8BAA8B,EAC9B,gCAAgC,GACjC,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,UAAU,CAAA;AACjB,YAAY,EACV,4BAA4B,EAC5B,0BAA0B,EAC1B,yBAAyB,EACzB,8BAA8B,EAC9B,2BAA2B,EAC3B,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,UAAU,CAAA;AAEjB,OAAO,EACL,8BAA8B,EAC9B,uCAAuC,GACxC,MAAM,SAAS,CAAA;AAChB,YAAY,EACV,kCAAkC,EAClC,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,0BAA0B,EAC1B,iCAAiC,EACjC,gCAAgC,EAChC,4BAA4B,EAC5B,+BAA+B,EAC/B,sBAAsB,EACtB,qBAAqB,EACrB,2BAA2B,EAC3B,+BAA+B,GAChC,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,8BAA8B,EAC9B,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,+BAA+B,EAC/B,wBAAwB,GACzB,MAAM,OAAO,CAAA;AACd,YAAY,EACV,wBAAwB,EACxB,oCAAoC,EACpC,iBAAiB,EACjB,uBAAuB,EACvB,2BAA2B,EAC3B,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,GAC1B,MAAM,OAAO,CAAA"}

package/dist/lib/native-hardware/index.js

@@ -0,0 +1,20 @@
+export { NativeHardwareBridgeError, getMoldableNativeCapabilities, toNativeHardwareBridgeError, } from './bridge';
+export { getNativeHardwareCapability, isNativeHardwareCapabilityDescriptor, isNativeHardwareCapabilityId, isNativeHardwareCapabilityManifest, supportsNativeHardwareCapability, } from './capabilities';
+export { readMoldableClipboardText, writeMoldableClipboardText, } from './clipboard';
+export { MoldableBluetoothConnection, connectMoldableBluetoothDevice, getMoldableBluetoothAvailability, getMoldableBluetoothCharacteristic, isMoldableBluetoothSupported, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, requestMoldableBluetoothDevice, requestMoldableBluetoothWithFallback, writeMoldableBluetoothValue, } from './bluetooth';
+export { getMoldableDisplays } from './displays';
+export { areMoldableGlobalShortcutsSuspended, isMoldableGlobalShortcutRegistered, isMoldableGlobalShortcut, registerAllMoldableGlobalShortcuts, registerMoldableGlobalShortcut, setMoldableGlobalShortcutsSuspended, unregisterAllMoldableGlobalShortcuts, unregisterMoldableGlobalShortcut, } from './global-shortcuts';
+export { getMoldableHapticAvailability, performMoldableHapticFeedback, } from './haptics';
+export { closeMoldableHidDevice, forgetMoldableHidDevice, getMoldableHidDevices, isMoldableHidSupported, listenForMoldableHidInputReports, openMoldableHidDevice, receiveMoldableHidFeatureReport, requestMoldableHidDevices, sendMoldableHidFeatureReport, sendMoldableHidReport, } from './hid';
+export { MOLDABLE_LOCATION_MAX_CACHE_AGE_MS, MOLDABLE_LOCATION_MAX_TIMEOUT_MS, MOLDABLE_LOCATION_MIN_TIMEOUT_MS, getMoldableCurrentPosition, getMoldableLocationAuthorizationStatus, } from './location';
+export { LOCAL_AUTHENTICATION_MAX_REASON_BYTES, authenticateMoldableLocalUser, getMoldableLocalAuthenticationAvailability, } from './local-authentication';
+export { enumerateMoldableMediaDevices, getMoldableCameraStream, getMoldableDisplayStream, getMoldableMicrophoneStream, stopMoldableMediaStream, } from './media';
+export { NATIVE_SYSTEM_AUDIO_MAX_REPLAY_FRAMES, NATIVE_SYSTEM_AUDIO_PERMISSION_REQUEST_TIMEOUT_MS, getMoldableSystemAudioCapabilities, getMoldableSystemAudioStatus, replayMoldableSystemAudioFrames, requestMoldableSystemAudioPermission, startMoldableSystemAudioCapture, stopMoldableSystemAudioCapture, subscribeMoldableSystemAudioEvents, } from './system-audio';
+export { NATIVE_MEDIA_PERMISSION_REQUEST_TIMEOUT_MS, getMoldableMediaPermissionDiagnostics, getMoldableMediaPermissionStatus, requestMoldableMediaPermission, } from './media-permissions';
+export { getMoldableMIDIInputs, getMoldableMIDIOutputs, isMoldableMIDISupported, observeMoldableMIDIState, openMoldableMIDIInput, openMoldableMIDIOutput, requestMoldableMIDIAccess, requestMoldableMIDIWithFallback, } from './midi';
+export { NATIVE_NOTIFICATION_MAX_BODY_LENGTH, NATIVE_NOTIFICATION_MAX_TAG_LENGTH, NATIVE_NOTIFICATION_MAX_TITLE_LENGTH, getMoldableNotificationPermission, requestMoldableNotificationPermission, sendMoldableNotification, } from './notifications';
+export { getMoldableCurrentThermalState, getMoldablePowerState, getMoldableSystemIdleState, getMoldableSystemIdleTime, isMoldableSleepBlockerStarted, isMoldablePowerSessionEvent, startMoldableSleepBlocker, stopMoldableSleepBlocker, watchMoldablePowerSession, } from './power-session';
+export { SECURE_STORAGE_MAX_KEY_LENGTH, SECURE_STORAGE_MAX_VALUE_BYTES, deleteMoldableSecureValue, getMoldableSecureStorageDiagnostics, getMoldableSecureValue, listMoldableSecureValues, setMoldableSecureValue, } from './secure-storage';
+export { closeMoldableSerialPort, forgetMoldableSerialPort, getMoldableSerialPorts, getMoldableSerialSignals, isMoldableSerialSupported, openMoldableSerialPort, readMoldableSerialPort, requestMoldableSerialPort, setMoldableSerialSignals, writeMoldableSerialPort, } from './serial';
+export { NATIVE_HARDWARE_CAPABILITY_IDS, NATIVE_HARDWARE_MANIFEST_SCHEMA_VERSION, } from './types';
+export { clearMoldableUsbHalt, closeMoldableUsbDevice, forgetMoldableUsbDevice, getMoldableUsbDevices, isMoldableUsbSupported, openMoldableUsbDevice, readMoldableUsbControlTransfer, readMoldableUsbEndpoint, requestMoldableUsbDevice, resetMoldableUsbDevice, writeMoldableUsbControlTransfer, writeMoldableUsbEndpoint, } from './usb';

package/dist/lib/native-hardware/local-authentication.d.ts

@@ -0,0 +1,32 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+export declare const NATIVE_LOCAL_AUTHENTICATION_REQUEST_TYPE: "moldable:native-local-authentication";
+export declare const NATIVE_LOCAL_AUTHENTICATION_RESULT_TYPE: "moldable:native-local-authentication-result";
+export declare const LOCAL_AUTHENTICATION_MAX_REASON_BYTES = 160;
+export declare const LOCAL_AUTHENTICATION_TIMEOUT_MS = 125000;
+export type MoldableLocalAuthenticationMethod = 'biometric' | 'device-owner' | 'device-credential' | 'unknown';
+export type MoldableLocalAuthenticationPolicy = 'biometric-only' | 'device-owner';
+export interface MoldableLocalAuthenticationOptions extends NativeHardwareBridgeOptions {
+    /** Defaults to device-owner for compatibility with earlier releases. */
+    policy?: MoldableLocalAuthenticationPolicy;
+}
+export type MoldableLocalAuthenticationOutcome = 'authenticated' | 'cancelled' | 'failed' | 'locked-out' | 'unavailable';
+export interface MoldableLocalAuthenticationAvailability {
+    available: boolean;
+    method: MoldableLocalAuthenticationMethod;
+    reason?: string;
+}
+export interface MoldableLocalAuthenticationResult {
+    outcome: MoldableLocalAuthenticationOutcome;
+    method: MoldableLocalAuthenticationMethod;
+    message?: string;
+    retryable: boolean;
+}
+export declare function getMoldableLocalAuthenticationAvailability(options?: NativeHardwareBridgeOptions): Promise<MoldableLocalAuthenticationAvailability>;
+/**
+ * Ask the operating system to verify the current device user.
+ *
+ * Authentication failures and user cancellation are returned as reasoned
+ * outcomes. Bridge failures still reject with NativeHardwareBridgeError.
+ */
+export declare function authenticateMoldableLocalUser(reason: string, options?: MoldableLocalAuthenticationOptions): Promise<MoldableLocalAuthenticationResult>;
+//# sourceMappingURL=local-authentication.d.ts.map

package/dist/lib/native-hardware/local-authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-authentication.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/local-authentication.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,wCAAwC,EACnD,sCAA+C,CAAA;AACjD,eAAO,MAAM,uCAAuC,EAClD,6CAAsD,CAAA;AAExD,eAAO,MAAM,qCAAqC,MAAM,CAAA;AACxD,eAAO,MAAM,+BAA+B,SAAU,CAAA;AAEtD,MAAM,MAAM,iCAAiC,GACzC,WAAW,GACX,cAAc,GACd,mBAAmB,GACnB,SAAS,CAAA;AAEb,MAAM,MAAM,iCAAiC,GACzC,gBAAgB,GAChB,cAAc,CAAA;AAElB,MAAM,WAAW,kCACf,SAAQ,2BAA2B;IACnC,wEAAwE;IACxE,MAAM,CAAC,EAAE,iCAAiC,CAAA;CAC3C;AAED,MAAM,MAAM,kCAAkC,GAC1C,eAAe,GACf,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,aAAa,CAAA;AAEjB,MAAM,WAAW,uCAAuC;IACtD,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,iCAAiC,CAAA;IACzC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,EAAE,kCAAkC,CAAA;IAC3C,MAAM,EAAE,iCAAiC,CAAA;IACzC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;CACnB;AASD,wBAAgB,0CAA0C,CACxD,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,uCAAuC,CAAC,CAUlD;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kCAAuC,GAC/C,OAAO,CAAC,iCAAiC,CAAC,CAiC5C"}

package/dist/lib/native-hardware/local-authentication.js

@@ -0,0 +1,46 @@
+import { callNativeHardwareBridge, } from './bridge';
+export const NATIVE_LOCAL_AUTHENTICATION_REQUEST_TYPE = 'moldable:native-local-authentication';
+export const NATIVE_LOCAL_AUTHENTICATION_RESULT_TYPE = 'moldable:native-local-authentication-result';
+export const LOCAL_AUTHENTICATION_MAX_REASON_BYTES = 160;
+export const LOCAL_AUTHENTICATION_TIMEOUT_MS = 125_000;
+function hasControlCharacters(value) {
+    return Array.from(value).some((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+    });
+}
+export function getMoldableLocalAuthenticationAvailability(options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_LOCAL_AUTHENTICATION_REQUEST_TYPE,
+        capability: 'local-authentication',
+        action: 'getAvailability',
+    }, NATIVE_LOCAL_AUTHENTICATION_RESULT_TYPE, options);
+}
+/**
+ * Ask the operating system to verify the current device user.
+ *
+ * Authentication failures and user cancellation are returned as reasoned
+ * outcomes. Bridge failures still reject with NativeHardwareBridgeError.
+ */
+export function authenticateMoldableLocalUser(reason, options = {}) {
+    if (reason.trim().length === 0 ||
+        hasControlCharacters(reason) ||
+        new TextEncoder().encode(reason).byteLength >
+            LOCAL_AUTHENTICATION_MAX_REASON_BYTES) {
+        return Promise.reject(new TypeError(`Authentication reason must contain 1-${LOCAL_AUTHENTICATION_MAX_REASON_BYTES} UTF-8 bytes and no control characters.`));
+    }
+    const { policy = 'device-owner', ...bridgeOptions } = options;
+    if (policy !== 'biometric-only' && policy !== 'device-owner') {
+        return Promise.reject(new TypeError('Invalid local authentication policy.'));
+    }
+    return callNativeHardwareBridge({
+        type: NATIVE_LOCAL_AUTHENTICATION_REQUEST_TYPE,
+        capability: 'local-authentication',
+        action: 'authenticate',
+        reason,
+        policy,
+    }, NATIVE_LOCAL_AUTHENTICATION_RESULT_TYPE, {
+        ...bridgeOptions,
+        timeoutMs: bridgeOptions.timeoutMs ?? LOCAL_AUTHENTICATION_TIMEOUT_MS,
+    });
+}