@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/dist/common/instantiation.js

@@ -0,0 +1,228 @@
+import * as wasi from "@bytecodealliance/preview2-shim";
+import { types, _createPreopenDescriptor } from "@bytecodealliance/preview2-shim/filesystem";
+/**
+ * (EXPERIMENTAL) A class that holds WASI shims and can be used to configure
+ * an instantiation of a WebAssembly component transpiled with jco
+ * (i.e. via `jco transpile`).
+ *
+ * Normally, transpiled components contain mapping for WASI interfaces
+ * and/or imports that import the relevant packages (ex. `@bytecodealliance/preview2-shim/clocks`)
+ * from the right sources.
+ *
+ * This function makes use of the `WASIShim` object to provide an object that can be easily
+ * fed to the `instantiate` function produced by a transpiled component:
+ *
+ * ```js
+ * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
+ * // ...
+ * import { instantiate } from "path/to/transpiled/component.js"
+ * // ...
+ * const component = await instantiate(null, new WASIShim().getImportObject())
+ * ```
+ *
+ * You can also replace imports that you'd like to override with custom implementations,
+ * by using the `WASIShim` object directly:
+ *
+ * ```js
+ * import { random } from "@bytecodealliance/preview2-shim"
+ * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
+ * // ...
+ * import { instantiate } from "path/to/transpiled/component.js"
+ * // ...
+ * const customWASIShim = new WASIShim({
+ *     random: {
+ *         // For these two interfaces we re-use the default provided shim
+ *         random: random.random,
+ *         insecure-seed: random.insecureSeed,
+ *         // For insecure, we can supply our own custom implementation
+ *         insecure: {
+ *             ...
+ *         }
+ *     }
+ * });
+ *
+ * const component = await instantiate(null, customWASIShim.getImportObject())
+ * ```
+ *
+ * For sandboxing, you can configure preopens, environment variables, and other
+ * capabilities via the `sandbox` option:
+ *
+ * ```js
+ * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
+ *
+ * // Fully sandboxed - no filesystem, network, or env access
+ * const sandboxedShim = new WASIShim({
+ *   sandbox: {
+ *     preopens: {},           // No filesystem access
+ *     env: {},                // No environment variables
+ *     args: ['program'],      // Custom arguments
+ *     enableNetwork: false,   // Disable network (default: true for backward compat)
+ *   }
+ * });
+ *
+ * // Limited filesystem access
+ * const limitedShim = new WASIShim({
+ *   sandbox: {
+ *     preopens: {
+ *       '/data': '/tmp/guest-data',  // Guest sees /data, maps to /tmp/guest-data
+ *       '/config': '/etc/app'        // Guest sees /config, maps to /etc/app
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * Note that this object is similar but not identical to the Node `WASI` object --
+ * it is solely concerned with shimming of preview2 when dealing with a WebAssembly
+ * component transpiled by Jco. While this object *does* work with Node (and the browser)
+ * semantics are not the same as Node's `WASI` object.
+ *
+ * @class WASIShim
+ */
+export class WASIShim {
+    /** Object that confirms to the shim interface for `wasi:cli` */
+    #cli;
+    /** Object that confirms to the shim interface for `wasi:filesystem` */
+    #filesystem;
+    /** Object that confirms to the shim interface for `wasi:io` */
+    #io;
+    /** Object that confirms to the shim interface for `wasi:random` */
+    #random;
+    /** Object that confirms to the shim interface for `wasi:clocks` */
+    #clocks;
+    /** Object that confirms to the shim interface for `wasi:sockets` */
+    #sockets;
+    /** Object that confirms to the shim interface for `wasi:http` */
+    #http;
+    /** Isolated preopens for this instance */
+    #preopens;
+    /** Isolated environment for this instance */
+    #environment;
+    /**
+     * Create a new WASIShim instance.
+     *
+     * @param config - Configuration options
+     */
+    constructor(config) {
+        // Support both old 'shims' parameter name and new 'config' style
+        const shims = config;
+        this.#cli = shims?.cli ?? wasi.cli;
+        this.#filesystem = shims?.filesystem ?? wasi.filesystem;
+        this.#io = shims?.io ?? wasi.io;
+        this.#random = shims?.random ?? wasi.random;
+        this.#clocks = shims?.clocks ?? wasi.clocks;
+        this.#sockets = shims?.sockets ?? wasi.sockets;
+        this.#http = shims?.http ?? wasi.http;
+        // Extract sandbox options
+        const sandbox = shims?.sandbox;
+        // Create isolated preopens if configured
+        if (sandbox?.preopens !== undefined) {
+            this.#preopens = createIsolatedPreopens(sandbox.preopens);
+        }
+        // Create isolated environment if env or args are configured
+        if (sandbox?.env !== undefined || sandbox?.args !== undefined) {
+            this.#environment = createIsolatedEnvironment(sandbox?.env, sandbox?.args, this.#cli);
+        }
+        // Apply network restrictions if disabled
+        if (sandbox?.enableNetwork === false) {
+            // Use the sockets module's built-in deny functions
+            if (this.#sockets._denyTcp) {
+                this.#sockets._denyTcp();
+            }
+            if (this.#sockets._denyUdp) {
+                this.#sockets._denyUdp();
+            }
+            if (this.#sockets._denyDnsLookup) {
+                this.#sockets._denyDnsLookup();
+            }
+        }
+    }
+    /**
+     * Generate an import object for the shim that can be used with
+     * functions like `instantiate` that are exposed from a transpiled
+     * WebAssembly component.
+     *
+     * @param opts - options for import object generation
+     * @returns WASIImportObject
+     */
+    getImportObject(opts) {
+        const versionSuffix = opts?.asVersion ? `@${opts.asVersion}` : "";
+        const obj = {};
+        obj[`wasi:cli/environment${versionSuffix}`] = this.#environment ?? this.#cli.environment;
+        obj[`wasi:cli/exit${versionSuffix}`] = this.#cli.exit;
+        obj[`wasi:cli/stderr${versionSuffix}`] = this.#cli.stderr;
+        obj[`wasi:cli/stdin${versionSuffix}`] = this.#cli.stdin;
+        obj[`wasi:cli/stdout${versionSuffix}`] = this.#cli.stdout;
+        obj[`wasi:cli/terminal-input${versionSuffix}`] = this.#cli.terminalInput;
+        obj[`wasi:cli/terminal-output${versionSuffix}`] = this.#cli.terminalOutput;
+        obj[`wasi:cli/terminal-stderr${versionSuffix}`] = this.#cli.terminalStderr;
+        obj[`wasi:cli/terminal-stdin${versionSuffix}`] = this.#cli.terminalStdin;
+        obj[`wasi:cli/terminal-stdout${versionSuffix}`] = this.#cli.terminalStdout;
+        obj[`wasi:sockets/instance-network${versionSuffix}`] = this.#sockets.instanceNetwork;
+        obj[`wasi:sockets/ip-name-lookup${versionSuffix}`] = this.#sockets.ipNameLookup;
+        obj[`wasi:sockets/network${versionSuffix}`] = this.#sockets.network;
+        obj[`wasi:sockets/tcp${versionSuffix}`] = this.#sockets.tcp;
+        obj[`wasi:sockets/tcp-create-socket${versionSuffix}`] = this.#sockets.tcpCreateSocket;
+        obj[`wasi:sockets/udp${versionSuffix}`] = this.#sockets.udp;
+        obj[`wasi:sockets/udp-create-socket${versionSuffix}`] = this.#sockets.udpCreateSocket;
+        obj[`wasi:filesystem/preopens${versionSuffix}`] =
+            this.#preopens ?? this.#filesystem.preopens;
+        obj[`wasi:filesystem/types${versionSuffix}`] = this.#filesystem.types;
+        obj[`wasi:io/error${versionSuffix}`] = this.#io.error;
+        obj[`wasi:io/poll${versionSuffix}`] = this.#io.poll;
+        obj[`wasi:io/streams${versionSuffix}`] = this.#io.streams;
+        obj[`wasi:random/random${versionSuffix}`] = this.#random.random;
+        obj[`wasi:random/insecure${versionSuffix}`] = this.#random.insecure;
+        obj[`wasi:random/insecure-seed${versionSuffix}`] = this.#random.insecureSeed;
+        obj[`wasi:clocks/monotonic-clock${versionSuffix}`] = this.#clocks.monotonicClock;
+        obj[`wasi:clocks/wall-clock${versionSuffix}`] = this.#clocks.wallClock;
+        obj[`wasi:http/types${versionSuffix}`] = this.#http.types;
+        obj[`wasi:http/outgoing-handler${versionSuffix}`] = this.#http.outgoingHandler;
+        return obj;
+    }
+}
+/**
+ * Create an isolated preopens object with its own preopen entries.
+ *
+ * @param preopensConfig - Map of virtual paths to host paths
+ * @returns A preopens object with Descriptor and getDirectories()
+ */
+function createIsolatedPreopens(preopensConfig) {
+    const entries = [];
+    // Populate entries using the filesystem's descriptor creation
+    if (_createPreopenDescriptor) {
+        for (const [virtualPath, hostPath] of Object.entries(preopensConfig)) {
+            const descriptor = _createPreopenDescriptor(hostPath);
+            entries.push([descriptor, virtualPath]);
+        }
+    }
+    return {
+        Descriptor: types.Descriptor,
+        getDirectories() {
+            return entries;
+        },
+    };
+}
+/**
+ * Create an isolated CLI environment with its own env and args.
+ *
+ * @param env - Environment variables
+ * @param args - Command-line arguments
+ * @param baseCli - The base CLI module to extend
+ * @returns An isolated CLI environment object
+ */
+function createIsolatedEnvironment(env, args, baseCli) {
+    const envEntries = env ? Object.entries(env) : null;
+    const argsArray = args || null;
+    return {
+        ...baseCli.environment,
+        getEnvironment() {
+            return envEntries ?? baseCli.environment.getEnvironment();
+        },
+        getArguments() {
+            return argsArray ?? baseCli.environment.getArguments();
+        },
+        initialCwd() {
+            return baseCli.environment.initialCwd();
+        },
+    };
+}

package/dist/io/calls.d.ts

@@ -0,0 +1,91 @@
+export declare const CALL_MASK = 4278190080;
+export declare const CALL_TYPE_MASK = 16777215;
+export declare const CALL_SHIFT = 24;
+export declare const STDIN: number;
+export declare const STDOUT: number;
+export declare const STDERR: number;
+export declare const FILE: number;
+export declare const HTTP: number;
+export declare const SOCKET_TCP: number;
+export declare const SOCKET_UDP: number;
+export declare const CLOCKS: number;
+export declare const INPUT_STREAM_CREATE: number;
+export declare const INPUT_STREAM_READ: number;
+export declare const INPUT_STREAM_BLOCKING_READ: number;
+export declare const INPUT_STREAM_SKIP: number;
+export declare const INPUT_STREAM_BLOCKING_SKIP: number;
+export declare const INPUT_STREAM_SUBSCRIBE: number;
+export declare const INPUT_STREAM_DISPOSE: number;
+export declare const OUTPUT_STREAM_CREATE: number;
+export declare const OUTPUT_STREAM_CHECK_WRITE: number;
+export declare const OUTPUT_STREAM_WRITE: number;
+export declare const OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH: number;
+export declare const OUTPUT_STREAM_FLUSH: number;
+export declare const OUTPUT_STREAM_BLOCKING_FLUSH: number;
+export declare const OUTPUT_STREAM_WRITE_ZEROES: number;
+export declare const OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH: number;
+export declare const OUTPUT_STREAM_SPLICE: number;
+export declare const OUTPUT_STREAM_BLOCKING_SPLICE: number;
+export declare const OUTPUT_STREAM_SUBSCRIBE: number;
+export declare const OUTPUT_STREAM_DISPOSE: number;
+export declare const OUTPUT_STREAM_GET_TOTAL_BYTES: number;
+export declare const POLL_POLLABLE_READY: number;
+export declare const POLL_POLLABLE_BLOCK: number;
+export declare const POLL_POLLABLE_DISPOSE: number;
+export declare const POLL_POLL_LIST: number;
+export declare const FUTURE_DISPOSE: number;
+export declare const FUTURE_TAKE_VALUE: number;
+export declare const FUTURE_SUBSCRIBE: number;
+export declare const HTTP_CREATE_REQUEST: number;
+export declare const HTTP_OUTPUT_STREAM_FINISH: number;
+export declare const HTTP_SERVER_START: number;
+export declare const HTTP_SERVER_STOP: number;
+export declare const HTTP_SERVER_INCOMING_HANDLER: number;
+export declare const HTTP_SERVER_SET_OUTGOING_RESPONSE: number;
+export declare const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE: number;
+export declare const HTTP_SERVER_GET_ADDRESS: number;
+export declare const HTTP_OUTGOING_BODY_DISPOSE: number;
+export declare const CLOCKS_DURATION_SUBSCRIBE: number;
+export declare const CLOCKS_INSTANT_SUBSCRIBE: number;
+export declare const SOCKET_TCP_CREATE_HANDLE: number;
+export declare const SOCKET_TCP_BIND_START: number;
+export declare const SOCKET_TCP_BIND_FINISH: number;
+export declare const SOCKET_TCP_CONNECT_START: number;
+export declare const SOCKET_TCP_CONNECT_FINISH: number;
+export declare const SOCKET_TCP_SUBSCRIBE: number;
+export declare const SOCKET_TCP_LISTEN_START: number;
+export declare const SOCKET_TCP_LISTEN_FINISH: number;
+export declare const SOCKET_TCP_IS_LISTENING: number;
+export declare const SOCKET_TCP_ACCEPT: number;
+export declare const SOCKET_TCP_GET_LOCAL_ADDRESS: number;
+export declare const SOCKET_TCP_GET_REMOTE_ADDRESS: number;
+export declare const SOCKET_TCP_SET_KEEP_ALIVE: number;
+export declare const SOCKET_TCP_SET_LISTEN_BACKLOG_SIZE: number;
+export declare const SOCKET_TCP_SHUTDOWN: number;
+export declare const SOCKET_TCP_DISPOSE: number;
+export declare const SOCKET_UDP_CREATE_HANDLE: number;
+export declare const SOCKET_UDP_BIND_START: number;
+export declare const SOCKET_UDP_BIND_FINISH: number;
+export declare const SOCKET_UDP_STREAM: number;
+export declare const SOCKET_UDP_SUBSCRIBE: number;
+export declare const SOCKET_UDP_DISPOSE: number;
+export declare const SOCKET_UDP_GET_LOCAL_ADDRESS: number;
+export declare const SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE: number;
+export declare const SOCKET_UDP_GET_REMOTE_ADDRESS: number;
+export declare const SOCKET_UDP_GET_SEND_BUFFER_SIZE: number;
+export declare const SOCKET_UDP_GET_UNICAST_HOP_LIMIT: number;
+export declare const SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE: number;
+export declare const SOCKET_UDP_SET_SEND_BUFFER_SIZE: number;
+export declare const SOCKET_UDP_SET_UNICAST_HOP_LIMIT: number;
+export declare const SOCKET_INCOMING_DATAGRAM_STREAM_RECEIVE: number;
+export declare const SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND: number;
+export declare const SOCKET_OUTGOING_DATAGRAM_STREAM_SEND: number;
+export declare const SOCKET_DATAGRAM_STREAM_SUBSCRIBE: number;
+export declare const SOCKET_DATAGRAM_STREAM_DISPOSE: number;
+export declare const SOCKET_GET_DEFAULT_SEND_BUFFER_SIZE: number;
+export declare const SOCKET_GET_DEFAULT_RECEIVE_BUFFER_SIZE: number;
+export declare const SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST: number;
+export declare const SOCKET_RESOLVE_ADDRESS_TAKE_REQUEST: number;
+export declare const SOCKET_RESOLVE_ADDRESS_SUBSCRIBE_REQUEST: number;
+export declare const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST: number;
+export declare const reverseMap: {};

package/{lib → dist}/io/calls.js

@@ -1,10 +1,8 @@
 let call_id = 0;
-
 // Call is a 32 bit integer, leading 8 bits are call number, trailing 24 bits allow custom call types
 export const CALL_MASK = 0xff000000;
 export const CALL_TYPE_MASK = 0x00ffffff;
 export const CALL_SHIFT = 24;
-
 // Type indiciator for generic Stream, Future, and Poll calls
 let cnt = 0;
 export const STDIN = ++cnt;
@@ -15,7 +13,6 @@ export const HTTP = ++cnt;
 export const SOCKET_TCP = ++cnt;
 export const SOCKET_UDP = ++cnt;
 export const CLOCKS = ++cnt;
-
 // Io Input Stream
 export const INPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
 export const INPUT_STREAM_READ = ++call_id << CALL_SHIFT;
@@ -24,7 +21,6 @@ export const INPUT_STREAM_SKIP = ++call_id << CALL_SHIFT;
 export const INPUT_STREAM_BLOCKING_SKIP = ++call_id << CALL_SHIFT;
 export const INPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const INPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
-
 // Io Output Stream
 export const OUTPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_CHECK_WRITE = ++call_id << CALL_SHIFT;
@@ -38,20 +34,16 @@ export const OUTPUT_STREAM_SPLICE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
-
 export const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << CALL_SHIFT;
-
 // Io Poll
 export const POLL_POLLABLE_READY = ++call_id << CALL_SHIFT;
 export const POLL_POLLABLE_BLOCK = ++call_id << CALL_SHIFT;
 export const POLL_POLLABLE_DISPOSE = ++call_id << CALL_SHIFT;
 export const POLL_POLL_LIST = ++call_id << CALL_SHIFT;
-
 // Futures
 export const FUTURE_DISPOSE = ++call_id << CALL_SHIFT;
 export const FUTURE_TAKE_VALUE = ++call_id << CALL_SHIFT;
 export const FUTURE_SUBSCRIBE = ++call_id << CALL_SHIFT;
-
 // Http
 export const HTTP_CREATE_REQUEST = ++call_id << 24;
 export const HTTP_OUTPUT_STREAM_FINISH = ++call_id << CALL_SHIFT;
@@ -63,11 +55,9 @@ export const HTTP_SERVER_SET_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
 export const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
 export const HTTP_SERVER_GET_ADDRESS = ++call_id << CALL_SHIFT;
 export const HTTP_OUTGOING_BODY_DISPOSE = ++call_id << CALL_SHIFT;
-
 // Clocks
 export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << CALL_SHIFT;
-
 // Sockets
 // Tcp
 export const SOCKET_TCP_CREATE_HANDLE = ++call_id << CALL_SHIFT;
@@ -106,23 +96,18 @@ export const SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND = ++call_id << CALL_SHIF
 export const SOCKET_OUTGOING_DATAGRAM_STREAM_SEND = ++call_id << CALL_SHIFT;
 export const SOCKET_DATAGRAM_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const SOCKET_DATAGRAM_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
-
 export const SOCKET_GET_DEFAULT_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
 export const SOCKET_GET_DEFAULT_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
-
 // Name lookup
 export const SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST = ++call_id << CALL_SHIFT;
 export const SOCKET_RESOLVE_ADDRESS_TAKE_REQUEST = ++call_id << CALL_SHIFT;
 export const SOCKET_RESOLVE_ADDRESS_SUBSCRIBE_REQUEST = ++call_id << CALL_SHIFT;
 export const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST = ++call_id << CALL_SHIFT;
-
 export const reverseMap = {};
-
 import * as calls from "./calls.js";
-
 for (const name of Object.getOwnPropertyNames(calls)) {
-  if (name === "reverseMap") {
-    continue;
-  }
-  reverseMap[calls[name]] = name;
+    if (name === "reverseMap") {
+        continue;
+    }
+    reverseMap[calls[name]] = name;
 }

package/dist/io/worker-http.d.ts

@@ -0,0 +1,17 @@
+export declare function stopHttpServer(id: any): Promise<void>;
+export declare function clearOutgoingResponse(id: any): void;
+export declare function getHttpServerAddress(id: any): Promise<any>;
+export declare function setOutgoingResponse(id: any, { statusCode, headers, streamId }: {
+    statusCode: any;
+    headers: any;
+    streamId: any;
+}): Promise<void>;
+export declare function startHttpServer(id: number, { port, host }: {
+    port: any;
+    host: any;
+}): Promise<void>;
+export declare function createHttpRequest(method: any, scheme: any, authority: any, pathWithQuery: any, headers: any, bodyId: any, connectTimeout: any, betweenBytesTimeout: any, firstByteTimeout: any): Promise<{
+    status: number | undefined;
+    headers: [string, string | string[] | undefined][];
+    bodyStreamId: number;
+}>;

package/dist/io/worker-http.js

@@ -0,0 +1,192 @@
+import { createReadableStream, getStreamOrThrow } from "./worker-thread.js";
+import { createServer, request as httpRequest, Agent as HttpAgent, } from "node:http";
+import { request as httpsRequest, Agent as HttpsAgent } from "node:https";
+import { parentPort } from "node:worker_threads";
+import { HTTP_SERVER_INCOMING_HANDLER } from "./calls.js";
+const agentOptions = {
+    keepAlive: true,
+};
+const httpAgent = new HttpAgent(agentOptions);
+const httpsAgent = new HttpsAgent(agentOptions);
+const servers = new Map();
+let responseCnt = 0;
+const responses = new Map();
+export async function stopHttpServer(id) {
+    await new Promise((resolve) => servers.get(id).close(resolve));
+}
+export function clearOutgoingResponse(id) {
+    responses.delete(id);
+}
+export async function getHttpServerAddress(id) {
+    return servers.get(id).address();
+}
+export async function setOutgoingResponse(id, { statusCode, headers, streamId }) {
+    const response = responses.get(id);
+    const textDecoder = new TextDecoder();
+    response.writeHead(statusCode, Object.fromEntries(headers.map(([key, val]) => [key, textDecoder.decode(val)])));
+    response.flushHeaders();
+    const { stream } = getStreamOrThrow(streamId);
+    stream.pipe(response);
+    responses.delete(id);
+}
+export async function startHttpServer(id, { port, host }) {
+    const server = createServer((req, res) => {
+        // MessagePort is only available when running in worker thread.
+        if (!parentPort) {
+            throw {
+                tag: "internal-error",
+                val: "Unable to post message. Likely running in main thread.",
+            };
+        }
+        // create the streams and their ids
+        const streamId = createReadableStream(req);
+        const responseId = ++responseCnt;
+        parentPort.postMessage({
+            type: HTTP_SERVER_INCOMING_HANDLER,
+            id,
+            payload: {
+                responseId,
+                method: req.method,
+                host: req.headers.host || host || "localhost",
+                pathWithQuery: req.url,
+                headers: Object.entries(req.headersDistinct).flatMap(([key, val]) => val?.map((val) => [key, val])),
+                streamId,
+            },
+        });
+        responses.set(responseId, res);
+    });
+    await new Promise((resolve, reject) => {
+        // @ts-expect-error Resolve has different signature
+        server.listen(port, host, resolve);
+        server.on("error", reject);
+    });
+    servers.set(id, server);
+}
+export async function createHttpRequest(method, scheme, authority, pathWithQuery, headers, bodyId, connectTimeout, betweenBytesTimeout, firstByteTimeout) {
+    let stream = null;
+    if (bodyId) {
+        try {
+            ({ stream } = getStreamOrThrow(bodyId));
+        }
+        catch (e) {
+            if (e.tag === "closed") {
+                throw {
+                    tag: "internal-error",
+                    val: "Unexpected closed body stream",
+                };
+            }
+            // it should never be possible for the body stream to already
+            // be closed, or for there to be a write error
+            // we therefore just throw internal error here
+            if (e.tag === "last-operation-failed") {
+                throw {
+                    tag: "internal-error",
+                    val: e.val,
+                };
+            }
+            // entirely unknown error -> trap
+            throw e;
+        }
+    }
+    try {
+        // Make a request
+        let req;
+        switch (scheme) {
+            case "http:":
+                req = httpRequest({
+                    agent: httpAgent,
+                    method,
+                    host: authority.split(":")[0],
+                    port: authority.split(":")[1],
+                    path: pathWithQuery,
+                    timeout: connectTimeout && Number(connectTimeout / 1000000n),
+                });
+                break;
+            case "https:":
+                req = httpsRequest({
+                    agent: httpsAgent,
+                    method,
+                    host: authority.split(":")[0],
+                    port: authority.split(":")[1],
+                    path: pathWithQuery,
+                    timeout: connectTimeout && Number(connectTimeout / 1000000n),
+                });
+                break;
+            default:
+                throw { tag: "HTTP-protocol-error" };
+        }
+        for (const [key, value] of headers) {
+            req.appendHeader(key, value);
+        }
+        req.flushHeaders();
+        if (stream) {
+            stream.pipe(req);
+        }
+        else {
+            req.end();
+        }
+        const res = await new Promise((resolve, reject) => {
+            req.once("timeout", () => {
+                reject({
+                    tag: "connection-timeout",
+                });
+                req.destroy();
+            });
+            req.once("response", resolve);
+            req.once("close", () => reject);
+            req.once("error", reject);
+        });
+        if (firstByteTimeout) {
+            res.setTimeout(Number(firstByteTimeout / 1000000n));
+        }
+        if (betweenBytesTimeout) {
+            res.once("readable", () => {
+                res.setTimeout(Number(betweenBytesTimeout / 1000000n));
+            });
+        }
+        const bodyStreamId = createReadableStream(res);
+        return {
+            status: res.statusCode,
+            headers: Array.from(Object.entries(res.headers)),
+            bodyStreamId,
+        };
+    }
+    catch (e) {
+        if (e?.tag) {
+            throw e;
+        }
+        const err = getFirstError(e);
+        switch (err.code) {
+            case "ECONNRESET":
+                throw { tag: "HTTP-protocol-error" };
+            case "ENOTFOUND":
+                throw {
+                    tag: "DNS-error",
+                    val: {
+                        rcode: err.code,
+                        infoCode: err.errno < 0 ? -err.errno : err.errno,
+                    },
+                };
+            case "ECONNREFUSED":
+                throw {
+                    tag: "connection-refused",
+                };
+        }
+        throw {
+            tag: "internal-error",
+            val: err.toString(),
+        };
+    }
+}
+function getFirstError(e) {
+    if (typeof e !== "object" || e === null) {
+        return e;
+    }
+    if (e.cause) {
+        return getFirstError(e.cause);
+    }
+    if (e instanceof AggregateError) {
+        return getFirstError(e.errors[0]);
+    }
+    return e;
+}