@moldable-ai/ui 0.2.19 → 0.2.21

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

@@ -0,0 +1,113 @@
+import { type NativeCapabilityBridgeOptions } from './bridge';
+import type { NativeCapabilityRequestEnvelope, NativeCapabilityResultEnvelope } from './types';
+export declare const NATIVE_POWER_SESSION_REQUEST_TYPE: "moldable:native-power-session";
+export declare const NATIVE_POWER_SESSION_RESULT_TYPE: "moldable:native-power-session-result";
+export declare const NATIVE_POWER_SESSION_EVENT_TYPE: "moldable:native-power-session-event";
+export type MoldablePowerSource = 'ac' | 'battery' | 'unknown';
+export type MoldableBatteryState = 'charging' | 'discharging' | 'empty' | 'full' | 'unknown';
+export interface MoldableBatteryStatus {
+    state: MoldableBatteryState;
+    chargePercent: number;
+    timeToEmptySeconds: number | null;
+    timeToFullSeconds: number | null;
+}
+export interface MoldablePowerState {
+    source: MoldablePowerSource;
+    batteries: MoldableBatteryStatus[];
+}
+export type MoldableSystemIdleState = 'active' | 'idle' | 'locked';
+export type MoldableThermalState = 'nominal' | 'fair' | 'serious' | 'critical' | 'unknown';
+export interface MoldableSystemIdleResult {
+    seconds: number;
+    state: MoldableSystemIdleState;
+    thresholdSeconds: number;
+}
+export type MoldableSleepBlockerType = 'prevent-app-suspension' | 'prevent-display-sleep';
+export type MoldablePowerSessionEvent = {
+    kind: 'suspend';
+    occurredAt: string;
+} | {
+    kind: 'resume';
+    occurredAt: string;
+} | {
+    kind: 'lock';
+    occurredAt: string;
+} | {
+    kind: 'unlock';
+    occurredAt: string;
+} | {
+    kind: 'session-active';
+    occurredAt: string;
+} | {
+    kind: 'session-inactive';
+    occurredAt: string;
+} | {
+    kind: 'shutdown';
+    occurredAt: string;
+} | {
+    kind: 'thermal-state-change';
+    occurredAt: string;
+    state: MoldableThermalState;
+} | {
+    kind: 'power-source-change';
+    occurredAt: string;
+    powerState: MoldablePowerState;
+};
+export type NativePowerSessionRequest = NativeCapabilityRequestEnvelope<typeof NATIVE_POWER_SESSION_REQUEST_TYPE, {
+    action: 'getPowerState';
+} | {
+    action: 'getCurrentThermalState';
+} | {
+    action: 'getIdleState';
+    thresholdSeconds: number;
+} | {
+    action: 'startSleepBlocker';
+    blockerType: MoldableSleepBlockerType;
+} | {
+    action: 'stopSleepBlocker';
+    blockerId: string;
+} | {
+    action: 'isSleepBlockerStarted';
+    blockerId: string;
+} | {
+    action: 'subscribeEvents';
+} | {
+    action: 'unsubscribeEvents';
+    subscriptionId: string;
+}>;
+export type NativePowerSessionResult = NativeCapabilityResultEnvelope<typeof NATIVE_POWER_SESSION_RESULT_TYPE, MoldablePowerState | MoldableThermalState | MoldableSystemIdleResult | {
+    blockerId: string;
+    blockerType: MoldableSleepBlockerType;
+} | {
+    stopped: true;
+} | {
+    started: boolean;
+} | {
+    subscriptionId: string;
+} | {
+    unsubscribed: true;
+}>;
+export interface WatchMoldablePowerSessionOptions {
+    signal?: AbortSignal;
+}
+export type StopWatchingMoldablePowerSession = () => Promise<void>;
+export declare function isMoldablePowerSessionEvent(value: unknown): value is MoldablePowerSessionEvent;
+export declare function getMoldablePowerState(options?: NativeCapabilityBridgeOptions): Promise<MoldablePowerState>;
+/** Return the host's current thermal pressure classification. */
+export declare function getMoldableCurrentThermalState(options?: NativeCapabilityBridgeOptions): Promise<MoldableThermalState>;
+export declare function getMoldableSystemIdleState(thresholdSeconds: number, options?: NativeCapabilityBridgeOptions): Promise<MoldableSystemIdleResult>;
+export declare function getMoldableSystemIdleTime(options?: NativeCapabilityBridgeOptions): Promise<number>;
+export interface MoldableSleepBlocker {
+    readonly id: string;
+    readonly type: MoldableSleepBlockerType;
+    readonly stopped: boolean;
+    isStarted(options?: NativeCapabilityBridgeOptions): Promise<boolean>;
+    stop(options?: NativeCapabilityBridgeOptions): Promise<void>;
+}
+export declare function startMoldableSleepBlocker(blockerType: MoldableSleepBlockerType, options?: NativeCapabilityBridgeOptions): Promise<MoldableSleepBlocker>;
+/** Stop a blocker returned by {@link startMoldableSleepBlocker}. */
+export declare function stopMoldableSleepBlocker(blocker: MoldableSleepBlocker, options?: NativeCapabilityBridgeOptions): Promise<void>;
+/** Ask the host whether a blocker still belongs to this active app scope. */
+export declare function isMoldableSleepBlockerStarted(blocker: MoldableSleepBlocker, options?: NativeCapabilityBridgeOptions): Promise<boolean>;
+export declare function watchMoldablePowerSession(listener: (event: MoldablePowerSessionEvent) => void, options?: WatchMoldablePowerSessionOptions & NativeCapabilityBridgeOptions): Promise<StopWatchingMoldablePowerSession>;
+//# sourceMappingURL=power-session.d.ts.map

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

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

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

@@ -0,0 +1,264 @@
+import { NativeCapabilityBridgeError, callNativeCapabilityBridge, resolveNativeCapabilityParentOrigin, } from './bridge';
+export const NATIVE_POWER_SESSION_REQUEST_TYPE = 'moldable:native-power-session';
+export const NATIVE_POWER_SESSION_RESULT_TYPE = 'moldable:native-power-session-result';
+export const NATIVE_POWER_SESSION_EVENT_TYPE = 'moldable:native-power-session-event';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPowerState(value) {
+    if (!isRecord(value))
+        return false;
+    if (!['ac', 'battery', 'unknown'].includes(String(value.source)))
+        return false;
+    if (!Array.isArray(value.batteries))
+        return false;
+    return value.batteries.every((battery) => isRecord(battery) &&
+        ['charging', 'discharging', 'empty', 'full', 'unknown'].includes(String(battery.state)) &&
+        typeof battery.chargePercent === 'number' &&
+        Number.isFinite(battery.chargePercent) &&
+        battery.chargePercent >= 0 &&
+        battery.chargePercent <= 100 &&
+        (battery.timeToEmptySeconds === null ||
+            (typeof battery.timeToEmptySeconds === 'number' &&
+                Number.isFinite(battery.timeToEmptySeconds) &&
+                battery.timeToEmptySeconds >= 0)) &&
+        (battery.timeToFullSeconds === null ||
+            (typeof battery.timeToFullSeconds === 'number' &&
+                Number.isFinite(battery.timeToFullSeconds) &&
+                battery.timeToFullSeconds >= 0)));
+}
+function isThermalState(value) {
+    return ['nominal', 'fair', 'serious', 'critical', 'unknown'].includes(String(value));
+}
+export function isMoldablePowerSessionEvent(value) {
+    if (!isRecord(value) || typeof value.occurredAt !== 'string')
+        return false;
+    if (Number.isNaN(Date.parse(value.occurredAt)))
+        return false;
+    if (value.kind === 'suspend' ||
+        value.kind === 'resume' ||
+        value.kind === 'lock' ||
+        value.kind === 'unlock' ||
+        value.kind === 'session-active' ||
+        value.kind === 'session-inactive' ||
+        value.kind === 'shutdown') {
+        return true;
+    }
+    if (value.kind === 'thermal-state-change') {
+        return isThermalState(value.state);
+    }
+    return value.kind === 'power-source-change' && isPowerState(value.powerState);
+}
+export async function getMoldablePowerState(options = {}) {
+    const value = await callNativeCapabilityBridge({ type: NATIVE_POWER_SESSION_REQUEST_TYPE, action: 'getPowerState' }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (!isPowerState(value)) {
+        throw new NativeCapabilityBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid power state.',
+            details: value,
+            retryable: false,
+        });
+    }
+    return value;
+}
+/** Return the host's current thermal pressure classification. */
+export async function getMoldableCurrentThermalState(options = {}) {
+    const value = await callNativeCapabilityBridge({
+        type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+        action: 'getCurrentThermalState',
+    }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (!isThermalState(value)) {
+        throw new NativeCapabilityBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid thermal state.',
+            details: value,
+            retryable: false,
+        });
+    }
+    return value;
+}
+export async function getMoldableSystemIdleState(thresholdSeconds, options = {}) {
+    if (!Number.isSafeInteger(thresholdSeconds) ||
+        thresholdSeconds < 1 ||
+        thresholdSeconds > 86_400) {
+        throw new RangeError('thresholdSeconds must be an integer from 1 to 86400.');
+    }
+    const value = await callNativeCapabilityBridge({
+        type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+        action: 'getIdleState',
+        thresholdSeconds,
+    }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (!isRecord(value) ||
+        typeof value.seconds !== 'number' ||
+        !Number.isFinite(value.seconds) ||
+        value.seconds < 0 ||
+        !['active', 'idle', 'locked'].includes(String(value.state)) ||
+        value.thresholdSeconds !== thresholdSeconds) {
+        throw new NativeCapabilityBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid system idle state.',
+            details: value,
+            retryable: false,
+        });
+    }
+    return value;
+}
+export async function getMoldableSystemIdleTime(options = {}) {
+    const result = await getMoldableSystemIdleState(86_400, options);
+    return result.seconds;
+}
+class MoldableSleepBlockerHandle {
+    id;
+    type;
+    #stopPromise = null;
+    #stopped = false;
+    constructor(id, type) {
+        this.id = id;
+        this.type = type;
+    }
+    get stopped() {
+        return this.#stopped;
+    }
+    async isStarted(options = {}) {
+        if (this.#stopped)
+            return false;
+        const result = await callNativeCapabilityBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'isSleepBlockerStarted',
+            blockerId: this.id,
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+        if (typeof result.started !== 'boolean') {
+            throw new NativeCapabilityBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid sleep blocker state.',
+                details: result,
+                retryable: false,
+            });
+        }
+        if (!result.started)
+            this.#stopped = true;
+        return result.started;
+    }
+    stop(options = {}) {
+        if (this.#stopped)
+            return Promise.resolve();
+        if (this.#stopPromise)
+            return this.#stopPromise;
+        this.#stopPromise = callNativeCapabilityBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'stopSleepBlocker',
+            blockerId: this.id,
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, options)
+            .then(() => {
+            this.#stopped = true;
+        })
+            .catch((error) => {
+            this.#stopPromise = null;
+            throw error;
+        });
+        return this.#stopPromise;
+    }
+}
+export async function startMoldableSleepBlocker(blockerType, options = {}) {
+    const result = await callNativeCapabilityBridge({
+        type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+        action: 'startSleepBlocker',
+        blockerType,
+    }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (typeof result.blockerId !== 'string' ||
+        result.blockerId.length === 0 ||
+        result.blockerType !== blockerType) {
+        throw new NativeCapabilityBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid sleep blocker handle.',
+            details: result,
+            retryable: false,
+        });
+    }
+    return new MoldableSleepBlockerHandle(result.blockerId, blockerType);
+}
+/** Stop a blocker returned by {@link startMoldableSleepBlocker}. */
+export function stopMoldableSleepBlocker(blocker, options = {}) {
+    return blocker.stop(options);
+}
+/** Ask the host whether a blocker still belongs to this active app scope. */
+export function isMoldableSleepBlockerStarted(blocker, options = {}) {
+    return blocker.isStarted(options);
+}
+export async function watchMoldablePowerSession(listener, options = {}) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        throw new NativeCapabilityBridgeError({
+            code: 'not_in_moldable',
+            message: 'Power/session events are only available inside Moldable.',
+            retryable: false,
+        });
+    }
+    const parentOrigin = resolveNativeCapabilityParentOrigin(document.referrer);
+    if (!parentOrigin) {
+        throw new NativeCapabilityBridgeError({
+            code: 'not_in_moldable',
+            message: 'The power/session event parent could not be verified.',
+            retryable: false,
+        });
+    }
+    let active = true;
+    const handleMessage = (event) => {
+        if (!active ||
+            event.source !== window.parent ||
+            event.origin !== parentOrigin ||
+            !isRecord(event.data)) {
+            return;
+        }
+        if (event.data.type !== NATIVE_POWER_SESSION_EVENT_TYPE)
+            return;
+        if (!isMoldablePowerSessionEvent(event.data.event))
+            return;
+        listener(event.data.event);
+    };
+    let stopPromise = null;
+    let subscriptionId = '';
+    const stop = () => {
+        if (stopPromise)
+            return stopPromise;
+        active = false;
+        window.removeEventListener('message', handleMessage);
+        options.signal?.removeEventListener('abort', handleAbort);
+        stopPromise = callNativeCapabilityBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'unsubscribeEvents',
+            subscriptionId,
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, { timeoutMs: options.timeoutMs })
+            .then(() => undefined)
+            .catch((error) => {
+            stopPromise = null;
+            throw error;
+        });
+        return stopPromise;
+    };
+    const handleAbort = () => void stop().catch(() => undefined);
+    window.addEventListener('message', handleMessage);
+    try {
+        const result = await callNativeCapabilityBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'subscribeEvents',
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+        if (typeof result.subscriptionId !== 'string' || !result.subscriptionId) {
+            throw new NativeCapabilityBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid power event subscription.',
+                details: result,
+                retryable: false,
+            });
+        }
+        subscriptionId = result.subscriptionId;
+    }
+    catch (error) {
+        active = false;
+        window.removeEventListener('message', handleMessage);
+        throw error;
+    }
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
+    if (options.signal?.aborted)
+        handleAbort();
+    return stop;
+}

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

@@ -0,0 +1,36 @@
+import { type NativeCapabilityBridgeOptions } from './bridge';
+export declare const NATIVE_SECURE_STORAGE_REQUEST_TYPE: "moldable:native-secure-storage";
+export declare const NATIVE_SECURE_STORAGE_RESULT_TYPE: "moldable:native-secure-storage-result";
+export declare const SECURE_STORAGE_MAX_KEY_LENGTH = 128;
+export declare const SECURE_STORAGE_MAX_VALUE_BYTES = 2048;
+export interface MoldableSecureStorageValueResult {
+    value: string | null;
+}
+export interface MoldableSecureStorageSetResult {
+    stored: true;
+}
+export interface MoldableSecureStorageDeleteResult {
+    deleted: boolean;
+}
+export interface MoldableSecureStorageEntryMetadata {
+    key: string;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export interface MoldableSecureStorageListResult {
+    entries: MoldableSecureStorageEntryMetadata[];
+}
+export type MoldableSecureStorageBackend = 'keychain' | 'credential-manager' | 'secret-service' | 'unsupported';
+export interface MoldableSecureStorageDiagnostics {
+    available: boolean;
+    backend: MoldableSecureStorageBackend;
+    reason?: string;
+}
+/** Inspect credential-store readiness without reading or returning a secret. */
+export declare function getMoldableSecureStorageDiagnostics(options?: NativeCapabilityBridgeOptions): Promise<MoldableSecureStorageDiagnostics>;
+export declare function getMoldableSecureValue(key: string, options?: NativeCapabilityBridgeOptions): Promise<MoldableSecureStorageValueResult>;
+export declare function setMoldableSecureValue(key: string, value: string, options?: NativeCapabilityBridgeOptions): Promise<MoldableSecureStorageSetResult>;
+export declare function deleteMoldableSecureValue(key: string, options?: NativeCapabilityBridgeOptions): Promise<MoldableSecureStorageDeleteResult>;
+/** List entry metadata for the current app and workspace; values are omitted. */
+export declare function listMoldableSecureValues(options?: NativeCapabilityBridgeOptions): Promise<MoldableSecureStorageListResult>;
+//# sourceMappingURL=secure-storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"secure-storage.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/secure-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,6BAA6B,EAEnC,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,kCAAkC,EAC7C,gCAAyC,CAAA;AAC3C,eAAO,MAAM,iCAAiC,EAC5C,uCAAgD,CAAA;AAElD,eAAO,MAAM,6BAA6B,MAAM,CAAA;AAGhD,eAAO,MAAM,8BAA8B,OAAQ,CAAA;AAEnD,MAAM,WAAW,gCAAgC;IAC/C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAED,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,IAAI,CAAA;CACb;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,kCAAkC;IACjD,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,kCAAkC,EAAE,CAAA;CAC9C;AAED,MAAM,MAAM,4BAA4B,GACpC,UAAU,GACV,oBAAoB,GACpB,gBAAgB,GAChB,aAAa,CAAA;AAEjB,MAAM,WAAW,gCAAgC;IAC/C,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,4BAA4B,CAAA;IACrC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,gFAAgF;AAChF,wBAAgB,mCAAmC,CACjD,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,gCAAgC,CAAC,CAU3C;AAkBD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,8BAA8B,CAAC,CAmBzC;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,iCAAiC,CAAC,CAY5C;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,+BAA+B,CAAC,CAU1C"}

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

@@ -0,0 +1,64 @@
+import { callNativeCapabilityBridge, } from './bridge';
+export const NATIVE_SECURE_STORAGE_REQUEST_TYPE = 'moldable:native-secure-storage';
+export const NATIVE_SECURE_STORAGE_RESULT_TYPE = 'moldable:native-secure-storage-result';
+export const SECURE_STORAGE_MAX_KEY_LENGTH = 128;
+// Windows Credential Manager has the smallest commonly supported payload;
+// keeping one cross-platform limit makes behavior portable between hosts.
+export const SECURE_STORAGE_MAX_VALUE_BYTES = 2_048;
+/** Inspect credential-store readiness without reading or returning a secret. */
+export function getMoldableSecureStorageDiagnostics(options = {}) {
+    return callNativeCapabilityBridge({
+        type: NATIVE_SECURE_STORAGE_REQUEST_TYPE,
+        capability: 'secure-storage',
+        action: 'getDiagnostics',
+    }, NATIVE_SECURE_STORAGE_RESULT_TYPE, options);
+}
+function assertValidKey(key) {
+    if (key.trim().length === 0 ||
+        key.length > SECURE_STORAGE_MAX_KEY_LENGTH ||
+        !/^[A-Za-z0-9._-]+$/.test(key)) {
+        throw new TypeError(`Secure-storage keys must contain 1-${SECURE_STORAGE_MAX_KEY_LENGTH} ASCII letters, numbers, dots, underscores, or hyphens.`);
+    }
+}
+function utf8Length(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+export function getMoldableSecureValue(key, options = {}) {
+    assertValidKey(key);
+    return callNativeCapabilityBridge({
+        type: NATIVE_SECURE_STORAGE_REQUEST_TYPE,
+        capability: 'secure-storage',
+        action: 'get',
+        key,
+    }, NATIVE_SECURE_STORAGE_RESULT_TYPE, options);
+}
+export function setMoldableSecureValue(key, value, options = {}) {
+    assertValidKey(key);
+    if (utf8Length(value) > SECURE_STORAGE_MAX_VALUE_BYTES) {
+        throw new TypeError(`Secure-storage values cannot exceed ${SECURE_STORAGE_MAX_VALUE_BYTES} UTF-8 bytes.`);
+    }
+    return callNativeCapabilityBridge({
+        type: NATIVE_SECURE_STORAGE_REQUEST_TYPE,
+        capability: 'secure-storage',
+        action: 'set',
+        key,
+        value,
+    }, NATIVE_SECURE_STORAGE_RESULT_TYPE, options);
+}
+export function deleteMoldableSecureValue(key, options = {}) {
+    assertValidKey(key);
+    return callNativeCapabilityBridge({
+        type: NATIVE_SECURE_STORAGE_REQUEST_TYPE,
+        capability: 'secure-storage',
+        action: 'delete',
+        key,
+    }, NATIVE_SECURE_STORAGE_RESULT_TYPE, options);
+}
+/** List entry metadata for the current app and workspace; values are omitted. */
+export function listMoldableSecureValues(options = {}) {
+    return callNativeCapabilityBridge({
+        type: NATIVE_SECURE_STORAGE_REQUEST_TYPE,
+        capability: 'secure-storage',
+        action: 'list',
+    }, NATIVE_SECURE_STORAGE_RESULT_TYPE, options);
+}

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

@@ -0,0 +1,23 @@
+import { type MoldableNativeDeviceDescriptor } from './native-device-io';
+import type { MoldableSerialInputSignals, MoldableSerialOpenOptions, MoldableSerialOutputSignals, MoldableSerialPort, MoldableSerialPortInfo } from './serial';
+export declare class NativeMoldableSerialPort extends EventTarget implements MoldableSerialPort {
+    readonly descriptor: MoldableNativeDeviceDescriptor;
+    readable: ReadableStream<Uint8Array> | null;
+    writable: WritableStream<Uint8Array> | null;
+    private handle?;
+    private closing?;
+    private readonly lifecycle;
+    constructor(descriptor: MoldableNativeDeviceDescriptor);
+    get connected(): boolean;
+    getInfo(): MoldableSerialPortInfo;
+    open(options: MoldableSerialOpenOptions): Promise<void>;
+    close(): Promise<void>;
+    forget(): Promise<void>;
+    getSignals(): Promise<MoldableSerialInputSignals>;
+    setSignals(signals: MoldableSerialOutputSignals): Promise<void>;
+    private createReadable;
+    private createWritable;
+    private execute;
+}
+export declare function isNativeMoldableSerialPort(port: MoldableSerialPort): port is NativeMoldableSerialPort;
+//# sourceMappingURL=serial-native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serial-native.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/serial-native.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,8BAA8B,EAMpC,MAAM,oBAAoB,CAAA;AAK3B,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,UAAU,CAAA;AAEjB,qBAAa,wBACX,SAAQ,WACR,YAAW,kBAAkB;IAQjB,QAAQ,CAAC,UAAU,EAAE,8BAA8B;IAN/D,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAO;IAClD,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAO;IAClD,OAAO,CAAC,MAAM,CAAC,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;gBAEnC,UAAU,EAAE,8BAA8B;IAI/D,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,OAAO,IAAI,sBAAsB;IAO3B,IAAI,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBtB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,UAAU,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAsBjD,UAAU,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IASrE,OAAO,CAAC,cAAc;IA8BtB,OAAO,CAAC,cAAc;YAqBR,OAAO;CA6BtB;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,kBAAkB,GACvB,IAAI,IAAI,wBAAwB,CAElC"}