@ruby/wasm-wasi 2.3.0 → 2.4.0

package/dist/index.umd.js

@@ -601,6 +601,107 @@
     };
   }
 
+  /**
+   * Create a console printer that can be used as an overlay of WASI imports.
+   * See the example below for how to use it.
+   *
+   * ```javascript
+   * const imports = {
+   *  "wasi_snapshot_preview1": wasi.wasiImport,
+   * }
+   * const printer = consolePrinter();
+   * printer.addToImports(imports);
+   *
+   * const instance = await WebAssembly.instantiate(module, imports);
+   * printer.setMemory(instance.exports.memory);
+   * ```
+   *
+   * Note that the `stdout` and `stderr` functions are called with text, not
+   * bytes. This means that bytes written to stdout/stderr will be decoded as
+   * UTF-8 and then passed to the `stdout`/`stderr` functions every time a write
+   * occurs without buffering.
+   *
+   * @param stdout A function that will be called when stdout is written to.
+   *               Defaults to `console.log`.
+   * @param stderr A function that will be called when stderr is written to.
+   *               Defaults to `console.warn`.
+   * @returns An object that can be used as an overlay of WASI imports.
+   */
+  function consolePrinter({ stdout, stderr, } = {
+      stdout: console.log,
+      stderr: console.warn,
+  }) {
+      let memory = undefined;
+      let _view = undefined;
+      function getMemoryView() {
+          if (typeof memory === "undefined") {
+              throw new Error("Memory is not set");
+          }
+          if (_view === undefined || _view.buffer.byteLength === 0) {
+              _view = new DataView(memory.buffer);
+          }
+          return _view;
+      }
+      const decoder = new TextDecoder();
+      return {
+          addToImports(imports) {
+              const wasiImport = imports.wasi_snapshot_preview1;
+              const original_fd_write = wasiImport.fd_write;
+              wasiImport.fd_write = (fd, iovs, iovsLen, nwritten) => {
+                  if (fd !== 1 && fd !== 2) {
+                      return original_fd_write(fd, iovs, iovsLen, nwritten);
+                  }
+                  const view = getMemoryView();
+                  const buffers = Array.from({ length: iovsLen }, (_, i) => {
+                      const ptr = iovs + i * 8;
+                      const buf = view.getUint32(ptr, true);
+                      const bufLen = view.getUint32(ptr + 4, true);
+                      return new Uint8Array(memory.buffer, buf, bufLen);
+                  });
+                  let written = 0;
+                  let str = "";
+                  for (const buffer of buffers) {
+                      str += decoder.decode(buffer);
+                      written += buffer.byteLength;
+                  }
+                  view.setUint32(nwritten, written, true);
+                  const log = fd === 1 ? stdout : stderr;
+                  log(str);
+                  return 0;
+              };
+              const original_fd_filestat_get = wasiImport.fd_filestat_get;
+              wasiImport.fd_filestat_get = (fd, filestat) => {
+                  if (fd !== 1 && fd !== 2) {
+                      return original_fd_filestat_get(fd, filestat);
+                  }
+                  const view = getMemoryView();
+                  const result = original_fd_filestat_get(fd, filestat);
+                  if (result !== 0) {
+                      return result;
+                  }
+                  const filetypePtr = filestat + 0;
+                  view.setUint8(filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
+                  return 0;
+              };
+              const original_fd_fdstat_get = wasiImport.fd_fdstat_get;
+              wasiImport.fd_fdstat_get = (fd, fdstat) => {
+                  if (fd !== 1 && fd !== 2) {
+                      return original_fd_fdstat_get(fd, fdstat);
+                  }
+                  const view = getMemoryView();
+                  const fs_filetypePtr = fdstat + 0;
+                  view.setUint8(fs_filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
+                  const fs_rights_basePtr = fdstat + 8;
+                  view.setBigUint64(fs_rights_basePtr, BigInt(1)); // RIGHTS_FD_WRITE
+                  return 0;
+              };
+          },
+          setMemory(m) {
+              memory = m;
+          },
+      };
+  }
+
   /**
    * A Ruby VM instance
    *
@@ -933,12 +1034,14 @@
       wrap(value) {
           return this.transport.importJsValue(value, this);
       }
+      /** @private */
       privateObject() {
           return {
               transport: this.transport,
               exceptionFormatter: this.exceptionFormatter,
           };
       }
+      /** @private */
       rbValueOfPointer(pointer) {
           const abiValue = new RbAbiValue(pointer, this.guest);
           return new RbValue(abiValue, this, this.privateObject());
@@ -1063,8 +1166,27 @@
   class RbExceptionFormatter {
       constructor() {
           this.literalsCache = null;
+          this.isFormmatting = false;
       }
       format(error, vm, privateObject) {
+          // All Ruby exceptions raised during formatting exception message should
+          // be caught and return a fallback message.
+          // Therefore, we don't need to worry about infinite recursion here ideally
+          // but checking re-entrancy just in case.
+          class RbExceptionFormatterError extends Error {
+          }
+          if (this.isFormmatting) {
+              throw new RbExceptionFormatterError("Unexpected exception occurred during formatting exception message");
+          }
+          this.isFormmatting = true;
+          try {
+              return this._format(error, vm, privateObject);
+          }
+          finally {
+              this.isFormmatting = false;
+          }
+      }
+      _format(error, vm, privateObject) {
           const [zeroLiteral, oneLiteral, newLineLiteral] = (() => {
               if (this.literalsCache == null) {
                   const zeroOneNewLine = [
@@ -1079,18 +1201,43 @@
                   return this.literalsCache;
               }
           })();
-          const backtrace = error.call("backtrace");
+          let className;
+          let backtrace;
+          let message;
+          try {
+              className = error.call("class").toString();
+          }
+          catch (e) {
+              className = "unknown";
+          }
+          try {
+              message = error.toString();
+          }
+          catch (e) {
+              message = "unknown";
+          }
+          try {
+              backtrace = error.call("backtrace");
+          }
+          catch (e) {
+              return this.formatString(className, message);
+          }
           if (backtrace.call("nil?").toString() === "true") {
-              return this.formatString(error.call("class").toString(), error.toString());
+              return this.formatString(className, message);
+          }
+          try {
+              const firstLine = backtrace.call("at", zeroLiteral);
+              const restLines = backtrace
+                  .call("drop", oneLiteral)
+                  .call("join", newLineLiteral);
+              return this.formatString(className, message, [
+                  firstLine.toString(),
+                  restLines.toString(),
+              ]);
+          }
+          catch (e) {
+              return this.formatString(className, message);
           }
-          const firstLine = backtrace.call("at", zeroLiteral);
-          const restLines = backtrace
-              .call("drop", oneLiteral)
-              .call("join", newLineLiteral);
-          return this.formatString(error.call("class").toString(), error.toString(), [
-              firstLine.toString(),
-              restLines.toString(),
-          ]);
       }
       formatString(klass, message, backtrace) {
           if (backtrace) {
@@ -1194,5 +1341,6 @@
   exports.RbFatalError = RbFatalError;
   exports.RbValue = RbValue;
   exports.RubyVM = RubyVM;
+  exports.consolePrinter = consolePrinter;
 
 }));

package/package.json

@@ -1,36 +1,25 @@
 {
   "name": "@ruby/wasm-wasi",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "WebAssembly port of CRuby with WASI",
-  "main": "./dist/index.cjs.js",
-  "umd:main": "./dist/index.umd.js",
-  "module": "./dist/index.esm.js",
-  "typings": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "browser": "./dist/index.umd.js",
+  "typings": "./dist/esm/index.d.ts",
   "exports": {
     ".": {
-      "browser": "./dist/index.esm.js",
-      "umd": "./dist/index.umd.js",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.cjs.js",
-      "types": "./dist/browser.d.ts"
+      "browser": "./dist/esm/index.js",
+      "umd": "./dist/umd/index.js",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/browser.d.ts"
     },
-    "./dist/browser": {
-      "browser": "./dist/browser.esm.js",
-      "umd": "./dist/browser.umd.js",
-      "import": "./dist/browser.esm.js",
-      "require": "./dist/browser.cjs.js",
-      "types": "./dist/browser.d.ts"
-    },
-    "./dist/browser.script": {
-      "browser": "./dist/browser.script.esm.js",
-      "umd": "./dist/browser.script.umd.js",
-      "import": "./dist/browser.script.esm.js",
-      "types": "./dist/browser.script.d.ts"
-    },
-    "./dist/node": {
-      "import": "./dist/node.esm.js",
-      "require": "./dist/node.cjs.js",
-      "types": "./dist/node.d.ts"
+    "./dist/*": {
+      "browser": "./dist/esm/*.js",
+      "umd": "./dist/umd/*.js",
+      "import": "./dist/esm/*.js",
+      "require": "./dist/cjs/*.js",
+      "types": "./dist/esm/*.d.ts"
     }
   },
   "files": [
@@ -61,25 +50,20 @@
     "serve:example": "bundle exec ruby -run -e httpd ./example -p 8085",
     "format": "prettier --write .",
     "build:static": "./tools/pack-bindgen-src.sh ./dist",
-    "build:rollup": "rollup -c rollup.config.mjs && tsc --build",
-    "build": "npm run build:static && npm run build:rollup"
+    "build:rollup": "rollup -c rollup.config.mjs",
+    "build:tsc": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
+    "build": "npm run build:rollup && npm run build:tsc && npm run build:static && ./tools/post-build.sh ./dist"
   },
   "devDependencies": {
-    "@babel/core": "^7.19.3",
-    "@babel/preset-env": "^7.19.3",
-    "@babel/preset-typescript": "^7.18.6",
-    "@rollup/plugin-inject": "^5.0.5",
     "@rollup/plugin-node-resolve": "^15.1.0",
     "@rollup/plugin-typescript": "^11.1.2",
     "@types/jest": "^29.5.3",
     "@types/node": "20.8.10",
-    "@wasmer/wasi": "^1.2.2",
-    "babel-jest": "^29.7.0",
     "jest": "^29.6.2",
     "prettier": "^3.0.0",
-    "rollup": "^3.2.2",
-    "rollup-plugin-polyfill-node": "^0.12.0",
-    "typescript": "^5.2.2"
+    "rollup": "^4.6.1",
+    "@bjorn3/browser_wasi_shim": "^0.2.17",
+    "typescript": "^5.3.2"
   },
   "dependencies": {
     "tslib": "^2.6.1"