@moldable-ai/ui 0.2.17 → 0.2.19

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

@@ -0,0 +1,36 @@
+import { type NativeHardwareBridgeOptions } 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?: NativeHardwareBridgeOptions): Promise<MoldableSecureStorageDiagnostics>;
+export declare function getMoldableSecureValue(key: string, options?: NativeHardwareBridgeOptions): Promise<MoldableSecureStorageValueResult>;
+export declare function setMoldableSecureValue(key: string, value: string, options?: NativeHardwareBridgeOptions): Promise<MoldableSecureStorageSetResult>;
+export declare function deleteMoldableSecureValue(key: string, options?: NativeHardwareBridgeOptions): Promise<MoldableSecureStorageDeleteResult>;
+/** List entry metadata for the current app and workspace; values are omitted. */
+export declare function listMoldableSecureValues(options?: NativeHardwareBridgeOptions): Promise<MoldableSecureStorageListResult>;
+//# sourceMappingURL=secure-storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"secure-storage.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/secure-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,EAEjC,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,2BAAgC,GACxC,OAAO,CAAC,gCAAgC,CAAC,CAU3C;AAkBD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,8BAA8B,CAAC,CAmBzC;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,iCAAiC,CAAC,CAY5C;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,+BAA+B,CAAC,CAU1C"}

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

@@ -0,0 +1,64 @@
+import { callNativeHardwareBridge, } 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 callNativeHardwareBridge({
+        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 callNativeHardwareBridge({
+        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 callNativeHardwareBridge({
+        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 callNativeHardwareBridge({
+        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 callNativeHardwareBridge({
+        type: NATIVE_SECURE_STORAGE_REQUEST_TYPE,
+        capability: 'secure-storage',
+        action: 'list',
+    }, NATIVE_SECURE_STORAGE_RESULT_TYPE, options);
+}

package/dist/lib/native-hardware/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-hardware/serial-native.d.ts.map

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

package/dist/lib/native-hardware/serial-native.js

@@ -0,0 +1,181 @@
+import { NativeHardwareBridgeError } from './bridge';
+import { bytesFromNativeDeviceResult, bytesWrittenFromNativeDeviceResult, closeMoldableNativeDevice, executeMoldableNativeDeviceOperation, openMoldableNativeDevice, } from './native-device-io';
+import { NativeDeviceLifecycle, isNativeDeviceDisconnect, } from './native-device-lifecycle';
+export class NativeMoldableSerialPort extends EventTarget {
+    descriptor;
+    readable = null;
+    writable = null;
+    handle;
+    closing;
+    lifecycle = new NativeDeviceLifecycle();
+    constructor(descriptor) {
+        super();
+        this.descriptor = descriptor;
+    }
+    get connected() {
+        return this.lifecycle.connected;
+    }
+    getInfo() {
+        return {
+            usbVendorId: this.descriptor.vendorId,
+            usbProductId: this.descriptor.productId,
+        };
+    }
+    async open(options) {
+        if (this.closing)
+            await this.closing;
+        if (this.handle && this.lifecycle.disconnected)
+            await this.close();
+        if (this.handle) {
+            throw new DOMException('Serial port is already open.', 'InvalidStateError');
+        }
+        if (options.bufferSize !== undefined) {
+            throw new NativeHardwareBridgeError({
+                code: 'unsupported',
+                message: 'The native serial fallback does not support bufferSize.',
+                retryable: false,
+            });
+        }
+        const opened = await openMoldableNativeDevice('serial', this.descriptor.selector, {
+            baudRate: options.baudRate,
+            dataBits: options.dataBits,
+            stopBits: options.stopBits,
+            parity: options.parity,
+            flowControl: options.flowControl,
+        });
+        if (opened.kind !== 'serial')
+            throw new Error('Native device kind mismatch.');
+        this.handle = opened.handle;
+        this.lifecycle.didOpen();
+        this.readable = this.createReadable();
+        this.writable = this.createWritable();
+    }
+    async close() {
+        if (this.closing)
+            return this.closing;
+        if (!this.handle)
+            return;
+        const handle = this.handle;
+        const closing = closeMoldableNativeDevice('serial', handle)
+            .then(() => {
+            if (this.handle === handle) {
+                this.handle = undefined;
+                this.readable = null;
+                this.writable = null;
+                this.lifecycle.didClose();
+            }
+        })
+            .finally(() => {
+            if (this.closing === closing)
+                this.closing = undefined;
+        });
+        this.closing = closing;
+        return closing;
+    }
+    async forget() {
+        await this.close();
+    }
+    async getSignals() {
+        const result = await this.execute({ action: 'serialGetSignals' });
+        if (result.kind !== 'signals' ||
+            typeof result.dataCarrierDetect !== 'boolean' ||
+            typeof result.clearToSend !== 'boolean' ||
+            typeof result.ringIndicator !== 'boolean' ||
+            typeof result.dataSetReady !== 'boolean') {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned invalid serial signals.',
+            });
+        }
+        return {
+            dataCarrierDetect: result.dataCarrierDetect,
+            clearToSend: result.clearToSend,
+            ringIndicator: result.ringIndicator,
+            dataSetReady: result.dataSetReady,
+        };
+    }
+    async setSignals(signals) {
+        await this.execute({
+            action: 'serialSetSignals',
+            dataTerminalReady: signals.dataTerminalReady,
+            requestToSend: signals.requestToSend,
+            sendBreak: signals.break,
+        });
+    }
+    createReadable() {
+        return new ReadableStream({
+            pull: async (controller) => {
+                if (!this.handle) {
+                    controller.close();
+                    return;
+                }
+                try {
+                    const result = await this.execute({
+                        action: 'read',
+                        endpoint: null,
+                        length: 65_536,
+                        timeoutMs: 1_000,
+                        bulk: false,
+                    });
+                    const bytes = bytesFromNativeDeviceResult(result);
+                    if (bytes.length > 0)
+                        controller.enqueue(bytes);
+                }
+                catch (error) {
+                    if (error instanceof NativeHardwareBridgeError &&
+                        error.code === 'timeout') {
+                        return;
+                    }
+                    controller.error(error);
+                }
+            },
+        });
+    }
+    createWritable() {
+        return new WritableStream({
+            write: async (data) => {
+                const result = await this.execute({
+                    action: 'write',
+                    endpoint: null,
+                    data: [...data],
+                    timeoutMs: 10_000,
+                    bulk: false,
+                });
+                if (bytesWrittenFromNativeDeviceResult(result) !== data.byteLength) {
+                    throw new NativeHardwareBridgeError({
+                        code: 'host_error',
+                        message: 'The serial device accepted only part of the write.',
+                        retryable: true,
+                    });
+                }
+            },
+        });
+    }
+    async execute(operation) {
+        if (!this.handle) {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_request',
+                message: 'Serial port is not open.',
+            });
+        }
+        if (this.lifecycle.disconnected) {
+            throw new NativeHardwareBridgeError({
+                code: 'unavailable',
+                message: 'Serial device is disconnected.',
+                retryable: true,
+            });
+        }
+        try {
+            return await executeMoldableNativeDeviceOperation('serial', this.handle, operation);
+        }
+        catch (error) {
+            if (isNativeDeviceDisconnect(error)) {
+                this.lifecycle.didDisconnect(this, error);
+            }
+            throw error;
+        }
+    }
+}
+export function isNativeMoldableSerialPort(port) {
+    return port instanceof NativeMoldableSerialPort;
+}

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

@@ -0,0 +1,76 @@
+export interface MoldableSerialOperationOptions {
+    signal?: AbortSignal;
+}
+export type MoldableBluetoothServiceUuid = number | string;
+export interface MoldableSerialPortFilter {
+    usbVendorId?: number;
+    usbProductId?: number;
+    bluetoothServiceClassId?: MoldableBluetoothServiceUuid;
+}
+export interface MoldableSerialOpenOptions {
+    baudRate: number;
+    dataBits?: 7 | 8;
+    stopBits?: 1 | 2;
+    parity?: 'none' | 'even' | 'odd';
+    bufferSize?: number;
+    flowControl?: 'none' | 'hardware';
+}
+export interface MoldableSerialPortInfo {
+    usbVendorId?: number;
+    usbProductId?: number;
+    bluetoothServiceClassId?: MoldableBluetoothServiceUuid;
+}
+export interface MoldableSerialInputSignals {
+    dataCarrierDetect: boolean;
+    clearToSend: boolean;
+    ringIndicator: boolean;
+    dataSetReady: boolean;
+}
+export interface MoldableSerialOutputSignals {
+    dataTerminalReady?: boolean;
+    requestToSend?: boolean;
+    break?: boolean;
+}
+/** Structural subset of the standard SerialPort interface used by the helpers. */
+export interface MoldableSerialPort extends EventTarget {
+    readonly readable: ReadableStream<Uint8Array> | null;
+    readonly writable: WritableStream<Uint8Array> | null;
+    readonly connected?: boolean;
+    getInfo(): MoldableSerialPortInfo;
+    open(options: MoldableSerialOpenOptions): Promise<void>;
+    close(): Promise<void>;
+    forget?(): Promise<void>;
+    getSignals(): Promise<MoldableSerialInputSignals>;
+    setSignals(signals: MoldableSerialOutputSignals): Promise<void>;
+}
+export interface MoldableSerialRequestOptions extends MoldableSerialOperationOptions {
+    filters?: readonly MoldableSerialPortFilter[];
+    allowedBluetoothServiceClassIds?: readonly MoldableBluetoothServiceUuid[];
+    /** Required when multiple native fallback ports match. Render a user choice. */
+    selectNativePort?: (ports: readonly MoldableSerialPort[]) => MoldableSerialPort | Promise<MoldableSerialPort>;
+}
+/** Returns true only when this WebView exposes the Web Serial entry point. */
+export declare function isMoldableSerialSupported(): boolean;
+/** Lists ports previously authorized through Web Serial. */
+export declare function getMoldableSerialPorts(): Promise<MoldableSerialPort[]>;
+/**
+ * Shows the browser's serial-port chooser. Call this directly from a user
+ * gesture. Aborting stops awaiting the result but may not dismiss the chooser.
+ */
+export declare function requestMoldableSerialPort(options?: MoldableSerialRequestOptions): Promise<MoldableSerialPort>;
+export declare function openMoldableSerialPort(port: MoldableSerialPort, options: MoldableSerialOpenOptions): Promise<void>;
+/** Closes a port after callers have released all stream readers and writers. */
+export declare function closeMoldableSerialPort(port: MoldableSerialPort): Promise<void>;
+/** Revokes the saved permission when the runtime supports SerialPort.forget(). */
+export declare function forgetMoldableSerialPort(port: MoldableSerialPort): Promise<void>;
+export declare function getMoldableSerialSignals(port: MoldableSerialPort): Promise<MoldableSerialInputSignals>;
+export declare function setMoldableSerialSignals(port: MoldableSerialPort, signals: MoldableSerialOutputSignals): Promise<void>;
+/** Reads one available serial chunk and always releases the stream reader. */
+export declare function readMoldableSerialPort(port: MoldableSerialPort, options?: MoldableSerialOperationOptions): Promise<ReadableStreamReadResult<Uint8Array>>;
+/**
+ * Writes one serial chunk and releases the stream writer. Aborting rejects the
+ * helper promptly and asks the stream to abort; the browser may finish an
+ * already-started hardware write before releasing the lock.
+ */
+export declare function writeMoldableSerialPort(port: MoldableSerialPort, data: Uint8Array, options?: MoldableSerialOperationOptions): Promise<void>;
+//# sourceMappingURL=serial.d.ts.map

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

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

package/dist/lib/native-hardware/serial.js

@@ -0,0 +1,212 @@
+import { NativeHardwareBridgeError } from './bridge';
+import { abortedDeviceIoError, awaitDeviceIoWithAbort, deviceIoError, unsupportedDeviceIoError, } from './device-io-errors';
+import { listMoldableNativeDevices } from './native-device-io';
+import { NativeMoldableSerialPort } from './serial-native';
+function assertNativeSerialFiltersSupported(options) {
+    if (options.allowedBluetoothServiceClassIds?.length ||
+        options.filters?.some((filter) => filter.bluetoothServiceClassId !== undefined)) {
+        throw new NativeHardwareBridgeError({
+            code: 'unsupported',
+            message: 'The native serial fallback cannot match Bluetooth service identifiers on this platform.',
+            retryable: false,
+        });
+    }
+}
+function serialApi() {
+    const api = typeof navigator === 'undefined'
+        ? undefined
+        : navigator.serial;
+    if (!api)
+        throw unsupportedDeviceIoError('serial');
+    return api;
+}
+/** Returns true only when this WebView exposes the Web Serial entry point. */
+export function isMoldableSerialSupported() {
+    return (typeof navigator !== 'undefined' &&
+        !!navigator.serial);
+}
+/** Lists ports previously authorized through Web Serial. */
+export async function getMoldableSerialPorts() {
+    if (!isMoldableSerialSupported()) {
+        throw unsupportedDeviceIoError('serial');
+    }
+    try {
+        return await serialApi().getPorts();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'enumerate', error);
+    }
+}
+/**
+ * Shows the browser's serial-port chooser. Call this directly from a user
+ * gesture. Aborting stops awaiting the result but may not dismiss the chooser.
+ */
+export async function requestMoldableSerialPort(options = {}) {
+    if (!isMoldableSerialSupported()) {
+        assertNativeSerialFiltersSupported(options);
+        const descriptors = await listMoldableNativeDevices('serial', {
+            signal: options.signal,
+            ...(options.filters
+                ? {
+                    filters: options.filters.map(({ usbVendorId, usbProductId }) => ({
+                        vendorId: usbVendorId,
+                        productId: usbProductId,
+                    })),
+                }
+                : {}),
+        });
+        const ports = descriptors
+            .filter((descriptor) => !options.filters || options.filters.length === 0
+            ? true
+            : options.filters.some((filter) => (filter.usbVendorId === undefined ||
+                filter.usbVendorId === descriptor.vendorId) &&
+                (filter.usbProductId === undefined ||
+                    filter.usbProductId === descriptor.productId)))
+            .map((descriptor) => new NativeMoldableSerialPort(descriptor));
+        if (ports.length === 0) {
+            throw deviceIoError('serial', 'request', new DOMException('No matching serial port is available.', 'NotFoundError'));
+        }
+        if (ports.length === 1)
+            return ports[0];
+        if (!options.selectNativePort) {
+            throw deviceIoError('serial', 'request', new TypeError('A native port selector is required when multiple serial ports match.'));
+        }
+        const selected = await options.selectNativePort(ports);
+        if (!ports.includes(selected)) {
+            throw deviceIoError('serial', 'request', new TypeError('Invalid native serial selection.'));
+        }
+        return selected;
+    }
+    try {
+        return await awaitDeviceIoWithAbort(serialApi().requestPort({
+            ...(options.filters ? { filters: [...options.filters] } : {}),
+            ...(options.allowedBluetoothServiceClassIds
+                ? {
+                    allowedBluetoothServiceClassIds: [
+                        ...options.allowedBluetoothServiceClassIds,
+                    ],
+                }
+                : {}),
+        }), 'serial', 'request', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'request', error);
+    }
+}
+export async function openMoldableSerialPort(port, options) {
+    try {
+        await port.open(options);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'open', error);
+    }
+}
+/** Closes a port after callers have released all stream readers and writers. */
+export async function closeMoldableSerialPort(port) {
+    if (port.readable?.locked || port.writable?.locked) {
+        throw deviceIoError('serial', 'close', new DOMException('Release active serial stream readers and writers before closing.', 'InvalidStateError'));
+    }
+    try {
+        await port.close();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'close', error);
+    }
+}
+/** Revokes the saved permission when the runtime supports SerialPort.forget(). */
+export async function forgetMoldableSerialPort(port) {
+    if (typeof port.forget !== 'function') {
+        throw unsupportedDeviceIoError('serial');
+    }
+    try {
+        await port.forget();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'close', error);
+    }
+}
+export async function getMoldableSerialSignals(port) {
+    try {
+        return await port.getSignals();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'read', error);
+    }
+}
+export async function setMoldableSerialSignals(port, signals) {
+    try {
+        await port.setSignals(signals);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'write', error);
+    }
+}
+/** Reads one available serial chunk and always releases the stream reader. */
+export async function readMoldableSerialPort(port, options = {}) {
+    if (options.signal?.aborted) {
+        throw abortedDeviceIoError('serial', 'read');
+    }
+    if (!port.readable) {
+        throw deviceIoError('serial', 'read', new DOMException('Serial port is not readable.', 'InvalidStateError'));
+    }
+    const reader = port.readable.getReader();
+    let aborted = false;
+    const handleAbort = () => {
+        aborted = true;
+        void reader.cancel().catch(() => undefined);
+    };
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
+    try {
+        const result = await reader.read();
+        if (aborted)
+            throw abortedDeviceIoError('serial', 'read');
+        return result;
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'read', error);
+    }
+    finally {
+        options.signal?.removeEventListener('abort', handleAbort);
+        reader.releaseLock();
+    }
+}
+/**
+ * Writes one serial chunk and releases the stream writer. Aborting rejects the
+ * helper promptly and asks the stream to abort; the browser may finish an
+ * already-started hardware write before releasing the lock.
+ */
+export async function writeMoldableSerialPort(port, data, options = {}) {
+    if (options.signal?.aborted) {
+        throw abortedDeviceIoError('serial', 'write');
+    }
+    if (!port.writable) {
+        throw deviceIoError('serial', 'write', new DOMException('Serial port is not writable.', 'InvalidStateError'));
+    }
+    const writer = port.writable.getWriter();
+    let settled = false;
+    let abortPromise;
+    const writePromise = writer.write(data).finally(() => {
+        settled = true;
+    });
+    const handleAbort = () => {
+        abortPromise = writer.abort(new DOMException('Serial write aborted.', 'AbortError'));
+    };
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
+    try {
+        await awaitDeviceIoWithAbort(writePromise, 'serial', 'write', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'write', error);
+    }
+    finally {
+        options.signal?.removeEventListener('abort', handleAbort);
+        if (settled) {
+            writer.releaseLock();
+        }
+        else {
+            void Promise.allSettled([writePromise, abortPromise]).then(() => {
+                writer.releaseLock();
+            });
+        }
+    }
+}