@ruby/wasm-wasi 2.5.1 → 2.5.2

package/dist/cjs/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/cjs/binding.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentBinding = exports.LegacyBinding = void 0;
+const tslib_1 = require("tslib");
+const RbAbi = tslib_1.__importStar(require("./bindgen/legacy/rb-abi-guest.js"));
+class LegacyBinding extends RbAbi.RbAbiGuest {
+    async setInstance(instance) {
+        await this.instantiate(instance);
+    }
+}
+exports.LegacyBinding = LegacyBinding;
+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
+    }
+}
+exports.ComponentBinding = ComponentBinding;

package/dist/cjs/browser.js

@@ -8,7 +8,12 @@ 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 browser_wasi_shim_1.OpenFile(new browser_wasi_shim_1.File([])),
+        new browser_wasi_shim_1.OpenFile(new browser_wasi_shim_1.File([])),
+        new browser_wasi_shim_1.OpenFile(new browser_wasi_shim_1.File([])),
+        new browser_wasi_shim_1.PreopenDirectory("/", new Map()),
+    ];
     const wasi = new browser_wasi_shim_1.WASI(args, env, fds, { debug: false });
     const vm = new vm_js_1.RubyVM();
     const imports = {

package/dist/cjs/node.js

@@ -4,7 +4,7 @@ exports.DefaultRubyVM = void 0;
 const wasi_1 = require("wasi");
 const vm_js_1 = require("./vm.js");
 const DefaultRubyVM = async (rubyModule, options = {}) => {
-    const wasi = new wasi_1.WASI({ env: options.env, version: "preview1" });
+    const wasi = new wasi_1.WASI({ env: options.env, version: "preview1", returnOnExit: true });
     const vm = new vm_js_1.RubyVM();
     const imports = {
         wasi_snapshot_preview1: wasi.wasiImport,

package/dist/cjs/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/cjs/vm.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RbFatalError = exports.RbError = exports.RbValue = exports.RubyVM = void 0;
 const tslib_1 = require("tslib");
-const RbAbi = tslib_1.__importStar(require("./bindgen/rb-abi-guest.js"));
-const rb_js_abi_host_js_1 = require("./bindgen/rb-js-abi-host.js");
+const RbAbi = tslib_1.__importStar(require("./bindgen/legacy/rb-abi-guest.js"));
+const rb_js_abi_host_js_1 = require("./bindgen/legacy/rb-js-abi-host.js");
+const binding_js_1 = require("./binding.js");
 /**
  * A Ruby VM instance
  *
@@ -24,7 +25,7 @@ const rb_js_abi_host_js_1 = require("./bindgen/rb-js-abi-host.js");
  *
  */
 class RubyVM {
-    constructor() {
+    constructor(binding) {
         this.instance = null;
         this.interfaceState = {
             hasJSFrameAfterRbFrame: false,
@@ -33,6 +34,7 @@ class RubyVM {
         // if the call stack has sandwitched JS frames like JS -> Ruby -> JS -> Ruby.
         const proxyExports = (exports) => {
             const excludedMethods = [
+                "setInstance",
                 "addToImports",
                 "instantiate",
                 "rbSetShouldProhibitRewind",
@@ -67,10 +69,34 @@ class RubyVM {
             }
             return exports;
         };
-        this.guest = proxyExports(new RbAbi.RbAbiGuest());
+        this.guest = proxyExports(binding !== null && binding !== void 0 ? binding : new binding_js_1.LegacyBinding());
         this.transport = new JsValueTransport();
         this.exceptionFormatter = new RbExceptionFormatter();
     }
+    static async _instantiate(initComponent, options) {
+        const binding = new binding_js_1.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
@@ -94,7 +120,7 @@ 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
@@ -103,43 +129,36 @@ 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);
             },
         };
+        (0, rb_js_abi_host_js_1.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
@@ -158,9 +177,24 @@ class RubyVM {
             }
             return imports;
         };
-        (0, rb_js_abi_host_js_1.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
@@ -168,45 +202,47 @@ 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" };
@@ -215,38 +251,40 @@ 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.");
@@ -255,7 +293,7 @@ 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.");
@@ -276,13 +314,11 @@ 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];
         });
     }
     /**
@@ -617,7 +653,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;

package/dist/esm/bindgen/interfaces/ruby-js-js-runtime.d.ts

@@ -0,0 +1,45 @@
+export namespace RubyJsJsRuntime {
+  export function evalJs(code: string): JsAbiResult;
+  export function isJs(value: JsAbiValue): boolean;
+  export function instanceOf(value: JsAbiValue, klass: JsAbiValue): boolean;
+  export function globalThis(): JsAbiValue;
+  export function intToJsNumber(value: number): JsAbiValue;
+  export function floatToJsNumber(value: number): JsAbiValue;
+  export function stringToJsString(value: string): JsAbiValue;
+  export function boolToJsBool(value: boolean): JsAbiValue;
+  export function procToJsFunction(): JsAbiValue;
+  export function rbObjectToJsRbValue(): JsAbiValue;
+  export function jsValueToString(value: JsAbiValue): string;
+  export function jsValueToInteger(value: JsAbiValue): RawInteger;
+  export function exportJsValueToHost(value: JsAbiValue): void;
+  export function importJsValueFromHost(): JsAbiValue;
+  export function jsValueTypeof(value: JsAbiValue): string;
+  export function jsValueEqual(lhs: JsAbiValue, rhs: JsAbiValue): boolean;
+  export function jsValueStrictlyEqual(lhs: JsAbiValue, rhs: JsAbiValue): boolean;
+  export function reflectApply(target: JsAbiValue, thisArgument: JsAbiValue, arguments: JsAbiValue[]): JsAbiResult;
+  export function reflectGet(target: JsAbiValue, propertyKey: string): JsAbiResult;
+  export function reflectSet(target: JsAbiValue, propertyKey: string, value: JsAbiValue): JsAbiResult;
+  export function throwProhibitRewindException(message: string): void;
+  export { JsAbiValue };
+}
+export type JsAbiResult = JsAbiResultSuccess | JsAbiResultFailure;
+export interface JsAbiResultSuccess {
+  tag: 'success',
+  val: JsAbiValue,
+}
+export interface JsAbiResultFailure {
+  tag: 'failure',
+  val: JsAbiValue,
+}
+export type RawInteger = RawIntegerAsFloat | RawIntegerBignum;
+export interface RawIntegerAsFloat {
+  tag: 'as-float',
+  val: number,
+}
+export interface RawIntegerBignum {
+  tag: 'bignum',
+  val: string,
+}
+
+export class JsAbiValue {
+}

package/dist/esm/bindgen/interfaces/ruby-js-ruby-runtime.d.ts

@@ -0,0 +1,42 @@
+export namespace RubyJsRubyRuntime {
+  export function rubyShowVersion(): void;
+  export function rubyInit(): void;
+  export function rubySysinit(args: string[]): void;
+  export function rubyOptions(args: string[]): RbIseq;
+  export function rubyScript(name: string): void;
+  export function rubyInitLoadpath(): void;
+  export function rbEvalStringProtect(str: string): [RbAbiValue, number];
+  export function rbFuncallvProtect(recv: RbAbiValue, mid: RbId, args: RbAbiValue[]): [RbAbiValue, number];
+  export function rbIntern(name: string): RbId;
+  export function rbErrinfo(): RbAbiValue;
+  export function rbClearErrinfo(): void;
+  export function rstringPtr(value: RbAbiValue): string;
+  export function rbVmBugreport(): void;
+  export function rbGcEnable(): boolean;
+  export function rbGcDisable(): boolean;
+  export function rbSetShouldProhibitRewind(newValue: boolean): boolean;
+  /**
+   * XXX: Do we really need them?
+   * wrap-js-value: func(value: js-abi-value) -> rb-abi-value;
+   * to-js-value: func(value: borrow<rb-abi-value>) -> js-abi-value;
+   * Transfer the value from Ruby to JS
+   * 
+   * 1. Ruby side registers the value in the stage
+   * 2. Ruby side calls JS's `import-rb-value-from-rb()`
+   * 3. `import-rb-value-from-rb()` calls `export-rb-value-to-js()`
+   * 4. `export-rb-value-to-js()` returns the staged value
+   */
+  export function exportRbValueToJs(): RbAbiValue;
+  export { RbIseq };
+  export { RbAbiValue };
+}
+import type { JsAbiValue } from './ruby-js-js-runtime.js';
+export { JsAbiValue };
+export type RbErrno = number;
+export type RbId = number;
+
+export class RbAbiValue {
+}
+
+export class RbIseq {
+}

package/dist/esm/bindgen/{rb-js-abi-host.d.ts → legacy/rb-js-abi-host.d.ts}

@@ -7,9 +7,9 @@ export interface JsAbiResultFailure {
   tag: "failure",
   val: JsAbiValue,
 }
-export type RawInteger = RawIntegerF64 | RawIntegerBignum;
-export interface RawIntegerF64 {
-  tag: "f64",
+export type RawInteger = RawIntegerAsFloat | RawIntegerBignum;
+export interface RawIntegerAsFloat {
+  tag: "as-float",
   val: number,
 }
 export interface RawIntegerBignum {

package/dist/esm/bindgen/{rb-js-abi-host.js → legacy/rb-js-abi-host.js}

@@ -76,13 +76,13 @@ export function addRbJsAbiHostToImports(imports, obj, get_export) {
         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);