typenative 0.1.3 → 0.3.0

package/types/typenative.d.ts

@@ -115,6 +115,8 @@ type Pick<T, K extends keyof T> = { [P in K]: T[P] };
 type Omit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
 type NonNullable<T> = T & {};
 type Record<K extends keyof any, T> = { [P in K]: T };
+type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
+type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
 
 // --- RegExp ---
 
@@ -320,7 +322,7 @@ interface String {
   /** Returns the Unicode code point at the specified index. */
   charCodeAt(pos: number): number;
   /** Returns the position of the first occurrence of a substring. */
-  indexOf(searchString: string): number;
+  indexOf(searchString: string, position?: number): number;
   /** Returns the position of the last occurrence of a substring. */
   lastIndexOf(searchString: string): number;
   /** Determines whether a string contains the specified substring. */
@@ -404,10 +406,22 @@ declare var Number: NumberConstructor;
 
 interface Console {
   log(...data: any[]): void;
+  info(...data: any[]): void;
+  debug(...data: any[]): void;
   error(...data: any[]): void;
   warn(...data: any[]): void;
+  trace(...data: any[]): void;
+  dir(item?: any, options?: { depth?: number | null }): void;
+  assert(condition?: boolean, ...data: any[]): void;
+  count(label?: string): void;
+  countReset(label?: string): void;
+  table(tabularData: unknown, properties?: readonly string[]): void;
+  group(...label: any[]): void;
+  groupCollapsed(...label: any[]): void;
+  groupEnd(): void;
   time(label?: string): void;
   timeEnd(label?: string): void;
+  timeLog(label?: string, ...data: any[]): void;
 }
 declare var console: Console;
 
@@ -461,6 +475,14 @@ declare function encodeURIComponent(uriComponent: string): string;
 declare function decodeURIComponent(uriComponent: string): string;
 declare function structuredClone<T>(value: T): T;
 
+// The running program (a native binary has no separate script file)
+declare var __filename: string;
+declare var __dirname: string;
+
+declare var MessageChannel: typeof import('node:worker_threads').MessageChannel;
+declare var MessagePort: typeof import('node:worker_threads').MessagePort;
+declare var BroadcastChannel: typeof import('node:worker_threads').BroadcastChannel;
+
 declare var NaN: number;
 declare var Infinity: number;
 
@@ -472,10 +494,10 @@ interface ImportMeta {
 }
 
 // Timers and microtasks. Handles are opaque; pass them to the matching clear function.
-declare function setTimeout(callback: () => void, ms?: number): number;
-declare function clearTimeout(id?: number): void;
-declare function setInterval(callback: () => void, ms?: number): number;
-declare function clearInterval(id?: number): void;
+declare function setTimeout(callback: (...args: any[]) => void, ms?: number): NodeJS.Timeout;
+declare function clearTimeout(id?: NodeJS.Timeout | number): void;
+declare function setInterval(callback: (...args: any[]) => void, ms?: number): NodeJS.Timeout;
+declare function clearInterval(id?: NodeJS.Timeout | number): void;
 declare function queueMicrotask(callback: () => void): void;
 
 // --- JSON / Object / process ---
@@ -510,24 +532,107 @@ declare var Object: ObjectConstructor;
 
 interface Process {
   argv: string[];
-  platform: string;
+  readonly argv0: string;
+  readonly execArgv: string[];
+  readonly execPath: string;
+  readonly platform: string;
+  readonly arch: string;
+  readonly pid: number;
+  readonly ppid: number;
+  readonly version: string;
+  readonly versions: { readonly node: string; readonly [name: string]: string | undefined };
+  readonly title: string;
+  exitCode: number | undefined;
+  env: { [key: string]: string | undefined };
   exit(code?: number): never;
   cwd(): string;
-  env: { [key: string]: string | undefined };
+  chdir(directory: string): void;
+  hrtime: { (time?: [number, number]): [number, number]; bigint(): bigint };
+  uptime(): number;
+  memoryUsage: {
+    (): { rss: number; heapTotal: number; heapUsed: number; external: number; arrayBuffers: number };
+    rss(): number;
+  };
+  nextTick<A extends any[]>(callback: (...args: A) => void, ...args: A): void;
+  kill(pid: number, signal?: string | number): true;
+  emitWarning(warning: string | Error): void;
+  getuid(): number;
+  getgid(): number;
+  geteuid(): number;
+  getegid(): number;
+  loadEnvFile(path?: string): void;
+  cpuUsage(previousValue?: { user: number; system: number }): { user: number; system: number };
+  resourceUsage(): {
+    userCPUTime: number;
+    systemCPUTime: number;
+    maxRSS: number;
+    sharedMemorySize: number;
+    unsharedDataSize: number;
+    unsharedStackSize: number;
+    minorPageFault: number;
+    majorPageFault: number;
+    swappedOut: number;
+    fsRead: number;
+    fsWrite: number;
+    ipcSent: number;
+    ipcReceived: number;
+    signalsCount: number;
+    voluntaryContextSwitches: number;
+    involuntaryContextSwitches: number;
+  };
+  availableMemory(): number;
+  constrainedMemory(): number;
+  on(event: 'uncaughtException' | 'uncaughtExceptionMonitor', listener: (error: Error, origin: 'uncaughtException' | 'unhandledRejection') => void): this;
+  on(event: 'unhandledRejection', listener: (reason: unknown, promise: Promise<unknown>) => void): this;
+  on(event: 'beforeExit', listener: (code: number) => void): this;
+  readonly stdout: import('node:stream').Writable & { readonly isTTY?: boolean; readonly fd: 1 };
+  readonly stderr: import('node:stream').Writable & { readonly isTTY?: boolean; readonly fd: 2 };
+  readonly stdin: import('node:stream').Readable & { readonly isTTY?: boolean; readonly fd: 0 };
+  on(event: 'exit', listener: (code: number) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
+  once(event: 'exit', listener: (code: number) => void): this;
+  once(event: string, listener: (...args: any[]) => void): this;
+  addListener(event: string, listener: (...args: any[]) => void): this;
+  off(event: string, listener: (...args: any[]) => void): this;
+  removeListener(event: string, listener: (...args: any[]) => void): this;
+  emit(event: string, ...args: any[]): boolean;
+  listenerCount(event: string): number;
+  // IPC of forked children (child_process.fork, cluster workers)
+  send?(message: any, callback?: (error: Error | null) => void): boolean;
+  readonly connected: boolean;
+  disconnect(): void;
 }
 declare var process: Process;
 
 // --- Error / Date ---
 
 interface Error {
+  name: string;
   message: string;
+  stack?: string;
+  cause?: unknown;
+}
+
+interface ErrorOptions {
+  cause?: unknown;
 }
 
 interface ErrorConstructor {
-  new (message?: string): Error;
+  new (message?: string, options?: ErrorOptions): Error;
+  (message?: string, options?: ErrorOptions): Error;
 }
 
 declare var Error: ErrorConstructor;
+// Built-in Error subclasses: TnErrors carrying their name
+declare var TypeError: ErrorConstructor;
+declare var RangeError: ErrorConstructor;
+declare var SyntaxError: ErrorConstructor;
+declare var ReferenceError: ErrorConstructor;
+declare var EvalError: ErrorConstructor;
+declare var URIError: ErrorConstructor;
+type TypeError = Error;
+type RangeError = Error;
+type SyntaxError = Error;
 
 interface Date {
   getTime(): number;
@@ -580,10 +685,16 @@ interface Promise<T> {
   finally(onfinally?: () => void): Promise<T>;
 }
 
+// Thenables (needed by the compiler for async callbacks passed to generic APIs)
+interface PromiseLike<T> {
+  then(onfulfilled?: (value: T) => any): any;
+}
+
 interface PromiseConstructor {
   new <T>(
     executor: (resolve: (value: T) => void, reject?: (reason?: any) => void) => void
   ): Promise<T>;
+  resolve(): Promise<void>;
   resolve<T>(value: T): Promise<T>;
   reject(reason?: any): Promise<never>;
   all<T>(values: Promise<T>[]): Promise<T[]>;
@@ -721,6 +832,538 @@ interface ClassMethodDecoratorContext<
   addInitializer(initializer: (this: This) => void): void;
 }
 
+// bigint values (*big.Int): toString(radix)
+interface BigInt {
+  toString(radix?: number): string;
+}
+
+// --- Node.js globals (Buffer, URL, TextEncoder, AbortController, performance, …) ---
+
+type BufferEncoding =
+  | 'ascii'
+  | 'utf8'
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf-16le'
+  | 'ucs2'
+  | 'ucs-2'
+  | 'base64'
+  | 'base64url'
+  | 'latin1'
+  | 'binary'
+  | 'hex';
+
+// Byte arrays: Uint8Array and Buffer are Go []byte (slices share memory)
+interface Uint8Array {
+  readonly length: number;
+  readonly byteLength: number;
+  [index: number]: number;
+  subarray(start?: number, end?: number): Uint8Array;
+  slice(start?: number, end?: number): Uint8Array;
+  set(array: ArrayLike<number>, offset?: number): void;
+  at(index: number): number | undefined;
+  [Symbol.iterator](): IterableIterator<number>;
+}
+
+interface Uint8ArrayConstructor {
+  new (length: number): Uint8Array;
+  new (array: ArrayLike<number> | Uint8Array): Uint8Array;
+  from(arrayLike: ArrayLike<number> | Iterable<number>): Uint8Array;
+}
+
+declare var Uint8Array: Uint8ArrayConstructor;
+
+// hkdfSync returns key bytes (an ArrayBuffer in Node); wrap with Buffer.from
+interface ArrayBuffer {
+  readonly byteLength: number;
+}
+
+interface Buffer extends Uint8Array {
+  toString(encoding?: BufferEncoding, start?: number, end?: number): string;
+  toJSON(): { type: 'Buffer'; data: number[] };
+  equals(otherBuffer: Uint8Array): boolean;
+  compare(otherBuffer: Uint8Array): number;
+  subarray(start?: number, end?: number): Buffer;
+  slice(start?: number, end?: number): Buffer;
+  indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+  lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+  includes(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): boolean;
+  fill(value: string | number | Uint8Array, offset?: number, end?: number): this;
+  fill(value: string, encoding: BufferEncoding): this;
+  write(string: string, offset?: number, length?: number, encoding?: BufferEncoding): number;
+  write(string: string, encoding: BufferEncoding): number;
+  copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+  readUInt8(offset?: number): number;
+  readUint8(offset?: number): number;
+  readUInt16LE(offset?: number): number;
+  readUint16LE(offset?: number): number;
+  readUInt16BE(offset?: number): number;
+  readUint16BE(offset?: number): number;
+  readUInt32LE(offset?: number): number;
+  readUint32LE(offset?: number): number;
+  readUInt32BE(offset?: number): number;
+  readUint32BE(offset?: number): number;
+  readInt8(offset?: number): number;
+  readInt16LE(offset?: number): number;
+  readInt16BE(offset?: number): number;
+  readInt32LE(offset?: number): number;
+  readInt32BE(offset?: number): number;
+  readFloatLE(offset?: number): number;
+  readFloatBE(offset?: number): number;
+  readDoubleLE(offset?: number): number;
+  readDoubleBE(offset?: number): number;
+  writeUInt8(value: number, offset?: number): number;
+  writeUint8(value: number, offset?: number): number;
+  writeUInt16LE(value: number, offset?: number): number;
+  writeUint16LE(value: number, offset?: number): number;
+  writeUInt16BE(value: number, offset?: number): number;
+  writeUint16BE(value: number, offset?: number): number;
+  writeUInt32LE(value: number, offset?: number): number;
+  writeUint32LE(value: number, offset?: number): number;
+  writeUInt32BE(value: number, offset?: number): number;
+  writeUint32BE(value: number, offset?: number): number;
+  writeInt8(value: number, offset?: number): number;
+  writeInt16LE(value: number, offset?: number): number;
+  writeInt16BE(value: number, offset?: number): number;
+  writeInt32LE(value: number, offset?: number): number;
+  writeInt32BE(value: number, offset?: number): number;
+  writeFloatLE(value: number, offset?: number): number;
+  writeFloatBE(value: number, offset?: number): number;
+  writeDoubleLE(value: number, offset?: number): number;
+  writeDoubleBE(value: number, offset?: number): number;
+  readBigInt64LE(offset?: number): bigint;
+  readBigInt64BE(offset?: number): bigint;
+  readBigUInt64LE(offset?: number): bigint;
+  readBigUInt64BE(offset?: number): bigint;
+  readBigUint64LE(offset?: number): bigint;
+  readBigUint64BE(offset?: number): bigint;
+  writeBigInt64LE(value: bigint, offset?: number): number;
+  writeBigInt64BE(value: bigint, offset?: number): number;
+  writeBigUInt64LE(value: bigint, offset?: number): number;
+  writeBigUInt64BE(value: bigint, offset?: number): number;
+  writeBigUint64LE(value: bigint, offset?: number): number;
+  writeBigUint64BE(value: bigint, offset?: number): number;
+  swap16(): Buffer;
+  swap32(): Buffer;
+  swap64(): Buffer;
+}
+
+interface BufferConstructor {
+  from(data: string, encoding?: BufferEncoding): Buffer;
+  from(data: ArrayLike<number> | Uint8Array | ArrayBuffer): Buffer;
+  alloc(size: number, fill?: string | number | Uint8Array, encoding?: BufferEncoding): Buffer;
+  allocUnsafe(size: number): Buffer;
+  allocUnsafeSlow(size: number): Buffer;
+  concat(list: readonly Uint8Array[], totalLength?: number): Buffer;
+  byteLength(string: string | Uint8Array, encoding?: BufferEncoding): number;
+  isBuffer(obj: any): obj is Buffer;
+  isEncoding(encoding: string): encoding is BufferEncoding;
+  compare(buf1: Uint8Array, buf2: Uint8Array): -1 | 0 | 1;
+}
+
+declare var Buffer: BufferConstructor;
+
+declare function atob(data: string): string;
+declare function btoa(data: string): string;
+
+interface TextEncoder {
+  readonly encoding: string;
+  encode(input?: string): Uint8Array;
+}
+declare var TextEncoder: { new (): TextEncoder };
+
+interface TextDecoder {
+  readonly encoding: string;
+  decode(input?: Uint8Array, options?: { stream?: boolean }): string;
+}
+declare var TextDecoder: { new (label?: string): TextDecoder };
+
+interface URLSearchParams extends Iterable<[string, string]> {
+  readonly size: number;
+  append(name: string, value: string): void;
+  delete(name: string, value?: string): void;
+  get(name: string): string | null;
+  getAll(name: string): string[];
+  has(name: string, value?: string): boolean;
+  set(name: string, value: string): void;
+  sort(): void;
+  toString(): string;
+  forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  entries(): IterableIterator<[string, string]>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+declare var URLSearchParams: {
+  new (init?: string | Record<string, string> | readonly (readonly [string, string])[] | URLSearchParams): URLSearchParams;
+};
+
+interface URL {
+  href: string;
+  protocol: string;
+  username: string;
+  password: string;
+  host: string;
+  hostname: string;
+  port: string;
+  pathname: string;
+  search: string;
+  hash: string;
+  readonly origin: string;
+  readonly searchParams: URLSearchParams;
+  toString(): string;
+  toJSON(): string;
+}
+declare var URL: {
+  new (input: string | URL, base?: string | URL): URL;
+  canParse(input: string, base?: string): boolean;
+  parse(input: string, base?: string): URL | null;
+};
+
+interface Event {
+  readonly type: string;
+  readonly defaultPrevented: boolean;
+  readonly target: any;
+  readonly timeStamp: number;
+  preventDefault(): void;
+}
+declare var Event: { new (type: string, options?: { cancelable?: boolean }): Event };
+
+interface EventTarget {
+  addEventListener(type: string, listener: (event: Event) => void, options?: { once?: boolean }): void;
+  removeEventListener(type: string, listener: (event: Event) => void): void;
+  dispatchEvent(event: Event): boolean;
+}
+declare var EventTarget: { new (): EventTarget };
+
+interface AbortSignal extends EventTarget {
+  readonly aborted: boolean;
+  readonly reason: any;
+  onabort: ((event: Event) => void) | null;
+  throwIfAborted(): void;
+}
+declare var AbortSignal: {
+  abort(reason?: any): AbortSignal;
+  timeout(milliseconds: number): AbortSignal;
+  any(signals: AbortSignal[]): AbortSignal;
+};
+
+interface AbortController {
+  readonly signal: AbortSignal;
+  abort(reason?: any): void;
+}
+declare var AbortController: { new (): AbortController };
+
+interface PerformanceEntry {
+  readonly name: string;
+  readonly entryType: string;
+  readonly startTime: number;
+  readonly duration: number;
+  readonly detail?: any;
+}
+interface PerformanceObserverEntryList {
+  getEntries(): PerformanceEntry[];
+  getEntriesByName(name: string, type?: string): PerformanceEntry[];
+  getEntriesByType(type: string): PerformanceEntry[];
+}
+interface PerformanceObserver {
+  observe(options: { entryTypes: readonly string[] } | { type: string; buffered?: boolean }): void;
+  disconnect(): void;
+  takeRecords(): PerformanceEntry[];
+}
+declare var PerformanceObserver: {
+  new (callback: (list: PerformanceObserverEntryList, observer: PerformanceObserver) => void): PerformanceObserver;
+  readonly supportedEntryTypes: readonly string[];
+};
+interface Performance {
+  timerify<T extends (...params: any[]) => any>(fn: T): T;
+  eventLoopUtilization(previous?: { idle: number; active: number; utilization: number }): { idle: number; active: number; utilization: number };
+  readonly timeOrigin: number;
+  now(): number;
+  mark(name: string, options?: { startTime?: number; detail?: any }): PerformanceEntry;
+  measure(name: string, startMark?: string, endMark?: string): PerformanceEntry;
+  measure(name: string, options: { start?: string; end?: string }): PerformanceEntry;
+  getEntries(): PerformanceEntry[];
+  getEntriesByName(name: string, type?: string): PerformanceEntry[];
+  getEntriesByType(type: string): PerformanceEntry[];
+  clearMarks(name?: string): void;
+  clearMeasures(name?: string): void;
+}
+declare var performance: Performance;
+
+declare var crypto: {
+  randomUUID(): string;
+  getRandomValues<T extends Uint8Array>(array: T): T;
+  readonly subtle: import('node:crypto').webcrypto.SubtleCrypto;
+};
+type CryptoKey = import('node:crypto').webcrypto.CryptoKey;
+
+// --- Web streams (node:stream/web globals) ---
+
+interface ReadableStreamReadResult<R> {
+  done: boolean;
+  value: R;
+}
+interface ReadableStreamDefaultController<R = any> {
+  readonly desiredSize: number | null;
+  enqueue(chunk?: R): void;
+  close(): void;
+  error(e?: any): void;
+}
+interface UnderlyingSource<R = any> {
+  type?: 'bytes';
+  start?(controller: ReadableStreamDefaultController<R>): any;
+  pull?(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
+  cancel?(reason?: any): void | PromiseLike<void>;
+}
+interface QueuingStrategy<T = any> {
+  highWaterMark?: number;
+  size?(chunk: T): number;
+}
+interface ReadableStreamDefaultReader<R = any> {
+  readonly closed: Promise<void>;
+  read(): Promise<ReadableStreamReadResult<R>>;
+  releaseLock(): void;
+  cancel(reason?: any): Promise<void>;
+}
+interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
+  preventClose?: boolean;
+  signal?: AbortSignal;
+}
+interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
+  writable: WritableStream<W>;
+}
+interface ReadableStream<R = any> extends AsyncIterable<R> {
+  readonly locked: boolean;
+  getReader(options?: { mode?: undefined }): ReadableStreamDefaultReader<R>;
+  cancel(reason?: any): Promise<void>;
+  tee(): [ReadableStream<R>, ReadableStream<R>];
+  pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
+  pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
+  values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+  [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+}
+declare var ReadableStream: {
+  new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+  from<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;
+};
+declare var ReadableStreamDefaultReader: { new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R> };
+
+interface WritableStreamDefaultController {
+  readonly signal: AbortSignal;
+  error(e?: any): void;
+}
+interface UnderlyingSink<W = any> {
+  start?(controller: WritableStreamDefaultController): any;
+  write?(chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
+  close?(): void | PromiseLike<void>;
+  abort?(reason?: any): void | PromiseLike<void>;
+}
+interface WritableStreamDefaultWriter<W = any> {
+  readonly closed: Promise<void>;
+  readonly ready: Promise<void>;
+  readonly desiredSize: number | null;
+  write(chunk?: W): Promise<void>;
+  close(): Promise<void>;
+  abort(reason?: any): Promise<void>;
+  releaseLock(): void;
+}
+interface WritableStream<W = any> {
+  readonly locked: boolean;
+  getWriter(): WritableStreamDefaultWriter<W>;
+  close(): Promise<void>;
+  abort(reason?: any): Promise<void>;
+}
+declare var WritableStream: { new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W> };
+declare var WritableStreamDefaultWriter: { new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W> };
+
+interface TransformStreamDefaultController<O = any> {
+  readonly desiredSize: number | null;
+  enqueue(chunk?: O): void;
+  error(reason?: any): void;
+  terminate(): void;
+}
+interface Transformer<I = any, O = any> {
+  start?(controller: TransformStreamDefaultController<O>): any;
+  transform?(chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+  flush?(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+  cancel?(reason?: any): void | PromiseLike<void>;
+}
+interface TransformStream<I = any, O = any> {
+  readonly readable: ReadableStream<O>;
+  readonly writable: WritableStream<I>;
+}
+declare var TransformStream: {
+  new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
+};
+
+interface TextEncoderStream extends TransformStream<string, Uint8Array> {
+  readonly encoding: 'utf-8';
+}
+declare var TextEncoderStream: { new (): TextEncoderStream };
+interface TextDecoderStream extends TransformStream<Uint8Array, string> {
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+}
+declare var TextDecoderStream: { new (label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoderStream };
+type CompressionFormat = 'deflate' | 'deflate-raw' | 'gzip';
+interface CompressionStream extends TransformStream<Uint8Array, Uint8Array> {}
+declare var CompressionStream: { new (format: CompressionFormat): CompressionStream };
+interface DecompressionStream extends TransformStream<Uint8Array, Uint8Array> {}
+declare var DecompressionStream: { new (format: CompressionFormat): DecompressionStream };
+
+interface CountQueuingStrategy extends QueuingStrategy {
+  readonly highWaterMark: number;
+  size(chunk?: any): 1;
+}
+declare var CountQueuingStrategy: { new (init: { highWaterMark: number }): CountQueuingStrategy };
+interface ByteLengthQueuingStrategy extends QueuingStrategy<Uint8Array> {
+  readonly highWaterMark: number;
+  size(chunk: Uint8Array): number;
+}
+declare var ByteLengthQueuingStrategy: { new (init: { highWaterMark: number }): ByteLengthQueuingStrategy };
+
+// --- Blob / File / FormData ---
+
+type BlobPart = string | Uint8Array | Blob;
+interface Blob {
+  readonly size: number;
+  readonly type: string;
+  text(): Promise<string>;
+  bytes(): Promise<Uint8Array>;
+  arrayBuffer(): Promise<Uint8Array>;
+  slice(start?: number, end?: number, contentType?: string): Blob;
+  stream(): ReadableStream<Uint8Array>;
+}
+declare var Blob: { new (blobParts?: BlobPart[], options?: { type?: string }): Blob };
+interface File extends Blob {
+  readonly name: string;
+  readonly lastModified: number;
+}
+declare var File: { new (fileBits: BlobPart[], fileName: string, options?: { type?: string; lastModified?: number }): File };
+
+type FormDataEntryValue = string | File;
+interface FormData extends Iterable<[string, FormDataEntryValue]> {
+  append(name: string, value: string | Blob, fileName?: string): void;
+  set(name: string, value: string | Blob, fileName?: string): void;
+  get(name: string): FormDataEntryValue | null;
+  getAll(name: string): FormDataEntryValue[];
+  has(name: string): boolean;
+  delete(name: string): void;
+  entries(): [string, FormDataEntryValue][];
+  keys(): string[];
+  values(): FormDataEntryValue[];
+  forEach(callback: (value: FormDataEntryValue, key: string, parent: FormData) => void): void;
+  [Symbol.iterator](): Iterator<[string, FormDataEntryValue]>;
+}
+declare var FormData: { new (): FormData };
+
+// --- fetch (WHATWG Fetch API, as in Node) ---
+
+type HeadersInit = Headers | Record<string, string> | [string, string][];
+interface Headers {
+  get(name: string): string | null;
+  getSetCookie(): string[];
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  entries(): [string, string][];
+  keys(): string[];
+  values(): string[];
+  forEach(callback: (value: string, key: string, parent: Headers) => void): void;
+  [Symbol.iterator](): Iterator<[string, string]>;
+}
+declare var Headers: { new (init?: HeadersInit): Headers };
+
+type BodyInit = string | Uint8Array | URLSearchParams | Blob | FormData | ReadableStream<Uint8Array | string>;
+interface Body {
+  readonly body: ReadableStream<Uint8Array> | null;
+  readonly bodyUsed: boolean;
+  text(): Promise<string>;
+  json(): Promise<any>;
+  bytes(): Promise<Uint8Array>;
+  arrayBuffer(): Promise<Uint8Array>;
+  blob(): Promise<Blob>;
+  formData(): Promise<FormData>;
+}
+interface RequestInit {
+  method?: string;
+  headers?: HeadersInit;
+  body?: BodyInit | null;
+  redirect?: 'follow' | 'manual' | 'error';
+  signal?: AbortSignal | null;
+  duplex?: 'half';
+}
+interface Request extends Body {
+  readonly url: string;
+  readonly method: string;
+  readonly headers: Headers;
+  readonly redirect: 'follow' | 'manual' | 'error';
+  readonly signal: AbortSignal;
+  clone(): Request;
+}
+declare var Request: { new (input: string | URL | Request, init?: RequestInit): Request };
+
+interface ResponseInit {
+  status?: number;
+  statusText?: string;
+  headers?: HeadersInit;
+}
+interface Response extends Body {
+  readonly status: number;
+  readonly statusText: string;
+  readonly ok: boolean;
+  readonly headers: Headers;
+  readonly url: string;
+  readonly redirected: boolean;
+  readonly type: 'basic' | 'default' | 'error';
+  clone(): Response;
+}
+declare var Response: {
+  new (body?: BodyInit | null, init?: ResponseInit): Response;
+  json(data: any, init?: ResponseInit): Response;
+  error(): Response;
+  redirect(url: string | URL, status?: number): Response;
+};
+
+declare function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+
+declare function setImmediate<A extends any[]>(callback: (...args: A) => void, ...args: A): NodeJS.Immediate;
+declare function clearImmediate(immediate?: NodeJS.Immediate | number): void;
+
+declare namespace NodeJS {
+  // Timer handles: an unref'ed timer does not keep the process alive
+  interface Timeout {
+    ref(): this;
+    unref(): this;
+    hasRef(): boolean;
+    refresh(): this;
+    close(): this;
+  }
+  interface Immediate {
+    ref(): this;
+    unref(): this;
+    hasRef(): boolean;
+  }
+  // Errors thrown by Node APIs: err.code ('ENOENT', 'ERR_INVALID_URL', …)
+  interface ErrnoException extends Error {
+    errno?: number;
+    code?: string;
+    path?: string;
+    syscall?: string;
+    /** dns errors: the queried name */
+    hostname?: string;
+    /** net errors: the remote address and port */
+    address?: string;
+    port?: number;
+  }
+}
+
 // --- Test helper ---
 
 declare function assert(condition: boolean, message?: string): void;