@bytecodealliance/preview2-shim 0.15.1 → 0.16.1

package/lib/io/calls.js

@@ -65,7 +65,6 @@ export const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
 export const HTTP_OUTGOING_BODY_DISPOSE = ++call_id << CALL_SHIFT;
 
 // Clocks
-export const CLOCKS_NOW = ++call_id << CALL_SHIFT;
 export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << CALL_SHIFT;
 

package/lib/io/worker-http.js

@@ -1,7 +1,4 @@
-import {
-  createReadableStream,
-  getStreamOrThrow,
-} from "./worker-thread.js";
+import { createReadableStream, getStreamOrThrow } from "./worker-thread.js";
 import {
   createServer,
   request as httpRequest,
@@ -117,7 +114,7 @@ export async function createHttpRequest(
           host: authority.split(":")[0],
           port: authority.split(":")[1],
           path: pathWithQuery,
-          timeout: connectTimeout && Number(connectTimeout),
+          timeout: connectTimeout && Number(connectTimeout / 1_000_000n),
         });
         break;
       case "https:":
@@ -127,7 +124,7 @@ export async function createHttpRequest(
           host: authority.split(":")[0],
           port: authority.split(":")[1],
           path: pathWithQuery,
-          timeout: connectTimeout && Number(connectTimeout),
+          timeout: connectTimeout && Number(connectTimeout / 1_000_000n),
         });
         break;
       default:
@@ -143,20 +140,26 @@ export async function createHttpRequest(
       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));
+    if (firstByteTimeout) res.setTimeout(Number(firstByteTimeout / 1_000_000n));
     if (betweenBytesTimeout)
       res.once("readable", () => {
-        res.setTimeout(Number(betweenBytesTimeout));
+        res.setTimeout(Number(betweenBytesTimeout / 1_000_000n));
       });
     const bodyStreamId = createReadableStream(res);
     return {
       status: res.statusCode,
       headers: Array.from(Object.entries(res.headers)),
-      bodyStreamId
+      bodyStreamId,
     };
   } catch (e) {
     if (e?.tag) throw e;

package/lib/io/worker-io.js

@@ -33,7 +33,9 @@ import {
   STDOUT,
   reverseMap,
 } from "./calls.js";
-import { _rawDebug, exit, stderr, stdout, env } from "node:process";
+import nodeProcess, { exit, stderr, stdout, env } from "node:process";
+
+const _rawDebug = nodeProcess._rawDebug || console.error.bind(console);
 
 const workerPath = fileURLToPath(
   new URL("./worker-thread.js", import.meta.url)
@@ -409,24 +411,19 @@ function pollableDispose(id) {
   ioCall(POLL_POLLABLE_DISPOSE, id);
 }
 
+const rep = Symbol.for("cabiRep");
+
 class Pollable {
-  #id;
   #finalizer;
   ready() {
-    if (this.#id === 0) return true;
-    return ioCall(POLL_POLLABLE_READY, this.#id);
+    return ioCall(POLL_POLLABLE_READY, this[rep]);
   }
   block() {
-    if (this.#id !== 0) {
-      ioCall(POLL_POLLABLE_BLOCK, this.#id);
-    }
-  }
-  static _getId(pollable) {
-    return pollable.#id;
+    ioCall(POLL_POLLABLE_BLOCK, this[rep]);
   }
   static _create(id, parent) {
     const pollable = new Pollable();
-    pollable.#id = id;
+    pollable[rep] = id;
     pollable.#finalizer = registerDispose(
       pollable,
       parent,
@@ -436,26 +433,88 @@ class Pollable {
     return pollable;
   }
   [symbolDispose]() {
-    if (this.#finalizer) {
+    if (this.#finalizer && this[rep]) {
       earlyDispose(this.#finalizer);
       this.#finalizer = null;
     }
   }
 }
 
+const cabiLowerSymbol = Symbol.for("cabiLower");
+const T_FLAG = 1 << 30;
+
+Pollable.prototype.ready[cabiLowerSymbol] = function ({
+  resourceTables: [table],
+}) {
+  return function pollableReady(handle) {
+    const rep = table[(handle << 1) + 1] & ~T_FLAG;
+    const ready = ioCall(POLL_POLLABLE_READY, rep);
+    return ready ? 1 : 0;
+  };
+};
+
+Pollable.prototype.block[cabiLowerSymbol] = function ({
+  resourceTables: [table],
+}) {
+  return function pollableBlock(handle) {
+    const rep = table[(handle << 1) + 1] & ~T_FLAG;
+    ioCall(POLL_POLLABLE_BLOCK, rep);
+  };
+};
+
+Pollable[Symbol.for("cabiDispose")] = function pollableDispose(rep) {
+  ioCall(POLL_POLLABLE_DISPOSE, rep);
+};
+
 export const pollableCreate = Pollable._create;
 delete Pollable._create;
 
-const pollableGetId = Pollable._getId;
-delete Pollable._getId;
-
 export const poll = {
   Pollable,
   poll(list) {
-    return ioCall(POLL_POLL_LIST, null, list.map(pollableGetId));
+    return ioCall(
+      POLL_POLL_LIST,
+      null,
+      list.map((pollable) => pollable[rep])
+    );
   },
 };
 
+poll.poll[cabiLowerSymbol] = function ({ memory, realloc, resourceTables: [table] }) {
+  return function pollPollList (listPtr, len, retptr) {
+    const handleList = new Uint32Array(memory.buffer, listPtr, len);
+    const repList = Array(len);
+    for (let i = 0; i < len; i++) {
+      const handle = handleList[i];
+      repList[i] = table[(handle << 1) + 1] & ~T_FLAG;
+    }
+    const result = ioCall(POLL_POLL_LIST, null, repList);
+    const ptr = realloc(0, 0, 4, result.byteLength);
+    const out = new Uint32Array(memory.buffer, ptr, result.length);
+    out.set(result);
+    const ret = new Uint32Array(memory.buffer, retptr, 2);
+    ret[0] = ptr;
+    ret[1] = result.length;
+    return retptr;
+  };
+};
+
 export function createPoll(call, id, initPayload) {
   return pollableCreate(ioCall(call, id, initPayload));
 }
+
+export function createPollLower(call, id, table) {
+  return function (initPayload) {
+    const rep = ioCall(call, id, initPayload);
+    const free = table[0] & ~T_FLAG;
+    if (free === 0) {
+      table.push(0);
+      table.push(rep | T_FLAG);
+      return (table.length >> 1) - 1;
+    }
+    table[0] = table[free << 1];
+    table[free << 1] = 0;
+    table[(free << 1) + 1] = rep | T_FLAG;
+    return free;
+  };
+}

package/lib/io/worker-socket-tcp.js

@@ -8,6 +8,7 @@ import {
   pollStateReady,
   verifyPollsDroppedForDrop,
 } from "./worker-thread.js";
+import process from "node:process";
 const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
 import {
   convertSocketError,

package/lib/io/worker-thread.js

@@ -18,7 +18,6 @@ import {
   CALL_TYPE_MASK,
   CLOCKS_DURATION_SUBSCRIBE,
   CLOCKS_INSTANT_SUBSCRIBE,
-  CLOCKS_NOW,
   FILE,
   FUTURE_DISPOSE,
   FUTURE_SUBSCRIBE,
@@ -147,6 +146,7 @@ import {
   socketUdpStream,
   udpSockets,
 } from "./worker-socket-udp.js";
+import process from "node:process";
 
 function log(msg) {
   if (debug) process._rawDebug(msg);
@@ -536,8 +536,6 @@ function handle(call, id, payload) {
     }
 
     // Clocks
-    case CLOCKS_NOW:
-      return hrtime.bigint();
     case CLOCKS_DURATION_SUBSCRIBE:
       payload = hrtime.bigint() + payload;
     // fallthrough
@@ -775,7 +773,9 @@ function handle(call, id, payload) {
         pollStateCheck(pollState);
         if (pollState.ready) doneList.push(idx);
       }
-      if (doneList.length > 0) return new Uint32Array(doneList);
+      if (doneList.length > 0) {
+        return new Uint32Array(doneList);
+      }
       let readyPromiseResolve;
       const readyPromise = new Promise(
         (resolve) => void (readyPromiseResolve = resolve)

package/lib/nodejs/cli.js

@@ -1,4 +1,4 @@
-import { argv, env, cwd } from "node:process";
+import process, { argv, env, cwd } from "node:process";
 import {
   ioCall,
   streams,

package/lib/nodejs/clocks.js

@@ -1,16 +1,20 @@
-import { ioCall, createPoll } from "../io/worker-io.js";
+import { createPoll } from "../io/worker-io.js";
 import {
-  CLOCKS_NOW,
   CLOCKS_INSTANT_SUBSCRIBE,
   CLOCKS_DURATION_SUBSCRIBE,
 } from "../io/calls.js";
+import { hrtime } from "node:process";
+
+const symbolCabiLower = Symbol.for("cabiLower");
+
+function resolution() {
+  return 1n;
+}
 
 export const monotonicClock = {
-  resolution() {
-    return 1n;
-  },
+  resolution,
   now() {
-    return ioCall(CLOCKS_NOW, null, null);
+    return hrtime.bigint();
   },
   subscribeInstant(instant) {
     return createPoll(CLOCKS_INSTANT_SUBSCRIBE, null, instant);
@@ -22,12 +26,39 @@ export const monotonicClock = {
 };
 
 export const wallClock = {
+  resolution() {
+    return { seconds: 0n, nanoseconds: 1e6 };
+  },
   now() {
     const seconds = BigInt(Math.floor(Date.now() / 1e3));
     const nanoseconds = (Date.now() % 1e3) * 1e6;
     return { seconds, nanoseconds };
   },
-  resolution() {
-    return { seconds: 0n, nanoseconds: 1e6 };
-  },
+};
+
+monotonicClock.resolution[symbolCabiLower] = () => resolution;
+monotonicClock.now[symbolCabiLower] = () => hrtime.bigint;
+wallClock.resolution[symbolCabiLower] = ({ memory }) => {
+  let buf32 = new Int32Array(memory.buffer);
+  return function now(retptr) {
+    if (memory.buffer !== buf32.buffer) buf32 = new Int32Array(memory.buffer);
+    if (retptr % 4) throw new Error('wasi-io trap: retptr not aligned');
+    buf32[(retptr >> 2) + 0] = 0;
+    buf32[(retptr >> 2) + 4] = 0;
+    buf32[(retptr >> 2) + 8] = 1_000_000;
+  };
+};
+
+wallClock.now[symbolCabiLower] = ({ memory }) => {
+  let buf32 = new Int32Array(memory.buffer);
+  let buf64 = new BigInt64Array(memory.buffer);
+  return function now(retptr) {
+    if (memory.buffer !== buf32.buffer) {
+      buf32 = new Int32Array(memory.buffer);
+      buf64 = new BigInt64Array(memory.buffer);
+    }
+    if (retptr % 4) throw new Error('wasi-io trap: retptr not aligned');
+    buf64[(retptr >> 2) + 0] = BigInt(Math.floor(Date.now() / 1e3));
+    buf32[(retptr >> 2) + 8] = (Date.now() % 1e3) * 1e6;
+  };
 };

package/lib/nodejs/filesystem.js

@@ -7,7 +7,7 @@ import {
 } from "../io/worker-io.js";
 import { INPUT_STREAM_CREATE, OUTPUT_STREAM_CREATE } from "../io/calls.js";
 import { FILE } from "../io/calls.js";
-import {
+import nodeFs, {
   closeSync,
   constants,
   fdatasyncSync,
@@ -17,7 +17,6 @@ import {
   futimesSync,
   linkSync,
   lstatSync,
-  lutimesSync,
   mkdirSync,
   opendirSync,
   openSync,
@@ -33,6 +32,8 @@ import {
 } from "node:fs";
 import { platform } from "node:process";
 
+const lutimesSync = nodeFs.lutimesSync;
+
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
 const isWindows = platform === "win32";
@@ -151,6 +152,8 @@ class Descriptor {
     try {
       ftruncateSync(this.#fd, Number(size));
     } catch (e) {
+      if (isWindows && e.code === 'EPERM')
+        throw 'access';
       throw convertFsError(e);
     }
   }
@@ -297,6 +300,9 @@ class Descriptor {
       dataModificationTimestamp.tag === "no-change" &&
         stats.dataModificationTimestamp
     );
+    if (!pathFlags.symlinkFollow && !lutimesSync){
+      throw new Error("Changing the timestamps of symlinks isn't supported");
+    }
     try {
       (pathFlags.symlinkFollow ? utimesSync : lutimesSync)(
         fullPath,
@@ -321,13 +327,14 @@ class Descriptor {
   }
 
   openAt(pathFlags, path, openFlags, descriptorFlags) {
+    if (preopenEntries.length === 0)
+      throw "access";
     const fullPath = this.#getFullPath(path, pathFlags.symlinkFollow);
     let fsOpenFlags = 0x0;
     if (openFlags.create) fsOpenFlags |= constants.O_CREAT;
     if (openFlags.directory) fsOpenFlags |= constants.O_DIRECTORY;
     if (openFlags.exclusive) fsOpenFlags |= constants.O_EXCL;
     if (openFlags.truncate) fsOpenFlags |= constants.O_TRUNC;
-
     if (descriptorFlags.read && descriptorFlags.write)
       fsOpenFlags |= constants.O_RDWR;
     else if (descriptorFlags.write) fsOpenFlags |= constants.O_WRONLY;

package/lib/nodejs/http.js

@@ -21,11 +21,13 @@ import {
   registerDispose,
   registerIncomingHttpHandler,
 } from "../io/worker-io.js";
-import { validateHeaderName, validateHeaderValue } from "node:http";
 import { HTTP } from "../io/calls.js";
 
+import * as http from "node:http";
+const { validateHeaderName = () => {}, validateHeaderValue = () => {} } = http;
+
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
-export const _forbiddenHeaders = new Set(["connection", "keep-alive"]);
+export const _forbiddenHeaders = new Set(["connection", "keep-alive", "host"]);
 
 class IncomingBody {
   #finished = false;
@@ -173,27 +175,29 @@ class ResponseOutparam {
 const responseOutparamCreate = ResponseOutparam._create;
 delete ResponseOutparam._create;
 
+const defaultHttpTimeout = 600_000_000_000n;
+
 class RequestOptions {
-  #connectTimeoutMs;
-  #firstByteTimeoutMs;
-  #betweenBytesTimeoutMs;
-  connectTimeoutMs() {
-    return this.#connectTimeoutMs;
+  #connectTimeout = defaultHttpTimeout;
+  #firstByteTimeout = defaultHttpTimeout;
+  #betweenBytesTimeout = defaultHttpTimeout;
+  connectTimeout() {
+    return this.#connectTimeout;
   }
-  setConnectTimeoutMs(duration) {
-    this.#connectTimeoutMs = duration;
+  setConnectTimeout(duration) {
+    this.#connectTimeout = duration;
   }
-  firstByteTimeoutMs() {
-    return this.#firstByteTimeoutMs;
+  firstByteTimeout() {
+    return this.#firstByteTimeout;
   }
-  setFirstByteTimeoutMs(duration) {
-    this.#firstByteTimeoutMs = duration;
+  setFirstByteTimeout(duration) {
+    this.#firstByteTimeout = duration;
   }
-  betweenBytesTimeoutMs() {
-    return this.#betweenBytesTimeoutMs;
+  betweenBytesTimeout() {
+    return this.#betweenBytesTimeout;
   }
-  setBetweenBytesTimeoutMs(duration) {
-    this.#betweenBytesTimeoutMs = duration;
+  setBetweenBytesTimeout(duration) {
+    this.#betweenBytesTimeout = duration;
   }
 }
 
@@ -270,9 +274,9 @@ class OutgoingRequest {
   }
   [symbolDispose]() {}
   static _handle(request, options) {
-    const connectTimeout = options?.connectTimeoutMs();
-    const betweenBytesTimeout = options?.betweenBytesTimeoutMs();
-    const firstByteTimeout = options?.firstByteTimeoutMs();
+    const connectTimeout = options?.connectTimeout();
+    const betweenBytesTimeout = options?.betweenBytesTimeout();
+    const firstByteTimeout = options?.firstByteTimeout();
     const scheme = schemeString(request.#scheme);
     // note: host header is automatically added by Node.js
     const headers = [];
@@ -289,7 +293,7 @@ class OutgoingRequest {
       outgoingBodyOutputStreamId(request.#body),
       connectTimeout,
       betweenBytesTimeout,
-      firstByteTimeout
+      firstByteTimeout,
     );
   }
 }

package/lib/nodejs/random.js

@@ -1,32 +1,45 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomFillSync } from "node:crypto";
 
 export const insecure = {
-  getInsecureRandomBytes (len) {
-    return randomBytes(Number(len));
-  },
-  getInsecureRandomU64 () {
+  getInsecureRandomBytes: getRandomBytes,
+  getInsecureRandomU64() {
     return new BigUint64Array(randomBytes(8).buffer)[0];
-  }
+  },
 };
 
 let insecureSeedValue1, insecureSeedValue2;
 
 export const insecureSeed = {
-  insecureSeed () {
+  insecureSeed() {
     if (insecureSeedValue1 === undefined) {
       insecureSeedValue1 = random.getRandomU64();
       insecureSeedValue2 = random.getRandomU64();
     }
     return [insecureSeedValue1, insecureSeedValue2];
-  }
+  },
 };
 
 export const random = {
-  getRandomBytes(len) {
-    return randomBytes(Number(len));
-  },
+  getRandomBytes,
 
-  getRandomU64 () {
+  getRandomU64() {
     return new BigUint64Array(randomBytes(8).buffer)[0];
-  }
+  },
+};
+
+function getRandomBytes(len) {
+  return randomBytes(Number(len));
+}
+
+getRandomBytes[Symbol.for("cabiLower")] = ({ memory, realloc }) => {
+  let buf32 = new Uint32Array(memory.buffer);
+  return function randomBytes(len, retptr) {
+    len = Number(len);
+    const ptr = realloc(0, 0, 1, len);
+    randomFillSync(memory.buffer, ptr, len);
+    if (memory.buffer !== buf32.buffer) buf32 = new Uint32Array(memory.buffer);
+    if (retptr % 4) throw new Error('wasi-io trap: retptr not aligned');
+    buf32[retptr >> 2] = ptr;
+    buf32[(retptr >> 2) + 1] = len;
+  };
 };

package/lib/synckit/index.js

@@ -87,7 +87,7 @@ export function createSyncFn(workerPath, debug, callbackHandler) {
     }
     return result;
   };
-  worker.unref();
+  if (worker.unref) worker.unref();
   return syncFn;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",

package/types/interfaces/wasi-cli-stderr.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiCliStderr {
   export function getStderr(): OutputStream;
 }
-import type { OutputStream } from '../interfaces/wasi-io-streams.js';
+import type { OutputStream } from './wasi-io-streams.js';
 export { OutputStream };

package/types/interfaces/wasi-cli-stdin.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiCliStdin {
   export function getStdin(): InputStream;
 }
-import type { InputStream } from '../interfaces/wasi-io-streams.js';
+import type { InputStream } from './wasi-io-streams.js';
 export { InputStream };

package/types/interfaces/wasi-cli-stdout.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiCliStdout {
   export function getStdout(): OutputStream;
 }
-import type { OutputStream } from '../interfaces/wasi-io-streams.js';
+import type { OutputStream } from './wasi-io-streams.js';
 export { OutputStream };

package/types/interfaces/wasi-cli-terminal-stderr.d.ts

@@ -5,5 +5,5 @@ export namespace WasiCliTerminalStderr {
    */
   export function getTerminalStderr(): TerminalOutput | undefined;
 }
-import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output.js';
+import type { TerminalOutput } from './wasi-cli-terminal-output.js';
 export { TerminalOutput };

package/types/interfaces/wasi-cli-terminal-stdin.d.ts

@@ -5,5 +5,5 @@ export namespace WasiCliTerminalStdin {
    */
   export function getTerminalStdin(): TerminalInput | undefined;
 }
-import type { TerminalInput } from '../interfaces/wasi-cli-terminal-input.js';
+import type { TerminalInput } from './wasi-cli-terminal-input.js';
 export { TerminalInput };

package/types/interfaces/wasi-cli-terminal-stdout.d.ts

@@ -5,5 +5,5 @@ export namespace WasiCliTerminalStdout {
    */
   export function getTerminalStdout(): TerminalOutput | undefined;
 }
-import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output.js';
+import type { TerminalOutput } from './wasi-cli-terminal-output.js';
 export { TerminalOutput };

package/types/interfaces/wasi-clocks-monotonic-clock.d.ts

@@ -23,7 +23,7 @@ export namespace WasiClocksMonotonicClock {
    */
   export function subscribeDuration(when: Duration): Pollable;
 }
-import type { Pollable } from '../interfaces/wasi-io-poll.js';
+import type { Pollable } from './wasi-io-poll.js';
 export { Pollable };
 /**
  * An instant in time, in nanoseconds. An instant is relative to an

package/types/interfaces/wasi-filesystem-preopens.d.ts

@@ -4,5 +4,5 @@ export namespace WasiFilesystemPreopens {
    */
   export function getDirectories(): [Descriptor, string][];
 }
-import type { Descriptor } from '../interfaces/wasi-filesystem-types.js';
+import type { Descriptor } from './wasi-filesystem-types.js';
 export { Descriptor };

package/types/interfaces/wasi-filesystem-types.d.ts

@@ -260,13 +260,13 @@ export namespace WasiFilesystemTypes {
    */
   export function filesystemErrorCode(err: Error): ErrorCode | undefined;
 }
-import type { InputStream } from '../interfaces/wasi-io-streams.js';
+import type { InputStream } from './wasi-io-streams.js';
 export { InputStream };
-import type { OutputStream } from '../interfaces/wasi-io-streams.js';
+import type { OutputStream } from './wasi-io-streams.js';
 export { OutputStream };
-import type { Error } from '../interfaces/wasi-io-streams.js';
+import type { Error } from './wasi-io-streams.js';
 export { Error };
-import type { Datetime } from '../interfaces/wasi-clocks-wall-clock.js';
+import type { Datetime } from './wasi-clocks-wall-clock.js';
 export { Datetime };
 /**
  * File size or length of a region within a file.
@@ -639,6 +639,10 @@ export interface MetadataHashValue {
   upper: bigint,
 }
 
+export class DirectoryEntryStream {
+  readDirectoryEntry(): DirectoryEntry | undefined;
+}
+
 export class Descriptor {
   readViaStream(offset: Filesize): InputStream;
   writeViaStream(offset: Filesize): OutputStream;
@@ -668,7 +672,3 @@ export class Descriptor {
   metadataHash(): MetadataHashValue;
   metadataHashAt(pathFlags: PathFlags, path: string): MetadataHashValue;
 }
-
-export class DirectoryEntryStream {
-  readDirectoryEntry(): DirectoryEntry | undefined;
-}

package/types/interfaces/wasi-http-incoming-handler.d.ts

@@ -13,7 +13,7 @@ export namespace WasiHttpIncomingHandler {
    */
   export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
 }
-import type { IncomingRequest } from '../interfaces/wasi-http-types.js';
+import type { IncomingRequest } from './wasi-http-types.js';
 export { IncomingRequest };
-import type { ResponseOutparam } from '../interfaces/wasi-http-types.js';
+import type { ResponseOutparam } from './wasi-http-types.js';
 export { ResponseOutparam };

package/types/interfaces/wasi-http-outgoing-handler.d.ts

@@ -13,11 +13,11 @@ export namespace WasiHttpOutgoingHandler {
    */
   export function handle(request: OutgoingRequest, options: RequestOptions | undefined): FutureIncomingResponse;
 }
-import type { OutgoingRequest } from '../interfaces/wasi-http-types.js';
+import type { OutgoingRequest } from './wasi-http-types.js';
 export { OutgoingRequest };
-import type { RequestOptions } from '../interfaces/wasi-http-types.js';
+import type { RequestOptions } from './wasi-http-types.js';
 export { RequestOptions };
-import type { FutureIncomingResponse } from '../interfaces/wasi-http-types.js';
+import type { FutureIncomingResponse } from './wasi-http-types.js';
 export { FutureIncomingResponse };
-import type { ErrorCode } from '../interfaces/wasi-http-types.js';
+import type { ErrorCode } from './wasi-http-types.js';
 export { ErrorCode };

package/types/interfaces/wasi-http-types.d.ts

@@ -354,15 +354,15 @@ export namespace WasiHttpTypes {
    * `output-stream` child.
    */
 }
-import type { Duration } from '../interfaces/wasi-clocks-monotonic-clock.js';
+import type { Duration } from './wasi-clocks-monotonic-clock.js';
 export { Duration };
-import type { InputStream } from '../interfaces/wasi-io-streams.js';
+import type { InputStream } from './wasi-io-streams.js';
 export { InputStream };
-import type { OutputStream } from '../interfaces/wasi-io-streams.js';
+import type { OutputStream } from './wasi-io-streams.js';
 export { OutputStream };
-import type { Error as IoError } from '../interfaces/wasi-io-error.js';
+import type { Error as IoError } from './wasi-io-error.js';
 export { IoError };
-import type { Pollable } from '../interfaces/wasi-io-poll.js';
+import type { Pollable } from './wasi-io-poll.js';
 export { Pollable };
 /**
  * This type corresponds to HTTP standard Methods.
@@ -629,10 +629,6 @@ export type Trailers = Fields;
 export type StatusCode = number;
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };
 
-export class ResponseOutparam {
-  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
-}
-
 export class OutgoingResponse {
   constructor(headers: Headers)
   statusCode(): StatusCode;
@@ -646,42 +642,22 @@ export class OutgoingBody {
   static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
 }
 
-export class Fields {
-  constructor()
-  static fromList(entries: [FieldKey, FieldValue][]): Fields;
-  get(name: FieldKey): FieldValue[];
-  has(name: FieldKey): boolean;
-  set(name: FieldKey, value: FieldValue[]): void;
-  'delete'(name: FieldKey): void;
-  append(name: FieldKey, value: FieldValue): void;
-  entries(): [FieldKey, FieldValue][];
-  clone(): Fields;
-}
-
-export class IncomingBody {
-  stream(): InputStream;
-  static finish(this_: IncomingBody): FutureTrailers;
-}
-
-export class FutureIncomingResponse {
-  subscribe(): Pollable;
-  get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
-}
-
-export class FutureTrailers {
-  subscribe(): Pollable;
-  get(): Result<Result<Trailers | undefined, ErrorCode>, void> | undefined;
-}
-
-export class IncomingRequest {
-  method(): Method;
-  pathWithQuery(): string | undefined;
-  scheme(): Scheme | undefined;
-  authority(): string | undefined;
+export class IncomingResponse {
+  status(): StatusCode;
   headers(): Headers;
   consume(): IncomingBody;
 }
 
+export class RequestOptions {
+  constructor()
+  connectTimeout(): Duration | undefined;
+  setConnectTimeout(duration: Duration | undefined): void;
+  firstByteTimeout(): Duration | undefined;
+  setFirstByteTimeout(duration: Duration | undefined): void;
+  betweenBytesTimeout(): Duration | undefined;
+  setBetweenBytesTimeout(duration: Duration | undefined): void;
+}
+
 export class OutgoingRequest {
   constructor(headers: Headers)
   body(): OutgoingBody;
@@ -696,18 +672,42 @@ export class OutgoingRequest {
   headers(): Headers;
 }
 
-export class IncomingResponse {
-  status(): StatusCode;
+export class IncomingRequest {
+  method(): Method;
+  pathWithQuery(): string | undefined;
+  scheme(): Scheme | undefined;
+  authority(): string | undefined;
   headers(): Headers;
   consume(): IncomingBody;
 }
 
-export class RequestOptions {
+export class Fields {
   constructor()
-  connectTimeout(): Duration | undefined;
-  setConnectTimeout(duration: Duration | undefined): void;
-  firstByteTimeout(): Duration | undefined;
-  setFirstByteTimeout(duration: Duration | undefined): void;
-  betweenBytesTimeout(): Duration | undefined;
-  setBetweenBytesTimeout(duration: Duration | undefined): void;
+  static fromList(entries: [FieldKey, FieldValue][]): Fields;
+  get(name: FieldKey): FieldValue[];
+  has(name: FieldKey): boolean;
+  set(name: FieldKey, value: FieldValue[]): void;
+  'delete'(name: FieldKey): void;
+  append(name: FieldKey, value: FieldValue): void;
+  entries(): [FieldKey, FieldValue][];
+  clone(): Fields;
+}
+
+export class FutureTrailers {
+  subscribe(): Pollable;
+  get(): Result<Result<Trailers | undefined, ErrorCode>, void> | undefined;
+}
+
+export class FutureIncomingResponse {
+  subscribe(): Pollable;
+  get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
+}
+
+export class IncomingBody {
+  stream(): InputStream;
+  static finish(this_: IncomingBody): FutureTrailers;
+}
+
+export class ResponseOutparam {
+  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
 }

package/types/interfaces/wasi-io-streams.d.ts

@@ -188,9 +188,9 @@ export namespace WasiIoStreams {
        * is ready for reading, before performing the `splice`.
        */
     }
-    import type { Error } from '../interfaces/wasi-io-error.js';
+    import type { Error } from './wasi-io-error.js';
     export { Error };
-    import type { Pollable } from '../interfaces/wasi-io-poll.js';
+    import type { Pollable } from './wasi-io-poll.js';
     export { Pollable };
     /**
      * An error for input-stream and output-stream operations.

package/types/interfaces/wasi-sockets-instance-network.d.ts

@@ -4,5 +4,5 @@ export namespace WasiSocketsInstanceNetwork {
    */
   export function instanceNetwork(): Network;
 }
-import type { Network } from '../interfaces/wasi-sockets-network.js';
+import type { Network } from './wasi-sockets-network.js';
 export { Network };

package/types/interfaces/wasi-sockets-ip-name-lookup.d.ts

@@ -45,13 +45,13 @@ export namespace WasiSocketsIpNameLookup {
    * It's planned to be removed when `future` is natively supported in Preview3.
    */
 }
-import type { Pollable } from '../interfaces/wasi-io-poll.js';
+import type { Pollable } from './wasi-io-poll.js';
 export { Pollable };
-import type { Network } from '../interfaces/wasi-sockets-network.js';
+import type { Network } from './wasi-sockets-network.js';
 export { Network };
-import type { ErrorCode } from '../interfaces/wasi-sockets-network.js';
+import type { ErrorCode } from './wasi-sockets-network.js';
 export { ErrorCode };
-import type { IpAddress } from '../interfaces/wasi-sockets-network.js';
+import type { IpAddress } from './wasi-sockets-network.js';
 export { IpAddress };
 
 export class ResolveAddressStream {

package/types/interfaces/wasi-sockets-tcp-create-socket.d.ts

@@ -23,11 +23,11 @@ export namespace WasiSocketsTcpCreateSocket {
    */
   export function createTcpSocket(addressFamily: IpAddressFamily): TcpSocket;
 }
-import type { Network } from '../interfaces/wasi-sockets-network.js';
+import type { Network } from './wasi-sockets-network.js';
 export { Network };
-import type { ErrorCode } from '../interfaces/wasi-sockets-network.js';
+import type { ErrorCode } from './wasi-sockets-network.js';
 export { ErrorCode };
-import type { IpAddressFamily } from '../interfaces/wasi-sockets-network.js';
+import type { IpAddressFamily } from './wasi-sockets-network.js';
 export { IpAddressFamily };
-import type { TcpSocket } from '../interfaces/wasi-sockets-tcp.js';
+import type { TcpSocket } from './wasi-sockets-tcp.js';
 export { TcpSocket };

package/types/interfaces/wasi-sockets-tcp.d.ts

@@ -302,21 +302,21 @@ export namespace WasiSocketsTcp {
    * - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
    */
 }
-import type { InputStream } from '../interfaces/wasi-io-streams.js';
+import type { InputStream } from './wasi-io-streams.js';
 export { InputStream };
-import type { OutputStream } from '../interfaces/wasi-io-streams.js';
+import type { OutputStream } from './wasi-io-streams.js';
 export { OutputStream };
-import type { Pollable } from '../interfaces/wasi-io-poll.js';
+import type { Pollable } from './wasi-io-poll.js';
 export { Pollable };
-import type { Duration } from '../interfaces/wasi-clocks-monotonic-clock.js';
+import type { Duration } from './wasi-clocks-monotonic-clock.js';
 export { Duration };
-import type { Network } from '../interfaces/wasi-sockets-network.js';
+import type { Network } from './wasi-sockets-network.js';
 export { Network };
-import type { ErrorCode } from '../interfaces/wasi-sockets-network.js';
+import type { ErrorCode } from './wasi-sockets-network.js';
 export { ErrorCode };
-import type { IpSocketAddress } from '../interfaces/wasi-sockets-network.js';
+import type { IpSocketAddress } from './wasi-sockets-network.js';
 export { IpSocketAddress };
-import type { IpAddressFamily } from '../interfaces/wasi-sockets-network.js';
+import type { IpAddressFamily } from './wasi-sockets-network.js';
 export { IpAddressFamily };
 /**
  * # Variants

package/types/interfaces/wasi-sockets-udp-create-socket.d.ts

@@ -23,11 +23,11 @@ export namespace WasiSocketsUdpCreateSocket {
    */
   export function createUdpSocket(addressFamily: IpAddressFamily): UdpSocket;
 }
-import type { Network } from '../interfaces/wasi-sockets-network.js';
+import type { Network } from './wasi-sockets-network.js';
 export { Network };
-import type { ErrorCode } from '../interfaces/wasi-sockets-network.js';
+import type { ErrorCode } from './wasi-sockets-network.js';
 export { ErrorCode };
-import type { IpAddressFamily } from '../interfaces/wasi-sockets-network.js';
+import type { IpAddressFamily } from './wasi-sockets-network.js';
 export { IpAddressFamily };
-import type { UdpSocket } from '../interfaces/wasi-sockets-udp.js';
+import type { UdpSocket } from './wasi-sockets-udp.js';
 export { UdpSocket };

package/types/interfaces/wasi-sockets-udp.d.ts

@@ -220,15 +220,15 @@ export namespace WasiSocketsUdp {
        * It's planned to be removed when `future` is natively supported in Preview3.
        */
     }
-    import type { Pollable } from '../interfaces/wasi-io-poll.js';
+    import type { Pollable } from './wasi-io-poll.js';
     export { Pollable };
-    import type { Network } from '../interfaces/wasi-sockets-network.js';
+    import type { Network } from './wasi-sockets-network.js';
     export { Network };
-    import type { ErrorCode } from '../interfaces/wasi-sockets-network.js';
+    import type { ErrorCode } from './wasi-sockets-network.js';
     export { ErrorCode };
-    import type { IpSocketAddress } from '../interfaces/wasi-sockets-network.js';
+    import type { IpSocketAddress } from './wasi-sockets-network.js';
     export { IpSocketAddress };
-    import type { IpAddressFamily } from '../interfaces/wasi-sockets-network.js';
+    import type { IpAddressFamily } from './wasi-sockets-network.js';
     export { IpAddressFamily };
     /**
      * A received datagram.