@moldable-ai/ui 0.2.19 → 0.2.20

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

@@ -0,0 +1,266 @@
+import { isNativeCapabilityManifest } from './capabilities';
+import { NATIVE_CAPABILITIES_REQUEST_TYPE, NATIVE_CAPABILITIES_RESULT_TYPE, } from './types';
+const DEFAULT_TIMEOUT_MS = 10_000;
+export const NATIVE_CAPABILITY_CANCEL_REQUEST_TYPE = 'moldable:native-capabilities-cancel';
+const ERROR_CODES = new Set([
+    'invalid_request',
+    'not_in_moldable',
+    'timeout',
+    'aborted',
+    'invalid_response',
+    'unsupported',
+    'unavailable',
+    'permission_denied',
+    'cancelled',
+    'host_error',
+]);
+export class NativeCapabilityBridgeError extends Error {
+    code;
+    details;
+    retryable;
+    constructor(error) {
+        super(error.message);
+        this.name = 'NativeCapabilityBridgeError';
+        this.code = error.code;
+        this.details = error.details;
+        this.retryable = error.retryable;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isNativeCapabilityErrorPayload(value) {
+    return (isRecord(value) &&
+        typeof value.code === 'string' &&
+        ERROR_CODES.has(value.code) &&
+        typeof value.message === 'string');
+}
+export function toNativeCapabilityBridgeError(value, fallbackMessage = 'Native capability request failed.') {
+    if (value instanceof NativeCapabilityBridgeError)
+        return value;
+    if (isNativeCapabilityErrorPayload(value)) {
+        return new NativeCapabilityBridgeError(value);
+    }
+    return new NativeCapabilityBridgeError({
+        code: 'host_error',
+        message: value instanceof Error ? value.message : fallbackMessage,
+        details: value,
+    });
+}
+function makeRequestId() {
+    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+        return `native-capabilities-${crypto.randomUUID()}`;
+    }
+    return `native-capabilities-${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 resolveNativeCapabilityParentOrigin(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 callNativeCapabilityBridge(request, responseType, options = {}) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        return Promise.reject(new NativeCapabilityBridgeError({
+            code: 'not_in_moldable',
+            message: 'Native capability APIs are only available inside Moldable.',
+            retryable: false,
+        }));
+    }
+    const parentOrigin = resolveNativeCapabilityParentOrigin(document.referrer);
+    if (!parentOrigin) {
+        return Promise.reject(new NativeCapabilityBridgeError({
+            code: 'not_in_moldable',
+            message: 'The native capability bridge parent could not be verified.',
+            retryable: false,
+        }));
+    }
+    if (options.signal?.aborted) {
+        return Promise.reject(new NativeCapabilityBridgeError({
+            code: 'aborted',
+            message: 'Native capability 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_CAPABILITY_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 NativeCapabilityBridgeError(error));
+        };
+        const handleAbort = () => {
+            cancelHostRequest();
+            fail({
+                code: 'aborted',
+                message: 'Native capability 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 &&
+                isNativeCapabilityErrorPayload(event.data.error)) {
+                fail(event.data.error);
+                return;
+            }
+            fail({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid native capability response.',
+                details: event.data,
+                retryable: false,
+            });
+        };
+        const timeout = window.setTimeout(() => {
+            cancelHostRequest();
+            fail({
+                code: 'timeout',
+                message: 'Native capability 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 capability request.',
+                details: error,
+                retryable: true,
+            });
+        }
+    });
+}
+export async function getNativeCapabilities(options = {}) {
+    const manifest = await callNativeCapabilityBridge({ type: NATIVE_CAPABILITIES_REQUEST_TYPE }, NATIVE_CAPABILITIES_RESULT_TYPE, options);
+    if (!isNativeCapabilityManifest(manifest)) {
+        throw new NativeCapabilityBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid native capability manifest.',
+            details: manifest,
+            retryable: false,
+        });
+    }
+    return manifest;
+}
+/** Public app-author API for querying the host's native capability manifest. */
+export const getMoldableNativeCapabilities = getNativeCapabilities;

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

@@ -0,0 +1,7 @@
+import { type NativeCapabilityDescriptor, type NativeCapabilityId, type NativeCapabilityManifest } from './types';
+export declare function isNativeCapabilityId(value: unknown): value is NativeCapabilityId;
+export declare function isNativeCapabilityDescriptor(value: unknown, expectedId?: NativeCapabilityId): value is NativeCapabilityDescriptor;
+export declare function isNativeCapabilityManifest(value: unknown): value is NativeCapabilityManifest;
+export declare function getNativeCapability(manifest: NativeCapabilityManifest, id: NativeCapabilityId): NativeCapabilityDescriptor;
+export declare function supportsNativeCapability(manifest: NativeCapabilityManifest, id: NativeCapabilityId): boolean;
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC9B,MAAM,SAAS,CAAA;AA+ChB,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,CAE7B;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,UAAU,CAAC,EAAE,kBAAkB,GAC9B,KAAK,IAAI,0BAA0B,CA4BrC;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,wBAAwB,CAenC;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,wBAAwB,EAClC,EAAE,EAAE,kBAAkB,GACrB,0BAA0B,CAE5B;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,wBAAwB,EAClC,EAAE,EAAE,kBAAkB,GACrB,OAAO,CAET"}

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

@@ -0,0 +1,95 @@
+import { NATIVE_CAPABILITY_IDS, NATIVE_CAPABILITY_MANIFEST_SCHEMA_VERSION, } from './types';
+const CAPABILITY_IDS = new Set(NATIVE_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 isNativeCapabilityId(value) {
+    return typeof value === 'string' && CAPABILITY_IDS.has(value);
+}
+export function isNativeCapabilityDescriptor(value, expectedId) {
+    if (!isRecord(value) || !isNativeCapabilityId(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 isNativeCapabilityManifest(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.schemaVersion !== NATIVE_CAPABILITY_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_CAPABILITY_IDS.every((id) => isNativeCapabilityDescriptor(capabilities[id], id));
+}
+export function getNativeCapability(manifest, id) {
+    return manifest.capabilities[id];
+}
+export function supportsNativeCapability(manifest, id) {
+    return getNativeCapability(manifest, id).support !== 'unsupported';
+}

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

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

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

@@ -0,0 +1,58 @@
+import { requireMoldableNativeCapabilityAccess } from './access';
+import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } 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 NativeCapabilityBridgeError)
+        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 toNativeCapabilityBridgeError({
+        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 {
+        await requireMoldableNativeCapabilityAccess(capability);
+        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 requireMoldableNativeCapabilityAccess(capability);
+        await clipboardFor(capability, 'writeText').writeText(text);
+    }
+    catch (error) {
+        throw clipboardError(capability, error);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { NativeCapabilityBridgeError } from './bridge';
+export type DeviceIoOperation = 'enumerate' | 'request' | 'open' | 'close' | 'read' | 'write';
+export declare function deviceIoError(capability: 'usb' | 'hid' | 'serial', operation: DeviceIoOperation, error: unknown): NativeCapabilityBridgeError;
+export declare function unsupportedDeviceIoError(capability: 'usb' | 'hid' | 'serial'): NativeCapabilityBridgeError;
+export declare function abortedDeviceIoError(capability: 'usb' | 'hid' | 'serial', operation: DeviceIoOperation): NativeCapabilityBridgeError;
+/**
+ * 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-capabilities/device-io-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-io-errors.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/device-io-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAE5B,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,2BAA2B,CAuB7B;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GACnC,2BAA2B,CAO7B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,EACpC,SAAS,EAAE,iBAAiB,GAC3B,2BAA2B,CAO7B;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-capabilities/device-io-errors.js

@@ -0,0 +1,82 @@
+import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } from './bridge';
+function errorCodeFor(error, operation) {
+    if (error instanceof NativeCapabilityBridgeError)
+        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 NativeCapabilityBridgeError)
+        return error;
+    const code = errorCodeFor(error, operation);
+    const cause = error instanceof DOMException ? error.name : undefined;
+    const fallbackMessage = `Unable to ${operation} ${capability} device.`;
+    return toNativeCapabilityBridgeError({
+        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 NativeCapabilityBridgeError({
+        code: 'unsupported',
+        message: `This runtime does not expose the Web ${capability.toUpperCase()} API.`,
+        details: { capability },
+        retryable: false,
+    });
+}
+export function abortedDeviceIoError(capability, operation) {
+    return new NativeCapabilityBridgeError({
+        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-capabilities/displays.d.ts

@@ -0,0 +1,38 @@
+import type { NativeCapabilityRequestEnvelope, NativeCapabilityResultEnvelope } 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 = NativeCapabilityRequestEnvelope<typeof NATIVE_DISPLAYS_REQUEST_TYPE>;
+export type MoldableDisplaysResultMessage = NativeCapabilityResultEnvelope<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-capabilities/displays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displays.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/displays.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,+BAA+B,EAC/B,8BAA8B,EAC/B,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,+BAA+B,CACnE,OAAO,4BAA4B,CACpC,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG,8BAA8B,CACxE,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-capabilities/displays.js

@@ -0,0 +1,12 @@
+import { callNativeCapabilityBridge } 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 callNativeCapabilityBridge({ type: NATIVE_DISPLAYS_REQUEST_TYPE }, NATIVE_DISPLAYS_RESULT_TYPE, options);
+}