@moddable/typings 9.0.1 → 10.0.0

package/piu/SVGImage.d.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026 Moddable Tech, Inc
+ *
+ *   This file is part of the Moddable SDK Tools.
+ *
+ *   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Tools is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// modules/piu/MC/outline/piuSVGImage.js (and the same content on Pebble)
+
+declare module "piu/SVGImage" {
+  import { Content, ContentDictionary } from "piu/MC";
+
+  interface SVGImage extends Content {
+    opacity: number;
+    center(x: number, y: number): void;
+    cx: number;
+    cy: number;
+    rotate(a: number): void;
+    r: number;
+    scale(x: number, y: number): void;
+    s: number;
+    sx: number;
+    sy: number;
+    translate(x: number, y: number): void;
+    tx: number;
+    ty: number;
+  }
+  interface SVGImageDictionary extends ContentDictionary {
+    clip?: boolean;
+    /** the path of the SVG resource */
+    path?: string;
+    /** the SVG resource itself, as parsed by load */
+    resource?: object;
+  }
+  interface SVGImageConstructor {
+    new(behaviorData?: any, dictionary?: SVGImageDictionary): SVGImage;
+    (behaviorData?: any, dictionary?: SVGImageDictionary): SVGImage;
+
+    template<T>(this: T, fn: (arg: any) => SVGImageDictionary): T;
+  }
+  const SVGImage: SVGImageConstructor;
+
+  global {
+    const SVGImage: SVGImageConstructor
+  }
+
+  export { SVGImage };
+  export default SVGImage;
+}

package/piu/Timeline.d.ts

@@ -19,32 +19,28 @@
  */
 
 declare module "piu/Timeline" {
+  type Easing = ((fraction: number) => number) | null;
+
+  export class Tween {
+    constructor(target: object, properties: object, duration: number, easing?: Easing, delay?: number);
+    static from(target: object, fromProperties: object, duration: number, easing?: Easing, delay?: number): Tween;
+    static on(target: object, onProperties: object, duration: number, easing?: Easing, delay?: number): Tween;
+    static to(target: object, toProperties: object, duration: number, easing?: Easing, delay?: number): Tween;
+    delay: number;
+    duration: number;
+    easing: Easing;
+    seekTo(time: number): void;
+  }
+
   class Timeline {
     duration: number;
     fraction: number;
     time: number;
-    from(
-      target: object,
-      fromProperties: object,
-      duration: number,
-      easing?: (fraction: number) => number,
-      delay?: number
-    ): Timeline;
-    on(
-      target: object,
-      onProperties: object,
-      duration: number,
-      easing?: (fraction: number) => number,
-      delay?: number
-    ): Timeline;
+    add(tween: Tween, when?: number): Timeline;
+    from(target: object, fromProperties: object, duration: number, easing?: Easing, delay?: number, when?: number): Timeline;
+    on(target: object, onProperties: object, duration: number, easing?: Easing, delay?: number, when?: number): Timeline;
     seekTo(time: number): void;
-    to(
-      target: object,
-      fromProperties: object,
-      duration: number,
-      easing?: (fraction: number) => number,
-      delay?: number
-    ): Timeline;
+    to(target: object, toProperties: object, duration: number, easing?: Easing, delay?: number, when?: number): Timeline;
   }
   export { Timeline as default }
 }

package/pococolorcell.d.ts

@@ -0,0 +1,25 @@
+/*
+* Copyright (c) 2025 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "commodetto/Poco" {
+  interface PocoPrototype {
+    drawFrame(frame: ArrayBuffer | HostBuffer, stream: { width: number, height: number, pixelFormat: number }, x: number, y: number): void
+  }
+}

package/pocoqrcode.d.ts

@@ -0,0 +1,25 @@
+/*
+* Copyright (c) 2025 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "commodetto/Poco" {
+  interface PocoPrototype {
+    drawQRCode(qrcode:ArrayBuffer, x: number, y: number, scale: number, fore: number): void
+  }
+}

package/pocostatic.d.ts

@@ -0,0 +1,25 @@
+/*
+* Copyright (c) 2025 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "commodetto/Poco" {
+  interface PocoPrototype {
+    fillStatic(x: number, y: number, width: number, height: number, brightness?: number): void
+  }
+}

package/preference.d.ts

@@ -19,6 +19,7 @@
 */
 
 declare module "preference" {
+  /** @deprecated Use the ECMA-419 key-value store, embedded:storage/key-value (see guides/key-value) */
   var Preference: {
     set: (domain: string, key: string, value: string | boolean | number | ArrayBuffer) => void;
     get: (domain: string, key: string) => string | boolean | number | ArrayBuffer | undefined;

package/securesocket.d.ts

@@ -23,6 +23,7 @@ declare module "securesocket" {
 
     type WriteData = number | string | ByteBuffer;
 
+    /** @deprecated Use the ECMA-419 TLS socket, embedded:io/socket/tcp/tls */
     export default class SecureSocket {
         sock: typeof Socket;
 

package/sntp.d.ts

@@ -31,6 +31,7 @@ declare module "sntp" {
     SNTPRetry
   )
   type SNTPCallback = (message: SNTPCallbackMessage, value?: number) => void;
+  /** @deprecated Use the ECMA-419 NTP client, embedded:network/ntp/client */
   class SNTP {
     static readonly time: SNTPTimeRetrieved;
     static readonly retry: SNTPRetry;

package/socket.d.ts

@@ -58,6 +58,7 @@ declare module "socket" {
     MessageDataReceived |
     MessageDataSent
   );
+  /** @deprecated Use the ECMA-419 sockets, embedded:io/socket/tcp, embedded:io/socket/udp and embedded:io/socket/listener */
   abstract class SocketBase {
     close(): void;
     read<T extends typeof String | typeof ArrayBuffer>(
@@ -66,14 +67,17 @@ declare module "socket" {
     ): T extends typeof String ? string : ArrayBuffer;
     callback: (message: MessageStatus, value?: number) => void;
   }
+  /** @deprecated Use the ECMA-419 sockets, embedded:io/socket/tcp, embedded:io/socket/udp and embedded:io/socket/listener */
   class RawSocket extends SocketBase {
     write(ip: string, data: ArrayBuffer): void;
     write(): number;
   }
+  /** @deprecated Use the ECMA-419 sockets, embedded:io/socket/tcp, embedded:io/socket/udp and embedded:io/socket/listener */
   class TCPSocket extends SocketBase {
     write(data: WriteData, ...moreData: WriteData[]): void;
     write(): number;
   }
+  /** @deprecated Use the ECMA-419 sockets, embedded:io/socket/tcp, embedded:io/socket/udp and embedded:io/socket/listener */
   class UDPSocket extends SocketBase {
     write(ip: string, port: number, data: ArrayBuffer): void;
     write(): number;
@@ -82,11 +86,13 @@ declare module "socket" {
     port?: number,
     address?: string
   };
+  /** @deprecated Use the ECMA-419 sockets, embedded:io/socket/tcp, embedded:io/socket/udp and embedded:io/socket/listener */
   class Listener {
     constructor(options: ListenerOptions);
     callback: (this: Listener) => void;
   }
   type Socket = RawSocket | TCPSocket | UDPSocket;
+  /** @deprecated Use the ECMA-419 sockets, embedded:io/socket/tcp, embedded:io/socket/udp and embedded:io/socket/listener */
   var Socket: {
     new <T extends RawSocketOptions | TCPSocketOptions | UDPSocketOptions>(
       dictionary: T

package/ssl/session.d.ts

@@ -0,0 +1,60 @@
+/*
+* Copyright (c) 2026 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "ssl/session" {
+  // the socket a session reads and writes through: the session consumes readable as it reads, and updates writable as it writes
+  export interface SSLSessionSocket {
+    readable: number;
+    writable: number;
+    read(buffer: Uint8Array): unknown;
+    write(buffer: ByteBuffer): number;
+  }
+
+  export interface SSLSessionOptions {
+    protocolVersion?: number;
+    minProtocolVersion?: number;
+    maxProtocolVersion?: number;
+    certificate?: ByteBuffer | ByteBuffer[];		// trusted CA certificates
+    clientCertificates?: ByteBuffer[];
+    clientKey?: ByteBuffer;
+    verify?: boolean;
+    trace?: boolean;
+    cache?: boolean;
+    clientAuth?: { cipherSuites: unknown; subjectDN: unknown };
+    serverName?: string;							// session_original: alias of tls_server_name
+    applicationLayerProtocolNegotiation?: string | ByteBuffer | (string | ByteBuffer)[];	// session_original: alias
+    tls_server_name?: string;
+    tls_max_fragment_length?: number;
+    tls_application_layer_protocol_negotiation?: string | ByteBuffer | (string | ByteBuffer)[];
+    tls_elliptic_curves?: number[];
+    tls_signature_algorithms?: { hash: number; sig: number }[];
+    [extension: `tls_${string}`]: unknown;			// the handshake sends every tls_ option it recognizes as an extension
+  }
+
+  class SSLSession {
+    constructor(options?: SSLSessionOptions);
+    initiateHandshake(socket?: SSLSessionSocket): void;
+    handshake(socket: SSLSessionSocket, count?: number): boolean;	// true when complete
+    read(socket: SSLSessionSocket, count?: number): Uint8Array | null | undefined;	// undefined: nothing yet; null: closed
+    write(socket: SSLSessionSocket, data: ByteBuffer, options?: { more?: boolean; byteLength?: number }): number;
+    close(socket: SSLSessionSocket): void;
+  }
+  export default SSLSession;
+}

package/time.d.ts

@@ -25,7 +25,7 @@ declare module "time" {
     ) => void,
     timezone: number;
     dst: number;
-    ticks: number;
+    readonly ticks: number;
     delta(start: number, end?: number): number;
     readonly microseconds?: number;
   }

package/tsconfig.es2024.json

@@ -5,7 +5,6 @@
 		"module": "preserve",
 		"moduleResolution": "bundler",
 		"target": "ES2024",
-		"baseUrl": ".",
 		"paths": {
 			"embedded:io/*": ["./embedded_io/*"],
 			"embedded:io/socket/*": ["./embedded_io/socket/*"],

package/tsconfig.es2025.json

@@ -1,5 +1,5 @@
 {
-	"_comment": "ES2025 overrides on top of the ES2024 base. Used when TypeScript >= 6 (see typesVersions in package.json).",
+	"_comment": "ES2025 overrides on top of the ES2024 base. This is tsconfig.base.json (see typesVersions in package.json). TypeScript 6 or later is required.",
 	"extends": "./tsconfig.es2024.json",
 	"compilerOptions": {
 		"lib": ["es2025", "esnext.disposable"],

package/web/bluetooth.d.ts

@@ -0,0 +1,112 @@
+/*
+* Copyright (c) 2026 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+// Web Bluetooth (https://webbluetoothcg.github.io/web-bluetooth/): the subset implemented by modules/io/ble/web-bluetooth
+declare module "web-bluetooth" {
+  // a 16- or 32-bit alias, a full 128-bit UUID string, or a name from the GATT assigned numbers (or config.webbluetooth)
+  export type BluetoothServiceUUID = number | string;
+  export type BluetoothCharacteristicUUID = number | string;
+  export type BluetoothDescriptorUUID = number | string;
+
+  export class BluetoothUUID {
+    static canonicalUUID(alias: number): string;
+    static getService(name: BluetoothServiceUUID): string;
+    static getCharacteristic(name: BluetoothCharacteristicUUID): string;
+    static getDescriptor(name: BluetoothDescriptorUUID): string;
+  }
+
+  export interface BluetoothLEScanFilter {
+    name?: string;
+    services?: BluetoothServiceUUID[];
+  }
+
+  export interface RequestDeviceOptions {
+    filters?: BluetoothLEScanFilter[];
+  }
+
+  export const bluetooth: {
+    requestDevice(options?: RequestDeviceOptions): Promise<BluetoothDevice>;
+  };
+
+  export class BluetoothDevice {
+    constructor(address: string, name?: string);		// Moddable SDK extension: a device discovered by other means, such as GAPClient
+    readonly id: string;
+    readonly name: string;
+    readonly gatt: BluetoothRemoteGATTServer;
+  }
+
+  export interface BluetoothRemoteGATTServer {
+    readonly device: BluetoothDevice;
+    readonly connected: boolean;
+    connect(): Promise<BluetoothRemoteGATTServer>;
+    disconnect(): void;
+    getPrimaryService(service: BluetoothServiceUUID): Promise<BluetoothRemoteGATTService>;
+    getPrimaryServices(services?: BluetoothServiceUUID[]): Promise<BluetoothRemoteGATTService[]>;
+  }
+
+  export interface BluetoothRemoteGATTService {
+    readonly device: BluetoothDevice;
+    readonly uuid: string;
+    readonly isPrimary: boolean;
+    getCharacteristic(characteristic: BluetoothCharacteristicUUID): Promise<BluetoothRemoteGATTCharacteristic>;
+    getCharacteristics(characteristics?: BluetoothCharacteristicUUID[]): Promise<BluetoothRemoteGATTCharacteristic[]>;
+  }
+
+  export interface BluetoothCharacteristicProperties {
+    readonly authenticatedSignedWrites: boolean;
+    readonly broadcast: boolean;
+    readonly indicate: boolean;
+    readonly notify: boolean;
+    readonly read: boolean;
+    readonly reliableWrite: boolean;
+    readonly write: boolean;
+    readonly writeWithoutResponse: boolean;
+  }
+
+  // the characteristic's value is always present in its characteristicvaluechanged event
+  export interface BluetoothCharacteristicValueChangedEvent {
+    readonly target: BluetoothRemoteGATTCharacteristic & { readonly value: DataView };
+  }
+
+  export interface BluetoothRemoteGATTCharacteristic {
+    readonly service: BluetoothRemoteGATTService;
+    readonly uuid: string;
+    readonly properties: BluetoothCharacteristicProperties;
+    readonly value: DataView | undefined;		// the most recently read or notified value
+    getDescriptor(descriptor: BluetoothDescriptorUUID): Promise<BluetoothRemoteGATTDescriptor>;
+    getDescriptors(descriptors?: BluetoothDescriptorUUID[]): Promise<BluetoothRemoteGATTDescriptor[]>;
+    readValue(): Promise<DataView>;
+    writeValue(value: ByteBuffer): Promise<void>;		// without response
+    writeValueWithResponse(value: ByteBuffer): Promise<void>;
+    writeValueWithoutResponse(value: ByteBuffer): Promise<void>;
+    startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+    stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+    addEventListener(type: "characteristicvaluechanged", listener: (event: BluetoothCharacteristicValueChangedEvent) => void): void;
+    removeEventListener(type: "characteristicvaluechanged", listener: (event: BluetoothCharacteristicValueChangedEvent) => void): void;
+  }
+
+  export interface BluetoothRemoteGATTDescriptor {
+    readonly characteristic: BluetoothRemoteGATTCharacteristic;
+    readonly uuid: string;
+    readonly value: DataView | undefined;
+    readValue(): Promise<DataView>;
+    writeValue(value: ByteBuffer): Promise<void>;
+  }
+}

package/web/decompressionstream.d.ts

@@ -21,7 +21,7 @@
 declare module "web/decompressionstream" {
   import type { ReadableStream, WritableStream } from "web/streams";
 
-  type DecompressionFormat = "deflate" | "deflate-raw" | "gzip";
+  export type DecompressionFormat = "deflate" | "deflate-raw" | "gzip";
 
   class DecompressionStream {
     constructor(format: DecompressionFormat);

package/web/eventsource.d.ts

@@ -23,7 +23,7 @@ declare module "web/eventsource" {
 
   interface EventSourceInit {
     method?: string;
-    headers?: Headers | Record<string, string>;
+    headers?: Headers | Map<string, string>;
     body?: string | ArrayBuffer;
   }
 
@@ -58,13 +58,13 @@ declare module "web/eventsource" {
     readonly readyState: number;
     readonly url: string;
 
-    onerror?(event: EventSourceErrorEvent): void;
-    onopen?(event: EventSourceEvent): void;
-    onmessage?(event: EventSourceMessageEvent): void;
+    onerror: ((this: EventSource, event: EventSourceErrorEvent) => void) | null;
+    onopen: ((this: EventSource, event: EventSourceEvent) => void) | null;
+    onmessage: ((this: EventSource, event: EventSourceMessageEvent) => void) | null;
 
-    addEventListener(type: "open", listener: (event: EventSourceEvent) => void): void;
-    addEventListener(type: "error", listener: (event: EventSourceErrorEvent) => void): void;
-    addEventListener(type: "message", listener: (event: EventSourceMessageEvent) => void): void;
+    addEventListener(type: "open", listener: (this: EventSource, event: EventSourceEvent) => void): void;
+    addEventListener(type: "error", listener: (this: EventSource, event: EventSourceErrorEvent) => void): void;
+    addEventListener(type: "message", listener: (this: EventSource, event: EventSourceMessageEvent) => void): void;
     addEventListener(type: string, listener: (event: EventSourceMessageEvent) => void): void;
 
     removeEventListener(type: string, listener: EventSourceEventListener): void;
@@ -74,3 +74,8 @@ declare module "web/eventsource" {
 
   export default EventSource;
 }
+
+// the specifier of the module in the Moddable SDK runtime
+declare module "eventsource" {
+  export { default } from "web/eventsource";
+}

package/web/fetch-streams.d.ts

@@ -0,0 +1,57 @@
+/*
+* Copyright (c) 2026  Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+// the manifest that supplies this module includes the manifests of these configurations
+/// <reference path="../config/httpsclient.d.ts" />
+
+// fetch implemented with web streams (examples/web/streams/fetch)
+declare module "web/fetch/streams" {
+  import {URL, URLSearchParams} from "url"
+  import Headers from "headers"
+  import type {ReadableStream} from "web/streams"
+  import type {AbortSignal} from "web/abortsignal"
+
+  class Response {
+    // the stream is returned once: body is undefined after it has been read
+    get body(): ReadableStream<Uint8Array> | undefined;
+    get bodyUsed(): boolean;
+    get headers(): Headers;
+    get ok(): boolean;
+    get redirected(): boolean;
+    get status(): number;
+    get statusText(): string;
+    get url(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+  }
+
+  interface RequestInit {
+    method?: string;
+    headers?: Headers | Record<string, string>;
+    body?: string | ByteBuffer | URLSearchParams | ReadableStream;
+    signal?: AbortSignal;
+  }
+
+  function fetch(resource: string | URL, options?: RequestInit): Promise<Response>;
+
+  export { fetch, Headers };
+  export default fetch;
+}

package/web/fetch.d.ts

@@ -43,6 +43,6 @@ declare module "fetch" {
 
   function fetch(resource: string | URL, options?: RequestInit): Promise<Response>;
 
-  export { fetch };
+  export { fetch, Headers };
   export default fetch;
 }

package/web/serial.d.ts

@@ -0,0 +1,58 @@
+/*
+* Copyright (c) 2026 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+// Web Serial (https://wicg.github.io/serial/): the subset implemented by modules/web/serial
+declare module "web/serial" {
+  import type { ReadableStream, WritableStream } from "web/streams";
+
+  export interface SerialOptions {
+    baudRate: number;
+    bufferSize?: number;		// 1 to 16384, default 255
+    dataBits?: 8;				// the only value supported
+    stopBits?: 1;				// the only value supported
+    parity?: "none";			// the only value supported
+  }
+
+  export interface SerialOutputSignals {
+    dataTerminalReady?: boolean;
+    requestToSend?: boolean;
+    break?: false;				// break is not supported
+  }
+
+  export interface SerialPortInfo {
+    usbVendorId?: number;
+    usbProductId?: number;
+  }
+
+  export interface SerialPort {
+    readonly connected: boolean;
+    readonly readable: ReadableStream<Uint8Array> | null;		// a byte stream: getReader({ mode: "byob" }) is supported
+    readonly writable: WritableStream<ByteBuffer> | null;
+    getInfo(): SerialPortInfo;
+    open(options: SerialOptions): Promise<void>;
+    setSignals(signals: SerialOutputSignals): Promise<void>;
+    close(): Promise<void>;
+    forget(): Promise<void>;
+  }
+
+  export const serial: {
+    requestPort(): Promise<SerialPort>;
+  };
+}