@moldable-ai/ui 0.2.17 → 0.2.19

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

@@ -0,0 +1,17 @@
+import type { NativeHardwareCapabilityId } from './types';
+type MediaCapability = Extract<NativeHardwareCapabilityId, 'camera' | 'microphone' | 'screen-capture'>;
+/**
+ * Enumerates browser-visible audio and video input/output devices.
+ * Pass the capability that initiated the enumeration for accurate error details.
+ */
+export declare function enumerateMoldableMediaDevices(capability?: Extract<MediaCapability, 'camera' | 'microphone'>): Promise<MediaDeviceInfo[]>;
+/** Requests a video-only camera stream using the standard MediaDevices API. */
+export declare function getMoldableCameraStream(constraints?: boolean | MediaTrackConstraints): Promise<MediaStream>;
+/** Requests an audio-only microphone stream using the standard MediaDevices API. */
+export declare function getMoldableMicrophoneStream(constraints?: boolean | MediaTrackConstraints): Promise<MediaStream>;
+/** Requests a screen/window stream using the standard display-media picker. */
+export declare function getMoldableDisplayStream(options?: DisplayMediaStreamOptions): Promise<MediaStream>;
+/** Stops every audio and video track owned by a stream. Safe to call repeatedly. */
+export declare function stopMoldableMediaStream(stream: MediaStream): void;
+export {};
+//# sourceMappingURL=media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/media.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,0BAA0B,EAE3B,MAAM,SAAS,CAAA;AAEhB,KAAK,eAAe,GAAG,OAAO,CAC5B,0BAA0B,EAC1B,QAAQ,GAAG,YAAY,GAAG,gBAAgB,CAC3C,CAAA;AAmED;;;GAGG;AACH,wBAAsB,6BAA6B,CACjD,UAAU,GAAE,OAAO,CAAC,eAAe,EAAE,QAAQ,GAAG,YAAY,CAAY,GACvE,OAAO,CAAC,eAAe,EAAE,CAAC,CAS5B;AAED,+EAA+E;AAC/E,wBAAsB,uBAAuB,CAC3C,WAAW,GAAE,OAAO,GAAG,qBAA4B,GAClD,OAAO,CAAC,WAAW,CAAC,CAWtB;AAED,oFAAoF;AACpF,wBAAsB,2BAA2B,CAC/C,WAAW,GAAE,OAAO,GAAG,qBAA4B,GAClD,OAAO,CAAC,WAAW,CAAC,CAWtB;AAED,+EAA+E;AAC/E,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,yBAAyD,GACjE,OAAO,CAAC,WAAW,CAAC,CAUtB;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAEjE"}

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

@@ -0,0 +1,99 @@
+import { NativeHardwareBridgeError, toNativeHardwareBridgeError, } from './bridge';
+function mediaDevicesFor(capability, method) {
+    if (typeof navigator === 'undefined' ||
+        !navigator.mediaDevices ||
+        typeof navigator.mediaDevices[method] !== 'function') {
+        throw mediaError(capability, new DOMException('Media API unavailable', 'NotSupportedError'));
+    }
+    return navigator.mediaDevices;
+}
+function mediaError(capability, error) {
+    if (error instanceof NativeHardwareBridgeError)
+        return error;
+    const name = error instanceof DOMException ? error.name : undefined;
+    let code = 'host_error';
+    let retryable = false;
+    if (name === 'NotSupportedError')
+        code = 'unsupported';
+    else if (name === 'NotAllowedError' || name === 'SecurityError') {
+        code = 'permission_denied';
+    }
+    else if (name === 'AbortError') {
+        code = 'aborted';
+        retryable = true;
+    }
+    else if (name === 'NotFoundError' ||
+        name === 'DevicesNotFoundError' ||
+        name === 'NotReadableError' ||
+        name === 'TrackStartError') {
+        code = 'unavailable';
+        retryable = true;
+    }
+    else if (name === 'OverconstrainedError' ||
+        name === 'ConstraintNotSatisfiedError' ||
+        error instanceof TypeError) {
+        code = 'invalid_request';
+    }
+    const fallbackMessage = `Unable to access ${capability}`;
+    return toNativeHardwareBridgeError({
+        code,
+        message: error instanceof Error
+            ? error.message || fallbackMessage
+            : fallbackMessage,
+        details: { capability, ...(name ? { cause: name } : {}) },
+        retryable,
+    }, fallbackMessage);
+}
+/**
+ * Enumerates browser-visible audio and video input/output devices.
+ * Pass the capability that initiated the enumeration for accurate error details.
+ */
+export async function enumerateMoldableMediaDevices(capability = 'camera') {
+    try {
+        return await mediaDevicesFor(capability, 'enumerateDevices').enumerateDevices();
+    }
+    catch (error) {
+        throw mediaError(capability, error);
+    }
+}
+/** Requests a video-only camera stream using the standard MediaDevices API. */
+export async function getMoldableCameraStream(constraints = true) {
+    const capability = 'camera';
+    try {
+        return await mediaDevicesFor(capability, 'getUserMedia').getUserMedia({
+            audio: false,
+            video: constraints,
+        });
+    }
+    catch (error) {
+        throw mediaError(capability, error);
+    }
+}
+/** Requests an audio-only microphone stream using the standard MediaDevices API. */
+export async function getMoldableMicrophoneStream(constraints = true) {
+    const capability = 'microphone';
+    try {
+        return await mediaDevicesFor(capability, 'getUserMedia').getUserMedia({
+            audio: constraints,
+            video: false,
+        });
+    }
+    catch (error) {
+        throw mediaError(capability, error);
+    }
+}
+/** Requests a screen/window stream using the standard display-media picker. */
+export async function getMoldableDisplayStream(options = { video: true, audio: false }) {
+    const capability = 'screen-capture';
+    try {
+        return await mediaDevicesFor(capability, 'getDisplayMedia').getDisplayMedia(options);
+    }
+    catch (error) {
+        throw mediaError(capability, error);
+    }
+}
+/** Stops every audio and video track owned by a stream. Safe to call repeatedly. */
+export function stopMoldableMediaStream(stream) {
+    for (const track of stream.getTracks())
+        track.stop();
+}

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

@@ -0,0 +1,13 @@
+import type { MoldableMIDIAccessOptions, MoldableMIDIConnectionOptions } from './midi-types';
+/** Checks only whether this runtime exposes Web MIDI; it does not request permission. */
+export declare function isMoldableMIDISupported(): boolean;
+/**
+ * Requests Web MIDI access. Invoke this directly from a trusted user action.
+ * SysEx access is disabled unless `sysex: true` is explicitly supplied.
+ */
+export declare function requestMoldableMIDIAccess(options?: MoldableMIDIAccessOptions): Promise<MIDIAccess>;
+export declare function getMoldableMIDIInputs(access: MIDIAccess): MIDIInput[];
+export declare function getMoldableMIDIOutputs(access: MIDIAccess): MIDIOutput[];
+/** Subscribes to device connection changes and returns an idempotent cleanup. */
+export declare function observeMoldableMIDIState(access: MIDIAccess, listener: (event: MIDIConnectionEvent) => void, options?: MoldableMIDIConnectionOptions): () => void;
+//# sourceMappingURL=midi-access.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"midi-access.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/midi-access.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,yBAAyB,EACzB,6BAA6B,EAC9B,MAAM,cAAc,CAAA;AAiBrB,yFAAyF;AACzF,wBAAgB,uBAAuB,IAAI,OAAO,CAKjD;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,UAAU,CAAC,CAsBrB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,EAAE,CAIrE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,EAAE,CAIvE;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,EAC9C,OAAO,GAAE,6BAAkC,GAC1C,MAAM,IAAI,CAaZ"}

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

@@ -0,0 +1,66 @@
+import { toNativeHardwareBridgeError } from './bridge';
+import { abortableMIDI, midiError } from './midi-internal';
+function assertUserGesture() {
+    if (typeof navigator === 'undefined')
+        return;
+    const activation = navigator.userActivation;
+    if (activation && !activation.isActive) {
+        throw toNativeHardwareBridgeError({
+            code: 'invalid_request',
+            message: 'MIDI access must be requested from a user-initiated action.',
+            details: { capability: 'midi', cause: 'user_gesture_required' },
+            retryable: true,
+        });
+    }
+}
+/** Checks only whether this runtime exposes Web MIDI; it does not request permission. */
+export function isMoldableMIDISupported() {
+    return (typeof navigator !== 'undefined' &&
+        typeof navigator.requestMIDIAccess === 'function');
+}
+/**
+ * Requests Web MIDI access. Invoke this directly from a trusted user action.
+ * SysEx access is disabled unless `sysex: true` is explicitly supplied.
+ */
+export async function requestMoldableMIDIAccess(options = {}) {
+    const operation = 'request MIDI access';
+    if (!isMoldableMIDISupported()) {
+        throw midiError(new DOMException('Web MIDI is unavailable', 'NotSupportedError'), operation);
+    }
+    assertUserGesture();
+    try {
+        return await abortableMIDI(navigator.requestMIDIAccess({
+            software: options.software,
+            sysex: options.sysex === true,
+        }), options.signal, operation);
+    }
+    catch (error) {
+        throw midiError(error, operation);
+    }
+}
+export function getMoldableMIDIInputs(access) {
+    const inputs = [];
+    access.inputs.forEach((input) => inputs.push(input));
+    return inputs;
+}
+export function getMoldableMIDIOutputs(access) {
+    const outputs = [];
+    access.outputs.forEach((output) => outputs.push(output));
+    return outputs;
+}
+/** Subscribes to device connection changes and returns an idempotent cleanup. */
+export function observeMoldableMIDIState(access, listener, options = {}) {
+    if (options.signal?.aborted)
+        return () => undefined;
+    let active = true;
+    const cleanup = () => {
+        if (!active)
+            return;
+        active = false;
+        access.removeEventListener('statechange', listener);
+        options.signal?.removeEventListener('abort', cleanup);
+    };
+    access.addEventListener('statechange', listener);
+    options.signal?.addEventListener('abort', cleanup, { once: true });
+    return cleanup;
+}

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

@@ -0,0 +1,12 @@
+import { NativeHardwareBridgeError } from './bridge';
+export type ClearableMIDIOutput = MIDIOutput & {
+    clear?: () => void;
+};
+export declare function midiError(error: unknown, operation: string): NativeHardwareBridgeError;
+export declare function midiAborted(operation: string): NativeHardwareBridgeError;
+export declare function abortableMIDI<T>(promise: Promise<T>, signal: AbortSignal | undefined, operation: string, onLateResolution?: (value: T) => void): Promise<T>;
+export declare function findMIDIPort<TPort extends MIDIPort>(ports: {
+    forEach(callback: (port: TPort) => void): void;
+}, id: string): TPort | undefined;
+export declare function missingMIDIPort(type: 'input' | 'output', id: string): never;
+//# sourceMappingURL=midi-internal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"midi-internal.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/midi-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EAE1B,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAErE,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAChB,yBAAyB,CAoC3B;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,yBAAyB,CAKxE;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC7B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GACpC,OAAO,CAAC,CAAC,CAAC,CA+BZ;AAED,wBAAgB,YAAY,CAAC,KAAK,SAAS,QAAQ,EACjD,KAAK,EAAE;IAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAA;CAAE,EACzD,EAAE,EAAE,MAAM,GACT,KAAK,GAAG,SAAS,CAMnB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,CAO3E"}

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

@@ -0,0 +1,88 @@
+import { NativeHardwareBridgeError, toNativeHardwareBridgeError, } from './bridge';
+export function midiError(error, operation) {
+    if (error instanceof NativeHardwareBridgeError)
+        return error;
+    const name = error instanceof DOMException ? error.name : undefined;
+    let code = 'host_error';
+    let retryable = false;
+    if (name === 'NotSupportedError')
+        code = 'unsupported';
+    else if (name === 'NotAllowedError' || name === 'SecurityError') {
+        code = 'permission_denied';
+    }
+    else if (name === 'AbortError')
+        code = 'aborted';
+    else if (name === 'NotFoundError') {
+        code = 'unavailable';
+        retryable = true;
+    }
+    else if (name === 'InvalidAccessError' || name === 'InvalidStateError') {
+        code = 'unavailable';
+        retryable = true;
+    }
+    else if (error instanceof TypeError)
+        code = 'invalid_request';
+    const fallbackMessage = `Unable to ${operation}`;
+    return toNativeHardwareBridgeError({
+        code,
+        message: error instanceof Error
+            ? error.message || fallbackMessage
+            : fallbackMessage,
+        details: {
+            capability: 'midi',
+            operation,
+            ...(name ? { cause: name } : {}),
+        },
+        retryable,
+    }, fallbackMessage);
+}
+export function midiAborted(operation) {
+    return midiError(new DOMException(`MIDI ${operation} was aborted`, 'AbortError'), operation);
+}
+export function abortableMIDI(promise, signal, operation, onLateResolution) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(midiAborted(operation));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            reject(midiAborted(operation));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            if (settled) {
+                onLateResolution?.(value);
+                return;
+            }
+            settled = true;
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+    });
+}
+export function findMIDIPort(ports, id) {
+    let result;
+    ports.forEach((port) => {
+        if (port.id === id)
+            result = port;
+    });
+    return result;
+}
+export function missingMIDIPort(type, id) {
+    throw toNativeHardwareBridgeError({
+        code: 'unavailable',
+        message: `MIDI ${type} ${id} is unavailable.`,
+        details: { capability: 'midi', portType: type, portId: id },
+        retryable: true,
+    });
+}

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

@@ -0,0 +1,27 @@
+import type { MoldableMIDIAccessOptions } from './midi-types';
+export type MoldableMIDITransport = {
+    kind: 'web-midi';
+    access: MIDIAccess;
+} | {
+    kind: 'desktop-bridge';
+    access: MoldableNativeMIDIAccess;
+};
+export interface MoldableNativeMIDIPort {
+    readonly id: string;
+    readonly kind: 'input' | 'output';
+    readonly name: string;
+    readonly closed: boolean;
+    /** Native fallback sends immediately; Web MIDI retains scheduled sends. */
+    send(data: Iterable<number>): Promise<void>;
+    observeMessages(listener: (data: Uint8Array, timestamp: number) => void): () => void;
+    close(): Promise<void>;
+}
+export interface MoldableNativeMIDIAccess {
+    requestPort(kind: 'input' | 'output'): Promise<MoldableNativeMIDIPort>;
+}
+/**
+ * Uses Web MIDI when the webview implements it; otherwise returns the scoped
+ * desktop fallback. Native port selection always opens the host-owned chooser.
+ */
+export declare function requestMoldableMIDIWithFallback(options?: MoldableMIDIAccessOptions): Promise<MoldableMIDITransport>;
+//# sourceMappingURL=midi-native-fallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"midi-native-fallback.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/midi-native-fallback.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AAO7D,MAAM,MAAM,qBAAqB,GAC7B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,wBAAwB,CAAA;CAAE,CAAA;AAEhE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,2EAA2E;IAC3E,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3C,eAAe,CACb,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GACtD,MAAM,IAAI,CAAA;IACb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACvE;AA+HD;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,qBAAqB,CAAC,CAwChC"}

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';