@bytecodealliance/preview2-shim 0.17.1 → 0.17.3

package/lib/synckit/index.js

@@ -23,105 +23,114 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-import path from "node:path";
+import path from 'node:path';
 import {
-  MessageChannel,
-  Worker,
-  receiveMessageOnPort,
-  workerData,
-  parentPort,
-} from "node:worker_threads";
+    MessageChannel,
+    Worker,
+    receiveMessageOnPort,
+    workerData,
+    parentPort,
+} from 'node:worker_threads';
 
 const DEFAULT_WORKER_BUFFER_SIZE = 1024;
 
 function extractProperties(object) {
-  if (object && typeof object === "object") {
-    const properties = {};
-    for (const key in object) {
-      properties[key] = object[key];
+    if (object && typeof object === 'object') {
+        const properties = {};
+        for (const key in object) {
+            properties[key] = object[key];
+        }
+        return properties;
     }
-    return properties;
-  }
 }
 
 const CALL_TIMEOUT = undefined;
 
 export function createSyncFn(workerPath, debug, callbackHandler) {
-  if (!path.isAbsolute(workerPath)) {
-    throw new Error("`workerPath` must be absolute");
-  }
-  const { port1: mainPort, port2: workerPort } = new MessageChannel();
-  const worker = new Worker(workerPath, {
-    workerData: { workerPort, debug },
-    transferList: [workerPort],
-    execArgv: []
-  });
-  worker.on('message', ({ type, id, payload }) => {
-    if (!type)
-      throw new Error('Internal error: Expected a type of a worker callback');
-    callbackHandler(type, id, payload);
-  });
-  let nextID = 0;
-  const syncFn = (...args) => {
-    const cid = nextID++;
-    const sharedBuffer = new SharedArrayBuffer(DEFAULT_WORKER_BUFFER_SIZE);
-    const sharedBufferView = new Int32Array(sharedBuffer);
-    const msg = { sharedBuffer, cid, args };
-    worker.postMessage(msg);
-    const status = Atomics.wait(sharedBufferView, 0, 0, CALL_TIMEOUT);
-    if (!["ok", "not-equal"].includes(status)) {
-      throw new Error("Internal error: Atomics.wait() failed: " + status);
-    }
-    const {
-      cid: cid2,
-      result,
-      error,
-      properties,
-    } = receiveMessageOnPort(mainPort).message;
-    if (cid !== cid2) {
-      throw new Error(`Internal error: Expected id ${cid} but got id ${cid2}`);
+    if (!path.isAbsolute(workerPath)) {
+        throw new Error('`workerPath` must be absolute');
     }
-    if (error) {
-      if (error instanceof Error) throw Object.assign(error, properties);
-      throw error;
+    const { port1: mainPort, port2: workerPort } = new MessageChannel();
+    const worker = new Worker(workerPath, {
+        workerData: { workerPort, debug },
+        transferList: [workerPort],
+        execArgv: [],
+    });
+    worker.on('message', ({ type, id, payload }) => {
+        if (!type) {
+            throw new Error(
+                'Internal error: Expected a type of a worker callback'
+            );
+        }
+        callbackHandler(type, id, payload);
+    });
+    let nextID = 0;
+    const syncFn = (...args) => {
+        const cid = nextID++;
+        const sharedBuffer = new SharedArrayBuffer(DEFAULT_WORKER_BUFFER_SIZE);
+        const sharedBufferView = new Int32Array(sharedBuffer);
+        const msg = { sharedBuffer, cid, args };
+        worker.postMessage(msg);
+        const status = Atomics.wait(sharedBufferView, 0, 0, CALL_TIMEOUT);
+        if (!['ok', 'not-equal'].includes(status)) {
+            throw new Error('Internal error: Atomics.wait() failed: ' + status);
+        }
+        const {
+            cid: cid2,
+            result,
+            error,
+            properties,
+        } = receiveMessageOnPort(mainPort).message;
+        if (cid !== cid2) {
+            throw new Error(
+                `Internal error: Expected id ${cid} but got id ${cid2}`
+            );
+        }
+        if (error) {
+            if (error instanceof Error) {
+                throw Object.assign(error, properties);
+            }
+            throw error;
+        }
+        return result;
+    };
+    if (worker.unref) {
+        worker.unref();
     }
-    return result;
-  };
-  if (worker.unref) worker.unref();
-  return syncFn;
+    return syncFn;
 }
 
 export function runAsWorker(fn) {
-  if (!workerData) {
-    return;
-  }
-  const { workerPort, debug } = workerData;
-  try {
-    parentPort.on("message", ({ sharedBuffer, cid, args }) => {
-      (async () => {
-        const sharedBufferView = new Int32Array(sharedBuffer);
-        let msg;
-        try {
-          msg = { cid, result: await fn(...args) };
-        } catch (error) {
-          msg = { cid, error, properties: extractProperties(error) };
-        }
-        workerPort.postMessage(msg);
-        Atomics.add(sharedBufferView, 0, 1);
-        Atomics.notify(sharedBufferView, 0);
-      })();
-    });
-  } catch (error) {
-    parentPort.on("message", ({ sharedBuffer, cid }) => {
-      const sharedBufferView = new Int32Array(sharedBuffer);
-      workerPort.postMessage({
-        cid,
-        error,
-        properties: extractProperties(error),
-      });
-      Atomics.add(sharedBufferView, 0, 1);
-      Atomics.notify(sharedBufferView, 0);
-    });
-  }
-  return debug;
+    if (!workerData) {
+        return;
+    }
+    const { workerPort, debug } = workerData;
+    try {
+        parentPort.on('message', ({ sharedBuffer, cid, args }) => {
+            (async () => {
+                const sharedBufferView = new Int32Array(sharedBuffer);
+                let msg;
+                try {
+                    msg = { cid, result: await fn(...args) };
+                } catch (error) {
+                    msg = { cid, error, properties: extractProperties(error) };
+                }
+                workerPort.postMessage(msg);
+                Atomics.add(sharedBufferView, 0, 1);
+                Atomics.notify(sharedBufferView, 0);
+            })();
+        });
+    } catch (error) {
+        parentPort.on('message', ({ sharedBuffer, cid }) => {
+            const sharedBufferView = new Int32Array(sharedBuffer);
+            workerPort.postMessage({
+                cid,
+                error,
+                properties: extractProperties(error),
+            });
+            Atomics.add(sharedBufferView, 0, 1);
+            Atomics.notify(sharedBufferView, 0);
+        });
+    }
+    return debug;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",
@@ -15,18 +15,22 @@
       "types": "./types/*.d.ts",
       "node": "./lib/nodejs/*.js",
       "default": "./lib/browser/*.js"
+    },
+    "./instantiation": {
+      "types": "./types/instantiation.d.ts",
+      "node": "./lib/common/instantiation.js",
+      "default": "./lib/common/instantiation.js"
     }
   },
   "scripts": {
-    "test": "node --expose-gc ../../node_modules/mocha/bin/mocha.js -u tdd test/test.js --timeout 30000"
+    "lint": "eslint -c ../../eslint.config.mjs ./lib/**/*.js",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "vitest run -c test/vitest.ts"
   },
   "files": [
     "types",
     "lib"
   ],
-  "devDependencies": {
-    "mocha": "^10.2.0"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bytecodealliance/jco.git"

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,6 @@
-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 random from "./random.d.ts";
+export type * as sockets from "./sockets.d.ts";

package/types/instantiation.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Type alias that represents the kind of imports that the average
+ * transpiled Jco component will require.
+ *
+ * For example, `wasi:http/types` and `wasi:http/outgoing-handler` are present due to
+ * the ability for a component to call `fetch()` at any point in time.
+ *
+ * While the feature can be disabled when building with `jco componentize` or `componentize-js`,
+ * by default it is enabled, and as such included here (practically, the implementations can be no-ops).
+ */
+type WASIImportObject = {
+    'wasi:cli/environment': typeof import('./interfaces/wasi-cli-environment.d.ts');
+    'wasi:cli/exit': typeof import('./interfaces/wasi-cli-exit.d.ts');
+    'wasi:cli/stderr': typeof import('./interfaces/wasi-cli-stderr.d.ts');
+    'wasi:cli/stdin': typeof import('./interfaces/wasi-cli-stdin.d.ts');
+    'wasi:cli/stdout': typeof import('./interfaces/wasi-cli-stdout.d.ts');
+    'wasi:cli/terminal-input': typeof import('./interfaces/wasi-cli-terminal-input.d.ts');
+    'wasi:cli/terminal-output': typeof import('./interfaces/wasi-cli-terminal-output.d.ts');
+    'wasi:cli/terminal-stderr': typeof import('./interfaces/wasi-cli-terminal-stderr.d.ts');
+    'wasi:cli/terminal-stdin': typeof import('./interfaces/wasi-cli-terminal-stdin.d.ts');
+    'wasi:cli/terminal-stdout': typeof import('./interfaces/wasi-cli-terminal-stdout.d.ts');
+
+    'wasi:sockets/instance-network': typeof import('./interfaces/wasi-sockets-instance-network.d.ts');
+    'wasi:sockets/ip-name-lookup': typeof import('./interfaces/wasi-sockets-ip-name-lookup.d.ts');
+    'wasi:sockets/network': typeof import('./interfaces/wasi-sockets-network.d.ts');
+    'wasi:sockets/tcp': typeof import('./interfaces/wasi-sockets-tcp.d.ts');
+    'wasi:sockets/tcp-create-socket': typeof import('./interfaces/wasi-sockets-tcp-create-socket.d.ts');
+    'wasi:sockets/udp': typeof import('./interfaces/wasi-sockets-udp.d.ts');
+    'wasi:sockets/udp-create-socket': typeof import('./interfaces/wasi-sockets-udp-create-socket.d.ts');
+
+    'wasi:filesystem/preopens': typeof import('./interfaces/wasi-filesystem-preopens.d.ts');
+    'wasi:filesystem/types': typeof import('./interfaces/wasi-filesystem-types.d.ts');
+
+    'wasi:io/error': typeof import('./interfaces/wasi-io-error.d.ts');
+    'wasi:io/poll': typeof import('./interfaces/wasi-io-poll.d.ts');
+    'wasi:io/streams': typeof import('./interfaces/wasi-io-streams.d.ts');
+
+    'wasi:random/random': typeof import('./interfaces/wasi-random-random.d.ts');
+    'wasi:random/insecure': typeof import('./interfaces/wasi-random-insecure.d.ts');
+    'wasi:random/insecure-seed': typeof import('./interfaces/wasi-random-insecure-seed.d.ts');
+
+    'wasi:clocks/monotonic-clock': typeof import('./interfaces/wasi-clocks-monotonic-clock.d.ts');
+    'wasi:clocks/timezone': typeof import('./interfaces/wasi-clocks-timezone.d.ts');
+    'wasi:clocks/wall-clock': typeof import('./interfaces/wasi-clocks-wall-clock.d.ts');
+
+    'wasi:http/types': typeof import('./interfaces/wasi-http-types.d.ts');
+    'wasi:http/outgoing-handler': typeof import('./interfaces/wasi-http-outgoing-handler.d.ts');
+};
+
+/**
+ * (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())
+ * ```
+ *
+ * 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 {
+    constructor(shims?: Partial<WASIImportObject>);
+
+    /**
+     * Generate an import object for the shim that can be used with
+     * functions like `instantiate` that are exposed from a transpiled
+     * WebAssembly component.
+     *
+     * @returns {object}
+     */
+    getImportObject(): WASIImportObject;
+}

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;