ink-framework-network 0.0.0-stage → 0.1.0-alpha.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vandam Dinh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/ink-native.json

@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "modules": {
+    "src/index.ts": [
+      "network"
+    ],
+    "src/connectivity.ts": [
+      "connectivity"
+    ],
+    "src/downloads.ts": [
+      "downloads"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "ink-framework-network",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.10",
+  "exports": {
+    ".": "./src/index.ts",
+    "./connectivity": "./src/connectivity.ts",
+    "./downloads": "./src/downloads.ts"
+  },
+  "dependencies": {
+    "web-streams-polyfill": "4.3.0",
+    "whatwg-url": "14.2.0",
+    "@types/whatwg-url": "13.0.0"
+  },
+  "peerDependencies": {
+    "ink": "npm:ink-framework@0.1.0-alpha.10",
+    "@ink/files": "npm:ink-framework-files@0.1.0-alpha.10"
+  },
+  "sideEffects": [
+    "./src/index.ts"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/No-Scrolling/ink.git",
+    "directory": "packages/network"
+  },
+  "files": [
+    "src",
+    "*.json",
+    "*.ts"
+  ]
+}

package/runtime.d.ts

@@ -0,0 +1,53 @@
+import type * as Streams from "web-streams-polyfill";
+import type * as URLs from "whatwg-url";
+import type * as Bodies from "./src/blob";
+import type * as HTTP from "./src/fetch";
+import type * as Sockets from "./src/websocket";
+
+declare global {
+  const URL: typeof URLs.URL;
+  type URL = URLs.URL;
+  const URLSearchParams: typeof URLs.URLSearchParams;
+  type URLSearchParams = URLs.URLSearchParams;
+  const Blob: typeof Bodies.Blob;
+  interface Blob extends Bodies.Blob {}
+  const File: typeof Bodies.File;
+  type File = Bodies.File;
+  const FormData: typeof Bodies.FormData;
+  interface FormData extends Bodies.FormData {}
+  type BlobPart = ConstructorParameters<typeof Blob>[0] extends Iterable<infer P> | undefined ? P : never;
+  const Headers: typeof HTTP.Headers;
+  type Headers = HTTP.Headers;
+  const Request: typeof HTTP.Request;
+  type Request = HTTP.Request;
+  const Response: typeof HTTP.Response;
+  type Response = HTTP.Response;
+  const fetch: typeof HTTP.fetch;
+  type RequestInit = NonNullable<ConstructorParameters<typeof Request>[1]>;
+  type RequestInfo = Parameters<typeof fetch>[0];
+  type HeadersInit = NonNullable<ConstructorParameters<typeof Headers>[0]>;
+  type ResponseInit = NonNullable<ConstructorParameters<typeof Response>[1]>;
+  type BodyInit = NonNullable<ConstructorParameters<typeof Response>[0]>;
+  const WebSocket: typeof Sockets.WebSocket;
+  type WebSocket = Sockets.WebSocket;
+  const MessageEvent: typeof Sockets.MessageEvent;
+  type MessageEvent = Sockets.MessageEvent;
+  const CloseEvent: typeof Sockets.CloseEvent;
+  type CloseEvent = Sockets.CloseEvent;
+
+  const ReadableStream: typeof Streams.ReadableStream;
+  type ReadableStream<R = unknown> = Streams.ReadableStream<R>;
+  const WritableStream: typeof Streams.WritableStream;
+  type WritableStream<W = unknown> = Streams.WritableStream<W>;
+  const TransformStream: typeof Streams.TransformStream;
+  type TransformStream<I = unknown, O = unknown> = Streams.TransformStream<I, O>;
+  const ByteLengthQueuingStrategy: typeof Streams.ByteLengthQueuingStrategy;
+  type ByteLengthQueuingStrategy = Streams.ByteLengthQueuingStrategy;
+  const CountQueuingStrategy: typeof Streams.CountQueuingStrategy;
+  type CountQueuingStrategy = Streams.CountQueuingStrategy;
+  type ReadableStreamDefaultReader<R = unknown> = Streams.ReadableStreamDefaultReader<R>;
+  type ReadableStreamDefaultController<R = unknown> = Streams.ReadableStreamDefaultController<R>;
+  type WritableStreamDefaultWriter<W = unknown> = Streams.WritableStreamDefaultWriter<W>;
+  type WritableStreamDefaultController = Streams.WritableStreamDefaultController;
+  type TransformStreamDefaultController<O = unknown> = Streams.TransformStreamDefaultController<O>;
+}

package/src/blob.ts

@@ -0,0 +1,191 @@
+import { URLSearchParams } from "whatwg-url";
+import { ReadableStream } from "web-streams-polyfill";
+import { callNativeBytes } from "ink/native";
+
+type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob;
+type NativePart = { src: string; offset: number; size: number };
+type Part = Uint8Array | NativePart;
+const partSize = (part: Part) => part instanceof Uint8Array ? part.length : part.size;
+const blobParts = new WeakMap<Blob, Part[]>();
+function partsOf(blob: Blob): Part[] {
+  const parts = blobParts.get(blob);
+  if (!parts) throw new TypeError("Invalid Blob receiver");
+  return parts;
+}
+
+export function nativeBlob(src: string, size: number, type: string): Blob {
+  const blob = new Blob([], { type });
+  blobParts.set(blob, [{ src, offset: 0, size }]);
+  Object.defineProperty(blob, "size", { value: size });
+  return blob;
+}
+
+export function nativeBlobParts(blob: Blob): Iterable<{ bytes: Uint8Array } | NativePart> | undefined {
+  const parts = partsOf(blob);
+  if (!parts.some(part => !(part instanceof Uint8Array))) return undefined;
+  return (function* () {
+    for (const part of parts) {
+      if (part instanceof Uint8Array) {
+        for (let offset = 0; offset < part.length; offset += 32768) yield { bytes: part.subarray(offset, offset + 32768) };
+      } else yield part;
+    }
+  })();
+}
+export class Blob {
+  readonly size: number;
+  readonly type: string;
+  constructor(parts: Iterable<BlobPart> = [], options: { type?: string; endings?: "transparent" | "native" } = {}) {
+    const stored: Part[] = [];
+    blobParts.set(this, stored);
+    for (const part of parts) {
+      if (part instanceof Blob) stored.push(...partsOf(part));
+      else if (part instanceof ArrayBuffer) stored.push(new Uint8Array(part.slice(0)));
+      else if (ArrayBuffer.isView(part)) stored.push(new Uint8Array(part.buffer, part.byteOffset, part.byteLength).slice());
+      else stored.push(new TextEncoder().encode(options.endings === "native" ? String(part).replace(/\r\n|\r/g, "\n") : String(part)));
+    }
+    this.size = stored.reduce((size, part) => size + partSize(part), 0);
+    const type = String(options.type ?? "");
+    this.type = /[^\x20-\x7e]/.test(type) ? "" : type.toLowerCase();
+  }
+  slice(start = 0, end = this.size, type = "") {
+    const normalise = (value: number) => value < 0 ? Math.max(this.size + Math.trunc(value), 0) : Math.min(Math.trunc(value) || 0, this.size);
+    let offset = 0;
+    const result = new Blob([], { type });
+    const resultParts = partsOf(result);
+    const from = normalise(start), to = normalise(end);
+    for (const part of partsOf(this)) {
+      const left = Math.max(0, from - offset), right = Math.min(partSize(part), to - offset);
+      if (right > left) {
+        resultParts.push(part instanceof Uint8Array ? part.subarray(left, right) : { ...part, offset: part.offset + left, size: right - left });
+      }
+      offset += partSize(part);
+    }
+    Object.defineProperty(result, "size", { value: Math.max(to - from, 0) });
+    return result;
+  }
+  async bytes() {
+    const bytes = new Uint8Array(this.size);
+    let offset = 0;
+    const reader = this.stream().getReader();
+    try {
+      for (;;) { const chunk = await reader.read(); if (chunk.done) break; bytes.set(chunk.value, offset); offset += chunk.value.length; }
+    } finally { reader.releaseLock(); }
+    return bytes;
+  }
+  async arrayBuffer() { return (await this.bytes()).buffer; }
+  async text() { return new TextDecoder().decode(await this.bytes()); }
+  stream(): ReadableStream<Uint8Array> {
+    let index = 0, offset = 0;
+    const parts = partsOf(this);
+    return new ReadableStream({
+      async pull(controller) {
+        while (index < parts.length && offset === partSize(parts[index])) { index++; offset = 0; }
+        if (index === parts.length) { controller.close(); return; }
+        const part = parts[index];
+        const end = Math.min(offset + 32 * 1024, partSize(part));
+        const bytes = part instanceof Uint8Array ? part.slice(offset, end)
+          : (await callNativeBytes("network", "stream-file-read-bytes", { src: part.src, offset: part.offset + offset, size: end - offset })).bytes;
+        if (bytes.length !== end - offset) throw new TypeError("Managed file changed while reading");
+        controller.enqueue(bytes);
+        offset = end;
+      },
+    }, { highWaterMark: 0 });
+  }
+  get [Symbol.toStringTag]() { return "Blob"; }
+}
+export class File extends Blob {
+  readonly name: string;
+  readonly lastModified: number;
+  readonly webkitRelativePath = "";
+  constructor(parts: Iterable<BlobPart>, name: string, options: { type?: string; lastModified?: number } = {}) {
+    super(parts, options);
+    this.name = String(name);
+    this.lastModified = options.lastModified ?? Date.now();
+  }
+  get [Symbol.toStringTag]() { return "File"; }
+}
+
+type FormValue = string | File;
+export class FormData implements Iterable<[string, FormValue]> {
+  #entries: [string, FormValue][] = [];
+  append(name: string, value: string | Blob, filename?: string) {
+    this.#entries.push([String(name), value instanceof Blob
+      ? new File([value], filename ?? (value instanceof File ? value.name : "blob"), { type: value.type, lastModified: value instanceof File ? value.lastModified : undefined })
+      : String(value)]);
+  }
+  delete(name: string) { this.#entries = this.#entries.filter(entry => entry[0] !== String(name)); }
+  get(name: string): FormValue | null { return this.#entries.find(entry => entry[0] === String(name))?.[1] ?? null; }
+  getAll(name: string): FormValue[] { return this.#entries.filter(entry => entry[0] === String(name)).map(entry => entry[1]); }
+  has(name: string) { return this.#entries.some(entry => entry[0] === String(name)); }
+  set(name: string, value: string | Blob, filename?: string) {
+    const index = this.#entries.findIndex(entry => entry[0] === String(name));
+    this.delete(name);
+    this.append(name, value, filename);
+    const entry = this.#entries.pop();
+    if (entry) this.#entries.splice(index < 0 ? this.#entries.length : index, 0, entry);
+  }
+  *entries(): IterableIterator<[string, FormValue]> { yield* this.#entries; }
+  *keys() { for (const [name] of this.#entries) yield name; }
+  *values() { for (const [, value] of this.#entries) yield value; }
+  [Symbol.iterator]() { return this.entries(); }
+  forEach(callback: (value: FormValue, name: string, form: FormData) => void, thisArg?: unknown) {
+    for (const [name, value] of this) callback.call(thisArg, value, name, this);
+  }
+  get [Symbol.toStringTag]() { return "FormData"; }
+}
+
+export function multipart(form: FormData): Blob {
+  const boundary = `----ink-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
+  const parts: BlobPart[] = [];
+  const escape = (text: string) => text.replace(/\r\n|\r|\n/g, "\r\n").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/"/g, "%22");
+  for (const [name, value] of form) {
+    let header = `--${boundary}\r\nContent-Disposition: form-data; name="${escape(name)}"`;
+    if (value instanceof File) {
+      header += `; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}`;
+    }
+    parts.push(`${header}\r\n\r\n`, typeof value === "string" ? value.replace(/\r\n|\r|\n/g, "\r\n") : value, "\r\n");
+  }
+  parts.push(`--${boundary}--\r\n`);
+  return new Blob(parts, { type: `multipart/form-data; boundary=${boundary}` });
+}
+
+export function parseFormData(bytes: Uint8Array, contentType: string): FormData {
+  const form = new FormData();
+  if (/^application\/x-www-form-urlencoded(?:;|$)/i.test(contentType)) {
+    for (const [name, value] of new URLSearchParams(new TextDecoder().decode(bytes))) form.append(name, value);
+    return form;
+  }
+  const boundary = /^multipart\/form-data\s*;.*?boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+  if (!boundary) throw new TypeError("Response is not form data");
+  const encoder = new TextEncoder();
+  const delimiter = encoder.encode(`\r\n--${boundary[1] ?? boundary[2]}`);
+  const find = (needle: Uint8Array, start: number) => {
+    outer: for (let index = start; index <= bytes.length - needle.length; index++) {
+      for (let offset = 0; offset < needle.length; offset++) if (bytes[index + offset] !== needle[offset]) continue outer;
+      return index;
+    }
+    return -1;
+  };
+  let offset = find(delimiter.subarray(2), 0);
+  if (offset < 0) throw new TypeError("Invalid multipart boundary");
+  offset += delimiter.length - 2;
+  while (bytes[offset] !== 45 || bytes[offset + 1] !== 45) {
+    while (bytes[offset] === 32 || bytes[offset] === 9) offset++;
+    if (bytes[offset] !== 13 || bytes[offset + 1] !== 10) throw new TypeError("Invalid multipart framing");
+    const headersEnd = find(encoder.encode("\r\n\r\n"), offset + 2);
+    if (headersEnd < 0 || headersEnd - offset > 16 * 1024) throw new TypeError("Invalid multipart headers");
+    const headers = new TextDecoder().decode(bytes.subarray(offset + 2, headersEnd));
+    const disposition = /^content-disposition:\s*form-data;(.+)$/im.exec(headers)?.[1];
+    const name = disposition && /(?:^|;)\s*name="([^"]*)"/i.exec(disposition)?.[1];
+    const filename = disposition && /(?:^|;)\s*filename="([^"]*)"/i.exec(disposition)?.[1];
+    const end = find(delimiter, headersEnd + 4);
+    if (name === undefined || name === null || end < 0) throw new TypeError("Invalid multipart field");
+    const value = bytes.subarray(headersEnd + 4, end);
+    if (filename !== undefined && filename !== null) {
+      const type = /^content-type:\s*([^\r\n]+)/im.exec(headers)?.[1] ?? "application/octet-stream";
+      form.append(name, new File([value], filename, { type }));
+    } else form.append(name, new TextDecoder().decode(value));
+    offset = end + delimiter.length;
+  }
+  return form;
+}

package/src/connectivity.ts

@@ -0,0 +1,42 @@
+import type { Snapshot, SnapshotSource } from "ink";
+import { callNative, onNativeMessage } from "ink/native";
+
+export type ConnectionState = Readonly<{
+  status: "unknown" | "offline" | "connected";
+  transport?: "wifi" | "cellular" | "ethernet" | "vpn" | "other";
+  metered?: boolean;
+}>;
+let snapshot: Snapshot<ConnectionState> = { status: "loading" };
+const listeners = new Set<() => void>();
+function publish(data: ConnectionState) {
+  snapshot = { status: "ready", data: Object.freeze(data) };
+  for (const listener of listeners) listener();
+}
+function decode(value: unknown): ConnectionState {
+  if (!value || typeof value !== "object" || !("status" in value) || !["unknown", "offline", "connected"].includes(String(value.status))) throw new Error("Invalid connectivity snapshot");
+  return value as ConnectionState;
+}
+onNativeMessage("connectivity-changed", message => { publish(decode(message.data)); });
+async function read(operation: string): Promise<ConnectionState> {
+  try {
+    const data = decode(JSON.parse(await callNative("connectivity", operation, {})));
+    publish(data);
+    return data;
+  } catch (error) {
+    snapshot = { status: "error", error: error instanceof Error ? error : new Error(String(error)) };
+    for (const listener of listeners) listener();
+    throw error;
+  }
+}
+export const connectivity: SnapshotSource<ConnectionState> & { get(): Promise<ConnectionState> } = {
+  get: () => read("snapshot"),
+  getSnapshot: () => snapshot,
+  subscribe(listener) {
+    listeners.add(listener);
+    if (listeners.size === 1) void read("watch").catch(() => {});
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) void callNative("connectivity", "unwatch", {}).catch(() => {});
+    };
+  },
+};

package/src/downloads.ts

@@ -0,0 +1,111 @@
+import type { Snapshot, SnapshotSource } from "ink";
+import { callNative } from "ink/native";
+import { attachNativeController } from "ink/native/controller";
+import type { FileRef } from "@ink/files";
+
+export type DownloadState = {
+  id: string;
+  state: "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
+  received: number;
+  total: number | null;
+  file: FileRef | null;
+  error: string | null;
+};
+function decode(value: unknown): DownloadState {
+  const byteCount = (number: unknown) => typeof number === "number" && Number.isSafeInteger(number) && number >= 0;
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string"
+    || !("state" in value) || !["queued", "running", "paused", "completed", "failed", "cancelled"].includes(String(value.state))
+    || !("received" in value) || !byteCount(value.received)
+    || !("total" in value) || (value.total !== null && !byteCount(value.total))
+    || !("file" in value) || !("error" in value) || (value.error !== null && typeof value.error !== "string")) {
+    throw new Error("Invalid download state");
+  }
+  if (value.file !== null) {
+    const file = value.file;
+    if (typeof file !== "object" || Array.isArray(file)
+      || !["id", "src", "name", "mimeType"].every(key => typeof Reflect.get(file, key) === "string")
+      || !byteCount(Reflect.get(file, "size"))) throw new Error("Invalid downloaded file");
+    for (const key of ["width", "height", "duration"]) {
+      const number: unknown = Reflect.get(file, key);
+      if (number !== undefined && !byteCount(number)) throw new Error("Invalid downloaded media metadata");
+    }
+  }
+  if (value.state === "completed" && value.file === null) throw new Error("Completed download has no file");
+  return value as DownloadState;
+}
+const sources = new Map<string, { source: SnapshotSource<DownloadState>; listeners: Set<() => void> }>();
+const idleSourceLimit = 128;
+function trimSources() {
+  let idle = 0;
+  for (const entry of sources.values()) if (!entry.listeners.size) idle++;
+  for (const [id, entry] of sources) {
+    if (idle <= idleSourceLimit) break;
+    if (!entry.listeners.size) { sources.delete(id); idle--; }
+  }
+}
+function observe(id: string): SnapshotSource<DownloadState> {
+  const existing = sources.get(id);
+  if (existing) {
+    sources.delete(id);
+    sources.set(id, existing);
+    return existing.source;
+  }
+  let snapshot: Snapshot<DownloadState> = { status: "loading" };
+  const listeners = new Set<() => void>();
+  let attachment: ReturnType<typeof attachNativeController> | undefined;
+  const publish = (value: Snapshot<DownloadState>) => { snapshot = value; for (const listener of listeners) listener(); };
+  const source: SnapshotSource<DownloadState> = {
+    getSnapshot: () => {
+      const current = sources.get(id)?.source;
+      return current && current !== source ? current.getSnapshot() : snapshot;
+    },
+    subscribe(listener) {
+      const current = sources.get(id)?.source;
+      if (current && current !== source) return current.subscribe(listener);
+      sources.set(id, entry);
+      listeners.add(listener);
+      trimSources();
+      if (!attachment) {
+        const current = attachNativeController("downloads", { id }, value => {
+          if (attachment !== current) return;
+          try { publish({ status: "ready", data: decode(value) }); }
+          catch (error) { publish({ status: "error", error: error instanceof Error ? error : new Error(String(error)) }); }
+        });
+        attachment = current;
+        void current.ready.catch(error => {
+          if (attachment === current) publish({ status: "error", error });
+        });
+      }
+      return () => {
+        listeners.delete(listener);
+        if (!listeners.size) {
+          const current = attachment;
+          attachment = undefined;
+          snapshot = { status: "loading" };
+          void current?.dispose().catch(error => console.error("Could not stop observing download", error));
+          trimSources();
+        }
+      };
+    },
+  };
+  const entry = { source, listeners };
+  sources.set(id, entry);
+  trimSources();
+  return source;
+}
+const command = async (operation: string, id: string): Promise<void> => {
+  await callNative("downloads", operation, { id });
+};
+export const downloads = {
+  async enqueue(options: { key: string; url: string; name: string; network?: "connected" | "unmetered" }): Promise<DownloadState> {
+    return decode(JSON.parse(await callNative("downloads", "enqueue", options)));
+  },
+  async get(id: string): Promise<DownloadState> {
+    return decode(JSON.parse(await callNative("downloads", "get", { id })));
+  },
+  observe,
+  pause: (id: string) => command("pause", id),
+  resume: (id: string) => command("resume", id),
+  cancel: (id: string) => command("cancel", id),
+  remove: (id: string) => command("remove", id),
+};

package/src/fetch.ts

@@ -0,0 +1,304 @@
+import { ReadableStream, type ReadableStreamDefaultReader } from "web-streams-polyfill";
+import { Blob, FormData, multipart, parseFormData, nativeBlob, nativeBlobParts } from "./blob";
+import { URL, URLSearchParams } from "whatwg-url";
+import { requestHttp } from "./http";
+import { callNative } from "ink/native";
+
+const immutableHeaders = new WeakSet<Headers>();
+const token = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+type HeaderInput = Headers | Iterable<readonly [string, string]> | Record<string, string>;
+function headerName(value: string): string {
+  const name = String(value);
+  if (!token.test(name)) throw new TypeError("Invalid HTTP header name");
+  return name.toLowerCase();
+}
+function headerValue(value: string): string {
+  const text = String(value).replace(/^[\t ]+|[\t ]+$/g, "");
+  if (/[\u0000\r\n\u0100-\uffff]/.test(text)) throw new TypeError("Invalid HTTP header value");
+  return text;
+}
+export class Headers implements Iterable<[string, string]> {
+  #values = new Map<string, string[]>();
+  constructor(input?: HeaderInput) {
+    if (input === undefined) return;
+    if (Symbol.iterator in input) {
+      for (const pair of input) {
+        if (pair.length !== 2) throw new TypeError("Headers require name/value pairs");
+        this.append(pair[0], pair[1]);
+      }
+    } else {
+      for (const [name, value] of Object.entries(input)) this.append(name, value);
+    }
+  }
+  #mutable() { if (immutableHeaders.has(this)) throw new TypeError("Headers are immutable"); }
+  append(name: string, value: string) {
+    this.#mutable();
+    const key = headerName(name);
+    const text = headerValue(value);
+    this.#values.set(key, [...(this.#values.get(key) ?? []), text]);
+  }
+  set(name: string, value: string) { this.#mutable(); this.#values.set(headerName(name), [headerValue(value)]); }
+  delete(name: string) { this.#mutable(); this.#values.delete(headerName(name)); }
+  get(name: string): string | null { return this.#values.get(headerName(name))?.join(", ") ?? null; }
+  has(name: string) { return this.#values.has(headerName(name)); }
+  getSetCookie() { return [...(this.#values.get("set-cookie") ?? [])]; }
+  *entries(): IterableIterator<[string, string]> {
+    for (const name of [...this.#values.keys()].sort()) {
+      if (name === "set-cookie") { for (const value of this.getSetCookie()) yield [name, value]; }
+      else yield [name, this.get(name) ?? ""];
+    }
+  }
+  *keys() { for (const [name] of this) yield name; }
+  *values() { for (const [, value] of this) yield value; }
+  [Symbol.iterator]() { return this.entries(); }
+  forEach(callback: (value: string, name: string, headers: Headers) => void, thisArg?: unknown) {
+    for (const [name, value] of this) callback.call(thisArg, value, name, this);
+  }
+}
+
+type BodyInput = string | ArrayBuffer | ArrayBufferView | URLSearchParams | Blob | FormData | ReadableStream<Uint8Array>;
+function bodyStream(input: BodyInput | null | undefined): ReadableStream<Uint8Array> | null {
+  if (input == null) return null;
+  if (input instanceof ReadableStream) return input;
+  if (input instanceof FormData) return multipart(input).stream();
+  if (input instanceof Blob) return input.stream();
+  return new Blob([input instanceof URLSearchParams ? String(input) : input]).stream();
+}
+class Body {
+  protected data: ReadableStream<Uint8Array> | null;
+  protected bodySignal?: AbortSignal;
+  protected nativeBlob?: Blob;
+  #disturbed = new WeakSet<ReadableStream<Uint8Array>>();
+  protected get contentType(): string { return ""; }
+  constructor(input?: BodyInput | null, signal?: AbortSignal) { this.data = this.track(bodyStream(input)); this.bodySignal = signal; this.nativeBlob = input instanceof Blob ? input : undefined; }
+  protected track(source: ReadableStream<Uint8Array> | null): ReadableStream<Uint8Array> | null {
+    if (!source) return null;
+    const disturbed = this.#disturbed;
+    let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    const stream = new ReadableStream<Uint8Array>({
+      async pull(controller) {
+        disturbed.add(stream);
+        reader ??= source.getReader();
+        try {
+          const chunk = await reader.read();
+          if (chunk.done) { reader.releaseLock(); controller.close(); }
+          else controller.enqueue(chunk.value);
+        } catch (error) { reader.releaseLock(); controller.error(error); }
+      },
+      cancel(reason) { disturbed.add(stream); return reader ? reader.cancel(reason) : source.cancel(reason); },
+    }, { highWaterMark: 0 });
+    return stream;
+  }
+  get body() { return this.data; }
+  get bodyUsed() { return this.data !== null && this.#disturbed.has(this.data); }
+  protected copyBody() {
+    if (this.bodyUsed || this.data?.locked) throw new TypeError("HTTP body has already been consumed");
+    if (!this.data) return null;
+    const [original, copy] = this.data.tee();
+    this.data = this.track(original);
+    return copy;
+  }
+  protected transferBody() {
+    if (this.bodyUsed || this.data?.locked) throw new TypeError("HTTP body has already been consumed");
+    if (this.data !== null) this.#disturbed.add(this.data);
+  }
+  protected takeBody(): ReadableStream<Uint8Array> | null {
+    this.transferBody();
+    if (!this.data) return null;
+    const reader = this.data.getReader();
+    return new ReadableStream<Uint8Array>({
+      async pull(controller) {
+        try {
+          const chunk = await reader.read();
+          if (chunk.done) { reader.releaseLock(); controller.close(); }
+          else controller.enqueue(chunk.value);
+        } catch (error) { reader.releaseLock(); controller.error(error); }
+      },
+      async cancel(reason) { try { await reader.cancel(reason); } finally { reader.releaseLock(); } },
+    }, { highWaterMark: 0 });
+  }
+  async bytes(): Promise<Uint8Array<ArrayBuffer>> {
+    this.bodySignal?.throwIfAborted();
+    this.transferBody();
+    if (!this.data) return new Uint8Array();
+    const reader = this.data.getReader();
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    try {
+      for (;;) {
+        this.bodySignal?.throwIfAborted();
+        const { value, done } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > 16 * 1024 * 1024) throw new RangeError("Buffered HTTP body exceeds 16 MiB; consume response.body incrementally");
+        chunks.push(value);
+      }
+    } catch (error) { await reader.cancel(error).catch(() => {}); throw error; }
+    finally { reader.releaseLock(); }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+    return bytes;
+  }
+  async arrayBuffer(): Promise<ArrayBuffer> { return (await this.bytes()).buffer; }
+  async text(): Promise<string> { return new TextDecoder().decode(await this.bytes()); }
+  async json(): Promise<unknown> { return JSON.parse(await this.text()); }
+  async blob() {
+    if (this.nativeBlob) { this.bodySignal?.throwIfAborted(); this.transferBody(); return this.nativeBlob; }
+    return new Blob([await this.bytes()], { type: this.contentType });
+  }
+  async formData() { return parseFormData(await this.bytes(), this.contentType); }
+}
+function setContentType(headers: Headers, body: BodyInput | null | undefined) {
+  if (headers.has("content-type")) return;
+  if (typeof body === "string") headers.set("content-type", "text/plain;charset=UTF-8");
+  else if (body instanceof Blob && body.type) headers.set("content-type", body.type);
+  else if (body instanceof URLSearchParams) headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+}
+type Init = {
+  method?: string; headers?: HeaderInput; body?: BodyInput | null;
+  signal?: AbortSignal | null; redirect?: "follow" | "error" | "manual";
+  credentials?: "omit" | "same-origin" | "include";
+};
+const requestBodies = new WeakMap<Request, Blob | undefined>();
+export class Request extends Body {
+  readonly url: string;
+  readonly method: string;
+  readonly headers: Headers;
+  readonly signal: AbortSignal;
+  readonly redirect: "follow" | "error" | "manual";
+  readonly credentials: "omit" | "same-origin" | "include";
+  constructor(input: string | URL | Request, init: Init = {}) {
+    const original = input instanceof Request ? input : undefined;
+    const supplied = init.body ?? original?.body;
+    const body = supplied instanceof FormData ? multipart(supplied) : supplied;
+    const signal = init.signal ?? original?.signal ?? new AbortController().signal;
+    super(body, signal);
+    requestBodies.set(this, body instanceof ReadableStream ? (init.body == null && original ? requestBodies.get(original) : undefined)
+      : body == null ? undefined : body instanceof Blob ? body : new Blob([body instanceof URLSearchParams ? String(body) : body]));
+    const url = new URL(original?.url ?? String(input));
+    if (url.username || url.password) throw new TypeError("HTTP URLs cannot contain credentials");
+    this.url = url.href;
+    let method = String(init.method ?? original?.method ?? "GET");
+    if (!token.test(method) || ["CONNECT", "TRACE", "TRACK"].includes(method.toUpperCase())) throw new TypeError("Invalid HTTP method");
+    if (["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"].includes(method.toUpperCase())) method = method.toUpperCase();
+    this.method = method;
+    if ((method === "GET" || method === "HEAD") && this.data !== null) throw new TypeError("GET and HEAD requests cannot have a body");
+    this.headers = new Headers(init.headers ?? original?.headers);
+    setContentType(this.headers, body);
+    this.signal = signal;
+    this.redirect = init.redirect ?? original?.redirect ?? "follow";
+    if (!["follow", "error", "manual"].includes(this.redirect)) throw new TypeError("Invalid redirect mode");
+    this.credentials = init.credentials ?? original?.credentials ?? "same-origin";
+    if (!["omit", "same-origin", "include"].includes(this.credentials)) throw new TypeError("Invalid credentials mode");
+    if (init.body == null && original) this.data = this.track(original.takeBody());
+  }
+  protected get contentType() { return this.headers.get("content-type") ?? ""; }
+  clone() {
+    const copy = new Request(this, { body: this.copyBody() });
+    requestBodies.set(copy, requestBodies.get(this));
+    return copy;
+  }
+}
+type ResponseOptions = { status?: number; statusText?: string; headers?: HeaderInput; url?: string; redirected?: boolean; signal?: AbortSignal };
+export class Response extends Body {
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: Headers;
+  readonly url: string;
+  readonly redirected: boolean;
+  readonly type = "default";
+  constructor(body?: BodyInput | null, init: ResponseOptions = {}) {
+    body = body instanceof FormData ? multipart(body) : body;
+    super(body, init.signal);
+    this.status = init.status ?? 200;
+    if (!Number.isInteger(this.status) || this.status < 200 || this.status > 599) throw new RangeError("Invalid HTTP response status");
+    if ([204, 205, 304].includes(this.status) && this.data !== null) throw new TypeError("This HTTP status cannot have a body");
+    this.statusText = init.statusText ?? "";
+    if (/[\r\n\u0100-\uffff]/.test(this.statusText)) throw new TypeError("Invalid HTTP status text");
+    this.headers = new Headers(init.headers);
+    setContentType(this.headers, body);
+    this.url = init.url ?? "";
+    this.redirected = init.redirected ?? false;
+  }
+  protected get contentType() { return this.headers.get("content-type") ?? ""; }
+  get ok() { return this.status >= 200 && this.status <= 299; }
+  clone() {
+    const result = new Response(this.copyBody(), { status: this.status, statusText: this.statusText, headers: this.headers, url: this.url, redirected: this.redirected, signal: this.bodySignal });
+    Object.defineProperty(result, "type", { value: this.type });
+    result.nativeBlob = this.nativeBlob;
+    if (immutableHeaders.has(this.headers)) immutableHeaders.add(result.headers);
+    return result;
+  }
+  static json(value: unknown, init: ResponseOptions = {}) {
+    const body = JSON.stringify(value);
+    if (body === undefined) throw new TypeError("Value cannot be serialised as JSON");
+    const headers = new Headers(init.headers);
+    if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    return new Response(body, { ...init, headers });
+  }
+  static redirect(url: string, status = 302) {
+    if (![301, 302, 303, 307, 308].includes(status)) throw new RangeError("Invalid redirect status");
+    const response = new Response(null, { status, headers: { location: new URL(url).href } });
+    immutableHeaders.add(response.headers);
+    return response;
+  }
+}
+
+export async function fetch(input: string | URL | Request, init?: Init): Promise<Response> {
+  const request = new Request(input, init);
+  if (request.url.startsWith("ink-file://")) {
+    request.signal.throwIfAborted();
+    if (request.method !== "GET" && request.method !== "HEAD") throw new TypeError("Managed files are read-only");
+    const file = JSON.parse(await callNative("files", "open", { id: request.url.slice("ink-file://".length) }, { signal: request.signal }));
+    if (!file) throw new TypeError("Managed file has been removed");
+    return new Response(request.method === "HEAD" ? null : nativeBlob(file.src, file.size, file.mimeType), {
+      url: request.url, headers: { "content-type": file.mimeType, "content-length": String(file.size) }, signal: request.signal,
+    });
+  }
+  let url = new URL(request.url);
+  let method = request.method;
+  const headers = new Headers(request.headers);
+  const replay = requestBodies.get(request);
+  let body = request.body;
+  for (let redirects = 0; ; redirects++) {
+    request.signal.throwIfAborted();
+    if (!["https:", "http:", "file:"].includes(url.protocol)) throw new TypeError("Unsupported network protocol");
+    let result;
+    try {
+      result = await requestHttp({ url: url.href, method, headers: Object.fromEntries(headers), nativeParts: body && replay ? nativeBlobParts(replay) : undefined }, body, request.signal);
+    } catch (error) {
+      request.signal.throwIfAborted();
+      throw new TypeError("Network request failed", { cause: error });
+    }
+    request.signal.throwIfAborted();
+    const responseHeaders = new Headers(result.headers);
+    const location = responseHeaders.get("location");
+    if ([301, 302, 303, 307, 308].includes(result.status) && location !== null && request.redirect !== "manual") {
+      await result.body?.cancel();
+      if (request.redirect === "error" || redirects >= 20) throw new TypeError("HTTP redirect was not allowed");
+      const next = new URL(location, url);
+      if (next.username || next.password) throw new TypeError("HTTP redirect contains credentials");
+      if (next.origin !== url.origin) {
+        for (const name of ["authorization", "proxy-authorization", "cookie", "cookie2", "host"]) headers.delete(name);
+      }
+      if (([301, 302].includes(result.status) && method === "POST") || (result.status === 303 && method !== "GET" && method !== "HEAD")) {
+        method = "GET";
+        body = null;
+        for (const name of ["content-type", "content-length", "content-encoding", "content-language", "content-location"]) headers.delete(name);
+      }
+      if (body !== null) {
+        body = replay?.stream() ?? null;
+        if (body === null) throw new TypeError("Cannot replay a streaming upload after an HTTP redirect");
+      }
+      url = next;
+      continue;
+    }
+    const responseBody = method === "HEAD" || [204, 205, 304].includes(result.status) ? null : result.body;
+    if (responseBody === null) await result.body?.cancel();
+    const response = new Response(responseBody, { status: result.status, statusText: result.statusText, headers: responseHeaders, url: result.url, redirected: redirects > 0, signal: request.signal });
+    Object.defineProperty(response, "type", { value: "basic" });
+    immutableHeaders.add(response.headers);
+    return response;
+  }
+}

package/src/http.ts

@@ -0,0 +1,89 @@
+import { ReadableStream } from "web-streams-polyfill";
+import { callNative, callNativeBytes, NativeError } from "ink/native";
+
+interface HttpRequest { url: string; method: string; headers: Readonly<Record<string, string>>; nativeParts?: Iterable<{ bytes: Uint8Array } | { src: string; offset: number; size: number }> }
+interface HttpResponse { status: number; statusText: string; url: string; headers: [string, string][]; body: ReadableStream<Uint8Array> | null }
+
+export async function requestHttp(request: HttpRequest, body: ReadableStream<Uint8Array> | null, signal: AbortSignal): Promise<HttpResponse> {
+  let upload: string | undefined;
+  if (body) {
+    upload = await callNative("network", "stream-upload-open", { managed: request.nativeParts !== undefined }, { signal });
+    const reader = request.nativeParts ? undefined : body.getReader();
+    let rejectAbort: (reason: unknown) => void = () => {};
+    const aborted = new Promise<never>((_, reject) => { rejectAbort = reject; });
+    const abort = () => {
+      if (reader) rejectAbort(signal.reason);
+      void reader?.cancel(signal.reason).catch(() => {});
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    try {
+      if (request.nativeParts) {
+        for (const part of request.nativeParts) {
+          if ("bytes" in part) await callNativeBytes("network", "stream-upload-write", { upload }, { signal, bytes: part.bytes });
+          else await callNative("network", "stream-upload-file", { upload, src: part.src, offset: part.offset, size: part.size }, { signal });
+        }
+      } else if (reader) {
+        for (;;) {
+          const { value, done } = await Promise.race([reader.read(), aborted]);
+          if (signal.aborted) throw signal.reason;
+          if (done) break;
+          if (!(value instanceof Uint8Array)) throw new TypeError("Upload streams must contain Uint8Array chunks");
+          for (let offset = 0; offset < value.length; offset += 32 * 1024) {
+            await callNativeBytes("network", "stream-upload-write", { upload }, { signal, bytes: value.subarray(offset, offset + 32 * 1024) });
+          }
+        }
+      }
+    } catch (error) {
+      void reader?.cancel(error).catch(() => {});
+      void callNative("network", "stream-upload-close", { upload }).catch(() => {});
+      throw error;
+    } finally {
+      signal.removeEventListener("abort", abort);
+      reader?.releaseLock();
+    }
+  }
+  let value: unknown;
+  try { value = JSON.parse(await callNative("network", "stream-open", { url: request.url, method: request.method, headers: request.headers, upload }, { signal })); }
+  catch (error) {
+    if (upload) await callNative("network", "stream-upload-close", { upload }).catch(() => {});
+    throw error;
+  }
+  if (typeof value !== "object" || value === null
+    || !("status" in value) || typeof value.status !== "number"
+    || !("statusText" in value) || typeof value.statusText !== "string"
+    || !("url" in value) || typeof value.url !== "string"
+    || !("headers" in value) || !Array.isArray(value.headers)
+    || !("stream" in value) || typeof value.stream !== "string") throw new NativeError("protocol", "Invalid HTTP response");
+  const headers = value.headers.map((entry: unknown): [string, string] => {
+    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || typeof entry[1] !== "string") throw new NativeError("protocol", "Invalid HTTP response header");
+    return [entry[0], entry[1]];
+  });
+  const stream = value.stream;
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    signal.removeEventListener("abort", abort);
+    await callNative("network", "stream-close", { stream });
+  };
+  let abort = () => {};
+  const responseBody = new ReadableStream<Uint8Array>({
+    start(controller) {
+      abort = () => { controller.error(signal.reason); void close().catch(() => {}); };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) abort();
+    },
+    async pull(controller) {
+      try {
+        const result = await callNativeBytes("network", "stream-read-bytes", { stream }, { signal });
+        const chunk: unknown = JSON.parse(result.value);
+        if (typeof chunk !== "object" || chunk === null || !("done" in chunk) || typeof chunk.done !== "boolean") throw new NativeError("protocol", "Invalid HTTP stream chunk");
+        if (chunk.done) { await close(); controller.close(); }
+        else controller.enqueue(result.bytes);
+      } catch (error) { await close().catch(() => {}); controller.error(error); }
+    },
+    cancel: close,
+  }, { highWaterMark: 0 });
+  return { status: value.status, statusText: value.statusText, url: value.url, headers, body: responseBody };
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+/// <reference path="../runtime.d.ts" />
+export {};
+
+// The bundler keeps this synchronous dependency uninitialised until first access.
+declare function require(path: "./web-globals"): typeof import("./web-globals");
+
+const names = [
+  "Blob", "File", "FormData", "ReadableStream", "WritableStream", "TransformStream",
+  "ByteLengthQueuingStrategy", "CountQueuingStrategy", "WebSocket", "MessageEvent",
+  "CloseEvent", "URL", "URLSearchParams", "fetch", "Headers", "Request", "Response",
+] as const;
+
+for (const name of names) {
+  Object.defineProperty(globalThis, name, {
+    configurable: true,
+    get() {
+      const value = require("./web-globals")[name];
+      Object.defineProperty(globalThis, name, { value, writable: true, configurable: true });
+      return value;
+    },
+    set(value) {
+      Object.defineProperty(globalThis, name, { value, writable: true, configurable: true });
+    },
+  });
+}

package/src/web-globals.ts

@@ -0,0 +1,5 @@
+export { ReadableStream, WritableStream, TransformStream, ByteLengthQueuingStrategy, CountQueuingStrategy } from "web-streams-polyfill";
+export { Blob, File, FormData } from "./blob";
+export { WebSocket, MessageEvent, CloseEvent } from "./websocket";
+export { URL, URLSearchParams } from "whatwg-url";
+export { fetch, Headers, Request, Response } from "./fetch";

package/src/websocket.ts

@@ -0,0 +1,136 @@
+import { URL } from "whatwg-url";
+import { Blob } from "./blob";
+import { callNative, callNativeBytes } from "ink/native";
+
+export class MessageEvent extends Event {
+  readonly data: unknown;
+  readonly origin: string;
+  readonly lastEventId: string;
+  readonly source = null;
+  readonly ports: readonly unknown[] = [];
+  constructor(type: string, options: EventInit & { data?: unknown; origin?: string; lastEventId?: string } = {}) {
+    super(type, options);
+    this.data = options.data ?? null;
+    this.origin = options.origin ?? "";
+    this.lastEventId = options.lastEventId ?? "";
+  }
+}
+export class CloseEvent extends Event {
+  readonly code: number;
+  readonly reason: string;
+  readonly wasClean: boolean;
+  constructor(type: string, options: EventInit & { code?: number; reason?: string; wasClean?: boolean } = {}) {
+    super(type, options);
+    this.code = options.code ?? 0;
+    this.reason = options.reason ?? "";
+    this.wasClean = options.wasClean ?? false;
+  }
+}
+
+export class WebSocket extends EventTarget {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+  readonly url: string;
+  readonly extensions = "";
+  protocol = "";
+  binaryType: "blob" | "arraybuffer" = "blob";
+  readyState = WebSocket.CONNECTING;
+  onopen: ((event: Event) => void) | null = null;
+  onmessage: ((event: MessageEvent) => void) | null = null;
+  onerror: ((event: Event) => void) | null = null;
+  onclose: ((event: CloseEvent) => void) | null = null;
+  #socket: Promise<string>;
+  #outgoing = Promise.resolve();
+  #queued = 0;
+  #nativeQueued = 0;
+  constructor(url: string | URL, protocols: string | string[] = []) {
+    super();
+    const parsed = new URL(String(url));
+    if (parsed.protocol === "https:") parsed.protocol = "wss:";
+    if ((parsed.protocol !== "wss:" && !(parsed.protocol === "ws:" && ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname))) || parsed.hash || parsed.username || parsed.password) throw new DOMException("WebSocket requires a WSS URL without credentials or fragments", "SyntaxError");
+    const names = typeof protocols === "string" ? [protocols] : protocols;
+    if (new Set(names).size !== names.length || names.some(name => !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name))) throw new DOMException("Invalid WebSocket protocols", "SyntaxError");
+    this.url = parsed.href;
+    this.#socket = callNative("network", "socket-open", { url: this.url, protocols: names });
+    void this.#receive();
+  }
+  get bufferedAmount() { return this.#queued + this.#nativeQueued; }
+  #dispatch(type: string, properties: Record<string, unknown> = {}) {
+    const event = type === "message" ? new MessageEvent(type, { data: properties.data, origin: String(properties.origin ?? "") })
+      : type === "close" ? new CloseEvent(type, { code: Number(properties.code), reason: String(properties.reason), wasClean: properties.wasClean === true })
+      : new Event(type);
+    if (type !== "message" && type !== "close") Object.defineProperties(event, Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, { value }])));
+    this.dispatchEvent(event);
+    try {
+      if (type === "open") this.onopen?.(event);
+      else if (type === "error") this.onerror?.(event);
+      else if (event instanceof MessageEvent) this.onmessage?.(event);
+      else if (event instanceof CloseEvent) this.onclose?.(event);
+    } catch (error) { console.error(error); }
+  }
+  async #receive() {
+    try {
+      const socket = await this.#socket;
+      while (this.readyState !== WebSocket.CLOSED) {
+        const result = await callNativeBytes("network", "socket-read-bytes", { socket });
+        const batch: { events: Record<string, unknown>[]; bufferedAmount: number } = JSON.parse(result.value);
+        this.#nativeQueued = batch.bufferedAmount;
+        for (const event of batch.events) {
+          if (event.type === "open") {
+            if (this.readyState !== WebSocket.CONNECTING) continue;
+            this.readyState = WebSocket.OPEN;
+            this.protocol = String(event.protocol);
+            this.#dispatch("open");
+          } else if (event.type === "message" && this.readyState === WebSocket.OPEN) {
+            let data: string | Blob | ArrayBuffer;
+            if (typeof event.text === "string") data = event.text;
+            else {
+              const offset = Number(event.offset), length = Number(event.length);
+              if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > result.bytes.length) throw new TypeError("Invalid WebSocket binary range");
+              const bytes = result.bytes.subarray(offset, offset + length);
+              data = this.binaryType === "arraybuffer" ? new Uint8Array(bytes).buffer : new Blob([bytes]);
+            }
+            this.#dispatch("message", { data, origin: new URL(this.url).origin, lastEventId: "", ports: [] });
+          } else if (event.type === "error") this.#dispatch("error", { message: event.message });
+          else if (event.type === "close") {
+            this.readyState = WebSocket.CLOSED;
+            this.#dispatch("close", { code: event.code, reason: event.reason, wasClean: event.wasClean });
+          }
+        }
+      }
+    } catch (error) {
+      if (this.readyState !== WebSocket.CLOSED) {
+        this.readyState = WebSocket.CLOSED;
+        this.#dispatch("error", { error });
+        this.#dispatch("close", { code: 1006, reason: "", wasClean: false });
+      }
+    } finally {
+      await this.#socket.then(socket => callNative("network", "socket-dispose", { socket })).catch(() => {});
+    }
+  }
+  send(data: string | ArrayBuffer | ArrayBufferView | Blob) {
+    if (this.readyState === WebSocket.CONNECTING) throw new DOMException("WebSocket is connecting", "InvalidStateError");
+    const blob = data instanceof Blob ? data : new Blob([data]);
+    if (blob.size > 256 * 1024 || this.bufferedAmount + blob.size > 512 * 1024) throw new RangeError("WebSocket send queue exceeds its limit");
+    this.#queued += blob.size;
+    if (this.readyState !== WebSocket.OPEN) return;
+    this.#outgoing = this.#outgoing.then(async () => {
+      try {
+        this.#nativeQueued = Number((await callNativeBytes("network", "socket-send", { socket: await this.#socket, text: typeof data === "string" }, { bytes: await blob.bytes() })).value);
+      } finally { this.#queued -= blob.size; }
+    }).catch(error => { this.#dispatch("error", { error }); this.close(); });
+  }
+  close(code = 1000, reason = "") {
+    if (code !== 1000 && (code < 3000 || code > 4999 || !Number.isInteger(code))) throw new DOMException("Invalid WebSocket close code", "InvalidAccessError");
+    if (new TextEncoder().encode(reason).length > 123) throw new DOMException("WebSocket close reason exceeds 123 bytes", "SyntaxError");
+    if (this.readyState >= WebSocket.CLOSING) return;
+    this.readyState = WebSocket.CLOSING;
+    void this.#outgoing.then(async () => callNative("network", "socket-close", { socket: await this.#socket, code, reason })).catch(() => {});
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.