@seanhogg/builderforce-webcontainers-core 2026.10.2 → 2026.10.3

package/src/node/http/client.ts

@@ -0,0 +1,173 @@
+/**
+ * Outbound HTTP: `http.request`/`http.get` (ClientRequest → IncomingMessage) and
+ * the `fetch` global a program sees. Requests to localhost reach this runtime's
+ * own virtual servers (`loopback`); everything else goes through the browser's
+ * fetch, so CORS applies — a public API without CORS headers is unreachable
+ * from a browser page, and no shim can change that.
+ */
+import { Buffer } from '../buffer.js';
+import type { EventLoop } from '../loop.js';
+import type { HttpRequestData, System } from '../../system/types.js';
+import { FakeSocket, IncomingMessage, OutgoingHeaders } from './server.js';
+
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '0.0.0.0', '::1', '[::1]']);
+/** Headers a browser refuses to let script set; dropping them beats a TypeError. */
+const FORBIDDEN = new Set(['host', 'connection', 'content-length', 'keep-alive', 'transfer-encoding', 'upgrade', 'expect', 'te', 'trailer', 'proxy-connection']);
+
+export interface ClientDeps {
+  system: System;
+  loop: EventLoop;
+}
+
+interface RequestOptions {
+  protocol?: string;
+  host?: string;
+  hostname?: string;
+  port?: number | string;
+  path?: string;
+  method?: string;
+  headers?: Record<string, string | number | string[]>;
+  auth?: string;
+  timeout?: number;
+  signal?: AbortSignal;
+}
+
+function toOptions(input: unknown, extra: unknown, defaultProtocol: string): RequestOptions {
+  let options: RequestOptions = {};
+  if (typeof input === 'string' || input instanceof URL) {
+    const url = new URL(String(input));
+    options = { protocol: url.protocol, hostname: url.hostname.replace(/^\[|\]$/g, ''), port: url.port, path: url.pathname + url.search, auth: url.username ? `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}` : undefined };
+    if (extra && typeof extra === 'object') options = { ...options, ...(extra as RequestOptions) };
+  } else if (input && typeof input === 'object') options = { ...(input as RequestOptions) };
+  options.protocol ??= defaultProtocol;
+  if (!options.hostname && options.host) {
+    const [h, p] = options.host.split(':');
+    options.hostname = h;
+    options.port ??= p;
+  }
+  options.hostname ??= 'localhost';
+  options.path ??= '/';
+  options.method = (options.method ?? 'GET').toUpperCase();
+  return options;
+}
+
+export function isLocalHost(hostname: string): boolean {
+  return LOCAL_HOSTS.has(hostname.toLowerCase());
+}
+
+function headersToRecord(headers: Headers): Record<string, string> {
+  const out: Record<string, string> = {};
+  headers.forEach((value, key) => (out[key] = value));
+  return out;
+}
+
+/** Perform a request against loopback or the network; returns a Fetch Response. */
+export async function sendRequest(system: System, url: URL, request: HttpRequestData, signal?: AbortSignal): Promise<Response> {
+  if (isLocalHost(url.hostname)) {
+    const port = Number(url.port || (url.protocol === 'https:' ? 443 : 80));
+    const reply = await system.loopback(port, request);
+    if (!reply) throw Object.assign(new Error(`connect ECONNREFUSED 127.0.0.1:${port}`), { code: 'ECONNREFUSED', errno: -111, syscall: 'connect', address: '127.0.0.1', port });
+    const headers = new Headers();
+    for (const [k, v] of Object.entries(reply.headers)) for (const item of Array.isArray(v) ? v : [v]) headers.append(k, String(item));
+    const empty = reply.status === 204 || reply.status === 304 || request.method === 'HEAD';
+    return new Response(empty ? null : (reply.body as unknown as BodyInit), { status: reply.status, statusText: reply.statusText, headers });
+  }
+  const headers: Record<string, string> = {};
+  for (const [k, v] of Object.entries(request.headers)) if (!FORBIDDEN.has(k.toLowerCase())) headers[k] = v;
+  const hasBody = request.body && request.method !== 'GET' && request.method !== 'HEAD';
+  return system.fetch(url.href, { method: request.method, headers, body: hasBody ? (request.body as unknown as BodyInit) : undefined, signal });
+}
+
+export class ClientRequest extends OutgoingHeaders {
+  method: string;
+  path: string;
+  host: string;
+  protocol: string;
+  aborted = false;
+  reusedSocket = false;
+  socket = new FakeSocket();
+  connection = this.socket;
+  private readonly chunks: Uint8Array[] = [];
+  private readonly controller = new AbortController();
+  private readonly options: RequestOptions;
+
+  constructor(private readonly deps: ClientDeps, input: unknown, extra: unknown, callback: ((res: IncomingMessage) => void) | undefined, defaultProtocol: string) {
+    super({ decodeStrings: true });
+    if (typeof extra === 'function') [callback, extra] = [extra as typeof callback, undefined];
+    this.options = toOptions(input, extra, defaultProtocol);
+    this.method = this.options.method!;
+    this.path = this.options.path!;
+    this.host = this.options.hostname!;
+    this.protocol = this.options.protocol!;
+    for (const [k, v] of Object.entries(this.options.headers ?? {})) this.setHeader(k, v as string);
+    if (this.options.auth && !this.hasHeader('authorization')) this.setHeader('authorization', `Basic ${Buffer.from(this.options.auth).toString('base64')}`);
+    if (callback) this.once('response', callback);
+    this.options.signal?.addEventListener('abort', () => this.destroy(Object.assign(new Error('The operation was aborted'), { name: 'AbortError', code: 'ABORT_ERR' })));
+  }
+
+  override _write(chunk: Uint8Array, _encoding: string, callback: () => void): void {
+    this.chunks.push(chunk);
+    callback();
+  }
+
+  override _final(callback: () => void): void {
+    this.headersSent = true;
+    callback();
+    void this.perform();
+  }
+
+  abort(): void {
+    this.aborted = true;
+    this.controller.abort();
+    this.emit('abort');
+    this.destroy();
+  }
+
+  override destroy(error?: Error | null): this {
+    this.controller.abort();
+    return super.destroy(error);
+  }
+
+  setNoDelay(): void {}
+  setSocketKeepAlive(): void {}
+
+  private async perform(): Promise<void> {
+    const release = this.deps.loop.hold();
+    try {
+      const port = this.options.port ? `:${this.options.port}` : '';
+      const host = this.host.includes(':') ? `[${this.host}]` : this.host;
+      const url = new URL(`${this.protocol}//${host}${port}${this.path}`);
+      const headers: Record<string, string> = {};
+      for (const [k, v] of Object.entries(this.getHeaders())) headers[k] = Array.isArray(v) ? v.join(', ') : String(v);
+      const body = this.chunks.length ? Buffer.concat(this.chunks) : null;
+      const response = await sendRequest(this.deps.system, url, { method: this.method, url: this.path, headers, body }, this.controller.signal);
+      const res = new IncomingMessage(this.socket);
+      res.statusCode = response.status;
+      res.statusMessage = response.statusText;
+      res._fill(headersToRecord(response.headers), new Uint8Array(await response.arrayBuffer()));
+      this.deps.loop._run(() => {
+        if (!this.emit('response', res)) res.resume();
+      });
+    } catch (error) {
+      if (!this.aborted) this.deps.loop._run(() => this.emit('error', error));
+    } finally {
+      release();
+    }
+  }
+}
+
+/** The `fetch` a program sees: loopback-aware and counted as pending work. */
+export function createFetch(deps: ClientDeps): typeof fetch {
+  return async (input: RequestInfo | URL, init?: RequestInit) => {
+    const release = deps.loop.hold();
+    try {
+      const request = new Request(input instanceof URL ? input.href : input, init);
+      const url = new URL(request.url);
+      if (!isLocalHost(url.hostname)) return await deps.system.fetch(url.href, init ?? (typeof input === 'object' && !(input instanceof URL) ? { method: request.method, headers: request.headers, body: request.body, signal: request.signal } : undefined));
+      const body = request.method === 'GET' || request.method === 'HEAD' ? null : new Uint8Array(await request.arrayBuffer());
+      return await sendRequest(deps.system, url, { method: request.method, url: url.pathname + url.search, headers: headersToRecord(request.headers), body });
+    } finally {
+      release();
+    }
+  };
+}

package/src/node/http/index.ts

@@ -0,0 +1,122 @@
+/**
+ * The `http`, `https` and `net` module objects. `https.createServer` is the
+ * same virtual server (TLS is the preview origin's job); `net` offers just
+ * enough — `isIP*` and a port-reserving `createServer` — for the port-probing
+ * helpers (get-port, detect-port) dev tools run before listening.
+ */
+import { EventEmitterBase } from '../events.js';
+import { ClientRequest, createFetch, type ClientDeps } from './client.js';
+import { FakeSocket, IncomingMessage, OutgoingHeaders, Server, ServerResponse } from './server.js';
+import { METHODS, STATUS_CODES } from './status.js';
+
+export { createFetch };
+
+class Agent extends EventEmitterBase {
+  maxSockets = Infinity;
+  maxFreeSockets = 256;
+  sockets = {};
+  requests = {};
+  freeSockets = {};
+  constructor(readonly options: Record<string, unknown> = {}) {
+    super();
+  }
+  destroy(): void {}
+}
+
+export function createHttpModule(deps: ClientDeps, protocol: 'http:' | 'https:'): Record<string, unknown> {
+  const request = (input: unknown, extra?: unknown, callback?: (res: IncomingMessage) => void) => new ClientRequest(deps, input, extra, callback, protocol);
+  const get = (input: unknown, extra?: unknown, callback?: (res: IncomingMessage) => void) => {
+    const req = request(input, extra, callback);
+    req.end();
+    return req;
+  };
+  const globalAgent = new Agent();
+  return {
+    createServer: (options?: unknown, listener?: (req: IncomingMessage, res: ServerResponse) => void) => new Server(deps, options, listener),
+    request,
+    get,
+    Server: class extends Server {
+      constructor(options?: unknown, listener?: (req: IncomingMessage, res: ServerResponse) => void) {
+        super(deps, options, listener);
+      }
+    },
+    IncomingMessage,
+    ServerResponse,
+    OutgoingMessage: OutgoingHeaders,
+    ClientRequest,
+    Agent,
+    globalAgent,
+    STATUS_CODES,
+    METHODS,
+    maxHeaderSize: 16384,
+    validateHeaderName(name: string) {
+      if (!/^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/.test(name)) throw Object.assign(new TypeError(`Header name must be a valid HTTP token ["${name}"]`), { code: 'ERR_INVALID_HTTP_TOKEN' });
+    },
+    validateHeaderValue(name: string, value: unknown) {
+      if (value === undefined) throw Object.assign(new TypeError(`Invalid value "undefined" for header "${name}"`), { code: 'ERR_HTTP_INVALID_HEADER_VALUE' });
+    },
+    setMaxIdleHTTPParsers: () => undefined,
+  };
+}
+
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/;
+const IPV6 = /^(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$/i;
+
+export function createNetModule(deps: ClientDeps): Record<string, unknown> {
+  /** A TCP server cannot exist here; one that only RESERVES its port keeps port probes truthful. */
+  class NetServer extends EventEmitterBase {
+    private reservation?: { port: number; close(): void };
+    private release?: () => void;
+    listening = false;
+    listen(...args: unknown[]): this {
+      const callback = typeof args[args.length - 1] === 'function' ? (args.pop() as () => void) : undefined;
+      const first = args[0];
+      const port = typeof first === 'object' && first ? Number((first as { port?: number }).port ?? 0) : Number(first ?? 0);
+      if (callback) this.once('listening', callback);
+      try {
+        this.reservation = deps.system.listen(port, async () => ({ status: 502, headers: { 'content-type': 'text/plain' }, body: new TextEncoder().encode('Not an HTTP server') }));
+      } catch (error) {
+        queueMicrotask(() => this.emit('error', error));
+        return this;
+      }
+      this.listening = true;
+      this.release = deps.loop.hold();
+      queueMicrotask(() => this.emit('listening'));
+      return this;
+    }
+    address() {
+      return this.reservation ? { address: '::', family: 'IPv6', port: this.reservation.port } : null;
+    }
+    close(callback?: () => void): this {
+      this.reservation?.close();
+      this.reservation = undefined;
+      this.listening = false;
+      this.release?.();
+      if (callback) this.once('close', callback);
+      queueMicrotask(() => this.emit('close'));
+      return this;
+    }
+    ref(): this { return this; }
+    unref(): this {
+      this.release?.();
+      this.release = undefined;
+      return this;
+    }
+  }
+  const noTcp = () => {
+    throw Object.assign(new Error('Raw TCP sockets are not available in the browser runtime'), { code: 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM' });
+  };
+  return {
+    createServer: () => new NetServer(),
+    Server: NetServer,
+    Socket: FakeSocket,
+    Stream: FakeSocket,
+    connect: noTcp,
+    createConnection: noTcp,
+    isIP: (s: string) => (IPV4.test(s) ? 4 : IPV6.test(s) ? 6 : 0),
+    isIPv4: (s: string) => IPV4.test(s),
+    isIPv6: (s: string) => IPV6.test(s),
+    getDefaultAutoSelectFamily: () => true,
+    setDefaultAutoSelectFamily: () => undefined,
+  };
+}

package/src/node/http/server.ts

@@ -0,0 +1,308 @@
+/**
+ * `http.createServer` on a virtual port. `listen(port)` registers a handler with
+ * the system; each request arrives as plain data (from the preview service
+ * worker, or `loopback` from inside the runtime), becomes an IncomingMessage /
+ * ServerResponse pair for the app, and the finished response goes back as data.
+ * Responses are buffered: streaming (SSE, long-polling) arrives in one piece.
+ */
+import { EventEmitterBase } from '../events.js';
+import { Buffer } from '../buffer.js';
+import { Readable } from '../stream/readable.js';
+import { Writable } from '../stream/writable.js';
+import type { EventLoop } from '../loop.js';
+import type { HttpRequestData, HttpResponseData, System } from '../../system/types.js';
+import { STATUS_CODES } from './status.js';
+
+/** Enough of net.Socket for frameworks that read connection details. */
+export class FakeSocket extends EventEmitterBase {
+  remoteAddress = '127.0.0.1';
+  remotePort = 50000 + Math.floor(Math.random() * 10000);
+  remoteFamily = 'IPv4';
+  localAddress = '127.0.0.1';
+  localPort: number;
+  encrypted = false;
+  readable = true;
+  writable = true;
+  destroyed = false;
+  bytesRead = 0;
+  bytesWritten = 0;
+  constructor(port = 0) {
+    super();
+    this.localPort = port;
+  }
+  setTimeout(_ms: number, cb?: () => void): this { if (cb) this.once('timeout', cb); return this; }
+  setNoDelay(): this { return this; }
+  setKeepAlive(): this { return this; }
+  address() { return { address: this.localAddress, family: 'IPv4', port: this.localPort }; }
+  ref(): this { return this; }
+  unref(): this { return this; }
+  cork(): void {}
+  uncork(): void {}
+  write(): boolean { return true; }
+  end(): this { return this; }
+  destroy(): this {
+    this.destroyed = true;
+    return this;
+  }
+}
+
+function lowerHeaders(headers: Record<string, string>): { headers: Record<string, string | string[]>; raw: string[] } {
+  const out: Record<string, string | string[]> = {};
+  const raw: string[] = [];
+  for (const [key, value] of Object.entries(headers)) {
+    const k = key.toLowerCase();
+    raw.push(key, value);
+    out[k] = k === 'set-cookie' ? [value] : value;
+  }
+  return { headers: out, raw };
+}
+
+export class IncomingMessage extends Readable {
+  httpVersion = '1.1';
+  httpVersionMajor = 1;
+  httpVersionMinor = 1;
+  method?: string;
+  url?: string;
+  statusCode?: number;
+  statusMessage?: string;
+  headers: Record<string, string | string[]> = {};
+  rawHeaders: string[] = [];
+  trailers: Record<string, string> = {};
+  rawTrailers: string[] = [];
+  complete = false;
+  aborted = false;
+  socket: FakeSocket;
+  connection: FakeSocket;
+
+  constructor(socket: FakeSocket = new FakeSocket()) {
+    super();
+    this.socket = socket;
+    this.connection = socket;
+  }
+
+  override _read(): void {
+    // the body is pushed up front
+  }
+
+  setTimeout(_ms: number, cb?: () => void): this {
+    if (cb) this.once('timeout', cb);
+    return this;
+  }
+
+  /** Fill from wire data; `body` null means none. */
+  _fill(headers: Record<string, string>, body: Uint8Array | null): void {
+    const { headers: lower, raw } = lowerHeaders(headers);
+    this.headers = lower;
+    this.rawHeaders = raw;
+    if (body?.length) this.push(Buffer.from(body));
+    this.push(null);
+    this.complete = true;
+  }
+}
+
+export class OutgoingHeaders extends Writable {
+  protected _headers = new Map<string, { name: string; value: string | string[] }>();
+  headersSent = false;
+  sendDate = true;
+
+  setHeader(name: string, value: string | number | readonly string[]): this {
+    if (this.headersSent) throw Object.assign(new Error('Cannot set headers after they are sent to the client'), { code: 'ERR_HTTP_HEADERS_SENT' });
+    this._headers.set(name.toLowerCase(), { name, value: Array.isArray(value) ? value.map(String) : String(value) });
+    return this;
+  }
+  appendHeader(name: string, value: string | readonly string[]): this {
+    const existing = this.getHeader(name);
+    const list = [...(existing === undefined ? [] : Array.isArray(existing) ? existing : [String(existing)]), ...(Array.isArray(value) ? value : [value as string])];
+    return this.setHeader(name, list);
+  }
+  getHeader(name: string): string | string[] | undefined {
+    return this._headers.get(name.toLowerCase())?.value;
+  }
+  getHeaders(): Record<string, string | string[]> {
+    const out: Record<string, string | string[]> = Object.create(null);
+    for (const [key, { value }] of this._headers) out[key] = value;
+    return out;
+  }
+  getHeaderNames(): string[] {
+    return [...this._headers.keys()];
+  }
+  getRawHeaderNames(): string[] {
+    return [...this._headers.values()].map((h) => h.name);
+  }
+  hasHeader(name: string): boolean {
+    return this._headers.has(name.toLowerCase());
+  }
+  removeHeader(name: string): void {
+    this._headers.delete(name.toLowerCase());
+  }
+  flushHeaders(): void {
+    this.headersSent = true;
+  }
+  setTimeout(_ms: number, cb?: () => void): this {
+    if (cb) this.once('timeout', cb);
+    return this;
+  }
+}
+
+export class ServerResponse extends OutgoingHeaders {
+  statusCode = 200;
+  statusMessage = '';
+  req: IncomingMessage;
+  socket: FakeSocket;
+  connection: FakeSocket;
+  chunkedEncoding = false;
+  shouldKeepAlive = false;
+  private readonly chunks: Uint8Array[] = [];
+
+  constructor(req: IncomingMessage, private readonly onDone: (response: HttpResponseData) => void) {
+    super({ decodeStrings: true });
+    this.req = req;
+    this.socket = req.socket;
+    this.connection = req.socket;
+  }
+
+  get finished(): boolean {
+    return this.writableEnded;
+  }
+
+  writeHead(status: number, message?: string | Record<string, unknown> | unknown[], headers?: Record<string, unknown> | unknown[]): this {
+    if (typeof message !== 'string') [headers, message] = [message, undefined];
+    this.statusCode = status;
+    if (message) this.statusMessage = message;
+    if (Array.isArray(headers)) {
+      for (let i = 0; i + 1 < headers.length; i += 2) this.setHeader(String(headers[i]), headers[i + 1] as string);
+    } else if (headers) {
+      for (const [k, v] of Object.entries(headers)) if (v !== undefined) this.setHeader(k, v as string);
+    }
+    this.headersSent = true;
+    return this;
+  }
+  writeContinue(): void {}
+  writeProcessing(): void {}
+  writeEarlyHints(): void {}
+  addTrailers(): void {}
+  assignSocket(): void {}
+  detachSocket(): void {}
+
+  override _write(chunk: Uint8Array, _encoding: string, callback: () => void): void {
+    this.headersSent = true;
+    this.chunks.push(chunk);
+    callback();
+  }
+
+  override _final(callback: () => void): void {
+    this.headersSent = true;
+    const headers: Record<string, string | string[]> = {};
+    for (const { name, value } of this._headers.values()) headers[name] = value;
+    const body = Buffer.concat(this.chunks);
+    if (this.req.method === 'HEAD') this.chunks.length = 0;
+    this.onDone({ status: this.statusCode, statusText: this.statusMessage || STATUS_CODES[this.statusCode] || '', headers, body: this.req.method === 'HEAD' ? new Uint8Array() : body });
+    callback();
+  }
+}
+
+export interface ServerDeps {
+  system: System;
+  loop: EventLoop;
+}
+
+export class Server extends EventEmitterBase {
+  listening = false;
+  timeout = 0;
+  keepAliveTimeout = 5000;
+  headersTimeout = 60000;
+  requestTimeout = 300000;
+  maxHeadersCount: number | null = null;
+  private registration?: { port: number; close(): void };
+  private release?: () => void;
+
+  constructor(private readonly deps: ServerDeps, options?: unknown, listener?: (req: IncomingMessage, res: ServerResponse) => void) {
+    super();
+    if (typeof options === 'function') listener = options as typeof listener;
+    if (listener) this.on('request', listener);
+  }
+
+  listen(...args: unknown[]): this {
+    const callback = typeof args[args.length - 1] === 'function' ? (args.pop() as () => void) : undefined;
+    const first = args[0];
+    const port = typeof first === 'object' && first ? Number((first as { port?: number }).port ?? 0) : Number(first ?? 0);
+    if (callback) this.once('listening', callback);
+    try {
+      this.registration = this.deps.system.listen(port, (request) => this.handle(request));
+    } catch (error) {
+      queueMicrotask(() => this.emit('error', error));
+      return this;
+    }
+    this.listening = true;
+    this.release = this.deps.loop.hold();
+    queueMicrotask(() => this.emit('listening'));
+    return this;
+  }
+
+  address(): { address: string; family: string; port: number } | null {
+    return this.registration ? { address: '::', family: 'IPv6', port: this.registration.port } : null;
+  }
+
+  close(callback?: (error?: Error) => void): this {
+    if (!this.registration) {
+      if (callback) queueMicrotask(() => callback(Object.assign(new Error('Server is not running.'), { code: 'ERR_SERVER_NOT_RUNNING' })));
+      return this;
+    }
+    this.registration.close();
+    this.registration = undefined;
+    this.listening = false;
+    this.release?.();
+    this.release = undefined;
+    if (callback) this.once('close', callback);
+    queueMicrotask(() => this.emit('close'));
+    return this;
+  }
+
+  closeAllConnections(): void {}
+  closeIdleConnections(): void {}
+  setTimeout(ms = 0, cb?: () => void): this {
+    this.timeout = ms;
+    if (cb) this.on('timeout', cb);
+    return this;
+  }
+  ref(): this {
+    if (this.registration && !this.release) this.release = this.deps.loop.hold();
+    return this;
+  }
+  unref(): this {
+    this.release?.();
+    this.release = undefined;
+    return this;
+  }
+  getConnections(cb: (error: null, count: number) => void): void {
+    cb(null, 0);
+  }
+
+  private handle(request: HttpRequestData): Promise<HttpResponseData> {
+    return new Promise((resolve) => {
+      const socket = new FakeSocket(this.registration?.port ?? 0);
+      const req = new IncomingMessage(socket);
+      req.method = request.method.toUpperCase();
+      req.url = request.url;
+      // Body parsers (body-parser/type-is) only read a body announced by
+      // content-length or transfer-encoding; a browser-originated request
+      // relayed by the service worker carries neither.
+      const headers = { ...request.headers };
+      const announced = Object.keys(headers).some((k) => /^(content-length|transfer-encoding)$/i.test(k));
+      if (!announced && request.body?.length) headers['content-length'] = String(request.body.length);
+      req._fill(headers, request.body);
+      const res = new ServerResponse(req, resolve);
+      this.deps.loop._run(() => {
+        try {
+          this.emit('request', req, res);
+        } catch (error) {
+          if (!res.writableEnded) {
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+          }
+          throw error;
+        }
+      });
+    });
+  }
+}

package/src/node/http/status.ts

@@ -0,0 +1,13 @@
+export const STATUS_CODES: Record<number, string> = {
+  100: 'Continue', 101: 'Switching Protocols', 102: 'Processing', 103: 'Early Hints',
+  200: 'OK', 201: 'Created', 202: 'Accepted', 203: 'Non-Authoritative Information', 204: 'No Content', 205: 'Reset Content', 206: 'Partial Content', 207: 'Multi-Status', 208: 'Already Reported', 226: 'IM Used',
+  300: 'Multiple Choices', 301: 'Moved Permanently', 302: 'Found', 303: 'See Other', 304: 'Not Modified', 305: 'Use Proxy', 307: 'Temporary Redirect', 308: 'Permanent Redirect',
+  400: 'Bad Request', 401: 'Unauthorized', 402: 'Payment Required', 403: 'Forbidden', 404: 'Not Found', 405: 'Method Not Allowed', 406: 'Not Acceptable', 407: 'Proxy Authentication Required',
+  408: 'Request Timeout', 409: 'Conflict', 410: 'Gone', 411: 'Length Required', 412: 'Precondition Failed', 413: 'Payload Too Large', 414: 'URI Too Long', 415: 'Unsupported Media Type',
+  416: 'Range Not Satisfiable', 417: 'Expectation Failed', 418: "I'm a Teapot", 421: 'Misdirected Request', 422: 'Unprocessable Entity', 423: 'Locked', 424: 'Failed Dependency', 425: 'Too Early',
+  426: 'Upgrade Required', 428: 'Precondition Required', 429: 'Too Many Requests', 431: 'Request Header Fields Too Large', 451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error', 501: 'Not Implemented', 502: 'Bad Gateway', 503: 'Service Unavailable', 504: 'Gateway Timeout', 505: 'HTTP Version Not Supported', 506: 'Variant Also Negotiates',
+  507: 'Insufficient Storage', 508: 'Loop Detected', 509: 'Bandwidth Limit Exceeded', 510: 'Not Extended', 511: 'Network Authentication Required',
+};
+
+export const METHODS = ['ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'QUERY', 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'];