@moldable-ai/ui 0.2.19 → 0.2.20

package/dist/components/ui/toolbar.js

@@ -0,0 +1,52 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../lib/utils';
+import { Separator } from './separator';
+import { Text } from './text';
+import { cva } from 'class-variance-authority';
+const toolbarVariants = cva('z-20 flex w-full shrink-0 items-center gap-2 px-3', {
+    variants: {
+        variant: {
+            default: 'border-border/70 bg-background/90 supports-[backdrop-filter]:bg-background/75 border-b backdrop-blur-xl',
+            plain: 'bg-transparent',
+            panel: 'border-border/60 bg-muted/35 border-b',
+        },
+        density: {
+            compact: 'min-h-8 py-1',
+            default: 'min-h-10 py-1.5',
+            comfortable: 'min-h-12 py-2',
+        },
+        position: {
+            static: '',
+            top: 'sticky top-0',
+            bottom: 'sticky bottom-0 border-t border-b-0',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        density: 'compact',
+        position: 'static',
+    },
+});
+function Toolbar({ variant, density, position, className, ...props }) {
+    return (_jsx("header", { "data-slot": "toolbar", "data-density": density ?? 'compact', "data-position": position ?? 'static', "data-variant": variant ?? 'default', className: cn(toolbarVariants({ variant, density, position }), className), ...props }));
+}
+function ToolbarGroup({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "toolbar-group", className: cn('flex min-w-0 items-center gap-1.5', className), ...props }));
+}
+function ToolbarContent({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "toolbar-content", className: cn('flex min-w-0 flex-1 flex-col', className), ...props }));
+}
+function ToolbarTitle({ className, ...props }) {
+    return (_jsx(Text, { as: "h2", variant: "strong", truncate: true, "data-slot": "toolbar-title", className: className, ...props }));
+}
+function ToolbarDescription({ className, ...props }) {
+    return (_jsx(Text, { as: "p", variant: "small", color: "secondary", truncate: true, "data-slot": "toolbar-description", className: className, ...props }));
+}
+function ToolbarActions({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "toolbar-actions", className: cn('ml-auto flex shrink-0 items-center gap-1', className), ...props }));
+}
+function ToolbarSeparator({ className, ...props }) {
+    return (_jsx(Separator, { orientation: "vertical", "data-slot": "toolbar-separator", className: cn('mx-1 h-4', className), ...props }));
+}
+export { Toolbar, ToolbarActions, ToolbarContent, ToolbarDescription, ToolbarGroup, ToolbarSeparator, ToolbarTitle, toolbarVariants, };

package/dist/index.d.ts

@@ -2,9 +2,9 @@ export { cn } from './lib/utils';
 export { ThemeProvider, useTheme, themeScript, type Theme } from './lib/theme';
 export { WorkspaceProvider, useWorkspace, WORKSPACE_HEADER, } from './lib/workspace';
 export { useMoldableCommands, useMoldableCommand, useMoldableAppCommands, useMoldableNavigationPop, useMoldableNavigationState, isInMoldable, sendToMoldable, pushMoldableNavigation, popMoldableNavigation, resetMoldableNavigation, downloadFile, publishMoldableArtifact, setMoldableWindowFullscreen, type AppCommand, type CommandAction, type CommandsResponse, type CommandMessage, type MoldableNavigationEntry, type MoldableNavigationPopMessage, type MoldableNavigationStateMessage, type DownloadFileOptions, type MoldableArtifactFile, type MoldableArtifactPublishOptions, type MoldableArtifactPublishResult, type MoldableWindowFullscreenMode, type MoldableWindowFullscreenOptions, type MoldableWindowFullscreenResult, type MoldableWindowFullscreenMessage, type MoldableWindowFullscreenResultMessage, } from './lib/commands';
-export * from './lib/native-hardware';
+export * from './lib/native-capabilities';
 export * from './components/ui';
-export * from './components/hardware';
+export * from './components/native-capabilities';
 export { TODAY_KIND_RANK, TODAY_KIND_TTL_MS, makeTodayItem, type TodayItem, type TodayItemKind, type TodaySurface, type TodayAction, type TodayResponse, type ResumeState, type HydratedTodayItem, type HydratedResume, } from './lib/today';
 export { useIsMobile } from './hooks/use-mobile';
 export { Markdown } from './components/markdown';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AAG9E,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,EACZ,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACnC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,qCAAqC,GAC3C,MAAM,gBAAgB,CAAA;AAGvB,cAAc,uBAAuB,CAAA;AAGrC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,uBAAuB,CAAA;AAGrC,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EACL,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGnD,OAAO,EACL,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,iCAAiC,CAAA;AAGxC,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAGrE,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AAG9E,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,EACZ,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACnC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,qCAAqC,GAC3C,MAAM,gBAAgB,CAAA;AAGvB,cAAc,2BAA2B,CAAA;AAGzC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,kCAAkC,CAAA;AAGhD,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EACL,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGnD,OAAO,EACL,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,iCAAiC,CAAA;AAGxC,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAGrE,cAAc,mBAAmB,CAAA"}

package/dist/index.js

@@ -6,12 +6,12 @@ export { ThemeProvider, useTheme, themeScript } from './lib/theme';
 export { WorkspaceProvider, useWorkspace, WORKSPACE_HEADER, } from './lib/workspace';
 // Export commands
 export { useMoldableCommands, useMoldableCommand, useMoldableAppCommands, useMoldableNavigationPop, useMoldableNavigationState, isInMoldable, sendToMoldable, pushMoldableNavigation, popMoldableNavigation, resetMoldableNavigation, downloadFile, publishMoldableArtifact, setMoldableWindowFullscreen, } from './lib/commands';
-// Export typed desktop/native hardware APIs
-export * from './lib/native-hardware';
+// Export typed desktop/native capability APIs
+export * from './lib/native-capabilities';
 // Export UI components
 export * from './components/ui';
-// Export native hardware components (polished wrappers over lib/native-hardware)
-export * from './components/hardware';
+// Export native capability components (polished wrappers over lib/native-capabilities)
+export * from './components/native-capabilities';
 // Export Today contract
 export { TODAY_KIND_RANK, TODAY_KIND_TTL_MS, makeTodayItem, } from './lib/today';
 // Export hooks

package/dist/lib/frame-lifecycle.d.ts

@@ -1,2 +1,30 @@
+export interface MoldableChatStateMessage {
+    type: 'moldable:chat-state';
+    expanded?: boolean;
+    minimized?: boolean;
+    safePadding?: unknown;
+}
+export interface MoldableHostContextMessage {
+    type: 'moldable:host-context';
+    version: 1;
+    displayMode: 'embedded' | 'window';
+    platform?: 'macos' | 'windows' | 'linux' | 'unknown';
+    windowId?: string;
+    safeInsets?: {
+        top?: unknown;
+        inlineStart?: unknown;
+        inlineEnd?: unknown;
+        bottom?: unknown;
+        titlebarHeight?: unknown;
+        controlInsetInlineStart?: unknown;
+        controlInsetInlineEnd?: unknown;
+        cornerRadius?: unknown;
+    };
+    chat?: {
+        presentation?: 'hidden' | 'docked' | 'expanded' | 'minimized';
+        safePadding?: unknown;
+    };
+}
+export declare function applyMoldableChatSafePadding(safePadding: unknown): boolean;
 export declare function installMoldableFrameLifecycle(): void;
 //# sourceMappingURL=frame-lifecycle.d.ts.map

package/dist/lib/frame-lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frame-lifecycle.d.ts","sourceRoot":"","sources":["../../src/lib/frame-lifecycle.ts"],"names":[],"mappings":"AAgEA,wBAAgB,6BAA6B,IAAI,IAAI,CAapD"}
+{"version":3,"file":"frame-lifecycle.d.ts","sourceRoot":"","sources":["../../src/lib/frame-lifecycle.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,qBAAqB,CAAA;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,uBAAuB,CAAA;IAC7B,OAAO,EAAE,CAAC,CAAA;IACV,WAAW,EAAE,UAAU,GAAG,QAAQ,CAAA;IAClC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE;QACX,GAAG,CAAC,EAAE,OAAO,CAAA;QACb,WAAW,CAAC,EAAE,OAAO,CAAA;QACrB,SAAS,CAAC,EAAE,OAAO,CAAA;QACnB,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,cAAc,CAAC,EAAE,OAAO,CAAA;QACxB,uBAAuB,CAAC,EAAE,OAAO,CAAA;QACjC,qBAAqB,CAAC,EAAE,OAAO,CAAA;QAC/B,YAAY,CAAC,EAAE,OAAO,CAAA;KACvB,CAAA;IACD,IAAI,CAAC,EAAE;QACL,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,CAAA;QAC7D,WAAW,CAAC,EAAE,OAAO,CAAA;KACtB,CAAA;CACF;AAwBD,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,CAa1E;AA0ID,wBAAgB,6BAA6B,IAAI,IAAI,CAcpD"}

package/dist/lib/frame-lifecycle.js

@@ -1,4 +1,87 @@
 let frameLifecycleInstalled = false;
+export function applyMoldableChatSafePadding(safePadding) {
+    if (typeof document === 'undefined')
+        return false;
+    const value = Number(safePadding);
+    if (!Number.isFinite(value))
+        return false;
+    // Keep a malformed or stale host message from creating an unusable canvas.
+    const boundedValue = Math.min(4096, Math.max(0, value));
+    document.documentElement.style.setProperty('--chat-safe-padding', `${boundedValue}px`);
+    return true;
+}
+function applyBoundedLength(property, value) {
+    const number = Number(value);
+    if (!Number.isFinite(number))
+        return;
+    document.documentElement.style.setProperty(property, `${Math.min(4096, Math.max(0, number))}px`);
+}
+function applyMoldableChatState(message) {
+    applyMoldableChatSafePadding(message.safePadding);
+    const presentation = message.expanded
+        ? 'expanded'
+        : message.minimized
+            ? 'minimized'
+            : 'docked';
+    document.documentElement.dataset.moldableChat = presentation;
+}
+function applyMoldableHostContext(message) {
+    const root = document.documentElement;
+    root.dataset.moldableDisplayMode = message.displayMode;
+    if (message.platform)
+        root.dataset.moldablePlatform = message.platform;
+    if (message.windowId)
+        root.dataset.moldableWindowId = message.windowId;
+    const insets = message.safeInsets;
+    if (insets) {
+        applyBoundedLength('--window-safe-area-top', insets.top);
+        applyBoundedLength('--window-safe-area-inline-start', insets.inlineStart);
+        applyBoundedLength('--window-safe-area-inline-end', insets.inlineEnd);
+        applyBoundedLength('--window-safe-area-bottom', insets.bottom);
+        applyBoundedLength('--window-titlebar-height', insets.titlebarHeight);
+        applyBoundedLength('--window-control-inset-inline-start', insets.controlInsetInlineStart);
+        applyBoundedLength('--window-control-inset-inline-end', insets.controlInsetInlineEnd);
+        applyBoundedLength('--window-corner-radius', insets.cornerRadius);
+    }
+    if (message.chat) {
+        applyMoldableChatSafePadding(message.chat.safePadding);
+        if (message.chat.presentation) {
+            root.dataset.moldableChat = message.chat.presentation;
+        }
+    }
+    window.dispatchEvent(new CustomEvent('moldable:host-context-change', { detail: message }));
+}
+function installHostStateLifecycle() {
+    const root = document.documentElement;
+    root.dataset.moldableDisplayMode =
+        window.parent === window ? 'window' : 'embedded';
+    // Standalone windows do not reserve space for the desktop chat dock.
+    if (window.parent === window) {
+        applyMoldableChatSafePadding(0);
+        return;
+    }
+    window.addEventListener('message', (event) => {
+        if (event.source !== window.parent)
+            return;
+        if (typeof event.data !== 'object' ||
+            event.data === null ||
+            !('type' in event.data) ||
+            typeof event.data.type !== 'string') {
+            return;
+        }
+        if (event.data.type === 'moldable:chat-state') {
+            applyMoldableChatState(event.data);
+        }
+        else if (event.data.type === 'moldable:host-context') {
+            const message = event.data;
+            if (message.version === 1 &&
+                (message.displayMode === 'embedded' ||
+                    message.displayMode === 'window')) {
+                applyMoldableHostContext(message);
+            }
+        }
+    });
+}
 function postMoldableFrameMessage(message) {
     if (typeof window === 'undefined' || window.parent === window)
         return;
@@ -37,6 +120,7 @@ export function installMoldableFrameLifecycle() {
     if (typeof window === 'undefined' || frameLifecycleInstalled)
         return;
     frameLifecycleInstalled = true;
+    installHostStateLifecycle();
     installViteHmrLifecycle();
     scheduleRenderReady();
     if (document.readyState === 'complete') {

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

@@ -0,0 +1,13 @@
+import { type NativeCapabilityBridgeOptions } from './bridge';
+import type { NativeCapabilityId } from './types';
+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 {
+    capability: NativeCapabilityId;
+    granted: boolean;
+}
+export declare function getMoldableNativeCapabilityAccess(capability: NativeCapabilityId, options?: NativeCapabilityBridgeOptions): Promise<MoldableNativeCapabilityAccessState>;
+export declare function requestMoldableNativeCapabilityAccess(capability: NativeCapabilityId, options?: NativeCapabilityBridgeOptions): Promise<MoldableNativeCapabilityAccessState>;
+export declare function assertMoldableNativeCapabilityAccess(capability: NativeCapabilityId, options?: NativeCapabilityBridgeOptions): Promise<void>;
+export declare function requireMoldableNativeCapabilityAccess(capability: NativeCapabilityId, options?: NativeCapabilityBridgeOptions): Promise<void>;
+//# sourceMappingURL=access.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/access.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,6BAA6B,EAEnC,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD,eAAO,MAAM,qCAAqC,EAChD,6CAAsD,CAAA;AACxD,eAAO,MAAM,oCAAoC,EAC/C,4CAAqD,CAAA;AAEvD,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,kBAAkB,CAAA;IAC9B,OAAO,EAAE,OAAO,CAAA;CACjB;AAgBD,wBAAsB,iCAAiC,CACrD,UAAU,EAAE,kBAAkB,EAC9B,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,mCAAmC,CAAC,CAY9C;AAED,wBAAsB,qCAAqC,CACzD,UAAU,EAAE,kBAAkB,EAC9B,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,mCAAmC,CAAC,CAY9C;AAED,wBAAsB,oCAAoC,CACxD,UAAU,EAAE,kBAAkB,EAC9B,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAsB,qCAAqC,CACzD,UAAU,EAAE,kBAAkB,EAC9B,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,IAAI,CAAC,CAWf"}

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

@@ -0,0 +1,53 @@
+import { NativeCapabilityBridgeError, callNativeCapabilityBridge, } from './bridge';
+import { isNativeCapabilityId } from './capabilities';
+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() {
+    return typeof window !== 'undefined' && window.parent !== window;
+}
+function validateCapability(capability) {
+    if (isNativeCapabilityId(capability))
+        return capability;
+    throw new NativeCapabilityBridgeError({
+        code: 'invalid_request',
+        message: 'Unknown native capability.',
+    });
+}
+export async function getMoldableNativeCapabilityAccess(capability, options = {}) {
+    const validated = validateCapability(capability);
+    if (!isEmbedded())
+        return { capability: validated, granted: true };
+    return callNativeCapabilityBridge({
+        type: NATIVE_CAPABILITY_ACCESS_REQUEST_TYPE,
+        action: 'getStatus',
+        capability: validated,
+    }, NATIVE_CAPABILITY_ACCESS_RESULT_TYPE, options);
+}
+export async function requestMoldableNativeCapabilityAccess(capability, options = {}) {
+    const validated = validateCapability(capability);
+    if (!isEmbedded())
+        return { capability: validated, granted: true };
+    return callNativeCapabilityBridge({
+        type: NATIVE_CAPABILITY_ACCESS_REQUEST_TYPE,
+        action: 'request',
+        capability: validated,
+    }, NATIVE_CAPABILITY_ACCESS_RESULT_TYPE, options);
+}
+export async function assertMoldableNativeCapabilityAccess(capability, options = {}) {
+    const result = await getMoldableNativeCapabilityAccess(capability, options);
+    if (!result.granted) {
+        throw new NativeCapabilityBridgeError({
+            code: 'permission_denied',
+            message: `Access to ${capability} was not approved for this app.`,
+        });
+    }
+}
+export async function requireMoldableNativeCapabilityAccess(capability, options = {}) {
+    const result = await requestMoldableNativeCapabilityAccess(capability, options);
+    if (!result.granted) {
+        throw new NativeCapabilityBridgeError({
+            code: 'permission_denied',
+            message: `Access to ${capability} was not approved for this app.`,
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { MoldableBluetoothAvailability, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRequestDeviceOptions, MoldableBluetoothRequestOptions } from './bluetooth-types';
+/** Checks only for the standards-based Web Bluetooth entry point. */
+export declare function isMoldableBluetoothSupported(): boolean;
+/**
+ * Returns adapter availability when the runtime exposes it. `unknown` means the
+ * API exists but cannot report adapter state, not that Bluetooth is available.
+ */
+export declare function getMoldableBluetoothAvailability(options?: MoldableBluetoothOperationOptions): Promise<MoldableBluetoothAvailability>;
+/**
+ * Opens the browser's device chooser. This must be called directly from a
+ * trusted user action; it never silently scans for or selects devices.
+ */
+export declare function requestMoldableBluetoothDevice(deviceOptions: MoldableBluetoothRequestDeviceOptions, options?: MoldableBluetoothRequestOptions): Promise<MoldableBluetoothDevice>;
+//# sourceMappingURL=bluetooth-access.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-access.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/bluetooth-access.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,6BAA6B,EAC7B,uBAAuB,EACvB,iCAAiC,EACjC,qCAAqC,EACrC,+BAA+B,EAChC,MAAM,mBAAmB,CAAA;AAE1B,qEAAqE;AACrE,wBAAgB,4BAA4B,IAAI,OAAO,CAGtD;AAED;;;GAGG;AACH,wBAAsB,gCAAgC,CACpD,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,6BAA6B,CAAC,CAgBxC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,aAAa,EAAE,qCAAqC,EACpD,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,uBAAuB,CAAC,CAgBlC"}

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

@@ -0,0 +1,43 @@
+import { assertMoldableNativeCapabilityAccess, requireMoldableNativeCapabilityAccess, } from './access';
+import { abortableBluetooth, assertBluetoothUserGesture, bluetoothError, getBluetoothAPI, getBluetoothNavigator, validateBluetoothRequestOptions, } from './bluetooth-internal';
+/** Checks only for the standards-based Web Bluetooth entry point. */
+export function isMoldableBluetoothSupported() {
+    const api = getBluetoothNavigator()?.bluetooth;
+    return Boolean(api && typeof api.requestDevice === 'function');
+}
+/**
+ * Returns adapter availability when the runtime exposes it. `unknown` means the
+ * API exists but cannot report adapter state, not that Bluetooth is available.
+ */
+export async function getMoldableBluetoothAvailability(options = {}) {
+    const operation = 'check Bluetooth availability';
+    await assertMoldableNativeCapabilityAccess('bluetooth', options);
+    const api = getBluetoothAPI(operation);
+    if (typeof api.getAvailability !== 'function')
+        return 'unknown';
+    try {
+        return (await abortableBluetooth(api.getAvailability(), options.signal, operation))
+            ? 'available'
+            : 'unavailable';
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}
+/**
+ * Opens the browser's device chooser. This must be called directly from a
+ * trusted user action; it never silently scans for or selects devices.
+ */
+export async function requestMoldableBluetoothDevice(deviceOptions, options = {}) {
+    const operation = 'request a Bluetooth device';
+    validateBluetoothRequestOptions(deviceOptions);
+    assertBluetoothUserGesture();
+    try {
+        await requireMoldableNativeCapabilityAccess('bluetooth', options);
+        const api = getBluetoothAPI(operation);
+        return await abortableBluetooth(api.requestDevice(deviceOptions), options.signal, operation, (device) => device.gatt?.disconnect());
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { MoldableBluetoothConnectionOptions, MoldableBluetoothDevice, MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTServer, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID } from './bluetooth-types';
+export declare class MoldableBluetoothConnection {
+    readonly device: MoldableBluetoothDevice;
+    readonly server: MoldableBluetoothRemoteGATTServer;
+    private readonly abortSignal?;
+    private readonly disconnectListeners;
+    private isClosed;
+    constructor(device: MoldableBluetoothDevice, server: MoldableBluetoothRemoteGATTServer, options?: MoldableBluetoothConnectionOptions);
+    get connected(): boolean;
+    onDisconnected(listener: () => void, signal?: AbortSignal): () => void;
+    getPrimaryService(service: MoldableBluetoothUUID, options?: MoldableBluetoothOperationOptions): Promise<MoldableBluetoothRemoteGATTService>;
+    disconnect(): void;
+    private readonly handleAbort;
+    private readonly handleDisconnected;
+    private finish;
+}
+/** Connects a previously user-selected device and owns disconnect cleanup. */
+export declare function connectMoldableBluetoothDevice(device: MoldableBluetoothDevice, options?: MoldableBluetoothConnectionOptions): Promise<MoldableBluetoothConnection>;
+//# sourceMappingURL=bluetooth-connection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-connection.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/bluetooth-connection.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kCAAkC,EAClC,uBAAuB,EACvB,iCAAiC,EACjC,iCAAiC,EACjC,kCAAkC,EAClC,qBAAqB,EACtB,MAAM,mBAAmB,CAAA;AAE1B,qBAAa,2BAA2B;IACtC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAA;IACxC,QAAQ,CAAC,MAAM,EAAE,iCAAiC,CAAA;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAa;IAC1C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAwB;IAC5D,OAAO,CAAC,QAAQ,CAAQ;gBAGtB,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iCAAiC,EACzC,OAAO,GAAE,kCAAuC;IASlD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,IAAI;IAWhE,iBAAiB,CACrB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,kCAAkC,CAAC;IAmB9C,UAAU,IAAI,IAAI;IAMlB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0B;IACtD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA0B;IAE7D,OAAO,CAAC,MAAM;CAqBf;AAED,8EAA8E;AAC9E,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,uBAAuB,EAC/B,OAAO,GAAE,kCAAuC,GAC/C,OAAO,CAAC,2BAA2B,CAAC,CA0BtC"}

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

@@ -0,0 +1,88 @@
+import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal';
+export class MoldableBluetoothConnection {
+    device;
+    server;
+    abortSignal;
+    disconnectListeners = new Set();
+    isClosed = false;
+    constructor(device, server, options = {}) {
+        this.device = device;
+        this.server = server;
+        this.abortSignal = options.signal;
+        device.addEventListener('gattserverdisconnected', this.handleDisconnected);
+        options.signal?.addEventListener('abort', this.handleAbort, { once: true });
+    }
+    get connected() {
+        return !this.isClosed && this.server.connected;
+    }
+    onDisconnected(listener, signal) {
+        if (signal?.aborted || this.isClosed)
+            return () => undefined;
+        this.disconnectListeners.add(listener);
+        const cleanup = () => {
+            this.disconnectListeners.delete(listener);
+            signal?.removeEventListener('abort', cleanup);
+        };
+        signal?.addEventListener('abort', cleanup, { once: true });
+        return cleanup;
+    }
+    async getPrimaryService(service, options = {}) {
+        const operation = `get Bluetooth service ${String(service)}`;
+        if (!this.connected) {
+            throw bluetoothError(new DOMException('Bluetooth device is disconnected', 'NetworkError'), operation);
+        }
+        try {
+            return await abortableBluetooth(this.server.getPrimaryService(service), options.signal, operation);
+        }
+        catch (error) {
+            throw bluetoothError(error, operation);
+        }
+    }
+    disconnect() {
+        if (this.isClosed)
+            return;
+        this.finish(false);
+        if (this.server.connected)
+            this.server.disconnect();
+    }
+    handleAbort = () => this.disconnect();
+    handleDisconnected = () => this.finish(true);
+    finish(notify) {
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        this.device.removeEventListener('gattserverdisconnected', this.handleDisconnected);
+        this.abortSignal?.removeEventListener('abort', this.handleAbort);
+        if (notify) {
+            const listeners = [...this.disconnectListeners];
+            this.disconnectListeners.clear();
+            for (const listener of listeners) {
+                try {
+                    listener();
+                }
+                catch {
+                    // A consumer callback must not prevent connection cleanup.
+                }
+            }
+        }
+        this.disconnectListeners.clear();
+    }
+}
+/** Connects a previously user-selected device and owns disconnect cleanup. */
+export async function connectMoldableBluetoothDevice(device, options = {}) {
+    const operation = `connect to Bluetooth device ${device.id}`;
+    if (!device.gatt) {
+        throw bluetoothError(new DOMException('Device does not expose a GATT server', 'NotSupportedError'), operation);
+    }
+    try {
+        const server = await abortableBluetooth(device.gatt.connect(), options.signal, operation, (lateServer) => lateServer.disconnect());
+        if (options.signal?.aborted) {
+            server.disconnect();
+            throw bluetoothAborted(operation);
+        }
+        return new MoldableBluetoothConnection(device, server, options);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { MoldableBluetoothOperationOptions, MoldableBluetoothRemoteGATTCharacteristic, MoldableBluetoothRemoteGATTService, MoldableBluetoothUUID, MoldableBluetoothWriteMode } from './bluetooth-types';
+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. */
+export declare function observeMoldableBluetoothNotifications(characteristic: MoldableBluetoothRemoteGATTCharacteristic, listener: (event: Event) => void, options?: MoldableBluetoothOperationOptions): Promise<() => Promise<void>>;
+export declare function writeMoldableBluetoothValue(characteristic: MoldableBluetoothRemoteGATTCharacteristic, value: BufferSource, mode?: MoldableBluetoothWriteMode, options?: MoldableBluetoothOperationOptions): Promise<void>;
+//# sourceMappingURL=bluetooth-gatt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-gatt.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/bluetooth-gatt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,iCAAiC,EACjC,yCAAyC,EACzC,kCAAkC,EAClC,qBAAqB,EACrB,0BAA0B,EAC3B,MAAM,mBAAmB,CAAA;AAE1B,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,kCAAkC,EAC3C,cAAc,EAAE,qBAAqB,EACrC,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,yCAAyC,CAAC,CAWpD;AAED,wBAAsB,0BAA0B,CAC9C,cAAc,EAAE,yCAAyC,EACzD,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,QAAQ,CAAC,CAWnB;AAED,+EAA+E;AAC/E,wBAAsB,qCAAqC,CACzD,cAAc,EAAE,yCAAyC,EACzD,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAmC9B;AAED,wBAAsB,2BAA2B,CAC/C,cAAc,EAAE,yCAAyC,EACzD,KAAK,EAAE,YAAY,EACnB,IAAI,GAAE,0BAAwC,EAC9C,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

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

@@ -0,0 +1,77 @@
+import { abortableBluetooth, bluetoothAborted, bluetoothError, } from './bluetooth-internal';
+export async function getMoldableBluetoothCharacteristic(service, characteristic, options = {}) {
+    const operation = `get Bluetooth characteristic ${String(characteristic)}`;
+    try {
+        return await abortableBluetooth(service.getCharacteristic(characteristic), options.signal, operation);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}
+export async function readMoldableBluetoothValue(characteristic, options = {}) {
+    const operation = `read Bluetooth characteristic ${characteristic.uuid}`;
+    try {
+        return await abortableBluetooth(characteristic.readValue(), options.signal, operation);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}
+/** Starts notifications and returns async, idempotent subscription cleanup. */
+export async function observeMoldableBluetoothNotifications(characteristic, listener, options = {}) {
+    const operation = `observe Bluetooth characteristic ${characteristic.uuid}`;
+    try {
+        await abortableBluetooth(characteristic.startNotifications(), options.signal, operation, (lateCharacteristic) => {
+            void lateCharacteristic.stopNotifications();
+        });
+        if (options.signal?.aborted) {
+            await characteristic.stopNotifications();
+            throw bluetoothAborted(operation);
+        }
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+    let active = true;
+    const cleanup = async () => {
+        if (!active)
+            return;
+        active = false;
+        characteristic.removeEventListener('characteristicvaluechanged', listener);
+        options.signal?.removeEventListener('abort', onAbort);
+        try {
+            await characteristic.stopNotifications();
+        }
+        catch (error) {
+            throw bluetoothError(error, `stop ${operation}`);
+        }
+    };
+    const onAbort = () => void cleanup().catch(() => undefined);
+    characteristic.addEventListener('characteristicvaluechanged', listener);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    return cleanup;
+}
+export async function writeMoldableBluetoothValue(characteristic, value, mode = 'automatic', options = {}) {
+    const operation = `write Bluetooth characteristic ${characteristic.uuid}`;
+    let write;
+    if (mode === 'with-response') {
+        write = characteristic.writeValueWithResponse?.bind(characteristic);
+    }
+    else if (mode === 'without-response') {
+        write = characteristic.writeValueWithoutResponse?.bind(characteristic);
+    }
+    else {
+        write =
+            characteristic.writeValueWithResponse?.bind(characteristic) ??
+                characteristic.writeValue.bind(characteristic);
+    }
+    if (!write) {
+        throw bluetoothError(new DOMException(`Bluetooth write mode ${mode} is unavailable`, 'NotSupportedError'), operation);
+    }
+    try {
+        await abortableBluetooth(write(value), options.signal, operation);
+    }
+    catch (error) {
+        throw bluetoothError(error, operation);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { MoldableBluetoothAPI, MoldableBluetoothNavigator, MoldableBluetoothRequestDeviceOptions } from './bluetooth-types';
+import { NativeCapabilityBridgeError } from './bridge';
+export declare function bluetoothError(error: unknown, operation: string): NativeCapabilityBridgeError;
+export declare function bluetoothAborted(operation: string): NativeCapabilityBridgeError;
+export declare function getBluetoothNavigator(): MoldableBluetoothNavigator | undefined;
+export declare function getBluetoothAPI(operation: string): MoldableBluetoothAPI;
+export declare function assertBluetoothUserGesture(): void;
+export declare function validateBluetoothRequestOptions(options: MoldableBluetoothRequestDeviceOptions): void;
+export declare function abortableBluetooth<T>(promise: Promise<T>, signal: AbortSignal | undefined, operation: string, onLateResolution?: (value: T) => void): Promise<T>;
+//# sourceMappingURL=bluetooth-internal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-internal.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/bluetooth-internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,qCAAqC,EACtC,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,2BAA2B,EAE5B,MAAM,UAAU,CAAA;AAGjB,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAChB,2BAA2B,CAsC7B;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAChB,2BAA2B,CAK7B;AAED,wBAAgB,qBAAqB,IACjC,0BAA0B,GAC1B,SAAS,CAIZ;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB,CASvE;AAED,wBAAgB,0BAA0B,IAAI,IAAI,CAWjD;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,qCAAqC,GAC7C,IAAI,CAiBN;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GACpC,OAAO,CAAC,CAAC,CAAC,CA+BZ"}