quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/index.ts

@@ -1,19 +1,28 @@
-import { QuickJSHandle, QuickJSVm } from "quickjs-emscripten";
-import {
+import type {
+  QuickJSDeferredPromise,
+  QuickJSHandle,
+  QuickJSContext,
   SuccessOrFail,
   VmCallResult,
-} from "quickjs-emscripten/dist/vm-interface";
+} from "quickjs-emscripten";
 
 import VMMap from "./vmmap";
 import marshal from "./marshal";
 import unmarshal from "./unmarshal";
 import { wrap, wrapHandle, unwrap, unwrapHandle, Wrapped } from "./wrapper";
 import { complexity, isES2015Class, isObject, walkObject } from "./util";
-import { call, eq, isHandleObject, send, consumeAll } from "./vmutil";
+import {
+  call,
+  eq,
+  isHandleObject,
+  json,
+  consumeAll,
+  mayConsume,
+  handleFrom,
+} from "./vmutil";
 import { defaultRegisteredObjects } from "./default";
 
 export {
-  Arena,
   VMMap,
   defaultRegisteredObjects,
   marshal,
@@ -25,25 +34,27 @@ export {
   call,
   eq,
   isHandleObject,
-  send,
+  json,
   consumeAll,
 };
 
 export type Options = {
   /** A callback that returns a boolean value that determines whether an object is marshalled or not. If false, no marshaling will be done and undefined will be passed to the QuickJS VM, otherwise marshaling will be done. By default, all objects will be marshalled. */
-  isMarshalable?: (target: any) => boolean;
+  isMarshalable?: boolean | "json" | ((target: any) => boolean | "json");
   /** You can pre-register a pair of objects that will be considered the same between the host and the QuickJS VM. This will be used automatically during the conversion. By default, it will be registered automatically with `defaultRegisteredObjects`.
    *
    * Instead of a string, you can also pass a QuickJSHandle directly. In that case, however, you have to dispose of them manually when destroying the VM.
    */
   registeredObjects?: Iterable<[any, QuickJSHandle | string]>;
+  /** Compatibility with quickjs-emscripten prior to v0.15. Inject code for compatibility into context at Arena class initialization time. */
+  compat?: boolean;
 };
 
 /**
  * The Arena class manages all generated handles at once by quickjs-emscripten and automatically converts objects between the host and the QuickJS VM.
  */
-export default class Arena {
-  vm: QuickJSVm;
+export class Arena {
+  context: QuickJSContext;
   _map: VMMap;
   _registeredMap: VMMap;
   _registeredMapDispose: Set<any> = new Set();
@@ -53,13 +64,21 @@ export default class Arena {
   _symbolHandle: QuickJSHandle;
   _options?: Options;
 
-  /** Constructs a new Arena instance. It requires a quickjs-emscripten VM initialized with `quickjs.createVM()`. */
-  constructor(vm: QuickJSVm, options?: Options) {
-    this.vm = vm;
+  /** Constructs a new Arena instance. It requires a quickjs-emscripten context initialized with `quickjs.newContext()`. */
+  constructor(ctx: QuickJSContext, options?: Options) {
+    if (options?.compat && !("runtime" in ctx)) {
+      (ctx as any).runtime = {
+        hasPendingJob: () => (ctx as any).hasPendingJob(),
+        executePendingJobs: (maxJobsToExecute?: number | void) =>
+          (ctx as any).executePendingJobs(maxJobsToExecute),
+      };
+    }
+
+    this.context = ctx;
     this._options = options;
-    this._symbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-    this._map = new VMMap(vm);
-    this._registeredMap = new VMMap(vm);
+    this._symbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+    this._map = new VMMap(ctx);
+    this._registeredMap = new VMMap(ctx);
     this.registerAll(options?.registeredObjects ?? defaultRegisteredObjects);
   }
 
@@ -76,7 +95,7 @@ export default class Arena {
    * Evaluate JS code in the VM and get the result as an object on the host side. It also converts and re-throws error objects when an error is thrown during evaluation.
    */
   evalCode<T = any>(code: string): T {
-    let handle = this.vm.evalCode(code);
+    const handle = this.context.evalCode(code);
     return this._unwrapResultAndUnmarshal(handle);
   }
 
@@ -84,11 +103,11 @@ export default class Arena {
    * Almost same as `vm.executePendingJobs()`, but it converts and re-throws error objects when an error is thrown during evaluation.
    */
   executePendingJobs(maxJobsToExecute?: number): number {
-    const result = this.vm.executePendingJobs(maxJobsToExecute);
+    const result = this.context.runtime.executePendingJobs(maxJobsToExecute);
     if ("value" in result) {
       return result.value;
     }
-    throw result.error.consume(err => this._unmarshal(err));
+    throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
   }
 
   /**
@@ -99,8 +118,9 @@ export default class Arena {
    */
   expose(obj: { [k: string]: any }) {
     for (const [key, value] of Object.entries(obj)) {
-      const handle = this._marshal(value);
-      this.vm.setProp(this.vm.global, key, handle);
+      mayConsume(this._marshal(value), (handle) => {
+        this.context.setProp(this.context.global, key, handle);
+      });
     }
   }
 
@@ -112,8 +132,9 @@ export default class Arena {
   sync<T>(target: T): T {
     const wrapped = this._wrap(target);
     if (typeof wrapped === "undefined") return target;
-    walkObject(wrapped, v => {
-      this._sync.add(this._unwrap(v));
+    walkObject(wrapped, (v) => {
+      const u = this._unwrap(v);
+      this._sync.add(u);
     });
     return wrapped;
   }
@@ -127,9 +148,9 @@ export default class Arena {
     if (this._registeredMap.has(target)) return;
     const handle =
       typeof handleOrCode === "string"
-        ? this._unwrapResult(this.vm.evalCode(handleOrCode))
+        ? this._unwrapResult(this.context.evalCode(handleOrCode))
         : handleOrCode;
-    if (eq(this.vm, handle, this.vm.undefined)) return;
+    if (eq(this.context, handle, this.context.undefined)) return;
     if (typeof handleOrCode === "string") {
       this._registeredMapDispose.add(target);
     }
@@ -167,7 +188,8 @@ export default class Arena {
 
   startSync(target: any) {
     if (!isObject(target)) return;
-    this._sync.add(this._unwrap(target));
+    const u = this._unwrap(target);
+    this._sync.add(u);
   }
 
   endSync(target: any) {
@@ -178,52 +200,85 @@ export default class Arena {
     if ("value" in result) {
       return result.value;
     }
-    throw result.error.consume(err => this._unmarshal(err));
+    throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
   }
 
   _unwrapResultAndUnmarshal(
     result: VmCallResult<QuickJSHandle> | undefined
   ): any {
     if (!result) return;
-    return this._unwrapResult(result).consume(h => this._unmarshal(h));
+    return this._unwrapIfNotSynced(
+      this._unwrapResult(result).consume(this._unmarshal)
+    );
   }
 
-  _marshal(target: any): QuickJSHandle {
+  _isMarshalable = (t: unknown): boolean | "json" => {
+    const im = this._options?.isMarshalable;
+    return (typeof im === "function" ? im(this._unwrap(t)) : im) ?? "json";
+  };
+
+  _marshalFind = (t: unknown) => {
+    const unwrappedT = this._unwrap(t);
+    const handle =
+      this._registeredMap.get(t) ??
+      (unwrappedT !== t ? this._registeredMap.get(unwrappedT) : undefined) ??
+      this._map.get(t) ??
+      (unwrappedT !== t ? this._map.get(unwrappedT) : undefined);
+    return handle;
+  };
+
+  _marshalPre = (
+    t: unknown,
+    h: QuickJSHandle | QuickJSDeferredPromise,
+    mode: true | "json" | undefined
+  ): Wrapped<QuickJSHandle> | undefined => {
+    if (mode === "json") return;
+    return this._register(t, handleFrom(h), this._map)?.[1];
+  };
+
+  _marshalPreApply = (
+    target: Function,
+    that: unknown,
+    args: unknown[]
+  ): void => {
+    const unwrapped = isObject(that) ? this._unwrap(that) : undefined;
+    // override sync mode of this object while calling the function
+    if (unwrapped) this._temporalSync.add(unwrapped);
+    try {
+      return target.apply(that, args);
+    } finally {
+      // restore sync mode
+      if (unwrapped) this._temporalSync.delete(unwrapped);
+    }
+  };
+
+  _marshal = (target: any): [QuickJSHandle, boolean] => {
     const registered = this._registeredMap.get(target);
     if (registered) {
-      return registered;
+      return [registered, false];
     }
 
-    const map = new VMMap(this.vm);
-    map.merge(this._map);
-
     const handle = marshal(this._wrap(target) ?? target, {
-      vm: this.vm,
-      unmarshal: h => this._unmarshal(h),
-      isMarshalable: t =>
-        this._options?.isMarshalable?.(this._unwrap(t)) ?? true,
-      find: t => this._registeredMap.get(t) ?? map.get(t),
-      pre: (t, h) => this._register(t, h, map)?.[1],
-      preApply: (target, that, args) => {
-        const unwrapped = isObject(that) ? this._unwrap(that) : undefined;
-        // override sync mode of this object while calling the function
-        if (unwrapped) this._temporalSync.add(unwrapped);
-        try {
-          return target.apply(that, args);
-        } finally {
-          // restore sync mode
-          if (unwrapped) this._temporalSync.delete(unwrapped);
-        }
-      },
+      ctx: this.context,
+      unmarshal: this._unmarshal,
+      isMarshalable: this._isMarshalable,
+      find: this._marshalFind,
+      pre: this._marshalPre,
+      preApply: this._marshalPreApply,
     });
 
-    this._map.merge(map);
-    map.clear();
-    map.dispose();
-    return handle;
-  }
+    return [handle, !this._map.hasHandle(handle)];
+  };
+
+  _preUnmarshal = (t: any, h: QuickJSHandle): Wrapped<any> => {
+    return this._register(t, h, undefined, true)?.[0];
+  };
+
+  _unmarshalFind = (h: QuickJSHandle): unknown => {
+    return this._registeredMap.getByHandle(h) ?? this._map.getByHandle(h);
+  };
 
-  _unmarshal(handle: QuickJSHandle): any {
+  _unmarshal = (handle: QuickJSHandle): any => {
     const registered = this._registeredMap.getByHandle(handle);
     if (typeof registered !== "undefined") {
       return registered;
@@ -231,13 +286,12 @@ export default class Arena {
 
     const [wrappedHandle] = this._wrapHandle(handle);
     return unmarshal(wrappedHandle ?? handle, {
-      vm: this.vm,
-      marshal: (v: any) => this._marshal(v),
-      find: h => this._registeredMap.getByHandle(h) ?? this._map.getByHandle(h),
-      pre: (t: any, h: QuickJSHandle) =>
-        this._register(t, h, undefined, true)?.[0],
+      ctx: this.context,
+      marshal: this._marshal,
+      find: this._unmarshalFind,
+      pre: this._preUnmarshal,
     });
-  }
+  };
 
   _register(
     t: any,
@@ -249,9 +303,11 @@ export default class Arena {
       return;
     }
 
-    const wrappedT = this._wrap(t);
+    let wrappedT = this._wrap(t);
     const [wrappedH] = this._wrapHandle(h);
-    if (!wrappedT || !wrappedH) return; // t or h is not an object
+    const isPromise = t instanceof Promise;
+    if (!wrappedH || (!wrappedT && !isPromise)) return; // t or h is not an object
+    if (isPromise) wrappedT = t;
 
     const unwrappedT = this._unwrap(t);
     const [unwrappedH, unwrapped] = this._unwrapHandle(h);
@@ -268,21 +324,21 @@ export default class Arena {
     return [wrappedT, wrappedH];
   }
 
-  _syncMode(obj: any) {
+  _syncMode = (obj: any): "both" | undefined => {
     const obj2 = this._unwrap(obj);
     return this._sync.has(obj2) || this._temporalSync.has(obj2)
       ? "both"
       : undefined;
-  }
+  };
 
   _wrap<T>(target: T): Wrapped<T> | undefined {
     return wrap(
-      this.vm,
+      this.context,
       target,
       this._symbol,
       this._symbolHandle,
-      t => this._marshal(t),
-      t => this._syncMode(t)
+      this._marshal,
+      this._syncMode
     );
   }
 
@@ -290,20 +346,27 @@ export default class Arena {
     return unwrap(target, this._symbol);
   }
 
+  _unwrapIfNotSynced = <T>(target: T): T => {
+    const unwrapped = this._unwrap(target);
+    return unwrapped instanceof Promise || !this._sync.has(unwrapped)
+      ? unwrapped
+      : target;
+  };
+
   _wrapHandle(
     handle: QuickJSHandle
   ): [Wrapped<QuickJSHandle> | undefined, boolean] {
     return wrapHandle(
-      this.vm,
+      this.context,
       handle,
       this._symbol,
       this._symbolHandle,
-      h => this._unmarshal(h),
-      t => this._syncMode(t)
+      this._unmarshal,
+      this._syncMode
     );
   }
 
   _unwrapHandle(target: QuickJSHandle): [QuickJSHandle, boolean] {
-    return unwrapHandle(this.vm, target, this._symbolHandle);
+    return unwrapHandle(this.context, target, this._symbolHandle);
   }
 }

package/src/marshal/function.test.ts

@@ -1,32 +1,34 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
-import { send, eq, call } from "../vmutil";
+
+import { json, eq, call } from "../vmutil";
 import marshalFunction from "./function";
+import { expect, test, vi } from "vitest";
 
 test("normal func", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const marshal = jest.fn(v => send(vm, v));
-  const unmarshal = jest.fn(v =>
-    eq(vm, v, vm.global) ? undefined : vm.dump(v)
+  const marshal = vi.fn((v) => json(ctx, v));
+  const unmarshal = vi.fn((v) =>
+    eq(ctx, v, ctx.global) ? undefined : ctx.dump(v)
   );
-  const preMarshal = jest.fn((_, a) => a);
-  const innerfn = jest.fn((..._args: any[]) => "hoge");
+  const preMarshal = vi.fn((_, a) => a);
+  const innerfn = vi.fn((..._args: any[]) => "hoge");
   const fn = (...args: any[]) => innerfn(...args);
 
-  const handle = marshalFunction(vm, fn, marshal, unmarshal, preMarshal);
+  const handle = marshalFunction(ctx, fn, marshal, unmarshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
   expect(marshal.mock.calls).toEqual([["length"], [0], ["name"], ["fn"]]); // fn.length, fn.name
   expect(preMarshal.mock.calls).toEqual([[fn, handle]]); // fn.length, fn.name
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(0);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("fn");
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(0);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("fn");
 
-  const result = vm.unwrapResult(
-    vm.callFunction(handle, vm.undefined, vm.newNumber(1), vm.true)
+  const result = ctx.unwrapResult(
+    ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), ctx.true)
   );
 
-  expect(vm.dump(result)).toBe("hoge");
+  expect(ctx.dump(result)).toBe("hoge");
   expect(innerfn).toBeCalledWith(1, true);
   expect(marshal).toHaveBeenLastCalledWith("hoge");
   expect(unmarshal).toBeCalledTimes(3);
@@ -35,48 +37,48 @@ test("normal func", async () => {
   expect(unmarshal.mock.results[2].value).toBe(true);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("func which has properties", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn(v => send(vm, v));
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v) => json(ctx, v));
 
   const fn = () => {};
   fn.hoge = "foo";
 
   const handle = marshalFunction(
-    vm,
+    ctx,
     fn,
     marshal,
-    v => vm.dump(v),
+    (v) => ctx.dump(v),
     (_, a) => a
   );
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "hoge"))).toBe("foo");
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "hoge"))).toBe("foo");
   expect(marshal).toBeCalledWith("foo");
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const disposables: QuickJSHandle[] = [];
   const marshal = (v: any) => {
-    if (typeof v === "string") return vm.newString(v);
-    if (typeof v === "number") return vm.newNumber(v);
+    if (typeof v === "string") return ctx.newString(v);
+    if (typeof v === "number") return ctx.newNumber(v);
     if (typeof v === "object") {
-      const obj = vm.newObject();
+      const obj = ctx.newObject();
       disposables.push(obj);
       return obj;
     }
-    return vm.null;
+    return ctx.null;
   };
-  const unmarshal = (v: QuickJSHandle) => vm.dump(v);
+  const unmarshal = (v: QuickJSHandle) => ctx.dump(v);
 
   class A {
     a: number;
@@ -86,47 +88,49 @@ test("class", async () => {
     }
   }
 
-  const handle = marshalFunction(vm, A, marshal, unmarshal, (_, a) => a);
+  const handle = marshalFunction(ctx, A, marshal, unmarshal, (_, a) => a);
   if (!handle) throw new Error("handle is undefined");
 
-  const newA = vm.unwrapResult(vm.evalCode(`A => new A(100)`));
-  const instance = vm.unwrapResult(vm.callFunction(newA, vm.undefined, handle));
+  const newA = ctx.unwrapResult(ctx.evalCode(`A => new A(100)`));
+  const instance = ctx.unwrapResult(
+    ctx.callFunction(newA, ctx.undefined, handle)
+  );
 
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("A");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(1);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("A");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
   expect(
-    vm.dump(
-      call(vm, "(cls, i) => i instanceof cls", undefined, handle, instance)
+    ctx.dump(
+      call(ctx, "(cls, i) => i instanceof cls", undefined, handle, instance)
     )
   ).toBe(true);
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   instance.dispose();
   newA.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("preApply", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const marshal = (v: any) => {
-    if (typeof v === "string") return vm.newString(v);
-    if (typeof v === "number") return vm.newNumber(v);
-    return vm.null;
+    if (typeof v === "string") return ctx.newString(v);
+    if (typeof v === "number") return ctx.newNumber(v);
+    return ctx.null;
   };
   const unmarshal = (v: QuickJSHandle) =>
-    vm.typeof(v) === "object" ? that : vm.dump(v);
-  const preApply = jest.fn(
+    ctx.typeof(v) === "object" ? that : ctx.dump(v);
+  const preApply = vi.fn(
     (a: Function, b: any, c: any[]) => a.apply(b, c) + "!"
   );
   const that = {};
-  const thatHandle = vm.newObject();
+  const thatHandle = ctx.newObject();
 
   const fn = () => "foo";
   const handle = marshalFunction(
-    vm,
+    ctx,
     fn,
     marshal,
     unmarshal,
@@ -137,31 +141,36 @@ test("preApply", async () => {
 
   expect(preApply).toBeCalledTimes(0);
 
-  const res = vm.unwrapResult(
-    vm.callFunction(handle, thatHandle, vm.newNumber(100), vm.newString("hoge"))
+  const res = ctx.unwrapResult(
+    ctx.callFunction(
+      handle,
+      thatHandle,
+      ctx.newNumber(100),
+      ctx.newString("hoge")
+    )
   );
 
   expect(preApply).toBeCalledTimes(1);
   expect(preApply).toBeCalledWith(fn, that, [100, "hoge"]);
-  expect(vm.dump(res)).toBe("foo!");
+  expect(ctx.dump(res)).toBe("foo!");
 
   thatHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
-
-  expect(marshalFunction(vm, undefined, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, null, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, false, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, true, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, 1, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, [1], f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, { a: 1 }, f, f, f)).toBe(undefined);
+  const ctx = (await getQuickJS()).newContext();
+  const f = vi.fn();
+
+  expect(marshalFunction(ctx, undefined, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, null, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, false, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, true, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, 1, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, [1], f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, { a: 1 }, f, f, f)).toBe(undefined);
   expect(f).toBeCalledTimes(0);
 
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/function.ts

@@ -1,10 +1,11 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { isES2015Class, isObject } from "../util";
 import { call } from "../vmutil";
 import marshalProperties from "./properties";
 
 export default function marshalFunction(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   marshal: (target: unknown) => QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => unknown,
@@ -16,16 +17,16 @@ export default function marshalFunction(
 ): QuickJSHandle | undefined {
   if (typeof target !== "function") return;
 
-  const raw = vm
-    .newFunction(target.name, function(...argHandles) {
+  const raw = ctx
+    .newFunction(target.name, function (...argHandles) {
       const that = unmarshal(this);
-      const args = argHandles.map(a => unmarshal(a));
+      const args = argHandles.map((a) => unmarshal(a));
 
       if (isES2015Class(target) && isObject(that)) {
         // Class constructors cannot be invoked without new expression, and new.target is not changed
         const result = new target(...args);
         Object.entries(result).forEach(([key, value]) => {
-          vm.setProp(this, key, marshal(value));
+          ctx.setProp(this, key, marshal(value));
         });
         return this;
       }
@@ -34,10 +35,10 @@ export default function marshalFunction(
         preApply ? preApply(target, that, args) : target.apply(that, args)
       );
     })
-    .consume(handle2 =>
+    .consume((handle2) =>
       // fucntions created by vm.newFunction are not callable as a class constrcutor
       call(
-        vm,
+        ctx,
         `Cls => {
           const fn = function(...args) { return Cls.apply(this, args); };
           fn.name = Cls.name;
@@ -50,7 +51,7 @@ export default function marshalFunction(
     );
 
   const handle = preMarshal(target, raw) ?? raw;
-  marshalProperties(vm, target, raw, marshal);
+  marshalProperties(ctx, target, raw, marshal);
 
   return handle;
 }