quickjs-emscripten-sync 1.3.0 → 1.5.1

package/src/index.ts

@@ -1,28 +1,18 @@
 import type {
   QuickJSDeferredPromise,
   QuickJSHandle,
-  QuickJSVm,
-} from "quickjs-emscripten";
-import type {
+  QuickJSContext,
   SuccessOrFail,
   VmCallResult,
-} from "quickjs-emscripten/dist/vm-interface";
+} from "quickjs-emscripten";
 
-import VMMap from "./vmmap";
+import { defaultRegisteredObjects } from "./default";
 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,
-  json,
-  consumeAll,
-  mayConsume,
-  handleFrom,
-} from "./vmutil";
-import { defaultRegisteredObjects } from "./default";
+import VMMap from "./vmmap";
+import { call, eq, isHandleObject, json, consumeAll, mayConsume, handleFrom } from "./vmutil";
+import { wrap, wrapHandle, unwrap, unwrapHandle, Wrapped } from "./wrapper";
 
 export {
   VMMap,
@@ -43,18 +33,28 @@ export {
 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?: 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`.
+  /** Pre-registered pairs 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]>;
+  /** Register functions to convert an object to a QuickJS handle. */
+  customMarshaller?: Iterable<(target: unknown, ctx: QuickJSContext) => QuickJSHandle | undefined>;
+  /** Register functions to convert a QuickJS handle to an object. */
+  customUnmarshaller?: Iterable<(target: QuickJSHandle, ctx: QuickJSContext) => any>;
+  /** A callback that returns a boolean value that determines whether an object is wrappable by proxies. If returns false, note that the object cannot be synchronized between the host and the QuickJS even if arena.sync is used. */
+  isWrappable?: (target: any) => boolean;
+  /** A callback that returns a boolean value that determines whether an QuickJS handle is wrappable by proxies. If returns false, note that the handle cannot be synchronized between the host and the QuickJS even if arena.sync is used. */
+  isHandleWrappable?: (handle: QuickJSHandle, ctx: QuickJSContext) => boolean;
+  /** 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 class Arena {
-  vm: QuickJSVm;
+  context: QuickJSContext;
   _map: VMMap;
   _registeredMap: VMMap;
   _registeredMapDispose: Set<any> = new Set();
@@ -64,13 +64,21 @@ export 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);
   }
 
@@ -87,7 +95,7 @@ export 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 {
-    const handle = this.vm.evalCode(code);
+    const handle = this.context.evalCode(code);
     return this._unwrapResultAndUnmarshal(handle);
   }
 
@@ -95,7 +103,7 @@ export 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;
     }
@@ -110,8 +118,8 @@ export class Arena {
    */
   expose(obj: { [k: string]: any }) {
     for (const [key, value] of Object.entries(obj)) {
-      mayConsume(this._marshal(value), (handle) => {
-        this.vm.setProp(this.vm.global, key, handle);
+      mayConsume(this._marshal(value), handle => {
+        this.context.setProp(this.context.global, key, handle);
       });
     }
   }
@@ -124,8 +132,9 @@ export 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;
   }
@@ -139,9 +148,9 @@ export 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);
     }
@@ -161,10 +170,7 @@ export class Arena {
    * Unregister a pair of objects that were registered with `registeredObjects` option and `register` method.
    */
   unregister(target: any, dispose?: boolean) {
-    this._registeredMap.delete(
-      target,
-      this._registeredMapDispose.has(target) || dispose
-    );
+    this._registeredMap.delete(target, this._registeredMapDispose.has(target) || dispose);
     this._registeredMapDispose.delete(target);
   }
 
@@ -179,7 +185,8 @@ export 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) {
@@ -193,13 +200,9 @@ export class Arena {
     throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
   }
 
-  _unwrapResultAndUnmarshal(
-    result: VmCallResult<QuickJSHandle> | undefined
-  ): any {
+  _unwrapResultAndUnmarshal(result: VmCallResult<QuickJSHandle> | undefined): any {
     if (!result) return;
-    return this._unwrapIfNotSynced(
-      this._unwrapResult(result).consume(this._unmarshal)
-    );
+    return this._unwrapIfNotSynced(this._unwrapResult(result).consume(this._unmarshal));
   }
 
   _isMarshalable = (t: unknown): boolean | "json" => {
@@ -220,17 +223,13 @@ export class Arena {
   _marshalPre = (
     t: unknown,
     h: QuickJSHandle | QuickJSDeferredPromise,
-    mode: true | "json" | undefined
+    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 => {
+  _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);
@@ -249,12 +248,13 @@ export class Arena {
     }
 
     const handle = marshal(this._wrap(target) ?? target, {
-      vm: this.vm,
+      ctx: this.context,
       unmarshal: this._unmarshal,
       isMarshalable: this._isMarshalable,
       find: this._marshalFind,
       pre: this._marshalPre,
       preApply: this._marshalPreApply,
+      custom: this._options?.customMarshaller,
     });
 
     return [handle, !this._map.hasHandle(handle)];
@@ -276,10 +276,11 @@ export class Arena {
 
     const [wrappedHandle] = this._wrapHandle(handle);
     return unmarshal(wrappedHandle ?? handle, {
-      vm: this.vm,
+      ctx: this.context,
       marshal: this._marshal,
       find: this._unmarshalFind,
       pre: this._preUnmarshal,
+      custom: this._options?.customUnmarshaller,
     });
   };
 
@@ -287,15 +288,17 @@ export class Arena {
     t: any,
     h: QuickJSHandle,
     map: VMMap = this._map,
-    sync?: boolean
+    sync?: boolean,
   ): [Wrapped<any>, Wrapped<QuickJSHandle>] | undefined {
     if (this._registeredMap.has(t) || this._registeredMap.hasHandle(h)) {
       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);
@@ -314,19 +317,18 @@ export class Arena {
 
   _syncMode = (obj: any): "both" | undefined => {
     const obj2 = this._unwrap(obj);
-    return this._sync.has(obj2) || this._temporalSync.has(obj2)
-      ? "both"
-      : undefined;
+    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,
       this._marshal,
-      this._syncMode
+      this._syncMode,
+      this._options?.isWrappable,
     );
   }
 
@@ -336,23 +338,22 @@ export class Arena {
 
   _unwrapIfNotSynced = <T>(target: T): T => {
     const unwrapped = this._unwrap(target);
-    return this._sync.has(unwrapped) ? target : unwrapped;
+    return unwrapped instanceof Promise || !this._sync.has(unwrapped) ? unwrapped : target;
   };
 
-  _wrapHandle(
-    handle: QuickJSHandle
-  ): [Wrapped<QuickJSHandle> | undefined, boolean] {
+  _wrapHandle(handle: QuickJSHandle): [Wrapped<QuickJSHandle> | undefined, boolean] {
     return wrapHandle(
-      this.vm,
+      this.context,
       handle,
       this._symbol,
       this._symbolHandle,
       this._unmarshal,
-      this._syncMode
+      this._syncMode,
+      this._options?.isHandleWrappable,
     );
   }
 
   _unwrapHandle(target: QuickJSHandle): [QuickJSHandle, boolean] {
-    return unwrapHandle(this.vm, target, this._symbolHandle);
+    return unwrapHandle(this.context, target, this._symbolHandle);
   }
 }

package/src/marshal/custom.test.ts

@@ -0,0 +1,50 @@
+import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import { call } from "../vmutil";
+
+import marshalCustom, { defaultCustom } from "./custom";
+
+test("symbol", async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const pre = vi.fn();
+  const sym = Symbol("foobar");
+
+  const marshal = (t: unknown) => marshalCustom(ctx, t, pre, defaultCustom);
+
+  expect(marshal({})).toBe(undefined);
+  expect(pre).toBeCalledTimes(0);
+
+  const handle = marshal(sym);
+  if (!handle) throw new Error("handle is undefined");
+  expect(ctx.typeof(handle)).toBe("symbol");
+  expect(ctx.getString(ctx.getProp(handle, "description"))).toBe("foobar");
+  expect(pre).toReturnTimes(1);
+  expect(pre.mock.calls[0][0]).toBe(sym);
+  expect(pre.mock.calls[0][1] === handle).toBe(true);
+
+  handle.dispose();
+  ctx.dispose();
+});
+
+test("date", async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const pre = vi.fn();
+  const date = new Date(2022, 7, 26);
+
+  const marshal = (t: unknown) => marshalCustom(ctx, t, pre, defaultCustom);
+
+  expect(marshal({})).toBe(undefined);
+  expect(pre).toBeCalledTimes(0);
+
+  const handle = marshal(date);
+  if (!handle) throw new Error("handle is undefined");
+  expect(ctx.dump(call(ctx, "d => d instanceof Date", undefined, handle))).toBe(true);
+  expect(ctx.dump(call(ctx, "d => d.getTime()", undefined, handle))).toBe(date.getTime());
+  expect(pre).toReturnTimes(1);
+  expect(pre.mock.calls[0][0]).toBe(date);
+  expect(pre.mock.calls[0][1] === handle).toBe(true);
+
+  handle.dispose();
+  ctx.dispose();
+});

package/src/marshal/custom.ts

@@ -0,0 +1,36 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import { call } from "../vmutil";
+
+export default function marshalCustom(
+  ctx: QuickJSContext,
+  target: unknown,
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
+  custom: Iterable<(target: unknown, ctx: QuickJSContext) => QuickJSHandle | undefined>,
+): QuickJSHandle | undefined {
+  let handle: QuickJSHandle | undefined;
+  for (const c of custom) {
+    handle = c(target, ctx);
+    if (handle) break;
+  }
+  return handle ? preMarshal(target, handle) ?? handle : undefined;
+}
+
+export function symbol(target: unknown, ctx: QuickJSContext): QuickJSHandle | undefined {
+  if (typeof target !== "symbol") return;
+  const handle = call(
+    ctx,
+    "d => Symbol(d)",
+    undefined,
+    target.description ? ctx.newString(target.description) : ctx.undefined,
+  );
+  return handle;
+}
+
+export function date(target: unknown, ctx: QuickJSContext): QuickJSHandle | undefined {
+  if (!(target instanceof Date)) return;
+  const handle = call(ctx, "d => new Date(d)", undefined, ctx.newNumber(target.getTime()));
+  return handle;
+}
+
+export const defaultCustom = [symbol, date];

package/src/marshal/function.test.ts

@@ -1,33 +1,33 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 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 = vi.fn((v) => json(vm, v));
-  const unmarshal = vi.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 = 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);
@@ -36,48 +36,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 = vi.fn((v) => json(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),
-    (_, a) => a
+    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;
@@ -87,82 +87,70 @@ 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(
-    vm.dump(
-      call(vm, "(cls, i) => i instanceof cls", undefined, handle, instance)
-    )
-  ).toBe(true);
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("A");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
+  expect(ctx.dump(call(ctx, "(cls, i) => i instanceof cls", undefined, handle, instance))).toBe(
+    true,
+  );
+  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 = vi.fn(
-    (a: Function, b: any, c: any[]) => a.apply(b, c) + "!"
-  );
+  const unmarshal = (v: QuickJSHandle) => (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,
-    fn,
-    marshal,
-    unmarshal,
-    (_, a) => a,
-    preApply
-  );
+  const handle = marshalFunction(ctx, fn, marshal, unmarshal, (_, a) => a, preApply);
   if (!handle) throw new Error("handle is undefined");
 
   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 ctx = (await getQuickJS()).newContext();
   const f = vi.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);
+  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();
 });