@moldable-ai/ui 0.2.17 → 0.2.19

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

@@ -0,0 +1,214 @@
+import { isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+import { callNativeHardwareBridge, } from './bridge';
+const REQUEST_TYPE = 'moldable:native-bluetooth';
+const RESULT_TYPE = 'moldable:native-bluetooth-result';
+const EVENT_TYPE = 'moldable:native-bluetooth-event';
+function isNativeConnectionResult(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const connection = value;
+    return (typeof connection.connectionId === 'string' &&
+        connection.connectionId.length > 0 &&
+        (connection.name === null || typeof connection.name === 'string'));
+}
+function uuid(value) {
+    if (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= 0 &&
+        value <= 0xffff) {
+        return value.toString(16).padStart(4, '0');
+    }
+    if (typeof value === 'string' && /^[0-9a-fA-F-]{4,64}$/.test(value))
+        return value.toLowerCase();
+    throw new TypeError('The native Bluetooth fallback requires numeric or UUID service identifiers.');
+}
+function dataBytes(source) {
+    const bytes = source instanceof ArrayBuffer
+        ? new Uint8Array(source)
+        : new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    if (bytes.byteLength > 512)
+        throw new TypeError('Bluetooth values are limited to 512 bytes.');
+    return Array.from(bytes);
+}
+function nativeRequest(connectionId, action, payload, options = {}) {
+    return callNativeHardwareBridge({ type: REQUEST_TYPE, action, connectionId, ...payload }, RESULT_TYPE, options);
+}
+function nativeDevice(connection) {
+    let disconnected = false;
+    const events = new EventTarget();
+    const activeSubscriptions = new Set();
+    const transitionDisconnected = () => {
+        if (disconnected)
+            return;
+        disconnected = true;
+        window.removeEventListener('message', onLifecycleMessage);
+        for (const cleanup of [...activeSubscriptions]) {
+            void cleanup().catch(() => undefined);
+        }
+        events.dispatchEvent(new Event('gattserverdisconnected'));
+    };
+    function onLifecycleMessage(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.connectionId === connection.connectionId &&
+            (value.kind === 'disconnected' || value.kind === 'adapterUnavailable')) {
+            transitionDisconnected();
+        }
+    }
+    window.addEventListener('message', onLifecycleMessage);
+    const assertConnected = () => {
+        if (disconnected) {
+            throw new DOMException('The Bluetooth device is disconnected.', 'InvalidStateError');
+        }
+    };
+    return {
+        id: connection.connectionId,
+        name: connection.name,
+        get connected() {
+            return !disconnected;
+        },
+        addEventListener(type, listener, options) {
+            events.addEventListener(type, listener, options);
+        },
+        removeEventListener(type, listener, options) {
+            events.removeEventListener(type, listener, options);
+        },
+        async getServices(options) {
+            assertConnected();
+            return nativeRequest(connection.connectionId, 'getServices', {}, options);
+        },
+        async read(serviceUuid, characteristicUuid, options) {
+            assertConnected();
+            const data = await nativeRequest(connection.connectionId, 'read', {
+                serviceUuid: uuid(serviceUuid),
+                characteristicUuid: uuid(characteristicUuid),
+            }, options);
+            if (!Array.isArray(data) ||
+                !data.every((byte) => Number.isInteger(byte))) {
+                throw new TypeError('The desktop returned an invalid Bluetooth value.');
+            }
+            return new DataView(Uint8Array.from(data).buffer);
+        },
+        async write(serviceUuid, characteristicUuid, data, options) {
+            assertConnected();
+            await nativeRequest(connection.connectionId, 'write', {
+                serviceUuid: uuid(serviceUuid),
+                characteristicUuid: uuid(characteristicUuid),
+                data: dataBytes(data),
+                withResponse: options?.withResponse !== false,
+            }, options);
+        },
+        async observe(serviceUuid, characteristicUuid, listener, options) {
+            assertConnected();
+            const service = uuid(serviceUuid);
+            const characteristic = uuid(characteristicUuid);
+            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.connectionId !== connection.connectionId ||
+                    value.kind !== 'notification' ||
+                    value.serviceUuid !== service ||
+                    value.characteristicUuid !== characteristic ||
+                    !Array.isArray(value.data))
+                    return;
+                if (!value.data.every((byte) => Number.isInteger(byte) &&
+                    Number(byte) >= 0 &&
+                    Number(byte) <= 255)) {
+                    return;
+                }
+                listener(new DataView(Uint8Array.from(value.data).buffer));
+            };
+            window.addEventListener('message', onMessage);
+            try {
+                await nativeRequest(connection.connectionId, 'subscribe', { serviceUuid: service, characteristicUuid: characteristic }, options);
+            }
+            catch (error) {
+                window.removeEventListener('message', onMessage);
+                throw error;
+            }
+            let cleanupPromise = null;
+            const cleanup = () => {
+                if (cleanupPromise)
+                    return cleanupPromise;
+                window.removeEventListener('message', onMessage);
+                options?.signal?.removeEventListener('abort', handleAbort);
+                activeSubscriptions.delete(cleanup);
+                cleanupPromise = disconnected
+                    ? Promise.resolve()
+                    : nativeRequest(connection.connectionId, 'unsubscribe', { serviceUuid: service, characteristicUuid: characteristic }, { timeoutMs: options?.timeoutMs }).then(() => undefined);
+                return cleanupPromise;
+            };
+            const handleAbort = () => void cleanup().catch(() => undefined);
+            activeSubscriptions.add(cleanup);
+            options?.signal?.addEventListener('abort', handleAbort, { once: true });
+            if (options?.signal?.aborted)
+                handleAbort();
+            return cleanup;
+        },
+        async disconnect(options) {
+            if (disconnected)
+                return;
+            window.removeEventListener('message', onLifecycleMessage);
+            const subscriptions = [...activeSubscriptions];
+            disconnected = true;
+            await Promise.allSettled(subscriptions.map((cleanup) => cleanup()));
+            try {
+                await nativeRequest(connection.connectionId, 'disconnect', {}, options);
+            }
+            finally {
+                events.dispatchEvent(new Event('gattserverdisconnected'));
+            }
+        },
+    };
+}
+/**
+ * Uses Web Bluetooth first, with a restrictive desktop BLE chooser fallback.
+ * The native branch mirrors physical disconnect and adapter-loss events.
+ */
+export async function requestMoldableBluetoothWithFallback(options, bridgeOptions = {}) {
+    if (isMoldableBluetoothSupported()) {
+        return {
+            kind: 'web-bluetooth',
+            device: await requestMoldableBluetoothDevice(options, bridgeOptions),
+        };
+    }
+    if (!('filters' in options) || !options.filters?.length) {
+        throw new TypeError('The native Bluetooth fallback does not allow acceptAllDevices.');
+    }
+    const filters = options.filters.map((filter) => {
+        if (filter.manufacturerData?.length || filter.serviceData?.length) {
+            throw new TypeError('The native Bluetooth fallback does not support data filters yet.');
+        }
+        return {
+            name: filter.name,
+            namePrefix: filter.namePrefix,
+            services: filter.services?.map(uuid),
+        };
+    });
+    const result = await callNativeHardwareBridge({
+        type: REQUEST_TYPE,
+        action: 'requestDevice',
+        filters,
+        optionalServices: options.optionalServices?.map(uuid) ?? [],
+    }, RESULT_TYPE, { timeoutMs: 120_000, ...bridgeOptions });
+    if (!isNativeConnectionResult(result)) {
+        throw new TypeError('The desktop returned an invalid Bluetooth device.');
+    }
+    return { kind: 'desktop-bridge', device: nativeDevice(result) };
+}

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

@@ -0,0 +1,85 @@
+/** Local structural Web Bluetooth types for runtimes whose DOM library omits them. */
+export type MoldableBluetoothUUID = string | number;
+export interface MoldableBluetoothDataFilter {
+    dataPrefix?: BufferSource;
+    mask?: BufferSource;
+}
+export interface MoldableBluetoothManufacturerDataFilter extends MoldableBluetoothDataFilter {
+    companyIdentifier: number;
+}
+export interface MoldableBluetoothServiceDataFilter extends MoldableBluetoothDataFilter {
+    service: MoldableBluetoothUUID;
+}
+export interface MoldableBluetoothLEScanFilter {
+    name?: string;
+    namePrefix?: string;
+    services?: MoldableBluetoothUUID[];
+    manufacturerData?: MoldableBluetoothManufacturerDataFilter[];
+    serviceData?: MoldableBluetoothServiceDataFilter[];
+}
+export type MoldableBluetoothRequestDeviceOptions = {
+    filters: MoldableBluetoothLEScanFilter[];
+    acceptAllDevices?: false;
+    optionalServices?: MoldableBluetoothUUID[];
+    optionalManufacturerData?: number[];
+} | {
+    filters?: never;
+    acceptAllDevices: true;
+    optionalServices?: MoldableBluetoothUUID[];
+    optionalManufacturerData?: number[];
+};
+export interface MoldableBluetoothRemoteGATTCharacteristic extends EventTarget {
+    readonly service: MoldableBluetoothRemoteGATTService;
+    readonly uuid: string;
+    readonly value?: DataView;
+    startNotifications(): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+    stopNotifications(): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+    readValue(): Promise<DataView>;
+    writeValue(value: BufferSource): Promise<void>;
+    writeValueWithResponse?(value: BufferSource): Promise<void>;
+    writeValueWithoutResponse?(value: BufferSource): Promise<void>;
+}
+export interface MoldableBluetoothRemoteGATTService {
+    readonly device: MoldableBluetoothDevice;
+    readonly isPrimary: boolean;
+    readonly uuid: string;
+    getCharacteristic(characteristic: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
+    getCharacteristics(characteristic?: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTCharacteristic[]>;
+}
+export interface MoldableBluetoothRemoteGATTServer {
+    readonly connected: boolean;
+    readonly device: MoldableBluetoothDevice;
+    connect(): Promise<MoldableBluetoothRemoteGATTServer>;
+    disconnect(): void;
+    getPrimaryService(service: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTService>;
+    getPrimaryServices(service?: MoldableBluetoothUUID): Promise<MoldableBluetoothRemoteGATTService[]>;
+}
+export interface MoldableBluetoothDeviceEventMap {
+    gattserverdisconnected: Event;
+}
+export interface MoldableBluetoothDevice extends EventTarget {
+    readonly id: string;
+    readonly name?: string;
+    readonly gatt?: MoldableBluetoothRemoteGATTServer;
+    addEventListener<K extends keyof MoldableBluetoothDeviceEventMap>(type: K, listener: (event: MoldableBluetoothDeviceEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MoldableBluetoothDeviceEventMap>(type: K, listener: (event: MoldableBluetoothDeviceEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+}
+export interface MoldableBluetoothAPI {
+    getAvailability?(): Promise<boolean>;
+    requestDevice(options: MoldableBluetoothRequestDeviceOptions): Promise<MoldableBluetoothDevice>;
+}
+export interface MoldableBluetoothNavigator extends Navigator {
+    bluetooth?: MoldableBluetoothAPI;
+}
+export type MoldableBluetoothAvailability = 'available' | 'unavailable' | 'unknown';
+export interface MoldableBluetoothRequestOptions {
+    signal?: AbortSignal;
+}
+export interface MoldableBluetoothConnectionOptions {
+    signal?: AbortSignal;
+}
+export interface MoldableBluetoothOperationOptions {
+    signal?: AbortSignal;
+}
+export type MoldableBluetoothWriteMode = 'with-response' | 'without-response' | 'automatic';
+//# sourceMappingURL=bluetooth-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-types.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth-types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+/** Local structural Web Bluetooth types for runtimes whose DOM library omits them. */
+export {};

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

@@ -0,0 +1,7 @@
+export { getMoldableBluetoothAvailability, isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
+export { connectMoldableBluetoothDevice, MoldableBluetoothConnection, } from './bluetooth-connection';
+export { getMoldableBluetoothCharacteristic, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, writeMoldableBluetoothValue, } from './bluetooth-gatt';
+export type * from './bluetooth-types';
+export { requestMoldableBluetoothWithFallback } from './bluetooth-native-fallback';
+export type { MoldableBluetoothTransport, MoldableNativeBluetoothDevice, MoldableNativeBluetoothService, } from './bluetooth-native-fallback';
+//# sourceMappingURL=bluetooth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/bluetooth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gCAAgC,EAChC,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,kCAAkC,EAClC,qCAAqC,EACrC,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,kBAAkB,CAAA;AACzB,mBAAmB,mBAAmB,CAAA;AACtC,OAAO,EAAE,oCAAoC,EAAE,MAAM,6BAA6B,CAAA;AAClF,YAAY,EACV,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,6BAA6B,CAAA"}

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"}