@bytecodealliance/preview2-shim 0.17.2 → 0.17.4

package/lib/browser/random.js

@@ -3,54 +3,56 @@ const MAX_BYTES = 65536;
 let insecureRandomValue1, insecureRandomValue2;
 
 export const insecure = {
-  getInsecureRandomBytes (len) {
-    return random.getRandomBytes(len);
-  },
-  getInsecureRandomU64 () {
-    return random.getRandomU64();
-  }
+    getInsecureRandomBytes(len) {
+        return random.getRandomBytes(len);
+    },
+    getInsecureRandomU64() {
+        return random.getRandomU64();
+    },
 };
 
 let insecureSeedValue1, insecureSeedValue2;
 
 export const insecureSeed = {
-  insecureSeed () {
-    if (insecureSeedValue1 === undefined) {
-      insecureSeedValue1 = random.getRandomU64();
-      insecureSeedValue2 = random.getRandomU64();
-    }
-    return [insecureSeedValue1, insecureSeedValue2];
-  }
+    insecureSeed() {
+        if (insecureSeedValue1 === undefined) {
+            insecureSeedValue1 = random.getRandomU64();
+            insecureSeedValue2 = random.getRandomU64();
+        }
+        return [insecureSeedValue1, insecureSeedValue2];
+    },
 };
 
 export const random = {
-  getRandomBytes(len) {
-    const bytes = new Uint8Array(Number(len));
-
-    if (len > MAX_BYTES) {
-      // this is the max bytes crypto.getRandomValues
-      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-      for (var generated = 0; generated < len; generated += MAX_BYTES) {
-        // buffer.slice automatically checks if the end is past the end of
-        // the buffer so we don't have to here
-        crypto.getRandomValues(bytes.subarray(generated, generated + MAX_BYTES));
-      }
-    } else {
-      crypto.getRandomValues(bytes);
-    }
-
-    return bytes;
-  },
-
-  getRandomU64 () {
-    return crypto.getRandomValues(new BigUint64Array(1))[0];
-  },
-
-  insecureRandom () {
-    if (insecureRandomValue1 === undefined) {
-      insecureRandomValue1 = random.getRandomU64();
-      insecureRandomValue2 = random.getRandomU64();
-    }
-    return [insecureRandomValue1, insecureRandomValue2];
-  }
+    getRandomBytes(len) {
+        const bytes = new Uint8Array(Number(len));
+
+        if (len > MAX_BYTES) {
+            // this is the max bytes crypto.getRandomValues
+            // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+            for (var generated = 0; generated < len; generated += MAX_BYTES) {
+                // buffer.slice automatically checks if the end is past the end of
+                // the buffer so we don't have to here
+                crypto.getRandomValues(
+                    bytes.subarray(generated, generated + MAX_BYTES)
+                );
+            }
+        } else {
+            crypto.getRandomValues(bytes);
+        }
+
+        return bytes;
+    },
+
+    getRandomU64() {
+        return crypto.getRandomValues(new BigUint64Array(1))[0];
+    },
+
+    insecureRandom() {
+        if (insecureRandomValue1 === undefined) {
+            insecureRandomValue1 = random.getRandomU64();
+            insecureRandomValue2 = random.getRandomU64();
+        }
+        return [insecureRandomValue1, insecureRandomValue2];
+    },
 };

package/lib/browser/sockets.js

@@ -1,186 +1,88 @@
 export const instanceNetwork = {
-  instanceNetwork () {
-    console.log(`[sockets] instance network`);
-  }
+    instanceNetwork() {
+        console.log(`[sockets] instance network`);
+    },
 };
 
 export const ipNameLookup = {
-  dropResolveAddressStream () {
-
-  },
-  subscribe () {
-  
-  },
-  resolveAddresses () {
-  
-  },
-  resolveNextAddress () {
-  
-  },
-  nonBlocking () {
-  
-  },
-  setNonBlocking () {
-  
-  },
+    dropResolveAddressStream() {},
+    subscribe() {},
+    resolveAddresses() {},
+    resolveNextAddress() {},
+    nonBlocking() {},
+    setNonBlocking() {},
 };
 
 export const network = {
-  dropNetwork () {
-
-  }
+    dropNetwork() {},
 };
 
 export const tcpCreateSocket = {
-  createTcpSocket () {
-
-  }
+    createTcpSocket() {},
 };
 
 export const tcp = {
-  subscribe () {
-
-  },
-  dropTcpSocket() {
-  
-  },
-  bind() {
-  
-  },
-  connect() {
-  
-  },
-  listen() {
-  
-  },
-  accept() {
-  
-  },
-  localAddress() {
-  
-  },
-  remoteAddress() {
-  
-  },
-  addressFamily() {
-  
-  },
-  setListenBacklogSize() {
-  
-  },
-  keepAlive() {
-  
-  },
-  setKeepAlive() {
-  
-  },
-  noDelay() {
-  
-  },
-  setNoDelay() {
-  
-  },
-  unicastHopLimit() {
-  
-  },
-  setUnicastHopLimit() {
-  
-  },
-  receiveBufferSize() {
-  
-  },
-  setReceiveBufferSize() {
-  
-  },
-  sendBufferSize() {
-  
-  },
-  setSendBufferSize() {
-  
-  },
-  nonBlocking() {
-  
-  },
-  setNonBlocking() {
-  
-  },
-  shutdown() {
-  
-  }
+    subscribe() {},
+    dropTcpSocket() {},
+    bind() {},
+    connect() {},
+    listen() {},
+    accept() {},
+    localAddress() {},
+    remoteAddress() {},
+    addressFamily() {},
+    setListenBacklogSize() {},
+    keepAlive() {},
+    setKeepAlive() {},
+    noDelay() {},
+    setNoDelay() {},
+    unicastHopLimit() {},
+    setUnicastHopLimit() {},
+    receiveBufferSize() {},
+    setReceiveBufferSize() {},
+    sendBufferSize() {},
+    setSendBufferSize() {},
+    nonBlocking() {},
+    setNonBlocking() {},
+    shutdown() {},
 };
 
 export const udp = {
-  subscribe () {
-
-  },
-  
-  dropUdpSocket () {
-  
-  },
-  
-  bind () {
-  
-  },
-  
-  connect () {
-  
-  },
-  
-  receive () {
-  
-  },
-  
-  send () {
-  
-  },
-  
-  localAddress () {
-  
-  },
-  
-  remoteAddress () {
-  
-  },
-  
-  addressFamily () {
-  
-  },
-  
-  unicastHopLimit () {
-  
-  },
-  
-  setUnicastHopLimit () {
-  
-  },
-  
-  receiveBufferSize () {
-  
-  },
-  
-  setReceiveBufferSize () {
-  
-  },
-  
-  sendBufferSize () {
-  
-  },
-  
-  setSendBufferSize () {
-  
-  },
-  
-  nonBlocking () {
-  
-  },
-  
-  setNonBlocking () {
-  
-  }
+    subscribe() {},
+
+    dropUdpSocket() {},
+
+    bind() {},
+
+    connect() {},
+
+    receive() {},
+
+    send() {},
+
+    localAddress() {},
+
+    remoteAddress() {},
+
+    addressFamily() {},
+
+    unicastHopLimit() {},
+
+    setUnicastHopLimit() {},
+
+    receiveBufferSize() {},
+
+    setReceiveBufferSize() {},
+
+    sendBufferSize() {},
+
+    setSendBufferSize() {},
+
+    nonBlocking() {},
+
+    setNonBlocking() {},
 };
 
 export const udpCreateSocket = {
-  createUdpSocket () {
-
-  }
+    createUdpSocket() {},
 };

package/lib/common/instantiation.js

@@ -0,0 +1,134 @@
+import * as wasi from '@bytecodealliance/preview2-shim';
+
+/**
+ * (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 {
+    /** Object that confirms to the shim interface for `wasi:cli` */
+    #cli;
+    /** Object that confirms to the shim interface for `wasi:filesystem` */
+    #filesystem;
+    /** Object that confirms to the shim interface for `wasi:io` */
+    #io;
+    /** Object that confirms to the shim interface for `wasi:random` */
+    #random;
+    /** Object that confirms to the shim interface for `wasi:clocks` */
+    #clocks;
+    /** Object that confirms to the shim interface for `wasi:sockets` */
+    #sockets;
+    /** Object that confirms to the shim interface for `wasi:http` */
+    #http;
+
+    constructor(shims) {
+        this.#cli = shims?.cli ?? wasi.cli;
+        this.#filesystem = shims?.filesystem ?? wasi.filesystem;
+        this.#io = shims?.io ?? wasi.io;
+        this.#random = shims?.random ?? wasi.random;
+        this.#clocks = shims?.clocks ?? wasi.clocks;
+        this.#sockets = shims?.sockets ?? wasi.sockets;
+        this.#http = shims?.http ?? wasi.http;
+    }
+
+    /**
+     * Generate an import object for the shim that can be used with
+     * functions like `instantiate` that are exposed from a transpiled
+     * WebAssembly component.
+     *
+     * @param {GetImportObjectArgs} [opts] - options for import object generation
+     * @returns {WASIImportObject}
+     *
+     * @typedef {{
+     *   asVersion?: number,
+     * }} GetImportObjectArgs
+     */
+    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;
+
+        obj[`wasi:filesystem/preopens${versionSuffix}`] = this.#filesystem.preopens;
+        obj[`wasi:filesystem/types${versionSuffix}`] = this.#filesystem.types;
+
+        obj[`wasi:io/error${versionSuffix}`] = this.#io.error;
+        obj[`wasi:io/poll${versionSuffix}`] = this.#io.poll;
+        obj[`wasi:io/streams${versionSuffix}`] = this.#io.streams;
+
+        obj[`wasi:random/random${versionSuffix}`] = this.#random.random;
+        obj[`wasi:random/insecure${versionSuffix}`] = this.#random.insecure;
+        obj[`wasi:random/insecure-seed${versionSuffix}`] = this.#random.insecureSeed;
+
+        obj[`wasi:clocks/monotonic-clock${versionSuffix}`] = this.#clocks.monotonicClock;
+        obj[`wasi:clocks/wall-clock${versionSuffix}`] = this.#clocks.wallClock;
+
+        obj[`wasi:http/types${versionSuffix}`] = this.#http.types;
+        obj[`wasi:http/outgoing-handler${versionSuffix}`] = this.#http.outgoingHandler;
+
+        return obj;
+    }
+}

package/lib/io/calls.js

@@ -34,7 +34,7 @@ export const OUTPUT_STREAM_FLUSH = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_BLOCKING_FLUSH = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_WRITE_ZEROES = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH =
-  ++call_id << CALL_SHIFT;
+    ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_SPLICE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
@@ -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
@@ -103,7 +104,7 @@ export const SOCKET_UDP_SET_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
 export const SOCKET_UDP_SET_UNICAST_HOP_LIMIT = ++call_id << CALL_SHIFT;
 export const SOCKET_INCOMING_DATAGRAM_STREAM_RECEIVE = ++call_id << CALL_SHIFT;
 export const SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND =
-  ++call_id << CALL_SHIFT;
+    ++call_id << CALL_SHIFT;
 export const SOCKET_OUTGOING_DATAGRAM_STREAM_SEND = ++call_id << CALL_SHIFT;
 export const SOCKET_DATAGRAM_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const SOCKET_DATAGRAM_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
@@ -119,9 +120,11 @@ export const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST = ++call_id << CALL_SHIFT;
 
 export const reverseMap = {};
 
-import * as calls from "./calls.js";
+import * as calls from './calls.js';
 
 for (const name of Object.getOwnPropertyNames(calls)) {
-  if (name === "reverseMap") continue;
-  reverseMap[calls[name]] = name;
+    if (name === 'reverseMap') {
+        continue;
+    }
+    reverseMap[calls[name]] = name;
 }