@moldable-ai/ui 0.2.21 → 0.2.24

package/dist/lib/host-services.js

@@ -0,0 +1,161 @@
+import { getMoldableHostServices } from './frame-lifecycle.js';
+const HOST_SERVICE_REQUEST_TYPE = 'moldable:service-request';
+const HOST_SERVICE_RESPONSE_TYPE = 'moldable:service-response';
+const HOST_SERVICE_CANCEL_TYPE = 'moldable:service-cancel';
+const HOST_SERVICE_DEFAULT_TIMEOUT_MS = 15_000;
+const HOST_SERVICE_CLIENT_TIMEOUT_GRACE_MS = 500;
+export class HostServiceRequestError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.name = 'HostServiceRequestError';
+        this.status = status;
+        this.code = code;
+    }
+}
+const pendingRequests = new Map();
+let responseListenerInstalled = false;
+function isServiceResponse(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        !('type' in value) ||
+        value.type !== HOST_SERVICE_RESPONSE_TYPE ||
+        !('requestId' in value) ||
+        typeof value.requestId !== 'string' ||
+        !('status' in value)) {
+        return false;
+    }
+    return (value.status === 'completed' ||
+        value.status === 'cancelled' ||
+        value.status === 'error' ||
+        value.status === 'timeout');
+}
+function removePending(requestId) {
+    const pending = pendingRequests.get(requestId);
+    if (!pending)
+        return null;
+    pendingRequests.delete(requestId);
+    window.clearTimeout(pending.timeoutId);
+    if (pending.signal && pending.abortHandler) {
+        pending.signal.removeEventListener('abort', pending.abortHandler);
+    }
+    return pending;
+}
+function responseError(response, status) {
+    const code = typeof response.error === 'object' &&
+        response.error !== null &&
+        typeof response.error.code === 'string'
+        ? response.error.code
+        : undefined;
+    const message = typeof response.error === 'string'
+        ? response.error
+        : typeof response.error === 'object' &&
+            response.error !== null &&
+            typeof response.error.message === 'string'
+            ? response.error.message
+            : status === 'cancelled'
+                ? 'The host service request was cancelled.'
+                : status === 'timeout'
+                    ? 'The host service request timed out.'
+                    : 'The host service request failed.';
+    return new HostServiceRequestError(status, message, code);
+}
+function installResponseListener() {
+    if (responseListenerInstalled || typeof window === 'undefined')
+        return;
+    responseListenerInstalled = true;
+    window.addEventListener('message', (event) => {
+        if (event.source !== window.parent || !isServiceResponse(event.data)) {
+            return;
+        }
+        const pending = removePending(event.data.requestId);
+        if (!pending)
+            return;
+        if (event.data.status === 'completed') {
+            pending.resolve(event.data.result);
+        }
+        else {
+            pending.reject(responseError(event.data, event.data.status));
+        }
+    });
+}
+function createRequestId() {
+    if (typeof globalThis.crypto !== 'undefined' &&
+        typeof globalThis.crypto.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    return `host-service-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function abortError() {
+    return new DOMException('The host service request was aborted.', 'AbortError');
+}
+function postCancel(requestId) {
+    window.parent.postMessage({
+        type: HOST_SERVICE_CANCEL_TYPE,
+        requestId,
+    }, '*');
+}
+export function isHostServiceAvailable(name) {
+    const advertisement = getMoldableHostServices();
+    return Boolean(advertisement &&
+        Object.prototype.hasOwnProperty.call(advertisement.services, name));
+}
+export function requestHostService(name, payload, options = {}) {
+    if (typeof window === 'undefined' || !isHostServiceAvailable(name)) {
+        return Promise.reject(new HostServiceRequestError('error', `Host service "${name}" is not available.`, 'service_not_available'));
+    }
+    if (options.signal?.aborted) {
+        return Promise.reject(abortError());
+    }
+    if (options.timeoutMs !== undefined &&
+        (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+        return Promise.reject(new TypeError('timeoutMs must be a positive finite number.'));
+    }
+    installResponseListener();
+    const requestId = createRequestId();
+    const hostTimeoutMs = Math.min(HOST_SERVICE_DEFAULT_TIMEOUT_MS, options.timeoutMs ?? HOST_SERVICE_DEFAULT_TIMEOUT_MS);
+    return new Promise((resolve, reject) => {
+        const timeoutId = window.setTimeout(() => {
+            const pending = removePending(requestId);
+            if (!pending)
+                return;
+            postCancel(requestId);
+            pending.reject(new HostServiceRequestError('timeout', 'The host service response did not arrive before the client timeout.', 'client_timeout'));
+        }, hostTimeoutMs + HOST_SERVICE_CLIENT_TIMEOUT_GRACE_MS);
+        const pending = {
+            resolve: (value) => resolve(value),
+            reject,
+            timeoutId,
+            signal: options.signal,
+        };
+        if (options.signal) {
+            pending.abortHandler = () => {
+                const active = removePending(requestId);
+                if (!active)
+                    return;
+                postCancel(requestId);
+                active.reject(abortError());
+            };
+            options.signal.addEventListener('abort', pending.abortHandler, {
+                once: true,
+            });
+        }
+        pendingRequests.set(requestId, pending);
+        try {
+            window.parent.postMessage({
+                type: HOST_SERVICE_REQUEST_TYPE,
+                service: name,
+                requestId,
+                payload,
+                ...(options.timeoutMs === undefined
+                    ? {}
+                    : { timeoutMs: options.timeoutMs }),
+            }, '*');
+        }
+        catch (error) {
+            removePending(requestId);
+            reject(error);
+        }
+    });
+}

package/dist/lib/host-share.d.ts

@@ -0,0 +1,39 @@
+import { type HostServiceRequestOptions } from './host-services.js';
+export type HostShareItem = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'url';
+    url: string;
+} | {
+    kind: 'fileReference';
+    path: string;
+};
+export interface HostShareAnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface HostShareOptions extends HostServiceRequestOptions {
+    anchor?: Element | HostShareAnchorRect;
+}
+export type HostShareResult = {
+    status: 'completed';
+    method: 'native' | 'web';
+} | {
+    status: 'cancelled';
+    method: 'native' | 'web';
+} | {
+    status: 'fallback';
+    method: 'portable';
+    items: HostShareItem[];
+    reason: 'web_share_unavailable' | 'file_references_unsupported';
+};
+export interface HostShare {
+    available: boolean;
+    share: (items: HostShareItem[], options?: HostShareOptions) => Promise<HostShareResult>;
+}
+export declare function shareWithHost(items: HostShareItem[], options?: HostShareOptions): Promise<HostShareResult>;
+export declare function useHostShare(): HostShare;
+//# sourceMappingURL=host-share.d.ts.map

package/dist/lib/host-share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-share.d.ts","sourceRoot":"","sources":["../../src/lib/host-share.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,yBAAyB,EAG/B,MAAM,iBAAiB,CAAA;AAOxB,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3C,MAAM,WAAW,mBAAmB;IAClC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,gBAAiB,SAAQ,yBAAyB;IACjE,MAAM,CAAC,EAAE,OAAO,GAAG,mBAAmB,CAAA;CACvC;AAED,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,KAAK,CAAA;CAAE,GACjD;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,KAAK,CAAA;CAAE,GACjD;IACE,MAAM,EAAE,UAAU,CAAA;IAClB,MAAM,EAAE,UAAU,CAAA;IAClB,KAAK,EAAE,aAAa,EAAE,CAAA;IACtB,MAAM,EAAE,uBAAuB,GAAG,6BAA6B,CAAA;CAChE,CAAA;AAML,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,CACL,KAAK,EAAE,aAAa,EAAE,EACtB,OAAO,CAAC,EAAE,gBAAgB,KACvB,OAAO,CAAC,eAAe,CAAC,CAAA;CAC9B;AA2HD,wBAAsB,aAAa,CACjC,KAAK,EAAE,aAAa,EAAE,EACtB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CAuD1B;AAED,wBAAgB,YAAY,IAAI,SAAS,CAoBxC"}

package/dist/lib/host-share.js

@@ -0,0 +1,161 @@
+import { useCallback, useEffect, useState } from 'react';
+import { HostServiceRequestError, isHostServiceAvailable, requestHostService, } from './host-services.js';
+const HOST_CONTEXT_CHANGE_EVENT = 'moldable:host-context-change';
+const SHARE_SERVICE_NAME = 'share';
+const MAX_SHARE_ITEMS = 64;
+const MAX_SHARE_ITEM_LENGTH = 256 * 1024;
+function isAllowedShareUrl(value) {
+    try {
+        const protocol = new URL(value).protocol;
+        return (protocol === 'http:' || protocol === 'https:' || protocol === 'mailto:');
+    }
+    catch {
+        return false;
+    }
+}
+function validateItems(items) {
+    if (!Array.isArray(items) ||
+        items.length === 0 ||
+        items.length > MAX_SHARE_ITEMS) {
+        throw new TypeError('Share requests require 1–64 items.');
+    }
+    for (const item of items) {
+        if (!item || typeof item !== 'object') {
+            throw new TypeError('Share items must be objects.');
+        }
+        if (item.kind === 'text' &&
+            (typeof item.text !== 'string' ||
+                item.text.length === 0 ||
+                item.text.length > MAX_SHARE_ITEM_LENGTH)) {
+            throw new TypeError('Text share items require non-empty text.');
+        }
+        if (item.kind === 'url' &&
+            (typeof item.url !== 'string' ||
+                item.url.length > MAX_SHARE_ITEM_LENGTH ||
+                !isAllowedShareUrl(item.url))) {
+            throw new TypeError('URL share items must use http, https, or mailto.');
+        }
+        if (item.kind === 'fileReference' &&
+            (typeof item.path !== 'string' ||
+                item.path.length === 0 ||
+                item.path.length > MAX_SHARE_ITEM_LENGTH ||
+                item.path.includes('\0') ||
+                item.path.split(/[\\/]/).includes('..'))) {
+            throw new TypeError('File-reference share items require a non-traversing path.');
+        }
+        if (item.kind !== 'text' &&
+            item.kind !== 'url' &&
+            item.kind !== 'fileReference') {
+            throw new TypeError('Share items contain an unsupported kind.');
+        }
+    }
+}
+function anchorRect(anchor) {
+    if (!anchor)
+        return undefined;
+    const rect = typeof Element !== 'undefined' && anchor instanceof Element
+        ? anchor.getBoundingClientRect()
+        : anchor;
+    if (!Number.isFinite(rect.x) ||
+        !Number.isFinite(rect.y) ||
+        !Number.isFinite(rect.width) ||
+        !Number.isFinite(rect.height) ||
+        rect.width < 0 ||
+        rect.height < 0) {
+        throw new TypeError('Share anchors require a finite, non-negative rect.');
+    }
+    return {
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+    };
+}
+function webShareData(items) {
+    if (items.some((item) => item.kind === 'fileReference'))
+        return null;
+    const textParts = [];
+    let url;
+    for (const item of items) {
+        if (item.kind === 'text') {
+            textParts.push(item.text);
+        }
+        else if (item.kind === 'url' && !url) {
+            url = item.url;
+        }
+        else if (item.kind === 'url') {
+            textParts.push(item.url);
+        }
+    }
+    return {
+        ...(textParts.length > 0 ? { text: textParts.join('\n') } : {}),
+        ...(url ? { url } : {}),
+    };
+}
+function abortError() {
+    return new DOMException('The share request was aborted.', 'AbortError');
+}
+function isCancelledError(error) {
+    return ((error instanceof HostServiceRequestError &&
+        error.status === 'cancelled') ||
+        (error instanceof DOMException && error.name === 'AbortError'));
+}
+export async function shareWithHost(items, options = {}) {
+    validateItems(items);
+    if (options.signal?.aborted)
+        throw abortError();
+    if (isHostServiceAvailable(SHARE_SERVICE_NAME)) {
+        try {
+            const result = await requestHostService(SHARE_SERVICE_NAME, {
+                items,
+                ...(options.anchor ? { anchor: anchorRect(options.anchor) } : {}),
+            }, {
+                signal: options.signal,
+                timeoutMs: options.timeoutMs,
+            });
+            if (result?.status !== 'completed') {
+                throw new Error('The native share service returned an invalid result.');
+            }
+            return { status: 'completed', method: 'native' };
+        }
+        catch (error) {
+            if (error instanceof HostServiceRequestError &&
+                error.status === 'cancelled') {
+                return { status: 'cancelled', method: 'native' };
+            }
+            throw error;
+        }
+    }
+    const shareData = webShareData(items);
+    if (shareData &&
+        typeof navigator !== 'undefined' &&
+        typeof navigator.share === 'function') {
+        try {
+            await navigator.share(shareData);
+            return { status: 'completed', method: 'web' };
+        }
+        catch (error) {
+            if (isCancelledError(error)) {
+                return { status: 'cancelled', method: 'web' };
+            }
+            throw error;
+        }
+    }
+    return {
+        status: 'fallback',
+        method: 'portable',
+        items,
+        reason: shareData ? 'web_share_unavailable' : 'file_references_unsupported',
+    };
+}
+export function useHostShare() {
+    const [available, setAvailable] = useState(() => isHostServiceAvailable(SHARE_SERVICE_NAME));
+    useEffect(() => {
+        const update = () => setAvailable(isHostServiceAvailable(SHARE_SERVICE_NAME));
+        update();
+        window.addEventListener(HOST_CONTEXT_CHANGE_EVENT, update);
+        return () => window.removeEventListener(HOST_CONTEXT_CHANGE_EVENT, update);
+    }, []);
+    const share = useCallback((items, options) => shareWithHost(items, options), []);
+    return { available, share };
+}

package/dist/lib/host-web-surface.d.ts

@@ -0,0 +1,31 @@
+import { type HostServiceRequestOptions } from './host-services.js';
+export interface HostWebSurfaceBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface HostWebSurfaceNavigationState {
+    surfaceId: string;
+    url: string;
+    title: string;
+    loading: boolean;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    faviconUrl?: string;
+}
+export type HostWebSurfaceNavigationSubscriber = (state: HostWebSurfaceNavigationState) => void;
+export interface HostWebSurface {
+    available: boolean;
+    create: (surfaceId: string, url: string, bounds: HostWebSurfaceBounds, options?: HostServiceRequestOptions) => Promise<void>;
+    navigate: (surfaceId: string, url: string, options?: HostServiceRequestOptions) => Promise<void>;
+    reload: (surfaceId: string, options?: HostServiceRequestOptions) => Promise<void>;
+    goBack: (surfaceId: string, options?: HostServiceRequestOptions) => Promise<void>;
+    goForward: (surfaceId: string, options?: HostServiceRequestOptions) => Promise<void>;
+    setBounds: (surfaceId: string, bounds: HostWebSurfaceBounds, options?: HostServiceRequestOptions) => Promise<void>;
+    setVisible: (surfaceId: string, visible: boolean, options?: HostServiceRequestOptions) => Promise<void>;
+    destroy: (surfaceId: string, options?: HostServiceRequestOptions) => Promise<void>;
+    onNavState: (subscribe: HostWebSurfaceNavigationSubscriber) => () => void;
+}
+export declare function useHostWebSurface(): HostWebSurface;
+//# sourceMappingURL=host-web-surface.d.ts.map

package/dist/lib/host-web-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-web-surface.d.ts","sourceRoot":"","sources":["../../src/lib/host-web-surface.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,yBAAyB,EAG/B,MAAM,iBAAiB,CAAA;AAQxB,MAAM,WAAW,oBAAoB;IACnC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,kCAAkC,GAAG,CAC/C,KAAK,EAAE,6BAA6B,KACjC,IAAI,CAAA;AAET,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,oBAAoB,EAC5B,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,QAAQ,EAAE,CACR,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,SAAS,EAAE,CACT,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,SAAS,EAAE,CACT,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,oBAAoB,EAC5B,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,UAAU,EAAE,CACV,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,OAAO,EAAE,CACP,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,yBAAyB,KAChC,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,UAAU,EAAE,CAAC,SAAS,EAAE,kCAAkC,KAAK,MAAM,IAAI,CAAA;CAC1E;AAmID,wBAAgB,iBAAiB,IAAI,cAAc,CAmElD"}

package/dist/lib/host-web-surface.js

@@ -0,0 +1,116 @@
+import { useCallback, useEffect, useState } from 'react';
+import { isHostServiceAvailable, requestHostService, } from './host-services.js';
+const HOST_CONTEXT_CHANGE_EVENT = 'moldable:host-context-change';
+const HOST_SERVICE_EVENT_TYPE = 'moldable:service-event';
+const WEB_SURFACE_SERVICE_NAME = 'webSurface';
+const SURFACE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const MAX_URL_LENGTH = 4096;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validateSurfaceId(surfaceId) {
+    if (!SURFACE_ID.test(surfaceId)) {
+        throw new TypeError('surfaceId must be 1–64 ASCII letters, numbers, underscores, or hyphens.');
+    }
+}
+function validateUrl(url) {
+    if (typeof url !== 'string' ||
+        url.length === 0 ||
+        url.length > MAX_URL_LENGTH) {
+        throw new TypeError('Web-surface URLs must be 1–4096 characters.');
+    }
+    try {
+        const protocol = new URL(url).protocol;
+        if (protocol !== 'http:' && protocol !== 'https:')
+            throw new Error();
+    }
+    catch {
+        throw new TypeError('Web-surface URLs must be valid http or https URLs.');
+    }
+}
+function validateBounds(bounds) {
+    if (!bounds ||
+        !Number.isFinite(bounds.x) ||
+        !Number.isFinite(bounds.y) ||
+        !Number.isFinite(bounds.width) ||
+        !Number.isFinite(bounds.height) ||
+        bounds.width < 0 ||
+        bounds.height < 0) {
+        throw new TypeError('Web-surface bounds require finite coordinates and non-negative dimensions.');
+    }
+}
+function validatePayload(payload) {
+    validateSurfaceId(payload.surfaceId);
+    if (payload.method === 'create' || payload.method === 'navigate') {
+        validateUrl(payload.url);
+    }
+    if (payload.method === 'create' || payload.method === 'setBounds') {
+        validateBounds(payload.bounds);
+    }
+}
+async function requestWebSurface(payload, options) {
+    validatePayload(payload);
+    const result = await requestHostService(WEB_SURFACE_SERVICE_NAME, payload, options);
+    if (result?.status !== 'completed') {
+        throw new Error('The host web-surface service returned an invalid result.');
+    }
+}
+function isNavigationState(value) {
+    return (isRecord(value) &&
+        typeof value.surfaceId === 'string' &&
+        SURFACE_ID.test(value.surfaceId) &&
+        typeof value.url === 'string' &&
+        value.url.length <= MAX_URL_LENGTH &&
+        typeof value.title === 'string' &&
+        typeof value.loading === 'boolean' &&
+        typeof value.canGoBack === 'boolean' &&
+        typeof value.canGoForward === 'boolean' &&
+        (value.faviconUrl === undefined || typeof value.faviconUrl === 'string'));
+}
+function subscribeToNavigationState(subscribe) {
+    if (typeof window === 'undefined')
+        return () => undefined;
+    const handler = (event) => {
+        if (event.source !== window.parent || !isRecord(event.data))
+            return;
+        if (event.data.type !== HOST_SERVICE_EVENT_TYPE ||
+            event.data.service !== WEB_SURFACE_SERVICE_NAME ||
+            event.data.event !== 'navigationState' ||
+            !isNavigationState(event.data.payload)) {
+            return;
+        }
+        subscribe(event.data.payload);
+    };
+    window.addEventListener('message', handler);
+    return () => window.removeEventListener('message', handler);
+}
+export function useHostWebSurface() {
+    const [available, setAvailable] = useState(() => isHostServiceAvailable(WEB_SURFACE_SERVICE_NAME));
+    useEffect(() => {
+        const update = () => setAvailable(isHostServiceAvailable(WEB_SURFACE_SERVICE_NAME));
+        update();
+        window.addEventListener(HOST_CONTEXT_CHANGE_EVENT, update);
+        return () => window.removeEventListener(HOST_CONTEXT_CHANGE_EVENT, update);
+    }, []);
+    const create = useCallback((surfaceId, url, bounds, options) => requestWebSurface({ method: 'create', surfaceId, url, bounds }, options), []);
+    const navigate = useCallback((surfaceId, url, options) => requestWebSurface({ method: 'navigate', surfaceId, url }, options), []);
+    const reload = useCallback((surfaceId, options) => requestWebSurface({ method: 'reload', surfaceId }, options), []);
+    const goBack = useCallback((surfaceId, options) => requestWebSurface({ method: 'goBack', surfaceId }, options), []);
+    const goForward = useCallback((surfaceId, options) => requestWebSurface({ method: 'goForward', surfaceId }, options), []);
+    const setBounds = useCallback((surfaceId, bounds, options) => requestWebSurface({ method: 'setBounds', surfaceId, bounds }, options), []);
+    const setVisible = useCallback((surfaceId, visible, options) => requestWebSurface({ method: 'setVisible', surfaceId, visible }, options), []);
+    const destroy = useCallback((surfaceId, options) => requestWebSurface({ method: 'destroy', surfaceId }, options), []);
+    const onNavState = useCallback(subscribeToNavigationState, []);
+    return {
+        available,
+        create,
+        navigate,
+        reload,
+        goBack,
+        goForward,
+        setBounds,
+        setVisible,
+        destroy,
+        onNavState,
+    };
+}

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

@@ -1,5 +1,5 @@
-import { type NativeCapabilityBridgeOptions } from './bridge';
-import type { NativeCapabilityId } from './types';
+import { type NativeCapabilityBridgeOptions } from './bridge.js';
+import type { NativeCapabilityId } from './types.js';
 export declare const NATIVE_CAPABILITY_ACCESS_REQUEST_TYPE: "moldable:native-capabilities-access-request";
 export declare const NATIVE_CAPABILITY_ACCESS_RESULT_TYPE: "moldable:native-capabilities-access-result";
 export interface MoldableNativeCapabilityAccessState {

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

@@ -1,5 +1,5 @@
-import { NativeCapabilityBridgeError, callNativeCapabilityBridge, } from './bridge';
-import { isNativeCapabilityId } from './capabilities';
+import { NativeCapabilityBridgeError, callNativeCapabilityBridge, } from './bridge.js';
+import { isNativeCapabilityId } from './capabilities.js';
 export const NATIVE_CAPABILITY_ACCESS_REQUEST_TYPE = 'moldable:native-capabilities-access-request';
 export const NATIVE_CAPABILITY_ACCESS_RESULT_TYPE = 'moldable:native-capabilities-access-result';
 function isEmbedded() {

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

@@ -1,4 +1,4 @@
-import type { MoldableBluetoothAvailability, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRequestDeviceOptions, MoldableBluetoothRequestOptions } from './bluetooth-types';
+import type { MoldableBluetoothAvailability, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRequestDeviceOptions, MoldableBluetoothRequestOptions } from './bluetooth-types.js';
 /** Checks only for the standards-based Web Bluetooth entry point. */
 export declare function isMoldableBluetoothSupported(): boolean;
 /**

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

@@ -1,5 +1,5 @@
-import { assertMoldableNativeCapabilityAccess, requireMoldableNativeCapabilityAccess, } from './access';
-import { abortableBluetooth, assertBluetoothUserGesture, bluetoothError, getBluetoothAPI, getBluetoothNavigator, validateBluetoothRequestOptions, } from './bluetooth-internal';
+import { assertMoldableNativeCapabilityAccess, requireMoldableNativeCapabilityAccess, } from './access.js';
+import { abortableBluetooth, assertBluetoothUserGesture, bluetoothError, getBluetoothAPI, getBluetoothNavigator, validateBluetoothRequestOptions, } from './bluetooth-internal.js';
 /** Checks only for the standards-based Web Bluetooth entry point. */
 export function isMoldableBluetoothSupported() {
     const api = getBluetoothNavigator()?.bluetooth;

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

@@ -1,4 +1,4 @@
-import type { MoldableBluetoothConnectionOptions, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTServer, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID } from './bluetooth-types';
+import type { MoldableBluetoothConnectionOptions, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTServer, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID } from './bluetooth-types.js';
 export declare class MoldableBluetoothConnection {
     readonly device: MoldableBluetoothDevice;
     readonly server: MoldableBluetoothRemoteGATTServer;

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

@@ -1,4 +1,4 @@
-import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal';
+import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal.js';
 export class MoldableBluetoothConnection {
     device;
     server;

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

@@ -1,4 +1,4 @@
-import type { MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTCharacteristic, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID, MoldableBluetoothWriteMode } from './bluetooth-types';
+import type { MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTCharacteristic, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID, MoldableBluetoothWriteMode } from './bluetooth-types.js';
 export declare function getMoldableBluetoothCharacteristic(service: MoldableBluetoothRemoteGATTService, characteristic: MoldableBluetoothUUID, options?: MoldableBluetoothOperationOptions): Promise<MoldableBluetoothRemoteGATTCharacteristic>;
 export declare function readMoldableBluetoothValue(characteristic: MoldableBluetoothRemoteGATTCharacteristic, options?: MoldableBluetoothOperationOptions): Promise<DataView>;
 /** Starts notifications and returns async, idempotent subscription cleanup. */

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

@@ -1,4 +1,4 @@
-import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal';
+import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal.js';
 export async function getMoldableBluetoothCharacteristic(service, characteristic, options = {}) {
     const operation = `get Bluetooth characteristic ${String(characteristic)}`;
     try {

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

@@ -1,5 +1,5 @@
-import type { MoldableBluetoothAPI, MoldableBluetoothNavigator, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types';
-import { NativeCapabilityBridgeError } from './bridge';
+import type { MoldableBluetoothAPI, MoldableBluetoothNavigator, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types.js';
+import { NativeCapabilityBridgeError } from './bridge.js';
 export declare function bluetoothError(error: unknown, operation: string): NativeCapabilityBridgeError;
 export declare function bluetoothAborted(operation: string): NativeCapabilityBridgeError;
 export declare function getBluetoothNavigator(): MoldableBluetoothNavigator | undefined;

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

@@ -1,4 +1,4 @@
-import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } from './bridge';
+import { NativeCapabilityBridgeError, toNativeCapabilityBridgeError, } from './bridge.js';
 export function bluetoothError(error, operation) {
     if (error instanceof NativeCapabilityBridgeError)
         return error;

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

@@ -1,5 +1,5 @@
-import type { MoldableBluetoothDevice, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types';
-import { type NativeCapabilityBridgeOptions } from './bridge';
+import type { MoldableBluetoothDevice, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types.js';
+import { type NativeCapabilityBridgeOptions } from './bridge.js';
 export type MoldableBluetoothTransport = {
     kind: 'web-bluetooth';
     device: MoldableBluetoothDevice;

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

@@ -1,5 +1,5 @@
-import { isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access';
-import { callNativeCapabilityBridge, } from './bridge';
+import { isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access.js';
+import { callNativeCapabilityBridge, } from './bridge.js';
 const REQUEST_TYPE = 'moldable:native-bluetooth';
 const RESULT_TYPE = 'moldable:native-bluetooth-result';
 const EVENT_TYPE = 'moldable:native-bluetooth-event';

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

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

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

@@ -1,4 +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';
+export { getMoldableBluetoothAvailability, isMoldableBluetoothSupported, requestMoldableBluetoothDevice, } from './bluetooth-access.js';
+export { connectMoldableBluetoothDevice, MoldableBluetoothConnection, } from './bluetooth-connection.js';
+export { getMoldableBluetoothCharacteristic, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, writeMoldableBluetoothValue, } from './bluetooth-gatt.js';
+export { requestMoldableBluetoothWithFallback } from './bluetooth-native-fallback.js';

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

@@ -1,4 +1,4 @@
-import { type NativeCapabilityErrorCode, type NativeCapabilityErrorPayload, type NativeCapabilityManifest } from './types';
+import { type NativeCapabilityErrorCode, type NativeCapabilityErrorPayload, type NativeCapabilityManifest } from './types.js';
 export declare const NATIVE_CAPABILITY_CANCEL_REQUEST_TYPE: "moldable:native-capabilities-cancel";
 export interface NativeCapabilityBridgeOptions {
     timeoutMs?: number;