@moldable-ai/ui 0.2.18 → 0.2.20

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

@@ -0,0 +1,49 @@
+export declare const MOLDABLE_LOCATION_MIN_TIMEOUT_MS = 1;
+export declare const MOLDABLE_LOCATION_MAX_TIMEOUT_MS = 60000;
+export declare const MOLDABLE_LOCATION_MAX_CACHE_AGE_MS = 86400000;
+/**
+ * Options accepted by the native one-shot location bridge.
+ *
+ * Unlike the browser's unrestricted `PositionOptions`, the native bridge
+ * requires integer millisecond values, a 1-60,000 ms timeout, and a
+ * 0-86,400,000 ms maximum cache age.
+ */
+export interface MoldableLocationOptions {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+}
+export type MoldableLocationAuthorization = 'granted' | 'denied' | 'restricted' | 'not-determined' | 'unknown' | 'unsupported';
+export interface MoldableLocationAuthorizationState {
+    authorization: MoldableLocationAuthorization;
+    servicesEnabled: boolean;
+    canRequest: boolean;
+    settingsRequired: boolean;
+    detail?: string;
+}
+export interface MoldableLocationCoordinates {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+}
+export interface MoldableLocationResult {
+    coords: MoldableLocationCoordinates;
+    timestamp: number;
+}
+export declare const NATIVE_LOCATION_REQUEST_TYPE: "moldable:native-location-request";
+export declare const NATIVE_LOCATION_RESULT_TYPE: "moldable:native-location-result";
+/** Reads macOS location authorization without requesting a position or prompting. */
+export declare function getMoldableLocationAuthorizationStatus(): Promise<MoldableLocationAuthorizationState>;
+/**
+ * Gets one browser-shaped location fix.
+ *
+ * Packaged macOS apps use Moldable's native Core Location bridge. Other
+ * runtimes fall back to navigator.geolocation only when the host explicitly
+ * reports that native location is unsupported.
+ */
+export declare function getMoldableCurrentPosition(options?: MoldableLocationOptions): Promise<MoldableLocationResult>;
+//# sourceMappingURL=location.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/location.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,gCAAgC,IAAI,CAAA;AACjD,eAAO,MAAM,gCAAgC,QAAS,CAAA;AACtD,eAAO,MAAM,kCAAkC,WAAa,CAAA;AAE5D;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,6BAA6B,GACrC,SAAS,GACT,QAAQ,GACR,YAAY,GACZ,gBAAgB,GAChB,SAAS,GACT,aAAa,CAAA;AAEjB,MAAM,WAAW,kCAAkC;IACjD,aAAa,EAAE,6BAA6B,CAAA;IAC5C,eAAe,EAAE,OAAO,CAAA;IACxB,UAAU,EAAE,OAAO,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,2BAA2B,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,eAAO,MAAM,4BAA4B,EACvC,kCAA2C,CAAA;AAC7C,eAAO,MAAM,2BAA2B,EACtC,iCAA0C,CAAA;AAE5C,qFAAqF;AACrF,wBAAgB,sCAAsC,IAAI,OAAO,CAAC,kCAAkC,CAAC,CAQpG;AAoGD;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,sBAAsB,CAAC,CAqBjC"}

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

@@ -0,0 +1,114 @@
+import { NativeCapabilityBridgeError, callNativeCapabilityBridge, toNativeCapabilityBridgeError, } from './bridge';
+export const MOLDABLE_LOCATION_MIN_TIMEOUT_MS = 1;
+export const MOLDABLE_LOCATION_MAX_TIMEOUT_MS = 60_000;
+export const MOLDABLE_LOCATION_MAX_CACHE_AGE_MS = 86_400_000;
+export const NATIVE_LOCATION_REQUEST_TYPE = 'moldable:native-location-request';
+export const NATIVE_LOCATION_RESULT_TYPE = 'moldable:native-location-result';
+/** Reads macOS location authorization without requesting a position or prompting. */
+export function getMoldableLocationAuthorizationStatus() {
+    return callNativeCapabilityBridge({
+        type: NATIVE_LOCATION_REQUEST_TYPE,
+        action: 'getStatus',
+    }, NATIVE_LOCATION_RESULT_TYPE);
+}
+function locationError(error) {
+    if (error instanceof NativeCapabilityBridgeError)
+        return error;
+    let code = 'host_error';
+    let retryable = false;
+    let cause;
+    if (isGeolocationError(error)) {
+        cause = error.code;
+        if (error.code === 1)
+            code = 'permission_denied';
+        else if (error.code === 2) {
+            code = 'unavailable';
+            retryable = true;
+        }
+        else if (error.code === 3) {
+            code = 'timeout';
+            retryable = true;
+        }
+    }
+    else if (error instanceof DOMException) {
+        cause = error.name;
+        if (error.name === 'NotSupportedError')
+            code = 'unsupported';
+        else if (error.name === 'NotAllowedError' ||
+            error.name === 'SecurityError') {
+            code = 'permission_denied';
+        }
+    }
+    const fallbackMessage = 'Unable to get current location';
+    return toNativeCapabilityBridgeError({
+        code,
+        message: error instanceof Error || isGeolocationError(error)
+            ? error.message || fallbackMessage
+            : fallbackMessage,
+        details: {
+            capability: 'location',
+            ...(cause !== undefined ? { cause } : {}),
+        },
+        retryable,
+    }, fallbackMessage);
+}
+function isGeolocationError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        typeof error.code === 'number' &&
+        'message' in error &&
+        typeof error.message === 'string');
+}
+function getBrowserCurrentPosition(options = {}) {
+    if (typeof navigator === 'undefined' ||
+        !navigator.geolocation ||
+        typeof navigator.geolocation.getCurrentPosition !== 'function') {
+        return Promise.reject(locationError(new DOMException('Geolocation API unavailable', 'NotSupportedError')));
+    }
+    return new Promise((resolve, reject) => {
+        navigator.geolocation.getCurrentPosition((position) => {
+            resolve({
+                coords: {
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                    altitude: position.coords.altitude,
+                    altitudeAccuracy: position.coords.altitudeAccuracy,
+                    heading: position.coords.heading,
+                    speed: position.coords.speed,
+                },
+                timestamp: position.timestamp,
+            });
+        }, (error) => reject(locationError(error)), options);
+    });
+}
+function isEmbeddedInMoldable() {
+    return typeof window !== 'undefined' && window.parent !== window;
+}
+/**
+ * Gets one browser-shaped location fix.
+ *
+ * Packaged macOS apps use Moldable's native Core Location bridge. Other
+ * runtimes fall back to navigator.geolocation only when the host explicitly
+ * reports that native location is unsupported.
+ */
+export async function getMoldableCurrentPosition(options = {}) {
+    if (!isEmbeddedInMoldable())
+        return getBrowserCurrentPosition(options);
+    try {
+        const nativeTimeout = options.timeout ?? 10_000;
+        return await callNativeCapabilityBridge({
+            type: NATIVE_LOCATION_REQUEST_TYPE,
+            action: 'getCurrentPosition',
+            options,
+        }, NATIVE_LOCATION_RESULT_TYPE, { timeoutMs: Math.max(nativeTimeout + 2_000, 12_000) });
+    }
+    catch (error) {
+        const mapped = locationError(error);
+        if (mapped.code === 'unsupported' || mapped.code === 'not_in_moldable') {
+            return getBrowserCurrentPosition(options);
+        }
+        throw mapped;
+    }
+}

package/dist/lib/native-capabilities/media-permissions.d.ts

@@ -0,0 +1,28 @@
+import { type NativeCapabilityBridgeOptions } from './bridge';
+export declare const NATIVE_MEDIA_PERMISSION_REQUEST_TIMEOUT_MS = 125000;
+export type MoldableMediaPermission = 'camera' | 'microphone' | 'screen-recording';
+export type MoldableMediaPermissionStatus = 'granted' | 'denied' | 'restricted' | 'not-determined' | 'unknown' | 'unsupported';
+export interface MoldableMediaPermissionState {
+    permission: MoldableMediaPermission;
+    status: MoldableMediaPermissionStatus;
+    canRequest: boolean;
+    settingsRequired: boolean;
+    detail?: string;
+}
+export interface MoldableMediaPermissionDiagnostics {
+    platform: string;
+    capturedAtMs: number;
+    /** Capture source choice remains owned by the OS/webview picker. */
+    captureSourceBoundary: 'system-picker';
+    permissions: MoldableMediaPermissionState[];
+}
+/** Reads native OS authorization without opening hardware or showing a prompt. */
+export declare function getMoldableMediaPermissionStatus(permission: MoldableMediaPermission, options?: NativeCapabilityBridgeOptions): Promise<MoldableMediaPermissionState>;
+/**
+ * Requests OS permission from a direct user action. This never selects or
+ * enumerates a display source; display capture still uses the system picker.
+ */
+export declare function requestMoldableMediaPermission(permission: MoldableMediaPermission, options?: NativeCapabilityBridgeOptions): Promise<MoldableMediaPermissionState>;
+/** Returns a current, non-capturing diagnostic snapshot for all media permissions. */
+export declare function getMoldableMediaPermissionDiagnostics(options?: NativeCapabilityBridgeOptions): Promise<MoldableMediaPermissionDiagnostics>;
+//# sourceMappingURL=media-permissions.d.ts.map

package/dist/lib/native-capabilities/media-permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-permissions.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/media-permissions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,6BAA6B,EAEnC,MAAM,UAAU,CAAA;AAOjB,eAAO,MAAM,0CAA0C,SAAU,CAAA;AAEjE,MAAM,MAAM,uBAAuB,GAC/B,QAAQ,GACR,YAAY,GACZ,kBAAkB,CAAA;AACtB,MAAM,MAAM,6BAA6B,GACrC,SAAS,GACT,QAAQ,GACR,YAAY,GACZ,gBAAgB,GAChB,SAAS,GACT,aAAa,CAAA;AAEjB,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,uBAAuB,CAAA;IACnC,MAAM,EAAE,6BAA6B,CAAA;IACrC,UAAU,EAAE,OAAO,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,kCAAkC;IACjD,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,oEAAoE;IACpE,qBAAqB,EAAE,eAAe,CAAA;IACtC,WAAW,EAAE,4BAA4B,EAAE,CAAA;CAC5C;AAQD,kFAAkF;AAClF,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,uBAAuB,EACnC,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,4BAA4B,CAAC,CAUvC;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,uBAAuB,EACnC,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,4BAA4B,CAAC,CAevC;AAED,sFAAsF;AACtF,wBAAgB,qCAAqC,CACnD,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,kCAAkC,CAAC,CAS7C"}

package/dist/lib/native-capabilities/media-permissions.js

@@ -0,0 +1,37 @@
+import { callNativeCapabilityBridge, } from './bridge';
+const NATIVE_MEDIA_PERMISSION_REQUEST_TYPE = 'moldable:native-media-permission';
+const NATIVE_MEDIA_PERMISSION_RESULT_TYPE = 'moldable:native-media-permission-result';
+export const NATIVE_MEDIA_PERMISSION_REQUEST_TIMEOUT_MS = 125_000;
+function capabilityFor(permission) {
+    return permission === 'screen-recording' ? 'screen-capture' : permission;
+}
+/** Reads native OS authorization without opening hardware or showing a prompt. */
+export function getMoldableMediaPermissionStatus(permission, options = {}) {
+    return callNativeCapabilityBridge({
+        type: NATIVE_MEDIA_PERMISSION_REQUEST_TYPE,
+        action: 'getStatus',
+        permission,
+    }, NATIVE_MEDIA_PERMISSION_RESULT_TYPE, options);
+}
+/**
+ * Requests OS permission from a direct user action. This never selects or
+ * enumerates a display source; display capture still uses the system picker.
+ */
+export function requestMoldableMediaPermission(permission, options = {}) {
+    return callNativeCapabilityBridge({
+        type: NATIVE_MEDIA_PERMISSION_REQUEST_TYPE,
+        action: 'request',
+        permission,
+        capability: capabilityFor(permission),
+    }, NATIVE_MEDIA_PERMISSION_RESULT_TYPE, {
+        ...options,
+        timeoutMs: options.timeoutMs ?? NATIVE_MEDIA_PERMISSION_REQUEST_TIMEOUT_MS,
+    });
+}
+/** Returns a current, non-capturing diagnostic snapshot for all media permissions. */
+export function getMoldableMediaPermissionDiagnostics(options = {}) {
+    return callNativeCapabilityBridge({
+        type: NATIVE_MEDIA_PERMISSION_REQUEST_TYPE,
+        action: 'getDiagnostics',
+    }, NATIVE_MEDIA_PERMISSION_RESULT_TYPE, options);
+}

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

@@ -0,0 +1,17 @@
+import type { NativeCapabilityId } from './types';
+type MediaCapability = Extract<NativeCapabilityId, '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-capabilities/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/media.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAA6B,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE5E,KAAK,eAAe,GAAG,OAAO,CAC5B,kBAAkB,EAClB,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,CAU5B;AAED,+EAA+E;AAC/E,wBAAsB,uBAAuB,CAC3C,WAAW,GAAE,OAAO,GAAG,qBAA4B,GAClD,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED,oFAAoF;AACpF,wBAAsB,2BAA2B,CAC/C,WAAW,GAAE,OAAO,GAAG,qBAA4B,GAClD,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED,+EAA+E;AAC/E,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,yBAAyD,GACjE,OAAO,CAAC,WAAW,CAAC,CAWtB;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAEjE"}

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

@@ -0,0 +1,104 @@
+import { assertMoldableNativeCapabilityAccess, requireMoldableNativeCapabilityAccess, } from './access';
+import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } 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 NativeCapabilityBridgeError)
+        return error;
+    const name = error instanceof DOMException ? error.name : undefined;
+    let code = 'host_error';
+    let retryable = false;
+    if (name === 'NotSupportedError')
+        code = 'unsupported';
+    else if (name === 'NotAllowedError' || name === 'SecurityError') {
+        code = 'permission_denied';
+    }
+    else if (name === 'AbortError') {
+        code = 'aborted';
+        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 toNativeCapabilityBridgeError({
+        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 {
+        await assertMoldableNativeCapabilityAccess(capability);
+        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 {
+        await requireMoldableNativeCapabilityAccess(capability);
+        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 {
+        await requireMoldableNativeCapabilityAccess(capability);
+        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 {
+        await requireMoldableNativeCapabilityAccess(capability);
+        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-capabilities/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-capabilities/midi-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midi-access.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/midi-access.ts"],"names":[],"mappings":"AAGA,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,CAuBrB;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-capabilities/midi-access.js

@@ -0,0 +1,68 @@
+import { requireMoldableNativeCapabilityAccess } from './access';
+import { toNativeCapabilityBridgeError } from './bridge';
+import { abortableMIDI, midiError } from './midi-internal';
+function assertUserGesture() {
+    if (typeof navigator === 'undefined')
+        return;
+    const activation = navigator.userActivation;
+    if (activation && !activation.isActive) {
+        throw toNativeCapabilityBridgeError({
+            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 {
+        await requireMoldableNativeCapabilityAccess('midi', options);
+        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-capabilities/midi-internal.d.ts

@@ -0,0 +1,12 @@
+import { NativeCapabilityBridgeError } from './bridge';
+export type ClearableMIDIOutput = MIDIOutput & {
+    clear?: () => void;
+};
+export declare function midiError(error: unknown, operation: string): NativeCapabilityBridgeError;
+export declare function midiAborted(operation: string): NativeCapabilityBridgeError;
+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-capabilities/midi-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midi-internal.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/midi-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAE5B,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,2BAA2B,CAoC7B;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,2BAA2B,CAK1E;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-capabilities/midi-internal.js

@@ -0,0 +1,88 @@
+import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } from './bridge';
+export function midiError(error, operation) {
+    if (error instanceof NativeCapabilityBridgeError)
+        return error;
+    const name = error instanceof DOMException ? error.name : undefined;
+    let code = 'host_error';
+    let retryable = false;
+    if (name === 'NotSupportedError')
+        code = 'unsupported';
+    else if (name === 'NotAllowedError' || name === 'SecurityError') {
+        code = 'permission_denied';
+    }
+    else if (name === 'AbortError')
+        code = 'aborted';
+    else if (name === 'NotFoundError') {
+        code = '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 toNativeCapabilityBridgeError({
+        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 toNativeCapabilityBridgeError({
+        code: 'unavailable',
+        message: `MIDI ${type} ${id} is unavailable.`,
+        details: { capability: 'midi', portType: type, portId: id },
+        retryable: true,
+    });
+}

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

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