@ruby/wasm-wasi 2.5.1 → 2.5.2

package/dist/esm/binding.d.ts

@@ -0,0 +1,54 @@
+import { RubyJsRubyRuntime } from "./bindgen/interfaces/ruby-js-ruby-runtime.js";
+import * as RbAbi from "./bindgen/legacy/rb-abi-guest.js";
+/**
+ * This interface bridges between the Ruby runtime and the JavaScript runtime
+ * and defines how to interact with underlying import/export functions.
+ */
+export interface Binding {
+    rubyShowVersion(): void;
+    rubyInit(): void;
+    rubySysinit(args: string[]): void;
+    rubyOptions(args: string[]): void;
+    rubyScript(name: string): void;
+    rubyInitLoadpath(): void;
+    rbEvalStringProtect(str: string): [RbAbiValue, number];
+    rbFuncallvProtect(recv: RbAbiValue, mid: RbAbi.RbId, args: RbAbiValue[]): [RbAbiValue, number];
+    rbIntern(name: string): RbAbi.RbId;
+    rbErrinfo(): RbAbiValue;
+    rbClearErrinfo(): void;
+    rstringPtr(value: RbAbiValue): string;
+    rbVmBugreport(): void;
+    rbGcEnable(): boolean;
+    rbGcDisable(): boolean;
+    rbSetShouldProhibitRewind(newValue: boolean): boolean;
+    setInstance(instance: WebAssembly.Instance): Promise<void>;
+    addToImports(imports: WebAssembly.Imports): void;
+}
+export interface RbAbiValue {
+}
+export declare class LegacyBinding extends RbAbi.RbAbiGuest implements Binding {
+    setInstance(instance: WebAssembly.Instance): Promise<void>;
+}
+export declare class ComponentBinding implements Binding {
+    underlying: typeof RubyJsRubyRuntime;
+    constructor();
+    setUnderlying(underlying: typeof RubyJsRubyRuntime): void;
+    rubyShowVersion(): void;
+    rubyInit(): void;
+    rubySysinit(args: string[]): void;
+    rubyOptions(args: string[]): void;
+    rubyScript(name: string): void;
+    rubyInitLoadpath(): void;
+    rbEvalStringProtect(str: string): [RbAbiValue, number];
+    rbFuncallvProtect(recv: RbAbiValue, mid: number, args: RbAbiValue[]): [RbAbiValue, number];
+    rbIntern(name: string): number;
+    rbErrinfo(): RbAbiValue;
+    rbClearErrinfo(): void;
+    rstringPtr(value: RbAbiValue): string;
+    rbVmBugreport(): void;
+    rbGcEnable(): boolean;
+    rbGcDisable(): boolean;
+    rbSetShouldProhibitRewind(newValue: boolean): boolean;
+    setInstance(instance: WebAssembly.Instance): Promise<void>;
+    addToImports(imports: WebAssembly.Imports): void;
+}

package/dist/esm/binding.js

@@ -0,0 +1,66 @@
+import * as RbAbi from "./bindgen/legacy/rb-abi-guest.js";
+export class LegacyBinding extends RbAbi.RbAbiGuest {
+    async setInstance(instance) {
+        await this.instantiate(instance);
+    }
+}
+export 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
+    }
+}

package/dist/esm/browser.js

@@ -1,11 +1,16 @@
-import { WASI } from "@bjorn3/browser_wasi_shim";
+import { File, OpenFile, PreopenDirectory, WASI } from "@bjorn3/browser_wasi_shim";
 import { consolePrinter } from "./console.js";
 import { RubyVM } from "./vm.js";
 export const DefaultRubyVM = async (rubyModule, options = {}) => {
     var _a, _b;
     const args = [];
     const env = Object.entries((_a = options.env) !== null && _a !== void 0 ? _a : {}).map(([k, v]) => `${k}=${v}`);
-    const fds = [];
+    const fds = [
+        new OpenFile(new File([])),
+        new OpenFile(new File([])),
+        new OpenFile(new File([])),
+        new PreopenDirectory("/", new Map()),
+    ];
     const wasi = new WASI(args, env, fds, { debug: false });
     const vm = new RubyVM();
     const imports = {

package/dist/esm/node.js

@@ -1,7 +1,7 @@
 import { WASI } from "wasi";
 import { RubyVM } from "./vm.js";
 export const DefaultRubyVM = async (rubyModule, options = {}) => {
-    const wasi = new WASI({ env: options.env, version: "preview1" });
+    const wasi = new WASI({ env: options.env, version: "preview1", returnOnExit: true });
     const vm = new RubyVM();
     const imports = {
         wasi_snapshot_preview1: wasi.wasiImport,

package/dist/esm/vm.d.ts

@@ -1,5 +1,7 @@
-import * as RbAbi from "./bindgen/rb-abi-guest.js";
-import { JsAbiValue } from "./bindgen/rb-js-abi-host.js";
+import type { RubyJsJsRuntime } from "./bindgen/interfaces/ruby-js-js-runtime.js";
+import type { RubyJsRubyRuntime } from "./bindgen/interfaces/ruby-js-ruby-runtime.js";
+import { JsAbiValue } from "./bindgen/legacy/rb-js-abi-host.js";
+import { Binding, RbAbiValue } from "./binding.js";
 /**
  * A Ruby VM instance
  *
@@ -20,12 +22,15 @@ import { JsAbiValue } from "./bindgen/rb-js-abi-host.js";
  *
  */
 export declare class RubyVM {
-    guest: RbAbi.RbAbiGuest;
+    guest: Binding;
     private instance;
     private transport;
     private exceptionFormatter;
     private interfaceState;
-    constructor();
+    constructor(binding?: Binding);
+    static _instantiate(initComponent: (_: typeof RubyJsJsRuntime) => Promise<typeof RubyJsRubyRuntime>, options: {
+        args?: string[];
+    }): Promise<RubyVM>;
     /**
      * Initialize the Ruby VM with the given command line arguments
      * @param args The command line arguments to pass to Ruby. Must be
@@ -48,6 +53,8 @@ export declare class RubyVM {
      * @param imports The import object to add to the WebAssembly instance
      */
     addToImports(imports: WebAssembly.Imports): void;
+    private throwProhibitRewindException;
+    private getImports;
     /**
      * Print the Ruby version to stdout
      */
@@ -132,7 +139,7 @@ export declare class RbValue {
     /**
      * @hideconstructor
      */
-    constructor(inner: RbAbi.RbAbiValue, vm: RubyVM, privateObject: RubyVMPrivate);
+    constructor(inner: RbAbiValue, vm: RubyVM, privateObject: RubyVMPrivate);
     /**
      * Call a given method with given arguments
      *

package/dist/esm/vm.js

@@ -1,5 +1,6 @@
-import * as RbAbi from "./bindgen/rb-abi-guest.js";
-import { addRbJsAbiHostToImports, } from "./bindgen/rb-js-abi-host.js";
+import * as RbAbi from "./bindgen/legacy/rb-abi-guest.js";
+import { addRbJsAbiHostToImports, } from "./bindgen/legacy/rb-js-abi-host.js";
+import { ComponentBinding, LegacyBinding } from "./binding.js";
 /**
  * A Ruby VM instance
  *
@@ -20,7 +21,7 @@ import { addRbJsAbiHostToImports, } from "./bindgen/rb-js-abi-host.js";
  *
  */
 export class RubyVM {
-    constructor() {
+    constructor(binding) {
         this.instance = null;
         this.interfaceState = {
             hasJSFrameAfterRbFrame: false,
@@ -29,6 +30,7 @@ export class RubyVM {
         // if the call stack has sandwitched JS frames like JS -> Ruby -> JS -> Ruby.
         const proxyExports = (exports) => {
             const excludedMethods = [
+                "setInstance",
                 "addToImports",
                 "instantiate",
                 "rbSetShouldProhibitRewind",
@@ -63,10 +65,34 @@ export class RubyVM {
             }
             return exports;
         };
-        this.guest = proxyExports(new RbAbi.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
@@ -90,7 +116,7 @@ export class RubyVM {
      */
     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
@@ -99,43 +125,36 @@ export class RubyVM {
      */
     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
@@ -154,9 +173,24 @@ export class RubyVM {
             }
             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
@@ -164,45 +198,47 @@ export class RubyVM {
             },
             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" };
@@ -211,38 +247,40 @@ export class RubyVM {
                     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.");
@@ -251,7 +289,7 @@ export class RubyVM {
                 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.");
@@ -272,13 +310,11 @@ export class RubyVM {
                 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];
         });
     }
     /**
@@ -611,7 +647,12 @@ function wrapRbOperation(vm, body) {
         }
         // 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;