@moldable-ai/ui 0.2.18 → 0.2.20

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

@@ -0,0 +1,127 @@
+import { callNativeHardwareBridge, } from './bridge';
+import { isMoldableMIDISupported, requestMoldableMIDIAccess, } from './midi-access';
+const REQUEST_TYPE = 'moldable:native-midi';
+const RESULT_TYPE = 'moldable:native-midi-result';
+const EVENT_TYPE = 'moldable:native-midi-event';
+const MAX_MESSAGE_BYTES = 16_384;
+function isNativeProbeResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.available === true &&
+        Object.keys(value).length === 1);
+}
+function isNativePortResult(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const port = value;
+    return (typeof port.handleId === 'string' &&
+        port.handleId.length > 0 &&
+        (port.kind === 'input' || port.kind === 'output') &&
+        typeof port.name === 'string');
+}
+function bytes(value) {
+    const result = Array.from(value);
+    if (result.length === 0 ||
+        result.length > MAX_MESSAGE_BYTES ||
+        result.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+        throw new TypeError('MIDI data must contain 1 to 16384 bytes.');
+    }
+    return result;
+}
+function nativePort(port, options) {
+    let closed = false;
+    const listeners = new Set();
+    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.handleId !== port.handleId || !Array.isArray(value.data))
+            return;
+        const data = value.data;
+        if (!data.every((byte) => Number.isInteger(byte) && Number(byte) >= 0 && Number(byte) <= 255))
+            return;
+        const timestamp = typeof value.timestamp === 'number' ? value.timestamp : 0;
+        for (const listener of listeners)
+            listener(Uint8Array.from(data), timestamp);
+    };
+    window.addEventListener('message', onMessage);
+    return {
+        id: port.handleId,
+        kind: port.kind,
+        name: port.name,
+        get closed() {
+            return closed;
+        },
+        async send(data) {
+            if (closed)
+                throw new DOMException('The MIDI port is closed.', 'InvalidStateError');
+            if (port.kind !== 'output')
+                throw new DOMException('Cannot send to a MIDI input.', 'InvalidStateError');
+            await callNativeHardwareBridge({
+                type: REQUEST_TYPE,
+                action: 'send',
+                handleId: port.handleId,
+                data: bytes(data),
+            }, RESULT_TYPE, options);
+        },
+        observeMessages(listener) {
+            if (closed)
+                throw new DOMException('The MIDI port is closed.', 'InvalidStateError');
+            if (port.kind !== 'input')
+                throw new DOMException('Only MIDI inputs receive messages.', 'InvalidStateError');
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        async close() {
+            if (closed)
+                return;
+            await callNativeHardwareBridge({ type: REQUEST_TYPE, action: 'close', handleId: port.handleId }, RESULT_TYPE, options);
+            closed = true;
+            listeners.clear();
+            window.removeEventListener('message', onMessage);
+        },
+    };
+}
+/**
+ * Uses Web MIDI when the webview implements it; otherwise returns the scoped
+ * desktop fallback. Native port selection always opens the host-owned chooser.
+ */
+export async function requestMoldableMIDIWithFallback(options = {}) {
+    if (isMoldableMIDISupported()) {
+        return {
+            kind: 'web-midi',
+            access: await requestMoldableMIDIAccess(options),
+        };
+    }
+    const bridgeOptions = { signal: options.signal };
+    const probe = await callNativeHardwareBridge({ type: REQUEST_TYPE, action: 'probe' }, RESULT_TYPE, { timeoutMs: 120_000, ...bridgeOptions });
+    if (!isNativeProbeResult(probe)) {
+        throw new TypeError('The desktop returned an invalid MIDI capability.');
+    }
+    return {
+        kind: 'desktop-bridge',
+        access: {
+            async requestPort(kind) {
+                const result = await callNativeHardwareBridge({
+                    type: REQUEST_TYPE,
+                    action: 'requestPort',
+                    kind,
+                    sysex: options.sysex === true,
+                }, RESULT_TYPE, { timeoutMs: 120_000, ...bridgeOptions });
+                if (!isNativePortResult(result)) {
+                    throw new TypeError('The desktop returned an invalid MIDI port.');
+                }
+                // The access request's AbortSignal must not poison later close/send
+                // operations and strand a host-owned port after access succeeds.
+                return nativePort(result, {});
+            },
+        },
+    };
+}

package/dist/lib/native-hardware/midi-ports.d.ts

@@ -0,0 +1,6 @@
+import type { MoldableMIDIConnectionOptions, MoldableMIDIInputConnection, MoldableMIDIOutputConnection } from './midi-types';
+/** Opens one input port and owns its message listener until `close()` or abort. */
+export declare function openMoldableMIDIInput(access: MIDIAccess, inputId: string, listener: (event: MIDIMessageEvent) => void, options?: MoldableMIDIConnectionOptions): Promise<MoldableMIDIInputConnection>;
+/** Opens one output port and validates outbound MIDI bytes before sending. */
+export declare function openMoldableMIDIOutput(access: MIDIAccess, outputId: string, options?: MoldableMIDIConnectionOptions): Promise<MoldableMIDIOutputConnection>;
+//# sourceMappingURL=midi-ports.d.ts.map

package/dist/lib/native-hardware/midi-ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midi-ports.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/midi-ports.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,6BAA6B,EAC7B,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,cAAc,CAAA;AAErB,mFAAmF;AACnF,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,EAC3C,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,2BAA2B,CAAC,CAwCtC;AAED,8EAA8E;AAC9E,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,4BAA4B,CAAC,CA+EvC"}

package/dist/lib/native-hardware/midi-ports.js

@@ -0,0 +1,115 @@
+import { abortableMIDI, findMIDIPort, midiAborted, midiError, missingMIDIPort, } from './midi-internal';
+/** Opens one input port and owns its message listener until `close()` or abort. */
+export async function openMoldableMIDIInput(access, inputId, listener, options = {}) {
+    const input = findMIDIPort(access.inputs, inputId);
+    if (!input)
+        return missingMIDIPort('input', inputId);
+    const operation = `open MIDI input ${inputId}`;
+    try {
+        await abortableMIDI(input.open(), options.signal, operation, (port) => {
+            void port.close();
+        });
+        if (options.signal?.aborted) {
+            await input.close();
+            throw midiAborted(operation);
+        }
+    }
+    catch (error) {
+        throw midiError(error, operation);
+    }
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        try {
+            await input.close();
+        }
+        catch (error) {
+            throw midiError(error, `close MIDI input ${inputId}`);
+        }
+        closed = true;
+        input.removeEventListener('midimessage', listener);
+        options.signal?.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => void close().catch(() => undefined);
+    input.addEventListener('midimessage', listener);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    return {
+        input,
+        get closed() {
+            return closed;
+        },
+        close,
+    };
+}
+/** Opens one output port and validates outbound MIDI bytes before sending. */
+export async function openMoldableMIDIOutput(access, outputId, options = {}) {
+    const output = findMIDIPort(access.outputs, outputId);
+    if (!output)
+        return missingMIDIPort('output', outputId);
+    const operation = `open MIDI output ${outputId}`;
+    try {
+        await abortableMIDI(output.open(), options.signal, operation, (port) => {
+            void port.close();
+        });
+        if (options.signal?.aborted) {
+            await output.close();
+            throw midiAborted(operation);
+        }
+    }
+    catch (error) {
+        throw midiError(error, operation);
+    }
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        try {
+            ;
+            output.clear?.call(output);
+            await output.close();
+        }
+        catch (error) {
+            throw midiError(error, `close MIDI output ${outputId}`);
+        }
+        closed = true;
+        options.signal?.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => void close().catch(() => undefined);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    return {
+        output,
+        get closed() {
+            return closed;
+        },
+        send(data, timestamp) {
+            if (closed) {
+                throw midiError(new DOMException('MIDI output is closed', 'InvalidStateError'), `send to MIDI output ${outputId}`);
+            }
+            const bytes = Array.from(data);
+            if (bytes.length === 0 ||
+                bytes.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+                throw midiError(new TypeError('MIDI data must contain bytes between 0 and 255'), `send to MIDI output ${outputId}`);
+            }
+            try {
+                output.send(bytes, timestamp);
+            }
+            catch (error) {
+                throw midiError(error, `send to MIDI output ${outputId}`);
+            }
+        },
+        clear() {
+            const clear = output.clear;
+            if (!clear) {
+                throw midiError(new DOMException('Clearing MIDI output is unavailable', 'NotSupportedError'), `clear MIDI output ${outputId}`);
+            }
+            try {
+                clear.call(output);
+            }
+            catch (error) {
+                throw midiError(error, `clear MIDI output ${outputId}`);
+            }
+        },
+        close,
+    };
+}

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

@@ -0,0 +1,25 @@
+export interface MoldableMIDIAccessOptions {
+    /**
+     * System Exclusive access is sensitive and is never enabled implicitly.
+     * Callers must set this to `true` from a user-initiated action.
+     */
+    sysex?: boolean;
+    software?: boolean;
+    signal?: AbortSignal;
+}
+export interface MoldableMIDIConnectionOptions {
+    signal?: AbortSignal;
+}
+export interface MoldableMIDIInputConnection {
+    readonly input: MIDIInput;
+    readonly closed: boolean;
+    close(): Promise<void>;
+}
+export interface MoldableMIDIOutputConnection {
+    readonly output: MIDIOutput;
+    readonly closed: boolean;
+    send(data: Iterable<number>, timestamp?: DOMHighResTimeStamp): void;
+    clear(): void;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=midi-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"midi-types.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/midi-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,MAAM,WAAW,6BAA6B;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACnE,KAAK,IAAI,IAAI,CAAA;IACb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+export { getMoldableMIDIInputs, getMoldableMIDIOutputs, isMoldableMIDISupported, observeMoldableMIDIState, requestMoldableMIDIAccess, } from './midi-access';
+export { openMoldableMIDIInput, openMoldableMIDIOutput } from './midi-ports';
+export { requestMoldableMIDIWithFallback } from './midi-native-fallback';
+export type { MoldableMIDITransport, MoldableNativeMIDIAccess, MoldableNativeMIDIPort, } from './midi-native-fallback';
+export type { MoldableMIDIAccessOptions, MoldableMIDIConnectionOptions, MoldableMIDIInputConnection, MoldableMIDIOutputConnection, } from './midi-types';
+//# sourceMappingURL=midi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"midi.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/midi.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAA;AACxE,YAAY,EACV,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACV,yBAAyB,EACzB,6BAA6B,EAC7B,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,cAAc,CAAA"}

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

@@ -0,0 +1,3 @@
+export { getMoldableMIDIInputs, getMoldableMIDIOutputs, isMoldableMIDISupported, observeMoldableMIDIState, requestMoldableMIDIAccess, } from './midi-access';
+export { openMoldableMIDIInput, openMoldableMIDIOutput } from './midi-ports';
+export { requestMoldableMIDIWithFallback } from './midi-native-fallback';

package/dist/lib/native-hardware/native-device-io.d.ts

@@ -0,0 +1,28 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+export type MoldableNativeDeviceKind = 'usb' | 'hid' | 'serial';
+export interface MoldableNativeDeviceDescriptor {
+    selector: string;
+    kind: MoldableNativeDeviceKind;
+    label: string;
+    vendorId?: number;
+    productId?: number;
+}
+export interface MoldableNativeDeviceHandle {
+    handle: string;
+    kind: MoldableNativeDeviceKind;
+}
+export interface MoldableNativeDeviceFilter {
+    vendorId?: number;
+    productId?: number;
+}
+export interface MoldableNativeDeviceListOptions extends NativeHardwareBridgeOptions {
+    filters?: readonly MoldableNativeDeviceFilter[];
+    exclusionFilters?: readonly MoldableNativeDeviceFilter[];
+}
+export declare function listMoldableNativeDevices(kind: MoldableNativeDeviceKind, options?: MoldableNativeDeviceListOptions): Promise<MoldableNativeDeviceDescriptor[]>;
+export declare function openMoldableNativeDevice(kind: MoldableNativeDeviceKind, selector: string, deviceOptions: Record<string, unknown>, options?: NativeHardwareBridgeOptions): Promise<MoldableNativeDeviceHandle>;
+export declare function executeMoldableNativeDeviceOperation(kind: MoldableNativeDeviceKind, handle: string, operation: Record<string, unknown>, options?: NativeHardwareBridgeOptions): Promise<Record<string, unknown>>;
+export declare function closeMoldableNativeDevice(kind: MoldableNativeDeviceKind, handle: string, options?: NativeHardwareBridgeOptions): Promise<void>;
+export declare function bytesFromNativeDeviceResult(result: Record<string, unknown>): Uint8Array;
+export declare function bytesWrittenFromNativeDeviceResult(result: Record<string, unknown>): number;
+//# sourceMappingURL=native-device-io.d.ts.map

package/dist/lib/native-hardware/native-device-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-device-io.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/native-device-io.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AAOjB,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAA;AAE/D,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,wBAAwB,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,wBAAwB,CAAA;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,+BACf,SAAQ,2BAA2B;IACnC,OAAO,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAA;IAC/C,gBAAgB,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAA;CACzD;AAkCD,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,wBAAwB,EAC9B,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAsB3C;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,wBAAwB,EAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,0BAA0B,CAAC,CAwBrC;AAED,wBAAsB,oCAAoC,CACxD,IAAI,EAAE,wBAAwB,EAC9B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAalC;AAED,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,wBAAwB,EAC9B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,IAAI,CAAC,CAMf;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,UAAU,CAYZ;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAUR"}

package/dist/lib/native-hardware/native-device-io.js

@@ -0,0 +1,91 @@
+import { NativeHardwareBridgeError, callNativeHardwareBridge, } from './bridge';
+const REQUEST_TYPE = 'moldable:native-device-io-request';
+const RESULT_TYPE = 'moldable:native-device-io-result';
+const OPAQUE_ID_PATTERN = /^(selector|device)-[a-f0-9]{36}$/;
+const MAX_TRANSFER_BYTES = 65_536;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function invalidResponse(message, details) {
+    throw new NativeHardwareBridgeError({
+        code: 'invalid_response',
+        message,
+        details,
+        retryable: false,
+    });
+}
+function isDescriptor(value) {
+    return (isRecord(value) &&
+        typeof value.selector === 'string' &&
+        OPAQUE_ID_PATTERN.test(value.selector) &&
+        (value.kind === 'usb' || value.kind === 'hid' || value.kind === 'serial') &&
+        typeof value.label === 'string' &&
+        value.label.length <= 120 &&
+        (value.vendorId === undefined ||
+            (Number.isInteger(value.vendorId) &&
+                Number(value.vendorId) >= 0 &&
+                Number(value.vendorId) <= 0xffff)) &&
+        (value.productId === undefined ||
+            (Number.isInteger(value.productId) &&
+                Number(value.productId) >= 0 &&
+                Number(value.productId) <= 0xffff)));
+}
+export async function listMoldableNativeDevices(kind, options = {}) {
+    const { filters, exclusionFilters, ...bridgeOptions } = options;
+    const result = await callNativeHardwareBridge({
+        type: REQUEST_TYPE,
+        action: 'list',
+        kind,
+        ...(filters ? { filters: [...filters] } : {}),
+        ...(exclusionFilters ? { exclusionFilters: [...exclusionFilters] } : {}),
+    }, RESULT_TYPE, { timeoutMs: 120_000, ...bridgeOptions });
+    if (!Array.isArray(result) ||
+        !result.every((descriptor) => isDescriptor(descriptor) && descriptor.kind === kind)) {
+        invalidResponse('Moldable returned an invalid native device list.', result);
+    }
+    return result;
+}
+export async function openMoldableNativeDevice(kind, selector, deviceOptions, options = {}) {
+    const result = await callNativeHardwareBridge({
+        type: REQUEST_TYPE,
+        action: 'open',
+        kind,
+        selector,
+        options: deviceOptions,
+    }, RESULT_TYPE, { timeoutMs: 120_000, ...options });
+    if (!isRecord(result) ||
+        typeof result.handle !== 'string' ||
+        !OPAQUE_ID_PATTERN.test(result.handle) ||
+        (result.kind !== 'usb' && result.kind !== 'hid' && result.kind !== 'serial')) {
+        invalidResponse('Moldable returned an invalid native device handle.', result);
+    }
+    return result;
+}
+export async function executeMoldableNativeDeviceOperation(kind, handle, operation, options = {}) {
+    const result = await callNativeHardwareBridge({ type: REQUEST_TYPE, action: 'execute', kind, handle, operation }, RESULT_TYPE, { timeoutMs: 35_000, ...options });
+    if (!isRecord(result)) {
+        invalidResponse('Moldable returned an invalid native device result.', result);
+    }
+    return result;
+}
+export async function closeMoldableNativeDevice(kind, handle, options = {}) {
+    await callNativeHardwareBridge({ type: REQUEST_TYPE, action: 'close', kind, handle }, RESULT_TYPE, options);
+}
+export function bytesFromNativeDeviceResult(result) {
+    if (result.kind !== 'data' ||
+        !Array.isArray(result.data) ||
+        result.data.length > MAX_TRANSFER_BYTES ||
+        !result.data.every((value) => Number.isInteger(value) && value >= 0 && value <= 255)) {
+        invalidResponse('Moldable returned invalid device bytes.', result);
+    }
+    return Uint8Array.from(result.data);
+}
+export function bytesWrittenFromNativeDeviceResult(result) {
+    if (result.kind !== 'written' ||
+        !Number.isInteger(result.bytesWritten) ||
+        Number(result.bytesWritten) < 0 ||
+        Number(result.bytesWritten) > MAX_TRANSFER_BYTES) {
+        invalidResponse('Moldable returned an invalid device write result.', result);
+    }
+    return Number(result.bytesWritten);
+}

package/dist/lib/native-hardware/native-device-lifecycle.d.ts

@@ -0,0 +1,13 @@
+export declare class NativeDeviceLifecycle {
+    private open;
+    private attached;
+    private disconnectDispatched;
+    get opened(): boolean;
+    get connected(): boolean;
+    get disconnected(): boolean;
+    didOpen(): void;
+    didClose(): void;
+    didDisconnect(target: EventTarget, error: unknown): void;
+}
+export declare function isNativeDeviceDisconnect(error: unknown): boolean;
+//# sourceMappingURL=native-device-lifecycle.d.ts.map

package/dist/lib/native-hardware/native-device-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-device-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/native-device-lifecycle.ts"],"names":[],"mappings":"AAEA,qBAAa,qBAAqB;IAChC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,oBAAoB,CAAQ;IAEpC,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,OAAO,IAAI,IAAI;IAMf,QAAQ,IAAI,IAAI;IAIhB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;CASzD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMhE"}

package/dist/lib/native-hardware/native-device-lifecycle.js

@@ -0,0 +1,40 @@
+import { NativeHardwareBridgeError } from './bridge';
+export class NativeDeviceLifecycle {
+    open = false;
+    attached = true;
+    disconnectDispatched = false;
+    get opened() {
+        return this.open;
+    }
+    get connected() {
+        return this.attached;
+    }
+    get disconnected() {
+        return !this.attached;
+    }
+    didOpen() {
+        this.open = true;
+        this.attached = true;
+        this.disconnectDispatched = false;
+    }
+    didClose() {
+        this.open = false;
+    }
+    didDisconnect(target, error) {
+        this.open = false;
+        this.attached = false;
+        if (this.disconnectDispatched)
+            return;
+        this.disconnectDispatched = true;
+        const event = new Event('disconnect');
+        Object.defineProperty(event, 'error', { value: error });
+        target.dispatchEvent(event);
+    }
+}
+export function isNativeDeviceDisconnect(error) {
+    if (!(error instanceof NativeHardwareBridgeError))
+        return false;
+    if (error.code !== 'unavailable')
+        return false;
+    return /\b(disconnected|no longer available|not connected)\b/i.test(error.message);
+}

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

@@ -0,0 +1,38 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+import type { NativeHardwareRequestEnvelope, NativeHardwareResultEnvelope } from './types';
+export declare const NATIVE_NOTIFICATION_REQUEST_TYPE: "moldable:native-notifications";
+export declare const NATIVE_NOTIFICATION_RESULT_TYPE: "moldable:native-notifications-result";
+export declare const NATIVE_NOTIFICATION_MAX_TITLE_LENGTH = 256;
+export declare const NATIVE_NOTIFICATION_MAX_BODY_LENGTH = 4096;
+export declare const NATIVE_NOTIFICATION_MAX_TAG_LENGTH = 128;
+export type MoldableNotificationPermission = 'granted' | 'denied' | 'prompt';
+export interface MoldableNotificationOptions {
+    title: string;
+    body?: string;
+    tag?: string;
+    silent?: boolean;
+}
+export interface MoldableNotificationPermissionResult {
+    permission: MoldableNotificationPermission;
+}
+export interface MoldableNotificationSendResult {
+    sent: true;
+}
+export type NativeNotificationAction = 'getPermission' | 'requestPermission' | 'send';
+export type NativeNotificationRequest = NativeHardwareRequestEnvelope<typeof NATIVE_NOTIFICATION_REQUEST_TYPE, {
+    capability: 'notifications';
+    action: 'getPermission';
+} | {
+    capability: 'notifications';
+    action: 'requestPermission';
+} | {
+    capability: 'notifications';
+    action: 'send';
+    notification: MoldableNotificationOptions;
+}>;
+export type NativeNotificationResult = NativeHardwareResultEnvelope<typeof NATIVE_NOTIFICATION_RESULT_TYPE, MoldableNotificationPermissionResult | MoldableNotificationSendResult>;
+export declare function isMoldableNotificationOptions(value: unknown): value is MoldableNotificationOptions;
+export declare function getMoldableNotificationPermission(options?: NativeHardwareBridgeOptions): Promise<MoldableNotificationPermissionResult>;
+export declare function requestMoldableNotificationPermission(options?: NativeHardwareBridgeOptions): Promise<MoldableNotificationPermissionResult>;
+export declare function sendMoldableNotification(notification: MoldableNotificationOptions, options?: NativeHardwareBridgeOptions): Promise<MoldableNotificationSendResult>;
+//# sourceMappingURL=notifications.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAC7B,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,gCAAgC,EAC3C,+BAAwC,CAAA;AAC1C,eAAO,MAAM,+BAA+B,EAC1C,sCAA+C,CAAA;AAEjD,eAAO,MAAM,oCAAoC,MAAM,CAAA;AACvD,eAAO,MAAM,mCAAmC,OAAQ,CAAA;AACxD,eAAO,MAAM,kCAAkC,MAAM,CAAA;AAErD,MAAM,MAAM,8BAA8B,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE5E,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,oCAAoC;IACnD,UAAU,EAAE,8BAA8B,CAAA;CAC3C;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,IAAI,CAAA;CACX;AAED,MAAM,MAAM,wBAAwB,GAChC,eAAe,GACf,mBAAmB,GACnB,MAAM,CAAA;AAEV,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CACnE,OAAO,gCAAgC,EACrC;IACE,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,eAAe,CAAA;CACxB,GACD;IACE,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,mBAAmB,CAAA;CAC5B,GACD;IACE,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CACJ,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,4BAA4B,CACjE,OAAO,+BAA+B,EACtC,oCAAoC,GAAG,8BAA8B,CACtE,CAAA;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CA+BtC;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oCAAoC,CAAC,CAU/C;AAED,wBAAgB,qCAAqC,CACnD,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oCAAoC,CAAC,CAU/C;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,2BAA2B,EACzC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,8BAA8B,CAAC,CAWzC"}

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

@@ -0,0 +1,50 @@
+import { callNativeHardwareBridge, } from './bridge';
+export const NATIVE_NOTIFICATION_REQUEST_TYPE = 'moldable:native-notifications';
+export const NATIVE_NOTIFICATION_RESULT_TYPE = 'moldable:native-notifications-result';
+export const NATIVE_NOTIFICATION_MAX_TITLE_LENGTH = 256;
+export const NATIVE_NOTIFICATION_MAX_BODY_LENGTH = 4_096;
+export const NATIVE_NOTIFICATION_MAX_TAG_LENGTH = 128;
+export function isMoldableNotificationOptions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const notification = value;
+    const { title, body, tag, silent } = notification;
+    if (typeof title !== 'string' ||
+        title.trim().length === 0 ||
+        title.length > NATIVE_NOTIFICATION_MAX_TITLE_LENGTH) {
+        return false;
+    }
+    if ((body !== undefined && typeof body !== 'string') ||
+        (typeof body === 'string' &&
+            body.length > NATIVE_NOTIFICATION_MAX_BODY_LENGTH)) {
+        return false;
+    }
+    if ((tag !== undefined &&
+        (typeof tag !== 'string' || tag.trim().length === 0)) ||
+        (typeof tag === 'string' && tag.length > NATIVE_NOTIFICATION_MAX_TAG_LENGTH)) {
+        return false;
+    }
+    return silent === undefined || typeof silent === 'boolean';
+}
+export function getMoldableNotificationPermission(options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_NOTIFICATION_REQUEST_TYPE,
+        capability: 'notifications',
+        action: 'getPermission',
+    }, NATIVE_NOTIFICATION_RESULT_TYPE, options);
+}
+export function requestMoldableNotificationPermission(options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_NOTIFICATION_REQUEST_TYPE,
+        capability: 'notifications',
+        action: 'requestPermission',
+    }, NATIVE_NOTIFICATION_RESULT_TYPE, options);
+}
+export function sendMoldableNotification(notification, options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_NOTIFICATION_REQUEST_TYPE,
+        capability: 'notifications',
+        action: 'send',
+        notification,
+    }, NATIVE_NOTIFICATION_RESULT_TYPE, options);
+}