@bytecodealliance/preview2-shim 0.17.0 → 0.17.2

package/lib/browser/cli.js

@@ -29,16 +29,19 @@ export const environment = {
 };
 
 class ComponentExit extends Error {
-  constructor(ok) {
-    super(`Component exited ${ok ? 'successfully' : 'with error'}`);
+  constructor(code) {
+    super(`Component exited ${code === 0 ? 'successfully' : 'with error'}`);
     this.exitError = true;
-    this.ok = ok;
+    this.code = code;
   }
 }
 
 export const exit = {
   exit (status) {
-    throw new ComponentExit(status.tag === 'err' ? true : false);
+    throw new ComponentExit(status.tag === 'err' ? 1 : 0);
+  },
+  exitWithCode (code) {
+    throw new ComponentExit(code);
   }
 };
 

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

@@ -31,7 +31,7 @@ import {
 } from "./worker-sockets.js";
 import { Socket, Server } from "node:net";
 
-const winOrMac = process.platform === 'win32' || process.platform === 'darwin';
+const win = process.platform === 'win32';
 
 /**
  * @typedef {import("../../types/interfaces/wasi-sockets-network.js").IpSocketAddress} IpSocketAddress
@@ -268,7 +268,7 @@ export function socketTcpGetRemoteAddress(id) {
 export function socketTcpShutdown(id, _shutdownType) {
   const socket = tcpSockets.get(id);
   if (socket.state !== SOCKET_STATE_CONNECTION) throw "invalid-state";
-  if (winOrMac && socket.tcpSocket.destroySoon)
+  if (win && socket.tcpSocket.destroySoon)
     socket.tcpSocket.destroySoon();
   else
     socket.tcpSocket.destroy();

package/lib/io/worker-thread.js

@@ -393,8 +393,9 @@ function handle(call, id, payload) {
       return;
     }
     case HTTP_OUTGOING_BODY_DISPOSE:
-      if (!streams.delete(id))
-        throw new Error("wasi-io trap: stream not found to dispose");
+      if (debug && !streams.has(id))
+        console.warn(`wasi-io: stream ${id} not found to dispose`);
+      streams.delete(id);
       return;
     case HTTP_SERVER_START:
       return startHttpServer(id, payload);
@@ -645,34 +646,86 @@ function handle(call, id, payload) {
       }
       stream.pollState.ready = false;
       return (stream.flushPromise = new Promise((resolve, reject) => {
-        stream.stream.write(payload, (err) => {
+        if (stream.stream === stdout || stream.stream === stderr) {
+          // Inside workers, NodeJS actually queues writes destined for
+          // stdout/stderr in a port that is only flushed on exit of the worker.
+          //
+          // In this case, we cannot attempt to wait for the promise.
+          //
+          // This code may have to be reworked for browsers.
+          //
+          // see: https://github.com/nodejs/node/blob/v22.12.0/lib/internal/worker/io.js#L288
+          // see: https://github.com/nodejs/node/blob/v22.12.0/lib/internal/worker.js#L303
+          // see: https://github.com/nodejs/node/blob/v22.12.0/typings/internalBinding/messaging.d.ts#L27
+          stream.stream.write(payload);
           stream.flushPromise = null;
           pollStateReady(stream.pollState);
-          if (err) return void reject(streamError(err));
           resolve(BigInt(payload.byteLength));
-        });
+        } else {
+          stream.stream.write(payload, (err) => {
+            stream.flushPromise = null;
+            pollStateReady(stream.pollState);
+            if (err) return void reject(streamError(err));
+            resolve(BigInt(payload.byteLength));
+          });
+        }
       }));
     }
     case OUTPUT_STREAM_FLUSH: {
       const stream = getStreamOrThrow(id);
       if (stream.flushPromise) return;
       stream.pollState.ready = false;
-      return (stream.flushPromise = new Promise((resolve, reject) => {
-        stream.stream.write(new Uint8Array([]), (err) => {
+      stream.flushPromise = new Promise((resolve, reject) => {
+        if (stream.stream === stdout || stream.stream === stderr) {
+          // Inside workers, NodeJS actually queues writes destined for
+          // stdout/stderr in a port that is only flushed on exit of the worker.
+          //
+          // In this case, we cannot attempt to wait for the promise.
+          //
+          // This code may have to be reworked for browsers.
+          //
+          // see: https://github.com/nodejs/node/blob/v22.12.0/lib/internal/worker/io.js#L288
+          // see: https://github.com/nodejs/node/blob/v22.12.0/lib/internal/worker.js#L303
+          // see: https://github.com/nodejs/node/blob/v22.12.0/typings/internalBinding/messaging.d.ts#L27
           stream.flushPromise = null;
           pollStateReady(stream.pollState);
-          if (err) return void reject(streamError(err));
           resolve();
-        });
-      }));
+        } else {
+          // For all other writes, we can perform the actual write and expect the write to complete
+          // and trigger the relevant callback
+          stream.stream.write(new Uint8Array([]), (err) => {
+            stream.flushPromise = null;
+            pollStateReady(stream.pollState);
+            if (err) return void reject(streamError(err));
+            resolve();
+          });
+        }
+      });
+      return stream.flushPromise;
     }
     case OUTPUT_STREAM_BLOCKING_FLUSH: {
       const stream = getStreamOrThrow(id);
       if (stream.flushPromise) return stream.flushPromise;
       return new Promise((resolve, reject) => {
-        stream.stream.write(new Uint8Array([]), (err) =>
-          err ? reject(streamError(err)) : resolve()
-        );
+        if (stream.stream === stdout || stream.stream === stderr) {
+          // Inside workers, NodeJS actually queues writes destined for
+          // stdout/stderr in a port that is only flushed on exit of the worker.
+          //
+          // In this case, we cannot attempt to wait for the promise.
+          //
+          // This code may have to be reworked for browsers.
+          //
+          // see: https://github.com/nodejs/node/blob/v22.12.0/lib/internal/worker/io.js#L288
+          // see: https://github.com/nodejs/node/blob/v22.12.0/lib/internal/worker.js#L303
+          // see: https://github.com/nodejs/node/blob/v22.12.0/typings/internalBinding/messaging.d.ts#L27
+          resolve();
+        } else {
+          // For all other writes, we can perform the actual write and expect the write to complete
+          // and trigger the relevant callback
+          stream.stream.write(new Uint8Array([]), (err) =>
+            err ? reject(streamError(err)) : resolve()
+          );
+        }
       });
     }
     case OUTPUT_STREAM_WRITE_ZEROES:

package/lib/nodejs/cli.js

@@ -47,6 +47,9 @@ export const exit = {
   exit(status) {
     process.exit(status.tag === "err" ? 1 : 0);
   },
+  exitWithCode(code) {
+    process.exit(code);
+  }
 };
 
 // Stdin is created as a FILE descriptor

package/lib/nodejs/filesystem.js

@@ -368,19 +368,16 @@ class Descriptor {
       }
     }
     try {
-      const fd = openSync(fullPath, fsOpenFlags);
+      const fd = openSync(fullPath.endsWith('/') ? fullPath.slice(0, -1) : fullPath, fsOpenFlags);
       const descriptor = descriptorCreate(
         fd,
         descriptorFlags,
         fullPath,
         preopenEntries
       );
-      if (fullPath.endsWith("/") && isWindows) {
-        // check if its a directory
-        if (descriptor.getType() !== "directory") {
-          descriptor[symbolDispose]();
-          throw "not-directory";
-        }
+      if (fullPath.endsWith('/') && descriptor.getType() !== 'directory') {
+        descriptor[symbolDispose]();
+        throw "not-directory";
       }
       return descriptor;
     } catch (e) {
@@ -671,6 +668,7 @@ function convertFsError(e) {
     case "ENOSPC":
       return "insufficient-space";
     case "ENOTDIR":
+    case 'ERR_FS_EISDIR':
       return "not-directory";
     case "ENOTEMPTY":
       return "not-empty";

package/package.json

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

package/types/cli.d.ts

@@ -1,23 +1,11 @@
-import type { WasiCliEnvironment } from './interfaces/wasi-cli-environment.d.ts';
-import type { WasiCliExit } from './interfaces/wasi-cli-exit.d.ts';
-import type { WasiCliRun } from './interfaces/wasi-cli-run.d.ts';
-import type { WasiCliStderr } from './interfaces/wasi-cli-stderr.d.ts';
-import type { WasiCliStdin } from './interfaces/wasi-cli-stdin.d.ts';
-import type { WasiCliStdout } from './interfaces/wasi-cli-stdout.d.ts';
-import type { WasiCliTerminalInput } from './interfaces/wasi-cli-terminal-input.d.ts';
-import type { WasiCliTerminalOutput } from './interfaces/wasi-cli-terminal-output.d.ts';
-import type { WasiCliTerminalStderr } from './interfaces/wasi-cli-terminal-stderr.d.ts';
-import type { WasiCliTerminalStdin } from './interfaces/wasi-cli-terminal-stdin.d.ts';
-import type { WasiCliTerminalStdout } from './interfaces/wasi-cli-terminal-stdout.d.ts';
-
-export const environment: typeof WasiCliEnvironment;
-export const exit: typeof WasiCliExit;
-export const run: typeof WasiCliRun;
-export const stderr: typeof WasiCliStderr;
-export const stdin: typeof WasiCliStdin;
-export const stdout: typeof WasiCliStdout;
-export const terminalInput: typeof WasiCliTerminalInput;
-export const terminalOutput: typeof WasiCliTerminalOutput;
-export const terminalStderr: typeof WasiCliTerminalStderr;
-export const terminalStdin: typeof WasiCliTerminalStdin;
-export const terminalStdout: typeof WasiCliTerminalStdout;
+export type * as environment from './interfaces/wasi-cli-environment.d.ts';
+export type * as exit from './interfaces/wasi-cli-exit.d.ts';
+export type * as run from './interfaces/wasi-cli-run.d.ts';
+export type * as stderr from './interfaces/wasi-cli-stderr.d.ts';
+export type * as stdin from './interfaces/wasi-cli-stdin.d.ts';
+export type * as stdout from './interfaces/wasi-cli-stdout.d.ts';
+export type * as terminalInput from './interfaces/wasi-cli-terminal-input.d.ts';
+export type * as terminalOutput from './interfaces/wasi-cli-terminal-output.d.ts';
+export type * as terminalStderr from './interfaces/wasi-cli-terminal-stderr.d.ts';
+export type * as terminalStdin from './interfaces/wasi-cli-terminal-stdin.d.ts';
+export type * as terminalStdout from './interfaces/wasi-cli-terminal-stdout.d.ts';

package/types/clocks.d.ts

@@ -1,5 +1,2 @@
-import type { WasiClocksMonotonicClock } from './interfaces/wasi-clocks-monotonic-clock.d.ts';
-import type { WasiClocksWallClock } from './interfaces/wasi-clocks-wall-clock.d.ts';
-
-export const wallClock: typeof WasiClocksWallClock;
-export const monotonicClock: typeof WasiClocksMonotonicClock;
+export type * as monotonicClock from './interfaces/wasi-clocks-monotonic-clock.d.ts';
+export type * as wallClock from './interfaces/wasi-clocks-wall-clock.d.ts';

package/types/filesystem.d.ts

@@ -1,5 +1,2 @@
-import type { WasiFilesystemPreopens } from './interfaces/wasi-filesystem-preopens.d.ts';
-import type { WasiFilesystemTypes } from './interfaces/wasi-filesystem-types.d.ts';
-
-export const preopens: typeof WasiFilesystemPreopens;
-export const types: typeof WasiFilesystemTypes;
+export type * as preopens from './interfaces/wasi-filesystem-preopens.d.ts';
+export type * as types from './interfaces/wasi-filesystem-types.d.ts';

package/types/http.d.ts

@@ -1,7 +1,3 @@
-import type { WasiHttpIncomingHandler } from './interfaces/wasi-http-incoming-handler.d.ts';
-import type { WasiHttpOutgoingHandler } from './interfaces/wasi-http-outgoing-handler.d.ts';
-import type { WasiHttpTypes } from './interfaces/wasi-http-types.d.ts';
-
-export const incomingHandler: typeof WasiHttpIncomingHandler;
-export const outgoingHandler: typeof WasiHttpOutgoingHandler;
-export const types: typeof WasiHttpTypes;
+export type * as incomingHandler from './interfaces/wasi-http-incoming-handler.d.ts';
+export type * as outgoingHandler from './interfaces/wasi-http-outgoing-handler.d.ts';
+export type * as types from './interfaces/wasi-http-types.d.ts';

package/types/index.d.ts

@@ -1,15 +1,7 @@
-import type * as WasiCli from "./cli.d.ts";
-import type * as WasiClocks from './clocks.d.ts';
-import type * as WasiFilesystem from './filesystem.d.ts';
-import type * as WasiHttp from "./http.d.ts";
-import type * as WasiIo from "./io.d.ts";
-import type * as WasiRandom from "./random.d.ts";
-import type * as WasiSockets from "./sockets.d.ts";
-
-export const cli: typeof WasiCli;
-export const clocks: typeof WasiClocks;
-export const filesystem: typeof WasiFilesystem;
-export const http: typeof WasiHttp;
-export const io: typeof WasiIo;
-export const random: typeof WasiRandom;
-export const sockets: typeof WasiSockets;
+export type * as cli from "./cli.d.ts";
+export type * as clocks from './clocks.d.ts';
+export type * as filesystem from './filesystem.d.ts';
+export type * as http from "./http.d.ts";
+export type * as io from "./io.d.ts";
+export type * as random from "./random.d.ts";
+export type * as sockets from "./sockets.d.ts";

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

@@ -1,22 +1,21 @@
-export namespace WasiCliEnvironment {
-  /**
-   * Get the POSIX-style environment variables.
-   * 
-   * Each environment variable is provided as a pair of string variable names
-   * and string value.
-   * 
-   * Morally, these are a value import, but until value imports are available
-   * in the component model, this import function should return the same
-   * values each time it is called.
-   */
-  export function getEnvironment(): Array<[string, string]>;
-  /**
-   * Get the POSIX-style arguments to the program.
-   */
-  export function getArguments(): Array<string>;
-  /**
-   * Return a path that programs should use as their initial current working
-   * directory, interpreting `.` as shorthand for this.
-   */
-  export function initialCwd(): string | undefined;
-}
+/** @module Interface wasi:cli/environment@0.2.3 **/
+/**
+ * Get the POSIX-style environment variables.
+ * 
+ * Each environment variable is provided as a pair of string variable names
+ * and string value.
+ * 
+ * Morally, these are a value import, but until value imports are available
+ * in the component model, this import function should return the same
+ * values each time it is called.
+ */
+export function getEnvironment(): Array<[string, string]>;
+/**
+ * Get the POSIX-style arguments to the program.
+ */
+export function getArguments(): Array<string>;
+/**
+ * Return a path that programs should use as their initial current working
+ * directory, interpreting `.` as shorthand for this.
+ */
+export function initialCwd(): string | undefined;

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

@@ -1,7 +1,6 @@
-export namespace WasiCliExit {
-  /**
-   * Exit the current instance and any linked instances.
-   */
-  export function exit(status: Result<void, void>): void;
-}
+/** @module Interface wasi:cli/exit@0.2.3 **/
+/**
+ * Exit the current instance and any linked instances.
+ */
+export function exit(status: Result<void, void>): void;
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

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

@@ -1,6 +1,5 @@
-export namespace WasiCliRun {
-  /**
-   * Run the program.
-   */
-  export function run(): void;
-}
+/** @module Interface wasi:cli/run@0.2.3 **/
+/**
+ * Run the program.
+ */
+export function run(): void;

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

@@ -1,5 +1,3 @@
-export namespace WasiCliStderr {
-  export function getStderr(): OutputStream;
-}
-import type { OutputStream } from './wasi-io-streams.js';
-export { OutputStream };
+/** @module Interface wasi:cli/stderr@0.2.3 **/
+export function getStderr(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

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

@@ -1,5 +1,3 @@
-export namespace WasiCliStdin {
-  export function getStdin(): InputStream;
-}
-import type { InputStream } from './wasi-io-streams.js';
-export { InputStream };
+/** @module Interface wasi:cli/stdin@0.2.3 **/
+export function getStdin(): InputStream;
+export type InputStream = import('./wasi-io-streams.js').InputStream;

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

@@ -1,5 +1,3 @@
-export namespace WasiCliStdout {
-  export function getStdout(): OutputStream;
-}
-import type { OutputStream } from './wasi-io-streams.js';
-export { OutputStream };
+/** @module Interface wasi:cli/stdout@0.2.3 **/
+export function getStdout(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

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

@@ -1,6 +1,8 @@
-export namespace WasiCliTerminalInput {
-  export { TerminalInput };
-}
+/** @module Interface wasi:cli/terminal-input@0.2.3 **/
 
 export class TerminalInput {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
 }

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

@@ -1,6 +1,8 @@
-export namespace WasiCliTerminalOutput {
-  export { TerminalOutput };
-}
+/** @module Interface wasi:cli/terminal-output@0.2.3 **/
 
 export class TerminalOutput {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
 }

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

@@ -1,9 +1,7 @@
-export namespace WasiCliTerminalStderr {
-  /**
-   * If stderr is connected to a terminal, return a `terminal-output` handle
-   * allowing further interaction with it.
-   */
-  export function getTerminalStderr(): TerminalOutput | undefined;
-}
-import type { TerminalOutput } from './wasi-cli-terminal-output.js';
-export { TerminalOutput };
+/** @module Interface wasi:cli/terminal-stderr@0.2.3 **/
+/**
+ * If stderr is connected to a terminal, return a `terminal-output` handle
+ * allowing further interaction with it.
+ */
+export function getTerminalStderr(): TerminalOutput | undefined;
+export type TerminalOutput = import('./wasi-cli-terminal-output.js').TerminalOutput;

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

@@ -1,9 +1,7 @@
-export namespace WasiCliTerminalStdin {
-  /**
-   * If stdin is connected to a terminal, return a `terminal-input` handle
-   * allowing further interaction with it.
-   */
-  export function getTerminalStdin(): TerminalInput | undefined;
-}
-import type { TerminalInput } from './wasi-cli-terminal-input.js';
-export { TerminalInput };
+/** @module Interface wasi:cli/terminal-stdin@0.2.3 **/
+/**
+ * If stdin is connected to a terminal, return a `terminal-input` handle
+ * allowing further interaction with it.
+ */
+export function getTerminalStdin(): TerminalInput | undefined;
+export type TerminalInput = import('./wasi-cli-terminal-input.js').TerminalInput;

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

@@ -1,9 +1,7 @@
-export namespace WasiCliTerminalStdout {
-  /**
-   * If stdout is connected to a terminal, return a `terminal-output` handle
-   * allowing further interaction with it.
-   */
-  export function getTerminalStdout(): TerminalOutput | undefined;
-}
-import type { TerminalOutput } from './wasi-cli-terminal-output.js';
-export { TerminalOutput };
+/** @module Interface wasi:cli/terminal-stdout@0.2.3 **/
+/**
+ * If stdout is connected to a terminal, return a `terminal-output` handle
+ * allowing further interaction with it.
+ */
+export function getTerminalStdout(): TerminalOutput | undefined;
+export type TerminalOutput = import('./wasi-cli-terminal-output.js').TerminalOutput;

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

@@ -1,29 +1,27 @@
-export namespace WasiClocksMonotonicClock {
-  /**
-   * Read the current value of the clock.
-   * 
-   * The clock is monotonic, therefore calling this function repeatedly will
-   * produce a sequence of non-decreasing values.
-   */
-  export function now(): Instant;
-  /**
-   * Query the resolution of the clock. Returns the duration of time
-   * corresponding to a clock tick.
-   */
-  export function resolution(): Duration;
-  /**
-   * Create a `pollable` which will resolve once the specified instant
-   * has occurred.
-   */
-  export function subscribeInstant(when: Instant): Pollable;
-  /**
-   * Create a `pollable` that will resolve after the specified duration has
-   * elapsed from the time this function is invoked.
-   */
-  export function subscribeDuration(when: Duration): Pollable;
-}
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
+/** @module Interface wasi:clocks/monotonic-clock@0.2.3 **/
+/**
+ * Read the current value of the clock.
+ * 
+ * The clock is monotonic, therefore calling this function repeatedly will
+ * produce a sequence of non-decreasing values.
+ */
+export function now(): Instant;
+/**
+ * Query the resolution of the clock. Returns the duration of time
+ * corresponding to a clock tick.
+ */
+export function resolution(): Duration;
+/**
+ * Create a `pollable` which will resolve once the specified instant
+ * has occurred.
+ */
+export function subscribeInstant(when: Instant): Pollable;
+/**
+ * Create a `pollable` that will resolve after the specified duration has
+ * elapsed from the time this function is invoked.
+ */
+export function subscribeDuration(when: Duration): Pollable;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
 /**
  * An instant in time, in nanoseconds. An instant is relative to an
  * unspecified initial value, and can only be compared to instances from

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

@@ -1,27 +1,26 @@
-export namespace WasiClocksWallClock {
-  /**
-   * Read the current value of the clock.
-   * 
-   * This clock is not monotonic, therefore calling this function repeatedly
-   * will not necessarily produce a sequence of non-decreasing values.
-   * 
-   * The returned timestamps represent the number of seconds since
-   * 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
-   * also known as [Unix Time].
-   * 
-   * The nanoseconds field of the output is always less than 1000000000.
-   * 
-   * [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
-   * [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
-   */
-  export function now(): Datetime;
-  /**
-   * Query the resolution of the clock.
-   * 
-   * The nanoseconds field of the output is always less than 1000000000.
-   */
-  export function resolution(): Datetime;
-}
+/** @module Interface wasi:clocks/wall-clock@0.2.3 **/
+/**
+ * Read the current value of the clock.
+ * 
+ * This clock is not monotonic, therefore calling this function repeatedly
+ * will not necessarily produce a sequence of non-decreasing values.
+ * 
+ * The returned timestamps represent the number of seconds since
+ * 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+ * also known as [Unix Time].
+ * 
+ * The nanoseconds field of the output is always less than 1000000000.
+ * 
+ * [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+ * [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+ */
+export function now(): Datetime;
+/**
+ * Query the resolution of the clock.
+ * 
+ * The nanoseconds field of the output is always less than 1000000000.
+ */
+export function resolution(): Datetime;
 /**
  * A time and date in seconds plus nanoseconds.
  */

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

@@ -1,8 +1,6 @@
-export namespace WasiFilesystemPreopens {
-  /**
-   * Return the set of preopened directories, and their path.
-   */
-  export function getDirectories(): Array<[Descriptor, string]>;
-}
-import type { Descriptor } from './wasi-filesystem-types.js';
-export { Descriptor };
+/** @module Interface wasi:filesystem/preopens@0.2.3 **/
+/**
+ * Return the set of preopened directories, and their paths.
+ */
+export function getDirectories(): Array<[Descriptor, string]>;
+export type Descriptor = import('./wasi-filesystem-types.js').Descriptor;