@moldable-ai/ui 0.2.18 → 0.2.20

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

@@ -0,0 +1,4 @@
+export { getMoldableBluetoothAvailability, isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+export { connectMoldableBluetoothDevice, MoldableBluetoothConnection, } from './bluetooth-connection';
+export { getMoldableBluetoothCharacteristic, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, writeMoldableBluetoothValue, } from './bluetooth-gatt';
+export { requestMoldableBluetoothWithFallback } from './bluetooth-native-fallback';

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

@@ -0,0 +1,23 @@
+import { type NativeHardwareCapabilityManifest, type NativeHardwareErrorCode, type NativeHardwareErrorPayload } from './types';
+export declare const NATIVE_HARDWARE_CANCEL_REQUEST_TYPE: "moldable:native-hardware-cancel";
+export interface NativeHardwareBridgeOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare class NativeHardwareBridgeError extends Error {
+    readonly code: NativeHardwareErrorCode;
+    readonly details?: unknown;
+    readonly retryable?: boolean;
+    constructor(error: NativeHardwareErrorPayload);
+}
+export declare function toNativeHardwareBridgeError(value: unknown, fallbackMessage?: string): NativeHardwareBridgeError;
+/** Resolve only desktop-owned parent origins; unknown embedders fail closed. */
+export declare function resolveNativeHardwareParentOrigin(referrer: string, immediateAncestorOrigin?: string, currentOrigin?: string, allowDevelopmentOrigin?: boolean): string | null;
+export declare function callNativeHardwareBridge<TResult>(request: {
+    type: string;
+    [key: string]: unknown;
+}, responseType: string, options?: NativeHardwareBridgeOptions): Promise<TResult>;
+export declare function getNativeHardwareCapabilities(options?: NativeHardwareBridgeOptions): Promise<NativeHardwareCapabilityManifest>;
+/** Public app-author API for querying the host's native capability manifest. */
+export declare const getMoldableNativeCapabilities: typeof getNativeHardwareCapabilities;
+//# sourceMappingURL=bridge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bridge.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAChC,MAAM,SAAS,CAAA;AAGhB,eAAO,MAAM,mCAAmC,EAC9C,iCAA0C,CAAA;AAc5C,MAAM,WAAW,2BAA2B;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAA;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;gBAEhB,KAAK,EAAE,0BAA0B;CAO9C;AAiBD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,eAAe,SAAoC,GAClD,yBAAyB,CAW3B;AA6FD,gFAAgF;AAChF,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,EAChB,uBAAuB,SAAgC,EACvD,aAAa,SAAyB,EACtC,sBAAsB,UAAmC,GACxD,MAAM,GAAG,IAAI,CAoBf;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAC9C,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EACjD,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,OAAO,CAAC,CAqIlB;AAED,wBAAsB,6BAA6B,CACjD,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,gCAAgC,CAAC,CAkB3C;AAED,gFAAgF;AAChF,eAAO,MAAM,6BAA6B,sCAAgC,CAAA"}

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

@@ -0,0 +1,266 @@
+import { isNativeHardwareCapabilityManifest } from './capabilities';
+import { NATIVE_HARDWARE_CAPABILITIES_REQUEST_TYPE, NATIVE_HARDWARE_CAPABILITIES_RESULT_TYPE, } from './types';
+const DEFAULT_TIMEOUT_MS = 10_000;
+export const NATIVE_HARDWARE_CANCEL_REQUEST_TYPE = 'moldable:native-hardware-cancel';
+const ERROR_CODES = new Set([
+    'invalid_request',
+    'not_in_moldable',
+    'timeout',
+    'aborted',
+    'invalid_response',
+    'unsupported',
+    'unavailable',
+    'permission_denied',
+    'cancelled',
+    'host_error',
+]);
+export class NativeHardwareBridgeError extends Error {
+    code;
+    details;
+    retryable;
+    constructor(error) {
+        super(error.message);
+        this.name = 'NativeHardwareBridgeError';
+        this.code = error.code;
+        this.details = error.details;
+        this.retryable = error.retryable;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isNativeHardwareErrorPayload(value) {
+    return (isRecord(value) &&
+        typeof value.code === 'string' &&
+        ERROR_CODES.has(value.code) &&
+        typeof value.message === 'string');
+}
+export function toNativeHardwareBridgeError(value, fallbackMessage = 'Native hardware request failed.') {
+    if (value instanceof NativeHardwareBridgeError)
+        return value;
+    if (isNativeHardwareErrorPayload(value)) {
+        return new NativeHardwareBridgeError(value);
+    }
+    return new NativeHardwareBridgeError({
+        code: 'host_error',
+        message: value instanceof Error ? value.message : fallbackMessage,
+        details: value,
+    });
+}
+function makeRequestId() {
+    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+        return `native-hardware-${crypto.randomUUID()}`;
+    }
+    return `native-hardware-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function hasExplicitAuthorityPort(value) {
+    const authorityStart = value.indexOf('//');
+    if (authorityStart < 0)
+        return false;
+    const authority = value
+        .slice(authorityStart + 2)
+        .split(/[/?#]/, 1)[0]
+        ?.split('@')
+        .at(-1);
+    return authority?.includes(':') === true;
+}
+function resolveDesktopOwnedOrigin(value, allowDevelopmentOrigin) {
+    try {
+        const url = new URL(value);
+        const hasUnexpectedAuthority = url.username !== '' ||
+            url.password !== '' ||
+            hasExplicitAuthorityPort(value);
+        if (url.protocol === 'tauri:' &&
+            url.hostname === 'localhost' &&
+            !hasUnexpectedAuthority) {
+            return `${url.protocol}//${url.host}`;
+        }
+        if ((url.protocol === 'http:' || url.protocol === 'https:') &&
+            url.hostname === 'tauri.localhost' &&
+            !hasUnexpectedAuthority) {
+            return url.origin;
+        }
+        if (allowDevelopmentOrigin &&
+            url.protocol === 'http:' &&
+            (url.hostname === 'localhost' || url.hostname === '127.0.0.1') &&
+            url.port === '5173') {
+            return url.origin;
+        }
+    }
+    catch {
+        // Invalid origins are never trusted.
+    }
+    return null;
+}
+function readImmediateAncestorOrigin() {
+    try {
+        return window.location.ancestorOrigins?.item(0) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function referrerMatchesCurrentOrigin(referrer, currentOrigin) {
+    try {
+        const referrerOrigin = new URL(referrer).origin;
+        const documentOrigin = new URL(currentOrigin).origin;
+        return (referrerOrigin !== 'null' &&
+            documentOrigin !== 'null' &&
+            referrerOrigin === documentOrigin);
+    }
+    catch {
+        return false;
+    }
+}
+function allowsDesktopDevelopmentOrigin() {
+    return (import.meta.env.DEV &&
+        import.meta.env.VITE_MOLDABLE_DESKTOP_DEV_BRIDGE === 'true');
+}
+/** Resolve only desktop-owned parent origins; unknown embedders fail closed. */
+export function resolveNativeHardwareParentOrigin(referrer, immediateAncestorOrigin = readImmediateAncestorOrigin(), currentOrigin = window.location.origin, allowDevelopmentOrigin = allowsDesktopDevelopmentOrigin()) {
+    const referrerValue = referrer.trim();
+    if (referrerValue) {
+        const trustedReferrer = resolveDesktopOwnedOrigin(referrerValue, allowDevelopmentOrigin);
+        if (trustedReferrer)
+            return trustedReferrer;
+        // A same-origin reload or HMR navigation can replace the parent referrer
+        // with the app's own URL. In that case the browser-owned ancestor list is
+        // still the authoritative embedding boundary. A different untrusted
+        // referrer never reaches this fallback.
+        if (!referrerMatchesCurrentOrigin(referrerValue, currentOrigin))
+            return null;
+    }
+    return resolveDesktopOwnedOrigin(immediateAncestorOrigin.trim(), allowDevelopmentOrigin);
+}
+export function callNativeHardwareBridge(request, responseType, options = {}) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        return Promise.reject(new NativeHardwareBridgeError({
+            code: 'not_in_moldable',
+            message: 'Native hardware APIs are only available inside Moldable.',
+            retryable: false,
+        }));
+    }
+    const parentOrigin = resolveNativeHardwareParentOrigin(document.referrer);
+    if (!parentOrigin) {
+        return Promise.reject(new NativeHardwareBridgeError({
+            code: 'not_in_moldable',
+            message: 'The native hardware bridge parent could not be verified.',
+            retryable: false,
+        }));
+    }
+    if (options.signal?.aborted) {
+        return Promise.reject(new NativeHardwareBridgeError({
+            code: 'aborted',
+            message: 'Native hardware request was aborted.',
+            retryable: false,
+        }));
+    }
+    return new Promise((resolve, reject) => {
+        const requestId = makeRequestId();
+        const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        let settled = false;
+        const cleanup = () => {
+            window.clearTimeout(timeout);
+            window.removeEventListener('message', handleResponse);
+            options.signal?.removeEventListener('abort', handleAbort);
+        };
+        const cancelHostRequest = () => {
+            if (settled)
+                return;
+            try {
+                window.parent.postMessage({
+                    type: NATIVE_HARDWARE_CANCEL_REQUEST_TYPE,
+                    requestType: request.type,
+                    requestId,
+                }, parentOrigin);
+            }
+            catch {
+                // The local rejection still completes if the parent disappeared.
+            }
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new NativeHardwareBridgeError(error));
+        };
+        const handleAbort = () => {
+            cancelHostRequest();
+            fail({
+                code: 'aborted',
+                message: 'Native hardware request was aborted.',
+                retryable: false,
+            });
+        };
+        const handleResponse = (event) => {
+            if (event.source !== window.parent)
+                return;
+            if (event.origin !== parentOrigin)
+                return;
+            if (!isRecord(event.data))
+                return;
+            if (event.data.type !== responseType)
+                return;
+            if (event.data.requestId !== requestId)
+                return;
+            if (event.data.ok === true && 'result' in event.data) {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(event.data.result);
+                return;
+            }
+            if (event.data.ok === false &&
+                isNativeHardwareErrorPayload(event.data.error)) {
+                fail(event.data.error);
+                return;
+            }
+            fail({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid native hardware response.',
+                details: event.data,
+                retryable: false,
+            });
+        };
+        const timeout = window.setTimeout(() => {
+            cancelHostRequest();
+            fail({
+                code: 'timeout',
+                message: 'Native hardware request timed out.',
+                details: { timeoutMs },
+                retryable: true,
+            });
+        }, timeoutMs);
+        window.addEventListener('message', handleResponse);
+        options.signal?.addEventListener('abort', handleAbort, { once: true });
+        try {
+            window.parent.postMessage({ ...request, requestId }, parentOrigin);
+        }
+        catch (error) {
+            fail({
+                code: 'host_error',
+                message: error instanceof Error
+                    ? error.message
+                    : 'Failed to send native hardware request.',
+                details: error,
+                retryable: true,
+            });
+        }
+    });
+}
+export async function getNativeHardwareCapabilities(options = {}) {
+    const manifest = await callNativeHardwareBridge({ type: NATIVE_HARDWARE_CAPABILITIES_REQUEST_TYPE }, NATIVE_HARDWARE_CAPABILITIES_RESULT_TYPE, options);
+    if (!isNativeHardwareCapabilityManifest(manifest)) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid native hardware manifest.',
+            details: manifest,
+            retryable: false,
+        });
+    }
+    return manifest;
+}
+/** Public app-author API for querying the host's native capability manifest. */
+export const getMoldableNativeCapabilities = getNativeHardwareCapabilities;

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

@@ -0,0 +1,7 @@
+import { type NativeHardwareCapabilityDescriptor, type NativeHardwareCapabilityId, type NativeHardwareCapabilityManifest } from './types';
+export declare function isNativeHardwareCapabilityId(value: unknown): value is NativeHardwareCapabilityId;
+export declare function isNativeHardwareCapabilityDescriptor(value: unknown, expectedId?: NativeHardwareCapabilityId): value is NativeHardwareCapabilityDescriptor;
+export declare function isNativeHardwareCapabilityManifest(value: unknown): value is NativeHardwareCapabilityManifest;
+export declare function getNativeHardwareCapability(manifest: NativeHardwareCapabilityManifest, id: NativeHardwareCapabilityId): NativeHardwareCapabilityDescriptor;
+export declare function supportsNativeHardwareCapability(manifest: NativeHardwareCapabilityManifest, id: NativeHardwareCapabilityId): boolean;
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kCAAkC,EACvC,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACtC,MAAM,SAAS,CAAA;AA+ChB,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,0BAA0B,CAErC;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,OAAO,EACd,UAAU,CAAC,EAAE,0BAA0B,GACtC,KAAK,IAAI,kCAAkC,CA4B7C;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,gCAAgC,CAe3C;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,gCAAgC,EAC1C,EAAE,EAAE,0BAA0B,GAC7B,kCAAkC,CAEpC;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,gCAAgC,EAC1C,EAAE,EAAE,0BAA0B,GAC7B,OAAO,CAET"}

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

@@ -0,0 +1,95 @@
+import { NATIVE_HARDWARE_CAPABILITY_IDS, NATIVE_HARDWARE_MANIFEST_SCHEMA_VERSION, } from './types';
+const CAPABILITY_IDS = new Set(NATIVE_HARDWARE_CAPABILITY_IDS);
+const PLATFORMS = new Set(['macos', 'windows', 'linux', 'unknown']);
+const SUPPORT_LEVELS = new Set(['supported', 'partial', 'unsupported']);
+const TRANSPORT_KINDS = new Set([
+    'web-api',
+    'desktop-bridge',
+    'tauri-command',
+    'hybrid',
+    'unavailable',
+]);
+const PERMISSION_NAMES = new Set([
+    'camera',
+    'microphone',
+    'screen-recording',
+    'location',
+    'clipboard-read',
+    'clipboard-write',
+    'notifications',
+    'global-shortcuts',
+    'local-authentication',
+    'secure-storage',
+    'usb',
+    'hid',
+    'serial',
+    'midi',
+    'bluetooth',
+    'none',
+]);
+const PERMISSION_AUTHORITIES = new Set([
+    'webview',
+    'operating-system',
+    'both',
+    'none',
+]);
+const PERMISSION_REQUESTS = new Set([
+    'on-use',
+    'explicit',
+    'system-settings',
+    'none',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function isNativeHardwareCapabilityId(value) {
+    return typeof value === 'string' && CAPABILITY_IDS.has(value);
+}
+export function isNativeHardwareCapabilityDescriptor(value, expectedId) {
+    if (!isRecord(value) || !isNativeHardwareCapabilityId(value.id))
+        return false;
+    if (expectedId && value.id !== expectedId)
+        return false;
+    if (typeof value.support !== 'string' || !SUPPORT_LEVELS.has(value.support)) {
+        return false;
+    }
+    if (!isRecord(value.transport))
+        return false;
+    if (typeof value.transport.kind !== 'string' ||
+        !TRANSPORT_KINDS.has(value.transport.kind) ||
+        typeof value.transport.name !== 'string') {
+        return false;
+    }
+    if (!isRecord(value.permission))
+        return false;
+    if (typeof value.permission.name !== 'string' ||
+        !PERMISSION_NAMES.has(value.permission.name) ||
+        typeof value.permission.required !== 'boolean' ||
+        typeof value.permission.authority !== 'string' ||
+        !PERMISSION_AUTHORITIES.has(value.permission.authority) ||
+        typeof value.permission.request !== 'string' ||
+        !PERMISSION_REQUESTS.has(value.permission.request)) {
+        return false;
+    }
+    return value.reason === undefined || typeof value.reason === 'string';
+}
+export function isNativeHardwareCapabilityManifest(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.schemaVersion !== NATIVE_HARDWARE_MANIFEST_SCHEMA_VERSION) {
+        return false;
+    }
+    if (typeof value.platform !== 'string' || !PLATFORMS.has(value.platform)) {
+        return false;
+    }
+    if (!isRecord(value.capabilities))
+        return false;
+    const capabilities = value.capabilities;
+    return NATIVE_HARDWARE_CAPABILITY_IDS.every((id) => isNativeHardwareCapabilityDescriptor(capabilities[id], id));
+}
+export function getNativeHardwareCapability(manifest, id) {
+    return manifest.capabilities[id];
+}
+export function supportsNativeHardwareCapability(manifest, id) {
+    return getNativeHardwareCapability(manifest, id).support !== 'unsupported';
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Reads plain text from the clipboard. Browsers generally require a secure context,
+ * clipboard permission, and a recent user gesture for reads.
+ */
+export declare function readMoldableClipboardText(): Promise<string>;
+/**
+ * Writes plain text to the clipboard. Browsers require a secure context and may
+ * require this call to run directly in response to a user gesture.
+ */
+export declare function writeMoldableClipboardText(text: string): Promise<void>;
+//# sourceMappingURL=clipboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/clipboard.ts"],"names":[],"mappings":"AA6DA;;;GAGG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,MAAM,CAAC,CAQjE;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ5E"}

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

@@ -0,0 +1,55 @@
+import { NativeHardwareBridgeError, toNativeHardwareBridgeError, } from './bridge';
+function clipboardFor(capability, method) {
+    if (typeof navigator === 'undefined' ||
+        !navigator.clipboard ||
+        typeof navigator.clipboard[method] !== 'function') {
+        throw clipboardError(capability, new DOMException('Clipboard API unavailable', 'NotSupportedError'));
+    }
+    return navigator.clipboard;
+}
+function clipboardError(capability, error) {
+    if (error instanceof NativeHardwareBridgeError)
+        return error;
+    const name = error instanceof DOMException ? error.name : undefined;
+    let code = 'host_error';
+    if (name === 'NotSupportedError')
+        code = 'unsupported';
+    else if (name === 'NotAllowedError' || name === 'SecurityError') {
+        code = 'permission_denied';
+    }
+    const fallbackMessage = `Unable to ${capability === 'clipboard-read' ? 'read' : 'write'} clipboard text`;
+    return toNativeHardwareBridgeError({
+        code,
+        message: error instanceof Error
+            ? error.message || fallbackMessage
+            : fallbackMessage,
+        details: { capability, ...(name ? { cause: name } : {}) },
+        retryable: false,
+    }, fallbackMessage);
+}
+/**
+ * Reads plain text from the clipboard. Browsers generally require a secure context,
+ * clipboard permission, and a recent user gesture for reads.
+ */
+export async function readMoldableClipboardText() {
+    const capability = 'clipboard-read';
+    try {
+        return await clipboardFor(capability, 'readText').readText();
+    }
+    catch (error) {
+        throw clipboardError(capability, error);
+    }
+}
+/**
+ * Writes plain text to the clipboard. Browsers require a secure context and may
+ * require this call to run directly in response to a user gesture.
+ */
+export async function writeMoldableClipboardText(text) {
+    const capability = 'clipboard-write';
+    try {
+        await clipboardFor(capability, 'writeText').writeText(text);
+    }
+    catch (error) {
+        throw clipboardError(capability, error);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { NativeHardwareBridgeError } from './bridge';
+export type DeviceIoOperation = 'enumerate' | 'request' | 'open' | 'close' | 'read' | 'write';
+export declare function deviceIoError(capability: 'usb' | 'hid' | 'serial', operation: DeviceIoOperation, error: unknown): NativeHardwareBridgeError;
+export declare function unsupportedDeviceIoError(capability: 'usb' | 'hid' | 'serial'): NativeHardwareBridgeError;
+export declare function abortedDeviceIoError(capability: 'usb' | 'hid' | 'serial', operation: DeviceIoOperation): NativeHardwareBridgeError;
+/**
+ * Rejects promptly when the caller aborts. The browser operation itself may
+ * continue when its underlying standard does not accept an AbortSignal.
+ */
+export declare function awaitDeviceIoWithAbort<T>(promise: Promise<T>, capability: 'usb' | 'hid' | 'serial', operation: DeviceIoOperation, signal?: AbortSignal): Promise<T>;
+//# sourceMappingURL=device-io-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-io-errors.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/device-io-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EAE1B,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,iBAAiB,GACzB,WAAW,GACX,SAAS,GACT,MAAM,GACN,OAAO,GACP,MAAM,GACN,OAAO,CAAA;AA8BX,wBAAgB,aAAa,CAC3B,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,EACpC,SAAS,EAAE,iBAAiB,EAC5B,KAAK,EAAE,OAAO,GACb,yBAAyB,CAuB3B;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GACnC,yBAAyB,CAO3B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,EACpC,SAAS,EAAE,iBAAiB,GAC3B,yBAAyB,CAO3B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,EACpC,SAAS,EAAE,iBAAiB,EAC5B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

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

@@ -0,0 +1,82 @@
+import { NativeHardwareBridgeError, toNativeHardwareBridgeError, } from './bridge';
+function errorCodeFor(error, operation) {
+    if (error instanceof NativeHardwareBridgeError)
+        return error.code;
+    const name = error instanceof DOMException ? error.name : undefined;
+    if (name === 'NotSupportedError')
+        return 'unsupported';
+    if (name === 'NotAllowedError' || name === 'SecurityError') {
+        return 'permission_denied';
+    }
+    if (name === 'AbortError')
+        return 'aborted';
+    if (name === 'NotFoundError') {
+        return operation === 'request' ? 'cancelled' : 'unavailable';
+    }
+    if (name === 'InvalidStateError' ||
+        name === 'DataError' ||
+        error instanceof TypeError) {
+        return 'invalid_request';
+    }
+    if (name === 'NetworkError')
+        return 'unavailable';
+    return 'host_error';
+}
+export function deviceIoError(capability, operation, error) {
+    if (error instanceof NativeHardwareBridgeError)
+        return error;
+    const code = errorCodeFor(error, operation);
+    const cause = error instanceof DOMException ? error.name : undefined;
+    const fallbackMessage = `Unable to ${operation} ${capability} device.`;
+    return toNativeHardwareBridgeError({
+        code,
+        message: error instanceof Error && error.message
+            ? error.message
+            : fallbackMessage,
+        details: { capability, operation, ...(cause ? { cause } : {}) },
+        retryable: code === 'unavailable' ||
+            code === 'cancelled' ||
+            code === 'aborted' ||
+            code === 'host_error',
+    }, fallbackMessage);
+}
+export function unsupportedDeviceIoError(capability) {
+    return new NativeHardwareBridgeError({
+        code: 'unsupported',
+        message: `This runtime does not expose the Web ${capability.toUpperCase()} API.`,
+        details: { capability },
+        retryable: false,
+    });
+}
+export function abortedDeviceIoError(capability, operation) {
+    return new NativeHardwareBridgeError({
+        code: 'aborted',
+        message: `${capability.toUpperCase()} ${operation} was aborted.`,
+        details: { capability, operation },
+        retryable: true,
+    });
+}
+/**
+ * Rejects promptly when the caller aborts. The browser operation itself may
+ * continue when its underlying standard does not accept an AbortSignal.
+ */
+export function awaitDeviceIoWithAbort(promise, capability, operation, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        return Promise.reject(abortedDeviceIoError(capability, operation));
+    }
+    return new Promise((resolve, reject) => {
+        const handleAbort = () => {
+            reject(abortedDeviceIoError(capability, operation));
+        };
+        signal.addEventListener('abort', handleAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener('abort', handleAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', handleAbort);
+            reject(error);
+        });
+    });
+}

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

@@ -0,0 +1,38 @@
+import type { NativeHardwareRequestEnvelope, NativeHardwareResultEnvelope } from './types';
+export declare const NATIVE_DISPLAYS_REQUEST_TYPE: "moldable:native-displays";
+export declare const NATIVE_DISPLAYS_RESULT_TYPE: "moldable:native-displays-result";
+/** A position in physical screen pixels within the virtual desktop. */
+export interface MoldableDisplayPosition {
+    x: number;
+    y: number;
+}
+/** A size in physical screen pixels. */
+export interface MoldableDisplaySize {
+    width: number;
+    height: number;
+}
+/** Serializable display metadata. This API never returns screen pixels. */
+export interface MoldableDisplay {
+    name: string | null;
+    position: MoldableDisplayPosition;
+    size: MoldableDisplaySize;
+    scaleFactor: number;
+    primary: boolean;
+}
+export interface MoldableDisplaysResult {
+    displays: MoldableDisplay[];
+}
+export type MoldableDisplaysRequest = NativeHardwareRequestEnvelope<typeof NATIVE_DISPLAYS_REQUEST_TYPE>;
+export type MoldableDisplaysResultMessage = NativeHardwareResultEnvelope<typeof NATIVE_DISPLAYS_RESULT_TYPE, MoldableDisplaysResult>;
+export interface GetMoldableDisplaysOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Query metadata for the displays attached to the native desktop host.
+ *
+ * This is intentionally a one-shot query. Display polling and change events are
+ * not exposed because monitor metadata can contribute to device fingerprinting.
+ */
+export declare function getMoldableDisplays(options?: GetMoldableDisplaysOptions): Promise<MoldableDisplaysResult>;
+//# sourceMappingURL=displays.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"displays.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/displays.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAC7B,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,4BAA4B,EAAG,0BAAmC,CAAA;AAC/E,eAAO,MAAM,2BAA2B,EACtC,iCAA0C,CAAA;AAE5C,uEAAuE;AACvE,MAAM,WAAW,uBAAuB;IACtC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,wCAAwC;AACxC,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,QAAQ,EAAE,uBAAuB,CAAA;IACjC,IAAI,EAAE,mBAAmB,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,eAAe,EAAE,CAAA;CAC5B;AAED,MAAM,MAAM,uBAAuB,GAAG,6BAA6B,CACjE,OAAO,4BAA4B,CACpC,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG,4BAA4B,CACtE,OAAO,2BAA2B,EAClC,sBAAsB,CACvB,CAAA;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,sBAAsB,CAAC,CAMjC"}

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

@@ -0,0 +1,12 @@
+import { callNativeHardwareBridge } from './bridge';
+export const NATIVE_DISPLAYS_REQUEST_TYPE = 'moldable:native-displays';
+export const NATIVE_DISPLAYS_RESULT_TYPE = 'moldable:native-displays-result';
+/**
+ * Query metadata for the displays attached to the native desktop host.
+ *
+ * This is intentionally a one-shot query. Display polling and change events are
+ * not exposed because monitor metadata can contribute to device fingerprinting.
+ */
+export function getMoldableDisplays(options = {}) {
+    return callNativeHardwareBridge({ type: NATIVE_DISPLAYS_REQUEST_TYPE }, NATIVE_DISPLAYS_RESULT_TYPE, options);
+}