@bytecodealliance/preview2-shim 0.17.3 → 0.17.5

package/README.md

@@ -6,6 +6,53 @@ Node.js support is fully tested and conformant against the Wasmtime test suite.
 
 Browser support is considered experimental, and not currently suitable for production applications.
 
+# Features
+
+## WASI Shim object for easy instantiation
+
+An default instantiation object can be used via the `WASIShim` class in `@bytecodealliance/preview2-shim/instantiation`:
+
+```typescript
+import { WASIShim } from '@bytecodealliance/preview2-shim/instantiation';
+import type {
+    VersionedWASIImportObject,
+    WASIImportObject,
+} from '@bytecodealliance/preview2-shim/instantiation';
+
+const shim = new WASIShim();
+
+const unversioned: WASIImportObject = shim.getImportObject();
+// console.log('unversioned', unversioned);
+unversioned satisfies WASIImportObject;
+unversioned satisfies VersionedWASIImportObject<''>;
+
+const versioned: VersionedWASIImportObject<'0.2.3'> = shim.getImportObject({
+    asVersion: '0.2.3',
+});
+//console.log('versioned', versioned);
+versioned satisfies VersionedWASIImportObject<'0.2.3'>;
+```
+
+The import object generated by `getImportObject` can be easily used in `instantiate()` calls
+produced by [`jco transpile`][jco] (with `--instantiation=async`):
+
+```js
+import { WASIShim } from '@bytecodealliance/preview2-shim/instantiation';
+
+// The code below assumes that you have output your transpiled WebAssembly component to `dist/transpiled`
+import { instantiate } from './dist/transpiled/component.js';
+
+const loader = async (path: string) => {
+    const buf = await readFile(`./dist/transpiled/${path}`);
+    return await WebAssembly.compile(buf.buffer as ArrayBuffer);
+};
+const component = await instantiate(loader, new WASIShim().getImportObject());
+
+// TODO: Code that uses your component's exports goes here.
+```
+
+[jco]: https://www.npmjs.com/package/@bytecodealliance/jco
+
 # License
 
 This project is licensed under the Apache 2.0 license with the LLVM exception.

package/lib/browser/cli.js

@@ -1,34 +1,10 @@
-import { _setCwd as fsSetCwd } from './filesystem.js';
 import { streams } from './io.js';
 const { InputStream, OutputStream } = streams;
 
-const symbolDispose = Symbol.dispose ?? Symbol.for('dispose');
-
-let _env = [],
-    _args = [],
-    _cwd = '/';
-export function _setEnv(envObj) {
-    _env = Object.entries(envObj);
-}
-export function _setArgs(args) {
-    _args = args;
-}
-
-export function _setCwd(cwd) {
-    fsSetCwd((_cwd = cwd));
-}
+export { _setEnv, _setArgs, environment } from './environment.js';
+export { _setCwd } from './config.js';
 
-export const environment = {
-    getEnvironment() {
-        return _env;
-    },
-    getArguments() {
-        return _args;
-    },
-    initialCwd() {
-        return _cwd;
-    },
-};
+const symbolDispose = Symbol.dispose ?? Symbol.for('dispose');
 
 class ComponentExit extends Error {
     constructor(code) {

package/lib/browser/config.js

@@ -0,0 +1,10 @@
+// eslint-disable-next-line no-unused-vars
+let _cwd = '/';
+
+export function _setCwd(cwd) {
+    _cwd = cwd;
+}
+
+export function _getCwd() {
+    return _cwd;
+}

package/lib/browser/environment.js

@@ -0,0 +1,29 @@
+import { _setCwd as fsSetCwd } from './config.js';
+
+let _env = [],
+    _args = [],
+    _cwd = '/';
+
+export function _setEnv(envObj) {
+    _env = Object.entries(envObj);
+}
+
+export function _setArgs(args) {
+    _args = args;
+}
+
+export function _setCwd(cwd) {
+    fsSetCwd((_cwd = cwd));
+}
+
+export const environment = {
+    getEnvironment() {
+        return _env;
+    },
+    getArguments() {
+        return _args;
+    },
+    initialCwd() {
+        return _cwd;
+    },
+};

package/lib/browser/filesystem.js

@@ -1,13 +1,10 @@
 import { streams } from './io.js';
-import { environment } from './cli.js';
+import { environment } from './environment.js';
 
-const { InputStream, OutputStream } = streams;
-
-let _cwd = '/';
+import { _setCwd, _getCwd } from './config.js';
+export { _setCwd } from './config.js';
 
-export function _setCwd(cwd) {
-    _cwd = cwd;
-}
+const { InputStream, OutputStream } = streams;
 
 export function _setFileData(fileData) {
     _fileData = fileData;
@@ -33,7 +30,7 @@ function getChildEntry(parentEntry, subpath, openFlags) {
         _rootPreopen &&
         descriptorGetEntry(_rootPreopen[0]) === parentEntry
     ) {
-        subpath = _cwd;
+        subpath = _getCwd();
         if (subpath.startsWith('/') && subpath !== '/') {
             subpath = subpath.slice(1);
         }

package/lib/common/instantiation.js

@@ -82,46 +82,53 @@ export class WASIShim {
      * functions like `instantiate` that are exposed from a transpiled
      * WebAssembly component.
      *
-     * @returns {object}
+     * @param {GetImportObjectArgs} [opts] - options for import object generation
+     * @returns {WASIImportObject}
+     *
+     * @typedef {{
+     *   asVersion?: number,
+     * }} GetImportObjectArgs
      */
-    getImportObject() {
-        return {
-            'wasi:cli/environment': this.#cli.environment,
-            'wasi:cli/exit': this.#cli.exit,
-            'wasi:cli/stderr': this.#cli.stderr,
-            'wasi:cli/stdin': this.#cli.stdin,
-            'wasi:cli/stdout': this.#cli.stdout,
-            'wasi:cli/terminal-input': this.#cli.terminalInput,
-            'wasi:cli/terminal-output': this.#cli.terminalOutput,
-            'wasi:cli/terminal-stderr': this.#cli.terminalStderr,
-            'wasi:cli/terminal-stdin': this.#cli.terminalStdin,
-            'wasi:cli/terminal-stdout': this.#cli.terminalStdout,
+    getImportObject(opts) {
+        const versionSuffix = opts?.asVersion ? `@${opts.asVersion}` : '';
+
+        const obj = {};
+        obj[`wasi:cli/environment${versionSuffix}`] = 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;
 
-            'wasi:sockets/instance-network': this.#sockets.instanceNetwork,
-            'wasi:sockets/ip-name-lookup': this.#sockets.ipNameLookup,
-            'wasi:sockets/network': this.#sockets.network,
-            'wasi:sockets/tcp': this.#sockets.tcp,
-            'wasi:sockets/tcp-create-socket': this.#sockets.tcpCreateSocket,
-            'wasi:sockets/udp': this.#sockets.udp,
-            'wasi:sockets/udp-create-socket': this.#sockets.udpCreateSocket,
+        obj[`wasi:filesystem/preopens${versionSuffix}`] = this.#filesystem.preopens;
+        obj[`wasi:filesystem/types${versionSuffix}`] = this.#filesystem.types;
 
-            'wasi:filesystem/preopens': this.#filesystem.preopens,
-            'wasi:filesystem/types': 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;
 
-            'wasi:io/error': this.#io.error,
-            'wasi:io/poll': this.#io.poll,
-            'wasi:io/streams': 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;
 
-            'wasi:random/random': this.#random.random,
-            'wasi:random/insecure': this.#random.insecure,
-            'wasi:random/insecure-seed': this.#random.insecureSeed,
+        obj[`wasi:clocks/monotonic-clock${versionSuffix}`] = this.#clocks.monotonicClock;
+        obj[`wasi:clocks/wall-clock${versionSuffix}`] = this.#clocks.wallClock;
 
-            'wasi:clocks/monotonic-clock': this.#clocks.monotonicClock,
-            'wasi:clocks/timezone': this.#clocks.timezone,
-            'wasi:clocks/wall-clock': this.#clocks.wallClock,
+        obj[`wasi:http/types${versionSuffix}`] = this.#http.types;
+        obj[`wasi:http/outgoing-handler${versionSuffix}`] = this.#http.outgoingHandler;
 
-            'wasi:http/types': this.#http.types,
-            'wasi:http/outgoing-handler': this.#http.outgoingHandler,
-        };
+        return obj;
     }
 }

package/lib/io/calls.js

@@ -62,6 +62,7 @@ export const HTTP_SERVER_STOP = ++call_id << CALL_SHIFT;
 export const HTTP_SERVER_INCOMING_HANDLER = ++call_id << CALL_SHIFT;
 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

package/lib/io/worker-http.js

@@ -27,6 +27,10 @@ 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 }
@@ -112,30 +116,30 @@ export async function createHttpRequest(
         // 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:
+        case 'http:':
+            req = httpRequest({
+                agent: httpAgent,
+                method,
+                host: authority.split(':')[0],
+                port: authority.split(':')[1],
+                path: pathWithQuery,
+                timeout:
                         connectTimeout && Number(connectTimeout / 1_000_000n),
-                });
-                break;
-            case 'https:':
-                req = httpsRequest({
-                    agent: httpsAgent,
-                    method,
-                    host: authority.split(':')[0],
-                    port: authority.split(':')[1],
-                    path: pathWithQuery,
-                    timeout:
+            });
+            break;
+        case 'https:':
+            req = httpsRequest({
+                agent: httpsAgent,
+                method,
+                host: authority.split(':')[0],
+                port: authority.split(':')[1],
+                path: pathWithQuery,
+                timeout:
                         connectTimeout && Number(connectTimeout / 1_000_000n),
-                });
-                break;
-            default:
-                throw { tag: 'HTTP-protocol-error' };
+            });
+            break;
+        default:
+            throw { tag: 'HTTP-protocol-error' };
         }
         for (const [key, value] of headers) {
             req.appendHeader(key, value);
@@ -177,20 +181,20 @@ export async function createHttpRequest(
         }
         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',
-                };
+        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',

package/lib/io/worker-io.js

@@ -52,8 +52,8 @@ const DEBUG =
     env.PREVIEW2_SHIM_DEBUG === '0'
         ? false
         : env.PREVIEW2_SHIM_DEBUG === '1'
-          ? true
-          : DEBUG_DEFAULT;
+            ? true
+            : DEBUG_DEFAULT;
 
 /**
  * @type {(call: number, id: number | null, payload: any) -> any}
@@ -219,23 +219,23 @@ class InputStream {
         stream.#streamType = streamType;
         let disposeFn;
         switch (streamType) {
-            case FILE:
-                disposeFn = fileInputStreamDispose;
-                break;
-            case SOCKET_TCP:
-                disposeFn = socketTcpInputStreamDispose;
-                break;
-            case STDIN:
-                disposeFn = stdinInputStreamDispose;
-                break;
-            case HTTP:
-                disposeFn = httpInputStreamDispose;
-                break;
-            default:
-                throw new Error(
-                    'wasi-io trap: Dispose function not created for stream type ' +
+        case FILE:
+            disposeFn = fileInputStreamDispose;
+            break;
+        case SOCKET_TCP:
+            disposeFn = socketTcpInputStreamDispose;
+            break;
+        case STDIN:
+            disposeFn = stdinInputStreamDispose;
+            break;
+        case HTTP:
+            disposeFn = httpInputStreamDispose;
+            break;
+        default:
+            throw new Error(
+                'wasi-io trap: Dispose function not created for stream type ' +
                         reverseMap[streamType]
-                );
+            );
         }
         stream.#finalizer = registerDispose(stream, null, id, disposeFn);
         return stream;
@@ -361,25 +361,25 @@ class OutputStream {
         stream.#streamType = streamType;
         let disposeFn;
         switch (streamType) {
-            case STDOUT:
-                disposeFn = stdoutOutputStreamDispose;
-                break;
-            case STDERR:
-                disposeFn = stderrOutputStreamDispose;
-                break;
-            case SOCKET_TCP:
-                disposeFn = socketTcpOutputStreamDispose;
-                break;
-            case FILE:
-                disposeFn = fileOutputStreamDispose;
-                break;
-            case HTTP:
-                return stream;
-            default:
-                throw new Error(
-                    'wasi-io trap: Dispose function not created for stream type ' +
+        case STDOUT:
+            disposeFn = stdoutOutputStreamDispose;
+            break;
+        case STDERR:
+            disposeFn = stderrOutputStreamDispose;
+            break;
+        case SOCKET_TCP:
+            disposeFn = socketTcpOutputStreamDispose;
+            break;
+        case FILE:
+            disposeFn = fileOutputStreamDispose;
+            break;
+        case HTTP:
+            return stream;
+        default:
+            throw new Error(
+                'wasi-io trap: Dispose function not created for stream type ' +
                         reverseMap[streamType]
-                );
+            );
         }
         stream.#finalizer = registerDispose(stream, null, id, disposeFn);
         return stream;

package/lib/io/worker-sockets.js

@@ -103,21 +103,21 @@ export function socketResolveAddress(name) {
         },
         (err) => {
             switch (err.code) {
-                // TODO: verify these more carefully
-                case NODATA:
-                case BADFAMILY:
-                case NONAME:
-                case NOTFOUND:
-                    throw 'name-unresolvable';
-                case TIMEOUT:
-                case REFUSED:
-                case CONNREFUSED:
-                case SERVFAIL:
-                case NOMEM:
-                case CANCELLED:
-                    throw 'temporary-resolver-failure';
-                default:
-                    throw 'permanent-resolver-failure';
+            // TODO: verify these more carefully
+            case NODATA:
+            case BADFAMILY:
+            case NONAME:
+            case NOTFOUND:
+                throw 'name-unresolvable';
+            case TIMEOUT:
+            case REFUSED:
+            case CONNREFUSED:
+            case SERVFAIL:
+            case NOMEM:
+            case CANCELLED:
+                throw 'temporary-resolver-failure';
+            default:
+                throw 'permanent-resolver-failure';
             }
         }
     );
@@ -125,82 +125,82 @@ export function socketResolveAddress(name) {
 
 export function convertSocketError(err) {
     switch (err?.code) {
-        case 'EBADF':
-        case 'ENOTCONN':
-        case 'ERR_SOCKET_DGRAM_NOT_CONNECTED':
-            return 'invalid-state';
-        case 'EACCES':
-        case 'EPERM':
-            return 'access-denied';
-        case 'ENOTSUP':
-            return 'not-supported';
-        case 'EINVAL':
-            return 'invalid-argument';
-        case 'ENOMEM':
-        case 'ENOBUFS':
-            return 'out-of-memory';
-        case 'EALREADY':
-            return 'concurrency-conflict';
-        case 'EWOULDBLOCK':
-            return 'would-block';
+    case 'EBADF':
+    case 'ENOTCONN':
+    case 'ERR_SOCKET_DGRAM_NOT_CONNECTED':
+        return 'invalid-state';
+    case 'EACCES':
+    case 'EPERM':
+        return 'access-denied';
+    case 'ENOTSUP':
+        return 'not-supported';
+    case 'EINVAL':
+        return 'invalid-argument';
+    case 'ENOMEM':
+    case 'ENOBUFS':
+        return 'out-of-memory';
+    case 'EALREADY':
+        return 'concurrency-conflict';
+    case 'EWOULDBLOCK':
+        return 'would-block';
         // TODO: return "new-socket-limit";
-        case 'EADDRNOTAVAIL':
-            return 'address-not-bindable';
-        case 'EADDRINUSE':
-            return 'address-in-use';
+    case 'EADDRNOTAVAIL':
+        return 'address-not-bindable';
+    case 'EADDRINUSE':
+        return 'address-in-use';
         // TODO: return "remote-unreachable";
-        case 'ECONNREFUSED':
-            return 'connection-refused';
-        case 'ECONNRESET':
-            return 'connection-reset';
-        case 'ECONNABORTED':
-            return 'connection-aborted';
-        default:
-            return 'unknown';
+    case 'ECONNREFUSED':
+        return 'connection-refused';
+    case 'ECONNRESET':
+        return 'connection-reset';
+    case 'ECONNABORTED':
+        return 'connection-aborted';
+    default:
+        return 'unknown';
     }
 }
 
 export function convertSocketErrorCode(code) {
     switch (code) {
-        case 4053: // windows
-        case 4083:
-        case ENOTCONN:
-        case EBADF:
-            return 'invalid-state';
-        case EACCES:
-        case EPERM:
-            return 'access-denied';
-        case ENOTSUP:
-            return 'not-supported';
-        case EINVAL:
-            return 'invalid-argument';
-        case ENOMEM:
-        case ENOBUFS:
-            return 'out-of-memory';
-        case EALREADY:
-            return 'concurrency-conflict';
-        case EWOULDBLOCK:
-            return 'would-block';
+    case 4053: // windows
+    case 4083:
+    case ENOTCONN:
+    case EBADF:
+        return 'invalid-state';
+    case EACCES:
+    case EPERM:
+        return 'access-denied';
+    case ENOTSUP:
+        return 'not-supported';
+    case EINVAL:
+        return 'invalid-argument';
+    case ENOMEM:
+    case ENOBUFS:
+        return 'out-of-memory';
+    case EALREADY:
+        return 'concurrency-conflict';
+    case EWOULDBLOCK:
+        return 'would-block';
         // TODO: return "new-socket-limit";
-        case 4090: // windows
-        case EADDRNOTAVAIL:
-            return 'address-not-bindable';
-        case 4091: // windows
-        case EADDRINUSE:
-            return 'address-in-use';
+    case 4090: // windows
+    case EADDRNOTAVAIL:
+        return 'address-not-bindable';
+    case 4091: // windows
+    case EADDRINUSE:
+        return 'address-in-use';
         // TODO: return "remote-unreachable";
-        case ECONNREFUSED:
-            return 'connection-refused';
-        case ECONNRESET:
-            return 'connection-reset';
-        case ECONNABORTED:
-            return 'connection-aborted';
+    case ECONNREFUSED:
+        return 'connection-refused';
+    case ECONNRESET:
+        return 'connection-reset';
+    case ECONNABORTED:
+        return 'connection-aborted';
         // TODO: return "datagram-too-large";
         // TODO: return "name-unresolvable";
         // TODO: return "temporary-resolver-failure";
-        default:
-            // process._rawDebug('unknown error code', code);
-            return 'unknown';
+    default:
+        // process._rawDebug('unknown error code', code);
+        return 'unknown';
     }
 }