@moldable-ai/ui 0.2.17 → 0.2.19

package/dist/lib/native-hardware/global-shortcuts.js

@@ -0,0 +1,351 @@
+import { NativeHardwareBridgeError, callNativeHardwareBridge, } from './bridge';
+export const NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE = 'moldable:native-global-shortcuts';
+export const NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE = 'moldable:native-global-shortcuts-result';
+export const NATIVE_GLOBAL_SHORTCUT_EVENT_TYPE = 'moldable:native-global-shortcut-event';
+export const NATIVE_GLOBAL_SHORTCUT_MAX_LENGTH = 128;
+export const NATIVE_GLOBAL_SHORTCUT_MAX_PER_APP = 32;
+const MODIFIERS = new Set([
+    'alt',
+    'altgr',
+    'capslock',
+    'cmd',
+    'cmdorctrl',
+    'command',
+    'commandorcontrol',
+    'control',
+    'ctrl',
+    'fn',
+    'fnlock',
+    'hyper',
+    'meta',
+    'numlock',
+    'option',
+    'scrolllock',
+    'shift',
+    'super',
+    'symbol',
+    'symbollock',
+]);
+const handlers = new Map();
+const pendingEvents = new Map();
+const MAX_PENDING_REGISTRATIONS = 64;
+let listeningWindow = null;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function isMoldableGlobalShortcut(value) {
+    if (typeof value !== 'string' || value !== value.trim())
+        return false;
+    if (value.length < 3 || value.length > NATIVE_GLOBAL_SHORTCUT_MAX_LENGTH) {
+        return false;
+    }
+    if (/\s/u.test(value) ||
+        [...value].some((character) => {
+            const code = character.charCodeAt(0);
+            return code <= 31 || code === 127;
+        })) {
+        return false;
+    }
+    const parts = value.split('+');
+    if (parts.length < 2 || parts.length > 8)
+        return false;
+    if (parts.some((part) => !/^[A-Za-z0-9]{1,32}$/u.test(part)))
+        return false;
+    const normalized = parts.map((part) => part.toLowerCase());
+    if (new Set(normalized).size !== normalized.length)
+        return false;
+    if (!normalized.slice(0, -1).every((part) => MODIFIERS.has(part))) {
+        return false;
+    }
+    return !MODIFIERS.has(normalized[normalized.length - 1] ?? '');
+}
+function isGlobalShortcutEvent(value) {
+    return (isRecord(value) &&
+        value.type === NATIVE_GLOBAL_SHORTCUT_EVENT_TYPE &&
+        typeof value.registrationId === 'string' &&
+        value.registrationId.length > 0 &&
+        isMoldableGlobalShortcut(value.shortcut) &&
+        (value.state === 'Pressed' || value.state === 'Released'));
+}
+function handleShortcutMessage(event) {
+    if (event.source !== window.parent || !isGlobalShortcutEvent(event.data)) {
+        return;
+    }
+    const handler = handlers.get(event.data.registrationId);
+    if (handler) {
+        try {
+            handler({
+                registrationId: event.data.registrationId,
+                shortcut: event.data.shortcut,
+                state: event.data.state,
+            });
+        }
+        catch {
+            // One app callback must not break delivery for other registrations.
+        }
+        return;
+    }
+    if (!pendingEvents.has(event.data.registrationId) &&
+        pendingEvents.size >= MAX_PENDING_REGISTRATIONS) {
+        return;
+    }
+    const queued = pendingEvents.get(event.data.registrationId) ?? [];
+    if (queued.length < 4)
+        queued.push(event.data);
+    pendingEvents.set(event.data.registrationId, queued);
+}
+function ensureGlobalShortcutListener() {
+    if (typeof window === 'undefined' || listeningWindow === window)
+        return;
+    if (listeningWindow) {
+        listeningWindow.removeEventListener('message', handleShortcutMessage);
+    }
+    window.addEventListener('message', handleShortcutMessage);
+    listeningWindow = window;
+}
+function bindHandler(registrationId, handler) {
+    handlers.set(registrationId, handler);
+    const queued = pendingEvents.get(registrationId) ?? [];
+    pendingEvents.delete(registrationId);
+    for (const event of queued) {
+        try {
+            handler({
+                registrationId: event.registrationId,
+                shortcut: event.shortcut,
+                state: event.state,
+            });
+        }
+        catch {
+            // Callback errors do not change a successfully created registration.
+        }
+    }
+}
+function invalidShortcutError() {
+    return new NativeHardwareBridgeError({
+        code: 'invalid_request',
+        message: 'A global shortcut must contain modifiers and one key, for example CommandOrControl+Shift+P.',
+        retryable: false,
+    });
+}
+function canonicalShortcut(shortcut) {
+    const aliases = {
+        cmd: 'meta',
+        command: 'meta',
+        cmdorctrl: 'commandorcontrol',
+        ctrl: 'control',
+        option: 'alt',
+    };
+    return shortcut
+        .split('+')
+        .map((part) => aliases[part.toLowerCase()] ?? part.toLowerCase())
+        .join('+');
+}
+function makeRegistrationId() {
+    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+        return `native-shortcut-${crypto.randomUUID()}`;
+    }
+    return `native-shortcut-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function makeRegistration(result) {
+    let active = true;
+    return {
+        registrationId: result.registrationId,
+        shortcut: result.shortcut,
+        async unregister(unregisterOptions = {}) {
+            if (!active)
+                return;
+            await unregisterMoldableGlobalShortcut(result.registrationId, unregisterOptions);
+            active = false;
+        },
+    };
+}
+export async function registerMoldableGlobalShortcut(shortcut, handler, options = {}) {
+    if (!isMoldableGlobalShortcut(shortcut) || typeof handler !== 'function') {
+        throw invalidShortcutError();
+    }
+    ensureGlobalShortcutListener();
+    const registrationId = makeRegistrationId();
+    let result;
+    try {
+        result =
+            await callNativeHardwareBridge({
+                type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+                capability: 'global-shortcuts',
+                action: 'register',
+                registrationId,
+                shortcut,
+            }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+        if (result.registered !== true ||
+            result.registrationId !== registrationId ||
+            result.shortcut !== shortcut) {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid global shortcut registration.',
+                details: result,
+                retryable: false,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof NativeHardwareBridgeError &&
+            (error.code === 'timeout' ||
+                error.code === 'aborted' ||
+                error.code === 'invalid_response')) {
+            void unregisterMoldableGlobalShortcut(registrationId).catch(() => {
+                // App-view teardown remains the final cleanup boundary.
+            });
+        }
+        throw error;
+    }
+    bindHandler(result.registrationId, handler);
+    return makeRegistration(result);
+}
+export async function registerAllMoldableGlobalShortcuts(shortcuts, handler, options = {}) {
+    if (!Array.isArray(shortcuts) ||
+        shortcuts.length === 0 ||
+        shortcuts.length > NATIVE_GLOBAL_SHORTCUT_MAX_PER_APP ||
+        typeof handler !== 'function' ||
+        !shortcuts.every(isMoldableGlobalShortcut) ||
+        new Set(shortcuts.map(canonicalShortcut)).size !== shortcuts.length) {
+        throw invalidShortcutError();
+    }
+    ensureGlobalShortcutListener();
+    const registrations = shortcuts.map((shortcut) => ({
+        registrationId: makeRegistrationId(),
+        shortcut,
+    }));
+    let result;
+    try {
+        result =
+            await callNativeHardwareBridge({
+                type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+                capability: 'global-shortcuts',
+                action: 'registerAll',
+                registrations,
+            }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+        if (result.registered !== true ||
+            !Array.isArray(result.registrations) ||
+            result.registrations.length !== registrations.length ||
+            result.registrations.some((registered, index) => {
+                const requested = registrations[index];
+                return (registered.registered !== true ||
+                    registered.registrationId !== requested?.registrationId ||
+                    registered.shortcut !== requested.shortcut);
+            })) {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned invalid global shortcut registrations.',
+                details: result,
+                retryable: false,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof NativeHardwareBridgeError &&
+            (error.code === 'timeout' ||
+                error.code === 'aborted' ||
+                error.code === 'host_error' ||
+                error.code === 'invalid_response')) {
+            void Promise.allSettled(registrations.map((registration) => unregisterMoldableGlobalShortcut(registration.registrationId)));
+        }
+        throw error;
+    }
+    for (const registration of result.registrations) {
+        bindHandler(registration.registrationId, handler);
+    }
+    return result.registrations.map(makeRegistration);
+}
+export async function isMoldableGlobalShortcutRegistered(shortcut, options = {}) {
+    if (!isMoldableGlobalShortcut(shortcut))
+        throw invalidShortcutError();
+    const result = await callNativeHardwareBridge({
+        type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+        capability: 'global-shortcuts',
+        action: 'isRegistered',
+        shortcut,
+    }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+    if (typeof result.registered !== 'boolean' || result.shortcut !== shortcut) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid global shortcut status.',
+            details: result,
+            retryable: false,
+        });
+    }
+    return result.registered;
+}
+export async function setMoldableGlobalShortcutsSuspended(suspended, options = {}) {
+    if (typeof suspended !== 'boolean') {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_request',
+            message: 'Global shortcut suspension must be a boolean.',
+            retryable: false,
+        });
+    }
+    const result = await callNativeHardwareBridge({
+        type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+        capability: 'global-shortcuts',
+        action: 'setSuspended',
+        suspended,
+    }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+    if (result.suspended !== suspended) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid global shortcut suspension state.',
+            details: result,
+            retryable: false,
+        });
+    }
+}
+export async function areMoldableGlobalShortcutsSuspended(options = {}) {
+    const result = await callNativeHardwareBridge({
+        type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+        capability: 'global-shortcuts',
+        action: 'isSuspended',
+    }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+    if (typeof result.suspended !== 'boolean') {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid global shortcut suspension state.',
+            details: result,
+            retryable: false,
+        });
+    }
+    return result.suspended;
+}
+export async function unregisterMoldableGlobalShortcut(registrationId, options = {}) {
+    if (registrationId.trim().length === 0 || registrationId.length > 128) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_request',
+            message: 'A valid global shortcut registration ID is required.',
+            retryable: false,
+        });
+    }
+    await callNativeHardwareBridge({
+        type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+        capability: 'global-shortcuts',
+        action: 'unregister',
+        registrationId,
+    }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+    handlers.delete(registrationId);
+    pendingEvents.delete(registrationId);
+}
+export async function unregisterAllMoldableGlobalShortcuts(options = {}) {
+    const result = await callNativeHardwareBridge({
+        type: NATIVE_GLOBAL_SHORTCUT_REQUEST_TYPE,
+        capability: 'global-shortcuts',
+        action: 'unregisterAll',
+    }, NATIVE_GLOBAL_SHORTCUT_RESULT_TYPE, options);
+    handlers.clear();
+    pendingEvents.clear();
+    return result;
+}
+/** Test-only reset for module-level event delivery state. */
+export function resetMoldableGlobalShortcutClientForTests() {
+    if (listeningWindow) {
+        listeningWindow.removeEventListener('message', handleShortcutMessage);
+    }
+    listeningWindow = null;
+    handlers.clear();
+    pendingEvents.clear();
+}

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

@@ -0,0 +1,25 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+export declare const NATIVE_HAPTICS_REQUEST_TYPE: "moldable:native-haptics";
+export declare const NATIVE_HAPTICS_RESULT_TYPE: "moldable:native-haptics-result";
+export type MoldableHapticPattern = 'generic' | 'alignment' | 'level-change';
+export interface MoldableHapticAvailability {
+    /** Compatibility alias for apiAvailable. */
+    available: boolean;
+    /** Whether the host can submit feedback requests to the operating system. */
+    apiAvailable: boolean;
+    /** Physical haptic hardware cannot be detected reliably by the macOS API. */
+    hardwareStatus: 'unknown' | 'unavailable';
+    patterns: MoldableHapticPattern[];
+    reason?: string;
+}
+export interface MoldableHapticResult {
+    /** Compatibility alias indicating that the OS accepted the request. */
+    performed: true;
+    accepted: true;
+    /** macOS does not report whether compatible hardware produced feedback. */
+    physicalFeedback: 'unknown';
+    pattern: MoldableHapticPattern;
+}
+export declare function getMoldableHapticAvailability(options?: NativeHardwareBridgeOptions): Promise<MoldableHapticAvailability>;
+export declare function performMoldableHapticFeedback(pattern?: MoldableHapticPattern, options?: NativeHardwareBridgeOptions): Promise<MoldableHapticResult>;
+//# sourceMappingURL=haptics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haptics.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/haptics.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,2BAA2B,EAAG,yBAAkC,CAAA;AAC7E,eAAO,MAAM,0BAA0B,EACrC,gCAAyC,CAAA;AAE3C,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,CAAA;AAE5E,MAAM,WAAW,0BAA0B;IACzC,4CAA4C;IAC5C,SAAS,EAAE,OAAO,CAAA;IAClB,6EAA6E;IAC7E,YAAY,EAAE,OAAO,CAAA;IACrB,6EAA6E;IAC7E,cAAc,EAAE,SAAS,GAAG,aAAa,CAAA;IACzC,QAAQ,EAAE,qBAAqB,EAAE,CAAA;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,uEAAuE;IACvE,SAAS,EAAE,IAAI,CAAA;IACf,QAAQ,EAAE,IAAI,CAAA;IACd,2EAA2E;IAC3E,gBAAgB,EAAE,SAAS,CAAA;IAC3B,OAAO,EAAE,qBAAqB,CAAA;CAC/B;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,0BAA0B,CAAC,CAUrC;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,GAAE,qBAAiC,EAC1C,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oBAAoB,CAAC,CAW/B"}

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

@@ -0,0 +1,18 @@
+import { callNativeHardwareBridge, } from './bridge';
+export const NATIVE_HAPTICS_REQUEST_TYPE = 'moldable:native-haptics';
+export const NATIVE_HAPTICS_RESULT_TYPE = 'moldable:native-haptics-result';
+export function getMoldableHapticAvailability(options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_HAPTICS_REQUEST_TYPE,
+        capability: 'haptics',
+        action: 'getAvailability',
+    }, NATIVE_HAPTICS_RESULT_TYPE, options);
+}
+export function performMoldableHapticFeedback(pattern = 'generic', options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_HAPTICS_REQUEST_TYPE,
+        capability: 'haptics',
+        action: 'perform',
+        pattern,
+    }, NATIVE_HAPTICS_RESULT_TYPE, options);
+}

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

@@ -0,0 +1,26 @@
+import type { MoldableHidDevice, MoldableHidInputReportEvent } from './hid';
+import { type MoldableNativeDeviceDescriptor } from './native-device-io';
+export declare class NativeMoldableHidDevice extends EventTarget implements MoldableHidDevice {
+    readonly descriptor: MoldableNativeDeviceDescriptor;
+    readonly vendorId: number;
+    readonly productId: number;
+    readonly productName: string;
+    private handle?;
+    private closing?;
+    private inputPump?;
+    private readonly lifecycle;
+    constructor(descriptor: MoldableNativeDeviceDescriptor);
+    get opened(): boolean;
+    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>;
+    listen(listener: (event: MoldableHidInputReportEvent) => void, signal?: AbortSignal): () => void;
+    private startInputPump;
+    private readLoop;
+    private execute;
+}
+export declare function isNativeMoldableHidDevice(device: MoldableHidDevice): device is NativeMoldableHidDevice;
+//# sourceMappingURL=hid-native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hid-native.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/hid-native.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,OAAO,CAAA;AAC3E,OAAO,EACL,KAAK,8BAA8B,EAMpC,MAAM,oBAAoB,CAAA;AAM3B,qBAAa,uBACX,SAAQ,WACR,YAAW,iBAAiB;IAUhB,QAAQ,CAAC,UAAU,EAAE,8BAA8B;IAR/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;gBAEnC,UAAU,EAAE,8BAA8B;IAO/D,IAAI,MAAM,IAAI,OAAO,CAEpB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAerB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BtB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB/D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAStE,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAW/D,MAAM,CACJ,QAAQ,EAAE,CAAC,KAAK,EAAE,2BAA2B,KAAK,IAAI,EACtD,MAAM,CAAC,EAAE,WAAW,GACnB,MAAM,IAAI;IAiBb,OAAO,CAAC,cAAc;YASR,QAAQ;YA6DR,OAAO;CA+BtB;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,GACxB,MAAM,IAAI,uBAAuB,CAEnC"}

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,
+        });
+    }
+}