@moddable/typings 8.3.1 → 9.0.1

package/embedded/storage/key-value.d.ts

@@ -33,8 +33,8 @@ declare module "embedded:storage/key-value" {
 
 		delete(key: string): void;
 
-		read(key: string): ArrayBuffer | string | number | bigint;
-		read(key: string, buffer: ByteBuffer): number;
+		read(key: string): ArrayBuffer | string | number | bigint | undefined;
+		read(key: string, buffer: ByteBuffer): number | undefined;
 		write(key: string, value: ByteBuffer | string | number | bigint): void;
 
 		[Symbol.iterator](): IterableIterator<string>;

package/embedded_io/socket/tcp/tls.d.ts

@@ -1,17 +1,54 @@
 declare module "embedded:io/socket/tcp/tls" {
-  import { Options as TCPOptions } from "embedded:io/socket/tcp"
-  export type Options = TCPOptions & {
+  import TCP, { Options as TCPOptions } from "embedded:io/socket/tcp"
+
+  export type TLSVersion = "TLSv1.1" | "TLSv1.2" | "TLSv1.3"
+
+  export type TLSOptions = {
+    /** Server Name Indication (SNI) and the name certificates are validated against. */
     host: string
-    secure: Record<string, any> // should be called "tls" according to std?
+    minimumVersion?: TLSVersion
+    maximumVersion?: TLSVersion
+    /** Application-Layer Protocol Negotiation (ALPN). */
+    applicationLayerProtocol?: string | ByteBuffer | Array<string | ByteBuffer>
+    maximumFragmentLength?: number
+    ca?: ByteBuffer | ByteBuffer[]
+    clientKey?: ByteBuffer | ByteBuffer[]
+    clientCertificate?: ByteBuffer | ByteBuffer[]
+
+    // Moddable SDK extensions
+    /** Trace TLS protocol activity. Defaults to `false`. */
+    trace?: boolean
+    /** Verify the server's certificate chain. Defaults to `true`. Never disable in production. */
+    verify?: boolean
+  }
+
+  /** Extends the TCP socket's options object. Listed explicitly so the callbacks
+      can be typed with `this` as the TLS socket rather than the TCP socket. */
+  export type Options = {
+    address: string
+    port: number
+    noDelay?: boolean
+    format?: "number" | "buffer"
+    target?: any
+    onReadable?: (this: TLSSocket, bytes: number) => void
+    onWritable?: (this: TLSSocket, bytes: number) => void
+    onError?: (this: TLSSocket) => void
+
+    tls: TLSOptions
+    /** The TCP socket this TLS socket runs over. A Moddable SDK extension. */
+    TCP: { io: new (options: TCPOptions) => TCP } & Partial<TCPOptions>
   }
-  export default class TLSSocket {
+
+  class TLSSocket {
     constructor(options: Options)
     close(): void
-    read(count: number|ArrayBufferLike) : undefined|ArrayBufferLike
-    write(buffer: ArrayBufferLike) : number
-    set format(format: string)
-    get format() : string
+    read(): number | ArrayBuffer
+    read(byteLength: number): ArrayBuffer
+    read(buffer: ByteBuffer): number
+    write(buffer: ByteBuffer, options?: { more?: boolean, byteLength?: number }): number
+    get format(): "number" | "buffer"
+    set format(value: "number" | "buffer")
   }
   interface TLSSocket extends Disposable {}
+  export default TLSSocket;
 }
-

package/embedded_io/socket/tcp.d.ts

@@ -19,16 +19,13 @@
 */
 
 declare module "embedded:io/socket/tcp" {
-  export type Options = ((({
+  export type Options = (({
     address: string;
-  } | {
-    host: string;
-  }) & {
     port: number;
   }) | {
     from: TCP;
   }) & {
-    nodelay?: boolean;
+    noDelay?: boolean;
     onReadable?: (this: TCP, bytes: number) => void;
     onWritable?: (this: TCP, bytes: number) => void;
     onError?: (this: TCP) => void;
@@ -40,9 +37,10 @@ declare module "embedded:io/socket/tcp" {
     constructor(options: Options)
     readonly remoteAddress: string | undefined;
     readonly remotePort: number | undefined;
-    read(byteLength?: number): number | ArrayBuffer;
-    read(buffer: ByteBuffer): void;
-    write(value: number | ByteBuffer): void;
+    read(): number | ArrayBuffer;
+    read(byteLength: number): ArrayBuffer;
+    read(buffer: ByteBuffer): number;
+    write(value: number | ByteBuffer): number;
     close(): void;
     get format(): "number" | "buffer"
     set format(value: "number" | "buffer")

package/embedded_network/interface/wifi/accesspoint.d.ts

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser 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 Runtime 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 Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:network/interface/wifi/accesspoint" {
+	export type WiFiAccessPointChangedProperty = "connection";
+
+	export type WiFiAccessPointAuthentication = "none" | "wpa_psk" | "wpa2_psk" | "wpa_wpa2_psk" | "wpa3_psk" | "wpa2_wpa3_psk";
+
+	export interface WiFiAccessPointStation extends Disposable {
+		close(): void;
+
+		readonly MAC: string;
+		readonly address: string | undefined;
+	}
+
+	export interface WiFiAccessPointConstructorOptions {
+		SSID: string;
+		password?: string;
+		authentication?: WiFiAccessPointAuthentication;
+		channel?: number;
+		hidden?: boolean;
+		max?: number;
+		interval?: number;
+		onChanged?(this: WiFiAccessPoint, property: WiFiAccessPointChangedProperty): void;
+		onConnect?(this: WiFiAccessPoint, station: WiFiAccessPointStation): void;
+		onDisconnect?(this: WiFiAccessPoint, station: WiFiAccessPointStation): void;
+	}
+
+	export interface WiFiAccessPointConfigureOptions {
+		portal?: string;
+	}
+
+	class WiFiAccessPoint {
+		constructor(options: WiFiAccessPointConstructorOptions);
+
+		close(): void;
+		configure(options: WiFiAccessPointConfigureOptions): void;
+
+		readonly connection: number;
+		readonly address: string | undefined;
+		readonly MAC: string | undefined;
+		readonly SSID: string | undefined;
+		readonly channel: number | undefined;
+	}
+	interface WiFiAccessPoint extends Disposable {}
+
+	export default WiFiAccessPoint;
+}

package/embedded_network/interface/wifi.d.ts

@@ -43,6 +43,7 @@ declare module "embedded:network/interface/wifi" {
 	export interface WiFiConnectOptions {
 		SSID: string;
 		password?: string;
+		secure?: boolean;
 	}
 
 	export interface WiFiStaticAddress {

package/mcpack.d.ts

@@ -18,32 +18,29 @@
  *
  */
 
+/// <reference path="./web/abortsignal.d.ts" />
+/// <reference path="./web/console.d.ts" />
+/// <reference path="./web/decompressionstream.d.ts" />
+/// <reference path="./web/domexception.d.ts" />
 /// <reference path="./web/eventsource.d.ts" />
 /// <reference path="./web/fetch.d.ts" />
 /// <reference path="./web/headers.d.ts" />
+/// <reference path="./web/streams.d.ts" />
 /// <reference path="./web/structuredClone.d.ts" />
+/// <reference path="./web/textdecoderstream.d.ts" />
+/// <reference path="./web/textencoderstream.d.ts" />
+/// <reference path="./web/timers.d.ts" />
 /// <reference path="./web/url.d.ts" />
-/// <reference path="./web/worker.d.ts" />
 /// <reference path="./web/websocket.d.ts" />
+/// <reference path="./web/websocketstream.d.ts" />
 /// <reference path="./web/webstorage.d.ts" />
+/// <reference path="./web/worker.d.ts" />
 /// <reference path="./text/decoder.d.ts" />
 /// <reference path="./text/encoder.d.ts" />
 
-import type Timer from "timer";
-
-interface Console {
-	log(...log: (string | number | boolean)[]):void;
-}
+export {};
 
 declare global {
-	const console: Console;
-	const clearImmediate: (timer: Timer) => void;
-	const clearInterval: (timer: Timer) => void;
-	const clearTimeout: (timer: Timer) => void;
-	const setImmediate: (handler: Function) => Timer;
-	const setInterval: (handler: Function, timeout?: number) => Timer;
-	const setTimeout: (handler: Function, timeout?: number) => Timer;
-
 	const EventSource: typeof import("web/eventsource").default;
 	type EventSource = import("web/eventsource").default;
 
@@ -76,5 +73,65 @@ declare global {
 
 	const SharedWorker: typeof import("worker").SharedWorker;
 	type SharedWorker = import("worker").SharedWorker;
+
+	const AbortController: typeof import("web/abortsignal").AbortController;
+	type AbortController = import("web/abortsignal").AbortController;
+
+	const AbortSignal: typeof import("web/abortsignal").AbortSignal;
+	type AbortSignal = import("web/abortsignal").AbortSignal;
+
+	const DOMException: typeof import("web/domexception").DOMException;
+	type DOMException = import("web/domexception").DOMException;
+
+	const ReadableStream: typeof import("web/streams").ReadableStream;
+	type ReadableStream<R = any> = import("web/streams").ReadableStream<R>;
+
+	const ReadableStreamDefaultReader: typeof import("web/streams").ReadableStreamDefaultReader;
+	type ReadableStreamDefaultReader<R = any> = import("web/streams").ReadableStreamDefaultReader<R>;
+
+	const ReadableStreamBYOBReader: typeof import("web/streams").ReadableStreamBYOBReader;
+	type ReadableStreamBYOBReader = import("web/streams").ReadableStreamBYOBReader;
+
+	const ReadableStreamDefaultController: typeof import("web/streams").ReadableStreamDefaultController;
+	type ReadableStreamDefaultController<R = any> = import("web/streams").ReadableStreamDefaultController<R>;
+
+	const ReadableByteStreamController: typeof import("web/streams").ReadableByteStreamController;
+	type ReadableByteStreamController = import("web/streams").ReadableByteStreamController;
+
+	const ReadableStreamBYOBRequest: typeof import("web/streams").ReadableStreamBYOBRequest;
+	type ReadableStreamBYOBRequest = import("web/streams").ReadableStreamBYOBRequest;
+
+	const WritableStream: typeof import("web/streams").WritableStream;
+	type WritableStream<W = any> = import("web/streams").WritableStream<W>;
+
+	const WritableStreamDefaultWriter: typeof import("web/streams").WritableStreamDefaultWriter;
+	type WritableStreamDefaultWriter<W = any> = import("web/streams").WritableStreamDefaultWriter<W>;
+
+	const WritableStreamDefaultController: typeof import("web/streams").WritableStreamDefaultController;
+	type WritableStreamDefaultController = import("web/streams").WritableStreamDefaultController;
+
+	const TransformStream: typeof import("web/streams").TransformStream;
+	type TransformStream<I = any, O = any> = import("web/streams").TransformStream<I, O>;
+
+	const TransformStreamDefaultController: typeof import("web/streams").TransformStreamDefaultController;
+	type TransformStreamDefaultController<O = any> = import("web/streams").TransformStreamDefaultController<O>;
+
+	const ByteLengthQueuingStrategy: typeof import("web/streams").ByteLengthQueuingStrategy;
+	type ByteLengthQueuingStrategy = import("web/streams").ByteLengthQueuingStrategy;
+
+	const CountQueuingStrategy: typeof import("web/streams").CountQueuingStrategy;
+	type CountQueuingStrategy = import("web/streams").CountQueuingStrategy;
+
+	const DecompressionStream: typeof import("web/decompressionstream").default;
+	type DecompressionStream = import("web/decompressionstream").default;
+
+	const TextDecoderStream: typeof import("web/textdecoderstream").default;
+	type TextDecoderStream = import("web/textdecoderstream").default;
+
+	const TextEncoderStream: typeof import("web/textencoderstream").default;
+	type TextEncoderStream = import("web/textencoderstream").default;
+
+	const WebSocketStream: typeof import("web/websocketstream").default;
+	type WebSocketStream = import("web/websocketstream").default;
 }
 

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "@moddable/typings",
-	"version": "8.3.1",
+	"version": "9.0.1",
 	"main": "",
-	"types": [
-		"xs.d.ts",
-		"mcpack.d.ts"
-	],
-	"author": "",
+	"types": "xs",
+	"typesVersions": {
+		">=6.0.0-0": { "tsconfig.base.json": ["./tsconfig.es2025.json"] },
+		">=5.4.0-0": { "tsconfig.base.json": ["./tsconfig.es2024.json"] }
+	},
+	"author": "Moddable",
 	"license": "ISC",
 	"description": ""
 }

package/pebble/location.d.ts

@@ -30,8 +30,8 @@ interface LocationSample {
 }
 
 interface LocationOptions {
-  onSample?: () => void;
-  onError?: (error: Error) => void;
+  onSample?: (this: Location) => void;
+  onError?: (this: Location, error: Error) => void;
 }
 
 interface LocationConfiguration {

package/web/abortsignal.d.ts

@@ -0,0 +1,37 @@
+/*
+* 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 "web/abortsignal" {
+  class AbortSignal {
+    readonly aborted: boolean;
+    readonly reason: any;
+    throwIfAborted(): void;
+    static abort(reason?: any): AbortSignal;
+    static timeout(milliseconds: number): AbortSignal;
+    static any(signals: AbortSignal[]): AbortSignal;
+  }
+
+  class AbortController {
+    readonly signal: AbortSignal;
+    abort(reason?: any): void;
+  }
+
+  export { AbortSignal, AbortController };
+}

package/web/console.d.ts

@@ -0,0 +1,50 @@
+/*
+ * 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/>.
+ *
+ */
+
+export {};
+
+declare module "web/console" {
+}
+
+declare global {
+	interface Console {
+		assert(condition?: boolean, ...data: any[]): void;
+		clear(): void;
+		count(label?: string): void;
+		countReset(label?: string): void;
+		debug(...data: any[]): void;
+		dir(item?: any): void;
+		dirxml(...data: any[]): void;
+		error(...data: any[]): void;
+		group(...data: any[]): void;
+		groupCollapsed(...data: any[]): void;
+		groupEnd(): void;
+		info(...data: any[]): void;
+		log(...data: any[]): void;
+		table(tabularData?: any): void;
+		time(label?: string): void;
+		timeEnd(label?: string): void;
+		timeLog(label?: string, ...data: any[]): void;
+		trace(...data: any[]): void;
+		warn(...data: any[]): void;
+	}
+
+	const console: Console;
+}

package/web/decompressionstream.d.ts

@@ -0,0 +1,34 @@
+/*
+* 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 "web/decompressionstream" {
+  import type { ReadableStream, WritableStream } from "web/streams";
+
+  type DecompressionFormat = "deflate" | "deflate-raw" | "gzip";
+
+  class DecompressionStream {
+    constructor(format: DecompressionFormat);
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+    readonly format: DecompressionFormat;
+  }
+
+  export default DecompressionStream;
+}

package/web/domexception.d.ts

@@ -0,0 +1,29 @@
+/*
+* 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 "web/domexception" {
+  class DOMException extends Error {
+    constructor(message?: string, name?: string);
+    readonly name: string;
+    readonly message: string;
+  }
+
+  export { DOMException };
+}

package/web/eventsource.d.ts

@@ -34,7 +34,7 @@ declare module "web/eventsource" {
   interface EventSourceMessageEvent extends EventSourceEvent {
     data: string;
     origin: string;
-    lastEventID: string;
+    lastEventId: string;
   }
 
   interface EventSourceErrorEvent extends EventSourceEvent {

package/web/streams.d.ts

@@ -0,0 +1,216 @@
+/*
+* 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 "web/streams" {
+  import type { AbortSignal } from "web/abortsignal";
+
+  interface QueuingStrategyInit {
+    highWaterMark: number;
+  }
+
+  interface QueuingStrategy<T = any> {
+    highWaterMark?: number;
+    size?(chunk: T): number;
+  }
+
+  interface UnderlyingSource<R = any> {
+    start?(controller: ReadableStreamDefaultController<R>): void | Promise<void>;
+    pull?(controller: ReadableStreamDefaultController<R>): void | Promise<void>;
+    cancel?(reason?: any): void | Promise<void>;
+    type?: undefined;
+  }
+
+  interface UnderlyingByteSource {
+    start?(controller: ReadableByteStreamController): void | Promise<void>;
+    pull?(controller: ReadableByteStreamController): void | Promise<void>;
+    cancel?(reason?: any): void | Promise<void>;
+    type: "bytes";
+    autoAllocateChunkSize?: number;
+  }
+
+  interface UnderlyingSink<W = any> {
+    start?(controller: WritableStreamDefaultController): void | Promise<void>;
+    write?(chunk: W, controller: WritableStreamDefaultController): void | Promise<void>;
+    close?(): void | Promise<void>;
+    abort?(reason?: any): void | Promise<void>;
+  }
+
+  interface Transformer<I = any, O = any> {
+    readableType?: undefined;
+    writableType?: undefined;
+    start?(controller: TransformStreamDefaultController<O>): void | Promise<void>;
+    transform?(chunk: I, controller: TransformStreamDefaultController<O>): void | Promise<void>;
+    flush?(controller: TransformStreamDefaultController<O>): void | Promise<void>;
+    cancel?(reason?: any): void | Promise<void>;
+  }
+
+  interface StreamPipeOptions {
+    preventClose?: boolean;
+    preventAbort?: boolean;
+    preventCancel?: boolean;
+    signal?: AbortSignal;
+  }
+
+  interface ReadableWritablePair<R = any, W = any> {
+    readable: ReadableStream<R>;
+    writable: WritableStream<W>;
+  }
+
+  type ReadableStreamReadValueResult<T> = { done: false; value: T };
+  type ReadableStreamReadDoneResult<T> = { done: true; value: T | undefined };
+  type ReadableStreamReadResult<T> =
+    | ReadableStreamReadValueResult<T>
+    | ReadableStreamReadDoneResult<T>;
+
+  class ReadableStream<R = any> {
+    constructor(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>);
+    constructor(underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>);
+    readonly locked: boolean;
+    cancel(reason?: any): Promise<void>;
+    getReader(): ReadableStreamDefaultReader<R>;
+    getReader(options: { mode?: undefined }): ReadableStreamDefaultReader<R>;
+    getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
+    pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
+    pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
+    tee(): [ReadableStream<R>, ReadableStream<R>];
+    values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+    static from<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;
+  }
+
+  class ReadableStreamDefaultReader<R = any> {
+    constructor(stream: ReadableStream<R>);
+    readonly closed: Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
+    read(): Promise<ReadableStreamReadResult<R>>;
+    releaseLock(): void;
+  }
+
+  class ReadableStreamBYOBReader {
+    constructor(stream: ReadableStream<Uint8Array>);
+    readonly closed: Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
+    read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
+    releaseLock(): void;
+  }
+
+  class ReadableStreamDefaultController<R = any> {
+    readonly desiredSize: number | null;
+    close(): void;
+    enqueue(chunk?: R): void;
+    error(e?: any): void;
+  }
+
+  class ReadableByteStreamController {
+    readonly byobRequest: ReadableStreamBYOBRequest | null;
+    readonly desiredSize: number | null;
+    close(): void;
+    enqueue(chunk: ArrayBufferView): void;
+    error(e?: any): void;
+  }
+
+  class ReadableStreamBYOBRequest {
+    readonly view: ArrayBufferView | null;
+    respond(bytesWritten: number): void;
+    respondWithNewView(view: ArrayBufferView): void;
+  }
+
+  class WritableStream<W = any> {
+    constructor(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>);
+    readonly locked: boolean;
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    getWriter(): WritableStreamDefaultWriter<W>;
+  }
+
+  class WritableStreamDefaultWriter<W = any> {
+    constructor(stream: WritableStream<W>);
+    readonly closed: Promise<undefined>;
+    readonly desiredSize: number | null;
+    readonly ready: Promise<undefined>;
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    releaseLock(): void;
+    write(chunk?: W): Promise<void>;
+  }
+
+  class WritableStreamDefaultController {
+    readonly signal: AbortSignal;
+    error(e?: any): void;
+  }
+
+  class TransformStream<I = any, O = any> {
+    constructor(
+      transformer?: Transformer<I, O>,
+      writableStrategy?: QueuingStrategy<I>,
+      readableStrategy?: QueuingStrategy<O>
+    );
+    readonly readable: ReadableStream<O>;
+    readonly writable: WritableStream<I>;
+  }
+
+  class TransformStreamDefaultController<O = any> {
+    readonly desiredSize: number | null;
+    enqueue(chunk?: O): void;
+    error(reason?: any): void;
+    terminate(): void;
+  }
+
+  class ByteLengthQueuingStrategy {
+    constructor(init: QueuingStrategyInit);
+    readonly highWaterMark: number;
+    size(chunk: ArrayBufferView): number;
+  }
+
+  class CountQueuingStrategy {
+    constructor(init: QueuingStrategyInit);
+    readonly highWaterMark: number;
+    size(): number;
+  }
+
+  export {
+    ReadableStream,
+    ReadableStreamDefaultReader,
+    ReadableStreamBYOBReader,
+    ReadableStreamDefaultController,
+    ReadableByteStreamController,
+    ReadableStreamBYOBRequest,
+    WritableStream,
+    WritableStreamDefaultWriter,
+    WritableStreamDefaultController,
+    TransformStream,
+    TransformStreamDefaultController,
+    ByteLengthQueuingStrategy,
+    CountQueuingStrategy,
+  };
+  export type {
+    QueuingStrategyInit,
+    QueuingStrategy,
+    UnderlyingSource,
+    UnderlyingByteSource,
+    UnderlyingSink,
+    Transformer,
+    StreamPipeOptions,
+    ReadableWritablePair,
+    ReadableStreamReadResult,
+    ReadableStreamReadValueResult,
+    ReadableStreamReadDoneResult,
+  };
+}

package/web/textdecoderstream.d.ts

@@ -0,0 +1,37 @@
+/*
+* 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 "web/textdecoderstream" {
+  import type { TransformStream } from "web/streams";
+
+  interface TextDecoderStreamInit {
+    fatal?: boolean;
+    ignoreBOM?: boolean;
+  }
+
+  class TextDecoderStream extends TransformStream<ArrayBuffer | ArrayBufferView, string> {
+    constructor(label?: string, options?: TextDecoderStreamInit);
+    readonly encoding: string;
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+  }
+
+  export default TextDecoderStream;
+}

package/web/textencoderstream.d.ts

@@ -0,0 +1,29 @@
+/*
+* 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 "web/textencoderstream" {
+  import type { TransformStream } from "web/streams";
+
+  class TextEncoderStream extends TransformStream<string, Uint8Array> {
+    constructor();
+  }
+
+  export default TextEncoderStream;
+}

package/web/timers.d.ts

@@ -0,0 +1,33 @@
+/*
+ * 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/>.
+ *
+ */
+
+import type Timer from "timer";
+
+declare module "web/timers" {
+}
+
+declare global {
+	const clearImmediate: (timer: Timer | undefined | null) => void;
+	const clearInterval: (timer: Timer | undefined | null) => void;
+	const clearTimeout: (timer: Timer | undefined | null) => void;
+	const setImmediate: (handler: Function) => Timer;
+	const setInterval: (handler: Function, timeout?: number) => Timer;
+	const setTimeout: (handler: Function, timeout?: number) => Timer;
+}

package/web/websocket.d.ts

@@ -21,16 +21,19 @@
 declare module "web/websocket" {
   import Headers from "headers"
 
-  interface WebSocketOptions {
+  interface WebSocketClientOptions {
     url: string;
     protocol?: string;
     keepalive?: number;
     headers?: Headers | Record<string, string>;
-    attach?: any;
     ws?: any;
     wss?: any;
   }
 
+  interface WebSocketAttachOptions {
+    attach: any;
+  }
+
   interface WebSocketCloseEvent {
     code: number;
     reason: string;
@@ -53,7 +56,8 @@ declare module "web/websocket" {
 
   class WebSocket {
     constructor(url: string, protocol?: string);
-    constructor(options: WebSocketOptions);
+    constructor(options: WebSocketClientOptions);
+    constructor(options: WebSocketAttachOptions);
 
     static readonly CONNECTING: 0;
     static readonly OPEN: 1;

package/web/websocketstream.d.ts

@@ -0,0 +1,53 @@
+/*
+* 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 "web/websocketstream" {
+  import type { AbortSignal } from "web/abortsignal";
+  import type { ReadableStream, WritableStream } from "web/streams";
+
+  interface WebSocketStreamOptions {
+    protocols?: string | string[];
+    signal?: AbortSignal;
+    ws?: any;
+    wss?: any;
+  }
+
+  interface WebSocketCloseInfo {
+    closeCode?: number;
+    reason?: string;
+  }
+
+  interface WebSocketConnection {
+    readable: ReadableStream<string | Uint8Array>;
+    writable: WritableStream<string | ArrayBuffer | ArrayBufferView>;
+    extensions: string;
+    protocol: string;
+  }
+
+  class WebSocketStream {
+    constructor(url: string, options?: WebSocketStreamOptions);
+    readonly url: string;
+    readonly opened: Promise<WebSocketConnection>;
+    readonly closed: Promise<Required<WebSocketCloseInfo>>;
+    close(closeInfo?: WebSocketCloseInfo): void;
+  }
+
+  export default WebSocketStream;
+}