@moddable/typings 8.3.0 → 9.0.0

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;
+}

package/xs.d.ts

@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2020-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/>.
- *
- */
-
- interface Trace {
-	(...log: (string | number | boolean)[]):void;
-	left(log: string | ArrayBufferLike, conversation?: string):void;
-	center(log: string | ArrayBufferLike, conversation?: string):void;
-	right(log: string | ArrayBufferLike, conversation?: string):void;
-}
-declare const trace:Trace;
-
-declare class HostBuffer {
-	readonly byteLength: number
-	private brand: boolean;
-}
-
-interface ArrayBufferTypes {
-	HostBuffer: HostBuffer;
-}
-
-interface ByteBufferTypes extends ArrayBufferTypes  {
-	Uint8Array: Uint8Array,
-	Uint8ClampedArray: Uint8ClampedArray,
-	Int8Array: Int8Array,
-	DataView: DataView
-}
-
-type ByteBuffer = ByteBufferTypes[keyof ByteBufferTypes];
-
-interface ObjectConstructor {
-	freeze<T>(obj: T, freeze?: boolean | number): Readonly<T>;
-}
-
-interface JSON {
-	parse(text: string, reviver?: string[]): any;
-}
-
-interface StringConstructor {
-	fromArrayBuffer(buffer: ArrayBufferLike): string;
-}
-
-interface ArrayBufferConstructor {
-	fromString(string: string): ArrayBuffer;
-	fromBigInt(value: bigint): ArrayBuffer;
-}
-
-interface ArrayBuffer {
-	concat(...buffers: ArrayBufferLike[]): ArrayBuffer;
-}
-
-interface Uint8Array {
-	toHex(): string;
-	toBase64(): string
-}
-
-interface FromBase64Options {
-	alphabet?: "base64url" | "base64";
-	lastChunkHandling?: "stop-before-partial" | "strict" | "loose";
-	omitPadding?: boolean;
-}
-
-interface Uint8ArrayConstructor {
-	fromBase64(base64: string, options?: FromBase64Options): Uint8Array;
-	fromHex(string: string): Uint8Array;
-}
-
-interface BigIntConstructor {
-	bitLength(value: bigint): number
-	fromArrayBuffer(buffer: ArrayBufferLike): bigint
-}
-
-// integer math proposal
-interface Math {
-	idiv(a: number, b: number): number
-	imod(a: number, b: number): number
-	imuldiv(a: number, b: number, c: number): number
-	irandom(a: number, b: number): number
-	irem(a: number, b: number): number
-	mod(a: number, b: number): number
-}
-
-// xs host objects, host functions
-declare function Native(name: string): new (...args: any[]) => any;
-declare function native(name: string): (...args: any[]) => any;
-
-// Compartment?