@moldable-ai/ui 0.2.20 → 0.2.22

package/dist/lib/host-native-menu.js

@@ -0,0 +1,187 @@
+import { useCallback, useEffect, useState } from 'react';
+import { HostServiceRequestError, isHostServiceAvailable, requestHostService, } from './host-services';
+const HOST_CONTEXT_CHANGE_EVENT = 'moldable:host-context-change';
+const NATIVE_MENU_SERVICE_NAME = 'nativeMenu';
+export const HOST_NATIVE_MENU_MAX_DEPTH = 3;
+export const HOST_NATIVE_MENU_MAX_ITEMS = 200;
+export const HOST_NATIVE_MENU_MAX_TITLE_LENGTH = 256;
+export const HOST_NATIVE_MENU_MAX_SUBLABEL_LENGTH = 512;
+function finitePoint(value) {
+    return Number.isFinite(value.x) && Number.isFinite(value.y);
+}
+function menuAnchorRect(anchor) {
+    const rect = typeof Element !== 'undefined' && anchor instanceof Element
+        ? anchor.getBoundingClientRect()
+        : anchor;
+    if (!finitePoint(rect) ||
+        !Number.isFinite(rect.width) ||
+        !Number.isFinite(rect.height) ||
+        rect.width < 0 ||
+        rect.height < 0) {
+        throw new TypeError('Native menu anchors require a finite, non-negative rect.');
+    }
+    return {
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+    };
+}
+function validateShortcut(shortcut) {
+    if (typeof shortcut.key !== 'string' || shortcut.key.length === 0) {
+        throw new TypeError('Native menu shortcuts require a non-empty key.');
+    }
+    if (shortcut.modifiers !== undefined &&
+        (!Array.isArray(shortcut.modifiers) ||
+            !shortcut.modifiers.every((modifier) => modifier === 'cmd' ||
+                modifier === 'shift' ||
+                modifier === 'alt' ||
+                modifier === 'ctrl'))) {
+        throw new TypeError('Native menu shortcuts contain an invalid modifier.');
+    }
+}
+function validateMenuItems(items) {
+    if (!Array.isArray(items) ||
+        items.length === 0 ||
+        items.length > HOST_NATIVE_MENU_MAX_ITEMS) {
+        throw new TypeError(`Native menus require 1–${HOST_NATIVE_MENU_MAX_ITEMS} total items.`);
+    }
+    const ids = new Set();
+    let totalItems = 0;
+    const visit = (values, depth) => {
+        if (depth > HOST_NATIVE_MENU_MAX_DEPTH) {
+            throw new TypeError(`Native menu depth must not exceed ${HOST_NATIVE_MENU_MAX_DEPTH}.`);
+        }
+        for (const item of values) {
+            totalItems += 1;
+            if (totalItems > HOST_NATIVE_MENU_MAX_ITEMS) {
+                throw new TypeError(`Native menus must not exceed ${HOST_NATIVE_MENU_MAX_ITEMS} total items.`);
+            }
+            if (!item || typeof item !== 'object' || Array.isArray(item)) {
+                throw new TypeError('Native menu items must be objects.');
+            }
+            const kind = item.kind ?? 'normal';
+            if (kind !== 'normal' &&
+                kind !== 'separator' &&
+                kind !== 'checkbox' &&
+                kind !== 'radio') {
+                throw new TypeError('Native menu items contain an unsupported kind.');
+            }
+            if (kind !== 'separator') {
+                if (typeof item.id !== 'string' ||
+                    item.id.trim().length === 0 ||
+                    ids.has(item.id)) {
+                    throw new TypeError('Selectable native menu items require unique, non-empty ids.');
+                }
+                ids.add(item.id);
+                if (typeof item.title !== 'string' ||
+                    item.title.length === 0 ||
+                    item.title.length > HOST_NATIVE_MENU_MAX_TITLE_LENGTH) {
+                    throw new TypeError(`Native menu item titles must contain 1–${HOST_NATIVE_MENU_MAX_TITLE_LENGTH} characters.`);
+                }
+            }
+            else {
+                if (item.id !== undefined && typeof item.id !== 'string') {
+                    throw new TypeError('Native menu separator ids must be strings when provided.');
+                }
+                if (item.title !== undefined &&
+                    (typeof item.title !== 'string' ||
+                        item.title.length > HOST_NATIVE_MENU_MAX_TITLE_LENGTH)) {
+                    throw new TypeError(`Native menu separator titles must not exceed ${HOST_NATIVE_MENU_MAX_TITLE_LENGTH} characters.`);
+                }
+            }
+            if (item.sublabel !== undefined &&
+                (typeof item.sublabel !== 'string' ||
+                    item.sublabel.length > HOST_NATIVE_MENU_MAX_SUBLABEL_LENGTH)) {
+                throw new TypeError(`Native menu sublabels must not exceed ${HOST_NATIVE_MENU_MAX_SUBLABEL_LENGTH} characters.`);
+            }
+            if (item.enabled !== undefined && typeof item.enabled !== 'boolean') {
+                throw new TypeError('Native menu enabled values must be booleans.');
+            }
+            if (item.destructive !== undefined &&
+                typeof item.destructive !== 'boolean') {
+                throw new TypeError('Native menu destructive values must be booleans.');
+            }
+            if (item.shortcut !== undefined)
+                validateShortcut(item.shortcut);
+            if (kind === 'checkbox' || kind === 'radio') {
+                if (item.checked !== undefined &&
+                    item.checked !== true &&
+                    item.checked !== false &&
+                    item.checked !== 'mixed') {
+                    throw new TypeError('Native menu checked values must be true, false, or mixed.');
+                }
+                if (kind === 'radio' && item.checked === 'mixed') {
+                    throw new TypeError('Native menu radio items do not support the mixed state.');
+                }
+            }
+            else if (item.checked !== undefined) {
+                throw new TypeError('Only checkbox and radio native menu items may be checked.');
+            }
+            if (item.submenu !== undefined) {
+                if (kind !== 'normal' || !Array.isArray(item.submenu)) {
+                    throw new TypeError('Only normal native menu items may contain submenu arrays.');
+                }
+                visit(item.submenu, depth + 1);
+            }
+        }
+    };
+    visit(items, 1);
+}
+function validatePlacement(options) {
+    const hasAnchor = options.anchor !== undefined;
+    const hasPosition = options.position !== undefined;
+    if (hasAnchor === hasPosition) {
+        throw new TypeError('Native menus require exactly one anchor or pointer position.');
+    }
+    if (options.anchor)
+        return { anchor: menuAnchorRect(options.anchor) };
+    if (!options.position || !finitePoint(options.position)) {
+        throw new TypeError('Native menu positions require finite x and y coordinates.');
+    }
+    return { position: { ...options.position } };
+}
+function abortError() {
+    return new DOMException('The native menu request was aborted.', 'AbortError');
+}
+export async function openNativeMenuWithHost(items, options) {
+    validateMenuItems(items);
+    const placement = validatePlacement(options);
+    if (options.signal?.aborted)
+        throw abortError();
+    if (!isHostServiceAvailable(NATIVE_MENU_SERVICE_NAME)) {
+        return { status: 'fallback' };
+    }
+    try {
+        const result = await requestHostService(NATIVE_MENU_SERVICE_NAME, { items, ...placement }, {
+            signal: options.signal,
+            timeoutMs: options.timeoutMs,
+        });
+        if (typeof result !== 'object' ||
+            result === null ||
+            !('selectedId' in result) ||
+            typeof result.selectedId !== 'string' ||
+            result.selectedId.length === 0) {
+            throw new Error('The native menu returned an invalid result.');
+        }
+        return { status: 'completed', selectedId: result.selectedId };
+    }
+    catch (error) {
+        if (error instanceof HostServiceRequestError &&
+            error.status === 'cancelled') {
+            return { status: 'cancelled' };
+        }
+        throw error;
+    }
+}
+export function useHostNativeMenu() {
+    const [available, setAvailable] = useState(() => isHostServiceAvailable(NATIVE_MENU_SERVICE_NAME));
+    useEffect(() => {
+        const update = () => setAvailable(isHostServiceAvailable(NATIVE_MENU_SERVICE_NAME));
+        update();
+        window.addEventListener(HOST_CONTEXT_CHANGE_EVENT, update);
+        return () => window.removeEventListener(HOST_CONTEXT_CHANGE_EVENT, update);
+    }, []);
+    const open = useCallback((items, options) => openNativeMenuWithHost(items, options), []);
+    return { available, open };
+}

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

@@ -0,0 +1,13 @@
+export interface HostServiceRequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export type HostServiceResponseStatus = 'completed' | 'cancelled' | 'error' | 'timeout';
+export declare class HostServiceRequestError extends Error {
+    readonly status: Exclude<HostServiceResponseStatus, 'completed'>;
+    readonly code?: string;
+    constructor(status: Exclude<HostServiceResponseStatus, 'completed'>, message: string, code?: string);
+}
+export declare function isHostServiceAvailable(name: string): boolean;
+export declare function requestHostService<TResult = unknown>(name: string, payload: unknown, options?: HostServiceRequestOptions): Promise<TResult>;
+//# sourceMappingURL=host-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"host-services.d.ts","sourceRoot":"","sources":["../../src/lib/host-services.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,yBAAyB,GACjC,WAAW,GACX,WAAW,GACX,OAAO,GACP,SAAS,CAAA;AAuBb,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,yBAAyB,EAAE,WAAW,CAAC,CAAA;IAChE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;gBAGpB,MAAM,EAAE,OAAO,CAAC,yBAAyB,EAAE,WAAW,CAAC,EACvD,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM;CAOhB;AA4GD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM5D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAG,OAAO,EAClD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,OAAO,CAAC,CAiFlB"}

package/dist/lib/host-services.js

@@ -0,0 +1,161 @@
+import { getMoldableHostServices } from './frame-lifecycle';
+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';
+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';
+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/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/lib/theme.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAMf,MAAM,OAAO,CAAA;AAEd,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;AAC/C,KAAK,aAAa,GAAG,OAAO,GAAG,MAAM,CAAA;AAErC,UAAU,iBAAiB;IACzB,KAAK,EAAE,KAAK,CAAA;IACZ,aAAa,EAAE,aAAa,CAAA;IAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AA6CD,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CA0ClE;AAED,wBAAgB,QAAQ,sBAMvB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,kYAYvB,CAAA"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/lib/theme.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAMf,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;AAC/C,KAAK,aAAa,GAAG,OAAO,GAAG,MAAM,CAAA;AAErC,UAAU,iBAAiB;IACzB,KAAK,EAAE,KAAK,CAAA;IACZ,aAAa,EAAE,aAAa,CAAA;IAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AA6CD,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CA0ClE;AAED,wBAAgB,QAAQ,sBAMvB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,kYAYvB,CAAA"}

package/dist/lib/theme.js

@@ -1,6 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useEffect, useState, } from 'react';
+import { TooltipProvider } from '../components/ui/tooltip';
 const ThemeContext = createContext(null);
 const STORAGE_KEY = 'moldable-theme';
 function getSystemTheme() {
@@ -69,7 +70,7 @@ export function ThemeProvider({ children }) {
         mediaQuery.addEventListener('change', handleChange);
         return () => mediaQuery.removeEventListener('change', handleChange);
     }, [theme]);
-    return (_jsx(ThemeContext.Provider, { value: { theme, resolvedTheme, setTheme }, children: children }));
+    return (_jsx(ThemeContext.Provider, { value: { theme, resolvedTheme, setTheme }, children: _jsx(TooltipProvider, { children: children }) }));
 }
 export function useTheme() {
     const context = useContext(ThemeContext);

package/docs/README.md

@@ -8,9 +8,11 @@ feels at home on macOS without imitating private platform implementation.
 
 - [Foundations](./foundations.md)
 - [Design tokens](./design-tokens.md)
+- [Adaptive materials](./adaptive-materials.md)
 - [App anatomy](./app-anatomy.md)
 - [Standalone app windows](./standalone-app-windows.md)
 - [Component catalog](./component-catalog.md)
+- [Visual and accessibility regression](./visual-regression.md)
 - [Accessibility](./accessibility.md)
 - [Native integration](./native-integration.md)
 - [Component guide template](./component-guide-template.md)
@@ -34,4 +36,5 @@ changed view.
 7. Design loading, empty, error, disabled, and permission states with the main
    view, not afterward.
 8. Review component work in the catalog across theme, density, width, and
-   interaction states.
+   interaction states. Material-bearing components also cover reduced
+   transparency, increased contrast, and reduced motion.