@ruby/wasm-wasi 2.5.1 → 2.5.2

package/dist/index.umd.js

@@ -500,13 +500,13 @@
         data_view(memory).setInt32(arg1 + 4, len0, true);
         data_view(memory).setInt32(arg1 + 0, ptr0, true);
       };
-      imports["rb-js-abi-host"]["js-value-to-integer: func(value: handle<js-abi-value>) -> variant { f64(float64), bignum(string) }"] = function(arg0, arg1) {
+      imports["rb-js-abi-host"]["js-value-to-integer: func(value: handle<js-abi-value>) -> variant { as-float(float64), bignum(string) }"] = function(arg0, arg1) {
         const memory = get_export("memory");
         const realloc = get_export("cabi_realloc");
         const ret0 = obj.jsValueToInteger(resources0.get(arg0));
         const variant1 = ret0;
         switch (variant1.tag) {
-          case "f64": {
+          case "as-float": {
             const e = variant1.val;
             data_view(memory).setInt8(arg1 + 0, 0, true);
             data_view(memory).setFloat64(arg1 + 8, +e, true);
@@ -702,6 +702,72 @@
       };
     }
 
+    class LegacyBinding extends RbAbiGuest {
+        async setInstance(instance) {
+            await this.instantiate(instance);
+        }
+    }
+    class ComponentBinding {
+        constructor() { }
+        setUnderlying(underlying) {
+            this.underlying = underlying;
+        }
+        rubyShowVersion() {
+            this.underlying.rubyShowVersion();
+        }
+        rubyInit() {
+            this.underlying.rubyInit();
+        }
+        rubySysinit(args) {
+            this.underlying.rubySysinit(args);
+        }
+        rubyOptions(args) {
+            this.underlying.rubyOptions(args);
+        }
+        rubyScript(name) {
+            this.underlying.rubyScript(name);
+        }
+        rubyInitLoadpath() {
+            this.underlying.rubyInitLoadpath();
+        }
+        rbEvalStringProtect(str) {
+            return this.underlying.rbEvalStringProtect(str);
+        }
+        rbFuncallvProtect(recv, mid, args) {
+            return this.underlying.rbFuncallvProtect(recv, mid, args);
+        }
+        rbIntern(name) {
+            return this.underlying.rbIntern(name);
+        }
+        rbErrinfo() {
+            return this.underlying.rbErrinfo();
+        }
+        rbClearErrinfo() {
+            return this.underlying.rbClearErrinfo();
+        }
+        rstringPtr(value) {
+            return this.underlying.rstringPtr(value);
+        }
+        rbVmBugreport() {
+            this.underlying.rbVmBugreport();
+        }
+        rbGcEnable() {
+            return this.underlying.rbGcEnable();
+        }
+        rbGcDisable() {
+            return this.underlying.rbGcDisable();
+        }
+        rbSetShouldProhibitRewind(newValue) {
+            return this.underlying.rbSetShouldProhibitRewind(newValue);
+        }
+        async setInstance(instance) {
+            // No-op
+        }
+        addToImports(imports) {
+            // No-op
+        }
+    }
+
     /**
      * A Ruby VM instance
      *
@@ -722,7 +788,7 @@
      *
      */
     class RubyVM {
-        constructor() {
+        constructor(binding) {
             this.instance = null;
             this.interfaceState = {
                 hasJSFrameAfterRbFrame: false,
@@ -731,6 +797,7 @@
             // if the call stack has sandwitched JS frames like JS -> Ruby -> JS -> Ruby.
             const proxyExports = (exports) => {
                 const excludedMethods = [
+                    "setInstance",
                     "addToImports",
                     "instantiate",
                     "rbSetShouldProhibitRewind",
@@ -765,10 +832,34 @@
                 }
                 return exports;
             };
-            this.guest = proxyExports(new RbAbiGuest());
+            this.guest = proxyExports(binding !== null && binding !== void 0 ? binding : new LegacyBinding());
             this.transport = new JsValueTransport();
             this.exceptionFormatter = new RbExceptionFormatter();
         }
+        static async _instantiate(initComponent, options) {
+            const binding = new ComponentBinding();
+            const vm = new RubyVM(binding);
+            class JsAbiValue {
+                constructor(underlying) {
+                    this.underlying = underlying;
+                }
+            }
+            const imports = vm.getImports((from) => new JsAbiValue(from), (to) => to.underlying);
+            const component = await initComponent(Object.assign(Object.assign({}, imports), { throwProhibitRewindException: (message) => {
+                    vm.throwProhibitRewindException(message);
+                }, procToJsFunction: () => {
+                    const rbValue = new RbValue(component.exportRbValueToJs(), vm, vm.privateObject());
+                    return new JsAbiValue((...args) => {
+                        return rbValue.call("call", ...args.map((arg) => vm.wrap(arg))).toJS();
+                    });
+                }, rbObjectToJsRbValue: () => {
+                    const rbValue = new RbValue(component.exportRbValueToJs(), vm, vm.privateObject());
+                    return new JsAbiValue(rbValue);
+                }, JsAbiValue: JsAbiValue }));
+            binding.setUnderlying(component);
+            vm.initialize(options.args);
+            return vm;
+        }
         /**
          * Initialize the Ruby VM with the given command line arguments
          * @param args The command line arguments to pass to Ruby. Must be
@@ -792,7 +883,7 @@
          */
         async setInstance(instance) {
             this.instance = instance;
-            await this.guest.instantiate(instance);
+            await this.guest.setInstance(instance);
         }
         /**
          * Add intrinsic import entries, which is necessary to interact JavaScript
@@ -801,43 +892,36 @@
          */
         addToImports(imports) {
             this.guest.addToImports(imports);
-            function wrapTry(f) {
-                return (...args) => {
-                    try {
-                        return { tag: "success", val: f(...args) };
-                    }
-                    catch (e) {
-                        if (e instanceof RbFatalError) {
-                            // RbFatalError should not be caught by Ruby because it Ruby VM
-                            // can be already in an inconsistent state.
-                            throw e;
-                        }
-                        return { tag: "failure", val: e };
-                    }
-                };
-            }
             imports["rb-js-abi-host"] = {
                 rb_wasm_throw_prohibit_rewind_exception: (messagePtr, messageLen) => {
                     const memory = this.instance.exports.memory;
                     const str = new TextDecoder().decode(new Uint8Array(memory.buffer, messagePtr, messageLen));
-                    let message = "Ruby APIs that may rewind the VM stack are prohibited under nested VM operation " +
-                        `(${str})\n` +
-                        "Nested VM operation means that the call stack has sandwitched JS frames like JS -> Ruby -> JS -> Ruby " +
-                        "caused by something like `window.rubyVM.eval(\"JS.global[:rubyVM].eval('Fiber.yield')\")`\n" +
-                        "\n" +
-                        "Please check your call stack and make sure that you are **not** doing any of the following inside the nested Ruby frame:\n" +
-                        "  1. Switching fibers (e.g. Fiber#resume, Fiber.yield, and Fiber#transfer)\n" +
-                        "     Note that `evalAsync` JS API switches fibers internally\n" +
-                        "  2. Raising uncaught exceptions\n" +
-                        "     Please catch all exceptions inside the nested operation\n" +
-                        "  3. Calling Continuation APIs\n";
-                    const error = new RbValue(this.guest.rbErrinfo(), this, this.privateObject());
-                    if (error.call("nil?").toString() === "false") {
-                        message += "\n" + this.exceptionFormatter.format(error, this, this.privateObject());
-                    }
-                    throw new RbFatalError(message);
+                    this.throwProhibitRewindException(str);
                 },
             };
+            addRbJsAbiHostToImports(imports, this.getImports((value) => value, (value) => value), (name) => {
+                return this.instance.exports[name];
+            });
+        }
+        throwProhibitRewindException(str) {
+            let message = "Ruby APIs that may rewind the VM stack are prohibited under nested VM operation " +
+                `(${str})\n` +
+                "Nested VM operation means that the call stack has sandwitched JS frames like JS -> Ruby -> JS -> Ruby " +
+                "caused by something like `window.rubyVM.eval(\"JS.global[:rubyVM].eval('Fiber.yield')\")`\n" +
+                "\n" +
+                "Please check your call stack and make sure that you are **not** doing any of the following inside the nested Ruby frame:\n" +
+                "  1. Switching fibers (e.g. Fiber#resume, Fiber.yield, and Fiber#transfer)\n" +
+                "     Note that `evalAsync` JS API switches fibers internally\n" +
+                "  2. Raising uncaught exceptions\n" +
+                "     Please catch all exceptions inside the nested operation\n" +
+                "  3. Calling Continuation APIs\n";
+            const error = new RbValue(this.guest.rbErrinfo(), this, this.privateObject());
+            if (error.call("nil?").toString() === "false") {
+                message += "\n" + this.exceptionFormatter.format(error, this, this.privateObject());
+            }
+            throw new RbFatalError(message);
+        }
+        getImports(toJSAbiValue, fromJSAbiValue) {
             // NOTE: The GC may collect objects that are still referenced by Wasm
             // locals because Asyncify cannot scan the Wasm stack above the JS frame.
             // So we need to keep track whether the JS frame is sandwitched by Ruby
@@ -856,9 +940,24 @@
                 }
                 return imports;
             };
-            addRbJsAbiHostToImports(imports, proxyImports({
+            function wrapTry(f) {
+                return (...args) => {
+                    try {
+                        return { tag: "success", val: f(...args) };
+                    }
+                    catch (e) {
+                        if (e instanceof RbFatalError) {
+                            // RbFatalError should not be caught by Ruby because it Ruby VM
+                            // can be already in an inconsistent state.
+                            throw e;
+                        }
+                        return { tag: "failure", val: toJSAbiValue(e) };
+                    }
+                };
+            }
+            return proxyImports({
                 evalJs: wrapTry((code) => {
-                    return Function(code)();
+                    return toJSAbiValue(Function(code)());
                 }),
                 isJs: (value) => {
                     // Just for compatibility with the old JS API
@@ -866,45 +965,47 @@
                 },
                 globalThis: () => {
                     if (typeof globalThis !== "undefined") {
-                        return globalThis;
+                        return toJSAbiValue(globalThis);
                     }
                     else if (typeof global !== "undefined") {
-                        return global;
+                        return toJSAbiValue(global);
                     }
                     else if (typeof window !== "undefined") {
-                        return window;
+                        return toJSAbiValue(window);
                     }
                     throw new Error("unable to locate global object");
                 },
                 intToJsNumber: (value) => {
-                    return value;
+                    return toJSAbiValue(value);
                 },
                 floatToJsNumber: (value) => {
-                    return value;
+                    return toJSAbiValue(value);
                 },
                 stringToJsString: (value) => {
-                    return value;
+                    return toJSAbiValue(value);
                 },
                 boolToJsBool: (value) => {
-                    return value;
+                    return toJSAbiValue(value);
                 },
                 procToJsFunction: (rawRbAbiValue) => {
                     const rbValue = this.rbValueOfPointer(rawRbAbiValue);
-                    return (...args) => {
+                    return toJSAbiValue((...args) => {
                         return rbValue.call("call", ...args.map((arg) => this.wrap(arg))).toJS();
-                    };
+                    });
                 },
                 rbObjectToJsRbValue: (rawRbAbiValue) => {
-                    return this.rbValueOfPointer(rawRbAbiValue);
+                    return toJSAbiValue(this.rbValueOfPointer(rawRbAbiValue));
                 },
                 jsValueToString: (value) => {
+                    value = fromJSAbiValue(value);
                     // According to the [spec](https://tc39.es/ecma262/multipage/text-processing.html#sec-string-constructor-string-value)
                     // `String(value)` always returns a string.
                     return String(value);
                 },
                 jsValueToInteger(value) {
+                    value = fromJSAbiValue(value);
                     if (typeof value === "number") {
-                        return { tag: "f64", val: value };
+                        return { tag: "as-float", val: value };
                     }
                     else if (typeof value === "bigint") {
                         return { tag: "bignum", val: BigInt(value).toString(10) + "\0" };
@@ -913,38 +1014,40 @@
                         return { tag: "bignum", val: value + "\0" };
                     }
                     else if (typeof value === "undefined") {
-                        return { tag: "f64", val: 0 };
+                        return { tag: "as-float", val: 0 };
                     }
                     else {
-                        return { tag: "f64", val: Number(value) };
+                        return { tag: "as-float", val: Number(value) };
                     }
                 },
                 exportJsValueToHost: (value) => {
                     // See `JsValueExporter` for the reason why we need to do this
-                    this.transport.takeJsValue(value);
+                    this.transport.takeJsValue(fromJSAbiValue(value));
                 },
                 importJsValueFromHost: () => {
-                    return this.transport.consumeJsValue();
+                    return toJSAbiValue(this.transport.consumeJsValue());
                 },
                 instanceOf: (value, klass) => {
+                    klass = fromJSAbiValue(klass);
                     if (typeof klass === "function") {
-                        return value instanceof klass;
+                        return fromJSAbiValue(value) instanceof klass;
                     }
                     else {
                         return false;
                     }
                 },
                 jsValueTypeof(value) {
-                    return typeof value;
+                    return typeof fromJSAbiValue(value);
                 },
                 jsValueEqual(lhs, rhs) {
-                    return lhs == rhs;
+                    return fromJSAbiValue(lhs) == fromJSAbiValue(rhs);
                 },
                 jsValueStrictlyEqual(lhs, rhs) {
-                    return lhs === rhs;
+                    return fromJSAbiValue(lhs) === fromJSAbiValue(rhs);
                 },
                 reflectApply: wrapTry((target, thisArgument, args) => {
-                    return Reflect.apply(target, thisArgument, args);
+                    const jsArgs = args.map((arg) => fromJSAbiValue(arg));
+                    return toJSAbiValue(Reflect.apply(fromJSAbiValue(target), fromJSAbiValue(thisArgument), jsArgs));
                 }),
                 reflectConstruct: function (target, args) {
                     throw new Error("Function not implemented.");
@@ -953,7 +1056,7 @@
                     throw new Error("Function not implemented.");
                 },
                 reflectGet: wrapTry((target, propertyKey) => {
-                    return target[propertyKey];
+                    return toJSAbiValue(fromJSAbiValue(target)[propertyKey]);
                 }),
                 reflectGetOwnPropertyDescriptor: function (target, propertyKey) {
                     throw new Error("Function not implemented.");
@@ -974,13 +1077,11 @@
                     throw new Error("Function not implemented.");
                 },
                 reflectSet: wrapTry((target, propertyKey, value) => {
-                    return Reflect.set(target, propertyKey, value);
+                    return toJSAbiValue(Reflect.set(fromJSAbiValue(target), propertyKey, fromJSAbiValue(value)));
                 }),
                 reflectSetPrototypeOf: function (target, prototype) {
                     throw new Error("Function not implemented.");
                 },
-            }), (name) => {
-                return this.instance.exports[name];
             });
         }
         /**
@@ -1313,7 +1414,12 @@
             }
             // All JS exceptions triggered by Ruby code are translated to Ruby exceptions,
             // so non-RbError exceptions are unexpected.
-            vm.guest.rbVmBugreport();
+            try {
+                vm.guest.rbVmBugreport();
+            }
+            catch (e) {
+                console.error("Tried to report internal Ruby VM state but failed: ", e);
+            }
             if (e instanceof WebAssembly.RuntimeError && e.message === "unreachable") {
                 const error = new RbError(`Something went wrong in Ruby VM: ${e}`);
                 error.stack = e.stack;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruby/wasm-wasi",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "description": "WebAssembly port of CRuby with WASI",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -39,28 +39,29 @@
   ],
   "license": "MIT",
   "scripts": {
-    "test:run": "npm run test:unit && npm run test:jest && npm run test:e2e",
-    "test:jest": "NODE_OPTIONS=\"--experimental-wasi-unstable-preview1\" jest --coverage",
+    "test:run:all": "npm run test:run && ENABLE_COMPONENT_TESTS=1 npm run test:run",
+    "test:run": "npm run test:unit && npm run test:vitest -- --run && npm run test:e2e",
+    "test:vitest": "vitest ./test/",
     "test:unit": "./tools/run-test-unit.mjs",
     "test:e2e": "playwright install && npm run test:e2e:examples && npm run test:e2e:integrations",
     "test:e2e:examples": "playwright test -c test-e2e/playwright.examples.config.ts",
     "test:e2e:integrations": "playwright test -c test-e2e/playwright.integrations.config.ts",
     "serve:example": "BUNDLE_GEMFILE=../../../Gemfile bundle exec ruby -run -e httpd ./example -p 8085",
     "format": "prettier --write .",
-    "build:static": "./tools/pack-bindgen-src.sh ./dist",
+    "build:static": "./tools/pack-bindgen-src.rb ./dist",
     "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": {
+    "@bjorn3/browser_wasi_shim": "^0.3.0",
+    "@bytecodealliance/jco": "../../../vendor/jco",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-typescript": "^11.1.6",
-    "@types/jest": "^29.5.11",
     "@types/node": "20.12.2",
-    "jest": "^29.7.0",
     "prettier": "^3.2.5",
-    "@bjorn3/browser_wasi_shim": "^0.2.19",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.3",
+    "vitest": "^1.5.3"
   },
   "dependencies": {
     "tslib": "^2.6.1"