quickjs-emscripten-sync 1.2.0 → 1.5.0

package/src/marshal/function.ts

@@ -1,43 +1,40 @@
-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,
-  preMarshal: (
-    target: unknown,
-    handle: QuickJSHandle
-  ) => QuickJSHandle | undefined,
-  preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
+  preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any,
 ): QuickJSHandle | undefined {
   if (typeof target !== "function") return;
 
-  const raw = vm
+  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;
       }
 
-      return marshal(
-        preApply ? preApply(target, that, args) : target.apply(that, args)
-      );
+      return marshal(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;
@@ -45,12 +42,12 @@ export default function marshalFunction(
           return fn;
         }`,
         undefined,
-        handle2
-      )
+        handle2,
+      ),
     );
 
   const handle = preMarshal(target, raw) ?? raw;
-  marshalProperties(vm, target, raw, marshal);
+  marshalProperties(ctx, target, raw, marshal);
 
   return handle;
 }

package/src/marshal/index.test.ts

@@ -1,10 +1,14 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import { newDeferred } from "../util";
 import VMMap from "../vmmap";
-import { instanceOf, call } from "../vmutil";
+import { instanceOf, call, handleFrom, fn } from "../vmutil";
+
 import marshal from ".";
 
 test("primitive, array, object", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   const target = {
     hoge: "foo",
@@ -14,7 +18,7 @@ test("primitive, array, object", async () => {
   };
   const handle = marshal(target);
 
-  expect(vm.dump(handle)).toEqual(target);
+  expect(ctx.dump(handle)).toEqual(target);
   expect(map.size).toBe(4);
   expect(map.get(target)).toBe(handle);
   expect(map.has(target.aaa)).toBe(true);
@@ -25,37 +29,33 @@ test("primitive, array, object", async () => {
 });
 
 test("object with symbol key", async () => {
-  const { vm, marshal, dispose } = await setup();
+  const { ctx, marshal, dispose } = await setup();
 
   const target = {
     foo: "hoge",
     [Symbol("a")]: 1,
   };
   const handle = marshal(target);
-  expect(vm.dump(call(vm, `a => a.foo`, undefined, handle))).toBe("hoge");
-  expect(
-    vm.dump(
-      call(vm, `a => a[Object.getOwnPropertySymbols(a)[0]]`, undefined, handle)
-    )
-  ).toBe(1);
+  expect(ctx.dump(call(ctx, `a => a.foo`, undefined, handle))).toBe("hoge");
+  expect(ctx.dump(call(ctx, `a => a[Object.getOwnPropertySymbols(a)[0]]`, undefined, handle))).toBe(
+    1,
+  );
 
   dispose();
 });
 
 test("arrow function", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
   const hoge = () => "foo";
   hoge.foo = { bar: 1 };
   const handle = marshal(hoge);
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(0);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("hoge");
-  const foo = vm.getProp(handle, "foo");
-  expect(vm.dump(foo)).toEqual({ bar: 1 });
-  expect(vm.dump(vm.unwrapResult(vm.callFunction(handle, vm.undefined)))).toBe(
-    "foo"
-  );
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(0);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("hoge");
+  const foo = ctx.getProp(handle, "foo");
+  expect(ctx.dump(foo)).toEqual({ bar: 1 });
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(handle, ctx.undefined)))).toBe("foo");
   expect(map.size).toBe(2);
   expect(map.get(hoge)).toBe(handle);
   expect(map.has(hoge.foo)).toBe(true);
@@ -65,33 +65,69 @@ test("arrow function", async () => {
 });
 
 test("function", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   const bar = function (a: number, b: { hoge: number }) {
     return a + b.hoge;
   };
   const handle = marshal(bar);
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(2);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("bar");
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("bar");
   expect(map.size).toBe(2);
   expect(map.get(bar)).toBe(handle);
   expect(map.has(bar.prototype)).toBe(true);
 
-  const b = vm.unwrapResult(vm.evalCode(`({ hoge: 2 })`));
+  const b = ctx.unwrapResult(ctx.evalCode(`({ hoge: 2 })`));
   expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(handle, vm.undefined, vm.newNumber(1), b))
-    )
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), b))),
   ).toBe(3);
 
   b.dispose();
   dispose();
 });
 
+test("promise", async () => {
+  const { ctx, marshal, dispose } = await setup();
+  const register = fn(
+    ctx,
+    `promise => { promise.then(d => notify("resolve", d), d => notify("reject", d)); }`,
+  );
+
+  let notified: any;
+  ctx
+    .newFunction("notify", (...handles) => {
+      notified = handles.map(h => ctx.dump(h));
+    })
+    .consume(h => {
+      ctx.setProp(ctx.global, "notify", h);
+    });
+
+  const deferred = newDeferred();
+  const handle = marshal(deferred.promise);
+  register(undefined, handle);
+
+  deferred.resolve("foo");
+  await deferred.promise;
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
+  expect(notified).toEqual(["resolve", "foo"]);
+
+  const deferred2 = newDeferred();
+  const handle2 = marshal(deferred2.promise);
+  register(undefined, handle2);
+
+  deferred2.reject("bar");
+  await expect(deferred2.promise).rejects.toBe("bar");
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
+  expect(notified).toEqual(["reject", "bar"]);
+
+  register.dispose();
+  dispose();
+});
+
 test("class", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   class A {
     a: number;
@@ -117,6 +153,7 @@ test("class", async () => {
     }
   }
 
+  expect(A.name).toBe("_A"); // class A's name is _A in vitest
   const handle = marshal(A);
   if (!map) throw new Error("map is undefined");
 
@@ -125,41 +162,33 @@ test("class", async () => {
   expect(map.has(A.prototype)).toBe(true);
   expect(map.has(A.a)).toBe(true);
   expect(map.has(A.prototype.hoge)).toBe(true);
-  expect(
-    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.get)
-  ).toBe(true);
-  expect(
-    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.set)
-  ).toBe(true);
-
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(1);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("A");
-  const staticA = vm.getProp(handle, "a");
-  expect(instanceOf(vm, staticA, handle)).toBe(true);
-  expect(vm.dump(vm.getProp(staticA, "a"))).toBe(100);
-  expect(vm.dump(vm.getProp(staticA, "b"))).toBe("a!");
-
-  const newA = vm.unwrapResult(vm.evalCode(`A => new A("foo")`));
-  const instance = vm.unwrapResult(vm.callFunction(newA, vm.undefined, handle));
-  expect(instanceOf(vm, instance, handle)).toBe(true);
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100);
-  expect(vm.dump(vm.getProp(instance, "b"))).toBe("foo!");
-  const methodHoge = vm.getProp(instance, "hoge");
-  expect(vm.dump(vm.unwrapResult(vm.callFunction(methodHoge, instance)))).toBe(
-    101
+  expect(map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.get)).toBe(true);
+  expect(map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.set)).toBe(true);
+
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("_A");
+  const staticA = ctx.getProp(handle, "a");
+  expect(instanceOf(ctx, staticA, handle)).toBe(true);
+  expect(ctx.dump(ctx.getProp(staticA, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(staticA, "b"))).toBe("a!");
+
+  const newA = ctx.unwrapResult(ctx.evalCode(`A => new A("foo")`));
+  const instance = ctx.unwrapResult(ctx.callFunction(newA, ctx.undefined, handle));
+  expect(instanceOf(ctx, instance, handle)).toBe(true);
+  expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(instance, "b"))).toBe("foo!");
+  const methodHoge = ctx.getProp(instance, "hoge");
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(methodHoge, instance)))).toBe(101);
+  expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100); // not synced
+
+  const getter = ctx.unwrapResult(ctx.evalCode(`a => a.foo`));
+  const setter = ctx.unwrapResult(ctx.evalCode(`(a, b) => a.foo = b`));
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(getter, ctx.undefined, instance)))).toBe(
+    "foo!",
   );
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100); // not synced
-
-  const getter = vm.unwrapResult(vm.evalCode(`a => a.foo`));
-  const setter = vm.unwrapResult(vm.evalCode(`(a, b) => a.foo = b`));
-  expect(
-    vm.dump(vm.unwrapResult(vm.callFunction(getter, vm.undefined, instance)))
-  ).toBe("foo!");
-  vm.unwrapResult(
-    vm.callFunction(setter, vm.undefined, instance, vm.newString("b"))
-  );
-  expect(vm.dump(vm.getProp(instance, "b"))).toBe("foo!"); // not synced
+  ctx.unwrapResult(ctx.callFunction(setter, ctx.undefined, instance, ctx.newString("b")));
+  expect(ctx.dump(ctx.getProp(instance, "b"))).toBe("foo!"); // not synced
 
   staticA.dispose();
   newA.dispose();
@@ -167,19 +196,34 @@ test("class", async () => {
   methodHoge.dispose();
   getter.dispose();
   setter.dispose();
-  map.dispose();
+  dispose();
+});
+
+test("date", async () => {
+  const { ctx, map, marshal, dispose } = await setup();
+
+  const date = new Date(2022, 7, 26);
+  const handle = marshal(date);
+  if (!map) throw new Error("map is undefined");
+
+  expect(map.size).toBe(1);
+  expect(map.get(date)).toBe(handle);
+
+  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());
+
   dispose();
 });
 
 test("marshalable", async () => {
-  const isMarshalable = jest.fn((a: any) => a !== globalThis);
-  const { vm, marshal, dispose } = await setup({
+  const isMarshalable = vi.fn((a: any) => a !== globalThis);
+  const { ctx, marshal, dispose } = await setup({
     isMarshalable,
   });
 
   const handle = marshal({ a: globalThis, b: 1 });
 
-  expect(vm.dump(handle)).toEqual({ a: undefined, b: 1 });
+  expect(ctx.dump(handle)).toEqual({ a: undefined, b: 1 });
   expect(isMarshalable).toBeCalledWith(globalThis);
   expect(isMarshalable).toReturnWith(false);
 
@@ -187,8 +231,8 @@ test("marshalable", async () => {
 });
 
 test("marshalable json", async () => {
-  const isMarshalable = jest.fn<"json", [any]>(() => "json");
-  const { vm, marshal, dispose } = await setup({
+  const isMarshalable = vi.fn(() => "json" as const);
+  const { ctx, marshal, dispose } = await setup({
     isMarshalable,
   });
 
@@ -199,7 +243,7 @@ test("marshalable json", async () => {
   };
   const handle = marshal(target);
 
-  expect(vm.dump(handle)).toEqual({
+  expect(ctx.dump(handle)).toEqual({
     a: { d: target.a.d.toISOString(), e: [null, 1, {}] },
     b: 1,
   });
@@ -215,25 +259,26 @@ const setup = async ({
 }: {
   isMarshalable?: (target: any) => boolean | "json";
 } = {}) => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
+  const ctx = (await getQuickJS()).newContext();
+  const map = new VMMap(ctx);
   return {
-    vm,
+    ctx,
     map,
     marshal: (v: any) =>
       marshal(v, {
-        vm,
-        unmarshal: (h) => map.getByHandle(h) ?? vm.dump(h),
+        ctx: ctx,
+        unmarshal: h => map.getByHandle(h) ?? ctx.dump(h),
         isMarshalable,
-        pre: (t, h) => {
+        pre: (t, d) => {
+          const h = handleFrom(d);
           map.set(t, h);
           return h;
         },
-        find: (t) => map.get(t),
+        find: t => map.get(t),
       }),
     dispose: () => {
       map.dispose();
-      vm.dispose();
+      ctx.dispose();
     },
   };
 };

package/src/marshal/index.ts

@@ -1,28 +1,31 @@
-import { QuickJSHandle, QuickJSVm } from "quickjs-emscripten";
+import type { QuickJSDeferredPromise, QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
+
+import marshalCustom, { defaultCustom } from "./custom";
 import marshalFunction from "./function";
+import marshalJSON from "./json";
 import marshalObject from "./object";
 import marshalPrimitive from "./primitive";
-import marshalSymbol from "./symbol";
-import marshalJSON from "./json";
+import marshalPromise from "./promise";
 
 export type Options = {
-  vm: QuickJSVm;
+  ctx: QuickJSContext;
   unmarshal: (handle: QuickJSHandle) => unknown;
   isMarshalable?: (target: unknown) => boolean | "json";
   find: (target: unknown) => QuickJSHandle | undefined;
   pre: (
     target: unknown,
-    handle: QuickJSHandle,
-    mode: true | "json" | undefined
+    handle: QuickJSHandle | QuickJSDeferredPromise,
+    mode: true | "json" | undefined,
   ) => QuickJSHandle | undefined;
   preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any;
+  custom?: Iterable<(obj: unknown, ctx: QuickJSContext) => QuickJSHandle | undefined>;
 };
 
 export function marshal(target: unknown, options: Options): QuickJSHandle {
-  const { vm, unmarshal, isMarshalable, find, pre } = options;
+  const { ctx, unmarshal, isMarshalable, find, pre } = options;
 
   {
-    const primitive = marshalPrimitive(vm, target);
+    const primitive = marshalPrimitive(ctx, target);
     if (primitive) {
       return primitive;
     }
@@ -35,21 +38,22 @@ export function marshal(target: unknown, options: Options): QuickJSHandle {
 
   const marshalable = isMarshalable?.(target);
   if (marshalable === false) {
-    return vm.undefined;
+    return ctx.undefined;
   }
 
-  const pre2 = (target: any, handle: QuickJSHandle) =>
+  const pre2 = (target: any, handle: QuickJSHandle | QuickJSDeferredPromise) =>
     pre(target, handle, marshalable);
   if (marshalable === "json") {
-    return marshalJSON(vm, target, pre2);
+    return marshalJSON(ctx, target, pre2);
   }
 
   const marshal2 = (t: unknown) => marshal(t, options);
   return (
-    marshalSymbol(vm, target, pre2) ??
-    marshalFunction(vm, target, marshal2, unmarshal, pre2, options.preApply) ??
-    marshalObject(vm, target, marshal2, pre2) ??
-    vm.undefined
+    marshalCustom(ctx, target, pre2, [...defaultCustom, ...(options.custom ?? [])]) ??
+    marshalPromise(ctx, target, marshal2, pre2) ??
+    marshalFunction(ctx, target, marshal2, unmarshal, pre2, options.preApply) ??
+    marshalObject(ctx, target, marshal2, pre2) ??
+    ctx.undefined
   );
 }
 

package/src/marshal/json.test.ts

@@ -1,59 +1,57 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import marshalJSON from "./json";
 
 test("empty object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const prototypeCheck = vm.unwrapResult(
-    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
 
   const obj = {};
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalJSON(vm, obj, preMarshal);
+  const handle = marshalJSON(ctx, obj, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
+  expect(ctx.typeof(handle)).toBe("object");
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(prototypeCheck, vm.undefined, handle))
-    )
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle)))).toBe(
+    true,
+  );
 
   handle.dispose();
   prototypeCheck.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("normal object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const prototypeCheck = vm.unwrapResult(
-    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
-  const entries = vm.unwrapResult(vm.evalCode(`Object.entries`));
+  const entries = ctx.unwrapResult(ctx.evalCode(`Object.entries`));
 
   const obj = { a: 100, b: "hoge" };
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalJSON(vm, obj, preMarshal);
+  const handle = marshalJSON(ctx, obj, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, "a"))).toBe(100);
-  expect(vm.getString(vm.getProp(handle, "b"))).toBe("hoge");
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, "a"))).toBe(100);
+  expect(ctx.getString(ctx.getProp(handle, "b"))).toBe("hoge");
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(prototypeCheck, vm.undefined, handle))
-    )
-  ).toBe(true);
-  const e = vm.unwrapResult(vm.callFunction(entries, vm.undefined, handle));
-  expect(vm.dump(e)).toEqual([
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle)))).toBe(
+    true,
+  );
+  const e = ctx.unwrapResult(ctx.callFunction(entries, ctx.undefined, handle));
+  expect(ctx.dump(e)).toEqual([
     ["a", 100],
     ["b", "hoge"],
   ]);
@@ -62,31 +60,29 @@ test("normal object", async () => {
   handle.dispose();
   prototypeCheck.dispose();
   entries.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("array", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const isArray = vm.unwrapResult(vm.evalCode(`Array.isArray`));
+  const ctx = (await getQuickJS()).newContext();
+  const isArray = ctx.unwrapResult(ctx.evalCode(`Array.isArray`));
 
   const array = [1, "aa"];
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalJSON(vm, array, preMarshal);
+  const handle = marshalJSON(ctx, array, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, 0))).toBe(1);
-  expect(vm.getString(vm.getProp(handle, 1))).toBe("aa");
-  expect(vm.getNumber(vm.getProp(handle, "length"))).toBe(2);
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, 0))).toBe(1);
+  expect(ctx.getString(ctx.getProp(handle, 1))).toBe("aa");
+  expect(ctx.getNumber(ctx.getProp(handle, "length"))).toBe(2);
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(array);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    vm.dump(vm.unwrapResult(vm.callFunction(isArray, vm.undefined, handle)))
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))).toBe(true);
 
   handle.dispose();
   isArray.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/json.ts

@@ -1,15 +1,13 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { json } from "../vmutil";
 
 export default function marshalJSON(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
-  preMarshal: (
-    target: unknown,
-    handle: QuickJSHandle
-  ) => QuickJSHandle | undefined
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
 ): QuickJSHandle {
-  const raw = json(vm, target);
+  const raw = json(ctx, target);
   const handle = preMarshal(target, raw) ?? raw;
   return handle;
 }