quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/marshal/object.test.ts

@@ -1,70 +1,72 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { call } from "../vmutil";
 import marshalObject from "./object";
 
 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 marshal = jest.fn();
-  const preMarshal = jest.fn((_, a) => a);
+  const marshal = vi.fn();
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalObject(vm, obj, marshal, preMarshal);
+  const handle = marshalObject(ctx, obj, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
+  expect(ctx.typeof(handle)).toBe("object");
   expect(marshal).toBeCalledTimes(0);
   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))
+    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 marshal = jest.fn(v =>
+  const marshal = vi.fn((v) =>
     typeof v === "number"
-      ? vm.newNumber(v)
+      ? ctx.newNumber(v)
       : typeof v === "string"
-      ? vm.newString(v)
-      : vm.null
+      ? ctx.newString(v)
+      : ctx.null
   );
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalObject(vm, obj, marshal, preMarshal);
+  const handle = marshalObject(ctx, obj, marshal, 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(marshal.mock.calls).toEqual([["a"], [100], ["b"], ["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))
+    ctx.dump(
+      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
     )
   ).toBe(true);
-  const e = vm.unwrapResult(vm.callFunction(entries, vm.undefined, handle));
-  expect(vm.dump(e)).toEqual([
+  const e = ctx.unwrapResult(ctx.callFunction(entries, ctx.undefined, handle));
+  expect(ctx.dump(e)).toEqual([
     ["a", 100],
     ["b", "hoge"],
   ]);
@@ -73,30 +75,30 @@ 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 marshal = jest.fn(v =>
+  const marshal = vi.fn((v) =>
     typeof v === "number"
-      ? vm.newNumber(v)
+      ? ctx.newNumber(v)
       : typeof v === "string"
-      ? vm.newString(v)
-      : vm.null
+      ? ctx.newString(v)
+      : ctx.null
   );
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalObject(vm, array, marshal, preMarshal);
+  const handle = marshalObject(ctx, array, marshal, 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(marshal.mock.calls).toEqual([
     ["0"],
     [1],
@@ -109,33 +111,33 @@ test("array", async () => {
   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)))
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))
   ).toBe(true);
 
   handle.dispose();
   isArray.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("prototype", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const proto = { a: 100 };
-  const protoHandle = vm.newObject();
-  vm.setProp(protoHandle, "a", vm.newNumber(100));
-  const preMarshal = jest.fn((_, a) => a);
+  const protoHandle = ctx.newObject();
+  ctx.setProp(protoHandle, "a", ctx.newNumber(100));
+  const preMarshal = vi.fn((_, a) => a);
 
   const obj = Object.create(proto);
   obj.b = "hoge";
   const handle = marshalObject(
-    vm,
+    ctx,
     obj,
-    v =>
+    (v) =>
       v === proto
         ? protoHandle
         : typeof v === "string"
-        ? vm.newString(v)
-        : vm.null,
+        ? ctx.newString(v)
+        : ctx.null,
     preMarshal
   );
   if (!handle) throw new Error("handle is undefined");
@@ -143,19 +145,24 @@ test("prototype", async () => {
   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.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, "a"))).toBe(100);
-  expect(vm.getString(vm.getProp(handle, "b"))).toBe("hoge");
-  const e = call(vm, "Object.entries", undefined, handle);
-  expect(vm.dump(e)).toEqual([["b", "hoge"]]);
-  const protoHandle2 = call(vm, "Object.getPrototypeOf", vm.undefined, handle);
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, "a"))).toBe(100);
+  expect(ctx.getString(ctx.getProp(handle, "b"))).toBe("hoge");
+  const e = call(ctx, "Object.entries", undefined, handle);
+  expect(ctx.dump(e)).toEqual([["b", "hoge"]]);
+  const protoHandle2 = call(
+    ctx,
+    "Object.getPrototypeOf",
+    ctx.undefined,
+    handle
+  );
   expect(
-    vm.dump(call(vm, `Object.is`, undefined, protoHandle, protoHandle2))
+    ctx.dump(call(ctx, `Object.is`, undefined, protoHandle, protoHandle2))
   ).toBe(true);
 
   protoHandle2.dispose();
   e.dispose();
   handle.dispose();
   protoHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/object.ts

@@ -1,9 +1,10 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 import marshalProperties from "./properties";
 
 export default function marshalObject(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   marshal: (target: unknown) => QuickJSHandle,
   preMarshal: (
@@ -13,7 +14,7 @@ export default function marshalObject(
 ): QuickJSHandle | undefined {
   if (typeof target !== "object" || target === null) return;
 
-  const raw = Array.isArray(target) ? vm.newArray() : vm.newObject();
+  const raw = Array.isArray(target) ? ctx.newArray() : ctx.newObject();
   const handle = preMarshal(target, raw) ?? raw;
 
   // prototype
@@ -24,7 +25,7 @@ export default function marshalObject(
       : undefined;
   if (prototypeHandle) {
     call(
-      vm,
+      ctx,
       "Object.setPrototypeOf",
       undefined,
       handle,
@@ -32,7 +33,7 @@ export default function marshalObject(
     ).dispose();
   }
 
-  marshalProperties(vm, target, raw, marshal);
+  marshalProperties(ctx, target, raw, marshal);
 
   return handle;
 }

package/src/marshal/primitive.test.ts

@@ -1,34 +1,40 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+
 import { eq } from "../vmutil";
 import marshalPrimitive from "./primitive";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  expect(marshalPrimitive(vm, undefined)).toBe(vm.undefined);
-  expect(marshalPrimitive(vm, null)).toBe(vm.null);
-  expect(marshalPrimitive(vm, false)).toBe(vm.false);
-  expect(marshalPrimitive(vm, true)).toBe(vm.true);
-  expect(eq(vm, marshalPrimitive(vm, 1) ?? vm.undefined, vm.newNumber(1))).toBe(
-    true
-  );
+  expect(marshalPrimitive(ctx, undefined)).toBe(ctx.undefined);
+  expect(marshalPrimitive(ctx, null)).toBe(ctx.null);
+  expect(marshalPrimitive(ctx, false)).toBe(ctx.false);
+  expect(marshalPrimitive(ctx, true)).toBe(ctx.true);
+  expect(
+    eq(ctx, marshalPrimitive(ctx, 1) ?? ctx.undefined, ctx.newNumber(1))
+  ).toBe(true);
   expect(
-    eq(vm, marshalPrimitive(vm, -100) ?? vm.undefined, vm.newNumber(-100))
+    eq(ctx, marshalPrimitive(ctx, -100) ?? ctx.undefined, ctx.newNumber(-100))
   ).toBe(true);
   expect(
-    eq(vm, marshalPrimitive(vm, "hoge") ?? vm.undefined, vm.newString("hoge"))
+    eq(
+      ctx,
+      marshalPrimitive(ctx, "hoge") ?? ctx.undefined,
+      ctx.newString("hoge")
+    )
   ).toBe(true);
   // expect(
   //   eq(
-  //     vm,
-  //     marshalPrimitive(vm, BigInt(1)) ?? vm.undefined,
-  //     vm.unwrapResult(vm.evalCode("BigInt(1)"))
+  //     ctx,
+  //     marshalPrimitive(ctx, BigInt(1)) ?? ctx.undefined,
+  //     ctx.unwrapResult(ctx.evalCode("BigInt(1)"))
   //   )
   // ).toBe(true);
 
-  expect(marshalPrimitive(vm, () => {})).toBe(undefined);
-  expect(marshalPrimitive(vm, [])).toBe(undefined);
-  expect(marshalPrimitive(vm, {})).toBe(undefined);
+  expect(marshalPrimitive(ctx, () => {})).toBe(undefined);
+  expect(marshalPrimitive(ctx, [])).toBe(undefined);
+  expect(marshalPrimitive(ctx, {})).toBe(undefined);
 
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/primitive.ts

@@ -1,29 +1,30 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 // import { call } from "../vmutil";
 
 export default function marshalPrimitive(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown
 ): QuickJSHandle | undefined {
   switch (typeof target) {
     case "undefined":
-      return vm.undefined;
+      return ctx.undefined;
     case "number":
-      return vm.newNumber(target);
+      return ctx.newNumber(target);
     case "string":
-      return vm.newString(target);
+      return ctx.newString(target);
     case "boolean":
-      return target ? vm.true : vm.false;
+      return target ? ctx.true : ctx.false;
     case "object":
-      return target === null ? vm.null : undefined;
+      return target === null ? ctx.null : undefined;
 
     // BigInt is not supported by quickjs-emscripten
     // case "bigint":
     //   return call(
-    //     vm,
+    //     ctx,
     //     `s => BigInt(s)`,
     //     undefined,
-    //     vm.newString(target.toString())
+    //     ctx.newString(target.toString())
     //   );
   }
 

package/src/marshal/promise.test.ts

@@ -0,0 +1,86 @@
+import {
+  getQuickJS,
+  type Disposable,
+  type QuickJSDeferredPromise,
+  type QuickJSHandle,
+} from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import marshalPromise from "./promise";
+import { newDeferred } from "../util";
+import { fn, json } from "../vmutil";
+
+const testPromise = (reject: boolean) => async () => {
+  const ctx = (await getQuickJS()).newContext();
+
+  const disposables: Disposable[] = [];
+  const marshal = vi.fn((v) => {
+    const handle = json(ctx, v);
+    disposables.push(handle);
+    return handle;
+  });
+  const preMarshal = vi.fn(
+    (_: any, a: QuickJSDeferredPromise): QuickJSHandle => {
+      disposables.push(a);
+      return a.handle;
+    }
+  );
+
+  const mockNotify = vi.fn();
+  const notify = ctx.newFunction("notify", (handle1, handle2) => {
+    const arg1 = ctx.dump(handle1);
+    const arg2 = ctx.dump(handle2);
+    mockNotify(arg1, arg2);
+  });
+  disposables.push(notify);
+
+  const notifier = fn(
+    ctx,
+    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`
+  );
+  disposables.push(notifier);
+
+  const deferred = newDeferred();
+  if (reject) {
+    deferred.promise.catch(() => {});
+  }
+  const handle = marshalPromise(ctx, deferred.promise, marshal, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  expect(marshal).toBeCalledTimes(0);
+  expect(preMarshal).toBeCalledTimes(1);
+  expect(preMarshal.mock.calls[0][0]).toBe(deferred.promise);
+  expect(preMarshal.mock.calls[0][1].handle).toBe(handle);
+
+  notifier(undefined, notify, handle);
+
+  expect(mockNotify).toBeCalledTimes(0);
+  expect(deferred.resolve).not.toBeUndefined();
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
+
+  if (reject) {
+    deferred.reject("hoge");
+  } else {
+    deferred.resolve("hoge");
+  }
+
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
+  if (reject) {
+    await expect(deferred.promise).rejects.toBe("hoge");
+  } else {
+    await expect(deferred.promise).resolves.toBe("hoge");
+  }
+  expect(ctx.runtime.hasPendingJob()).toBe(true);
+  const executed = ctx.unwrapResult(ctx.runtime.executePendingJobs());
+  expect(executed).toBe(1);
+  expect(mockNotify).toBeCalledTimes(1);
+  expect(mockNotify).toBeCalledWith(reject ? "rejected" : "resolved", "hoge");
+  expect(marshal).toBeCalledTimes(1);
+  expect(marshal.mock.calls).toEqual([["hoge"]]);
+
+  disposables.forEach((h) => h.dispose());
+  ctx.dispose();
+};
+
+test("resolve", testPromise(false));
+test("reject", testPromise(true));

package/src/marshal/promise.ts

@@ -0,0 +1,26 @@
+import type {
+  QuickJSDeferredPromise,
+  QuickJSHandle,
+  QuickJSContext,
+} from "quickjs-emscripten";
+
+export default function marshalPromise(
+  ctx: QuickJSContext,
+  target: unknown,
+  marshal: (target: unknown) => QuickJSHandle,
+  preMarshal: (
+    target: unknown,
+    handle: QuickJSDeferredPromise
+  ) => QuickJSHandle | undefined
+) {
+  if (!(target instanceof Promise)) return;
+
+  const promise = ctx.newPromise();
+
+  target.then(
+    (d) => promise.resolve(marshal(d)),
+    (d) => promise.reject(marshal(d))
+  );
+
+  return preMarshal(target, promise) ?? promise.handle;
+}

package/src/marshal/properties.test.ts

@@ -1,11 +1,13 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
-import { send } from "../vmutil";
+import { expect, test, vi } from "vitest";
+
+import { json } from "../vmutil";
 import marshalProperties from "./properties";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const descTester = vm.unwrapResult(
-    vm.evalCode(`(obj, expected) => {
+  const ctx = (await getQuickJS()).newContext();
+  const descTester = ctx.unwrapResult(
+    ctx.evalCode(`(obj, expected) => {
       const descs = Object.getOwnPropertyDescriptors(obj);
       for (const [k, v] of Object.entries(expected)) {
         const d = descs[k];
@@ -20,14 +22,14 @@ test("works", async () => {
   );
 
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn(t => {
-    if (typeof t !== "function") return send(vm, t);
-    const fn = vm.newFunction("", () => {});
+  const marshal = vi.fn((t) => {
+    if (typeof t !== "function") return json(ctx, t);
+    const fn = ctx.newFunction("", () => {});
     disposables.push(fn);
     return fn;
   });
 
-  const handle = vm.newObject();
+  const handle = ctx.newObject();
   const obj = {};
   const bar = () => {};
   const fooGet = () => {};
@@ -47,7 +49,7 @@ test("works", async () => {
     },
   });
 
-  marshalProperties(vm, obj, handle, marshal);
+  marshalProperties(ctx, obj, handle, marshal);
   expect(marshal.mock.calls).toEqual([
     ["bar"],
     [bar],
@@ -56,30 +58,32 @@ test("works", async () => {
     [fooSet],
   ]);
 
-  const expected = vm.unwrapResult(
-    vm.evalCode(`({
+  const expected = ctx.unwrapResult(
+    ctx.evalCode(`({
       bar: { valueType: "function", getType: "undefined", setType: "undefined", enumerable: true, configurable: true, writable: true },
       foo: { valueType: "undefined", getType: "function", setType: "function", enumerable: false, configurable: true }
     })`)
   );
-  vm.unwrapResult(vm.callFunction(descTester, vm.undefined, handle, expected));
+  ctx.unwrapResult(
+    ctx.callFunction(descTester, ctx.undefined, handle, expected)
+  );
 
   expected.dispose();
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
   descTester.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("empty", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn();
-  const handle = vm.newObject();
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn();
+  const handle = ctx.newObject();
   const obj = {};
 
-  marshalProperties(vm, obj, handle, marshal);
+  marshalProperties(ctx, obj, handle, marshal);
   expect(marshal).toHaveBeenCalledTimes(0);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/properties.ts

@@ -1,13 +1,14 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 
 export default function marshalProperties(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: object | Function,
   handle: QuickJSHandle,
   marshal: (target: unknown) => QuickJSHandle
 ): void {
-  const descs = vm.newObject();
+  const descs = ctx.newObject();
   const cb = (key: string | number | symbol, desc: PropertyDescriptor) => {
     const keyHandle = marshal(key);
     const valueHandle =
@@ -17,7 +18,7 @@ export default function marshalProperties(
     const setHandle =
       typeof desc.set === "undefined" ? undefined : marshal(desc.set);
 
-    vm.newObject().consume(descObj => {
+    ctx.newObject().consume((descObj) => {
       Object.entries(desc).forEach(([k, v]) => {
         const v2 =
           k === "value"
@@ -27,21 +28,21 @@ export default function marshalProperties(
             : k === "set"
             ? setHandle
             : v
-            ? vm.true
-            : vm.false;
+            ? ctx.true
+            : ctx.false;
         if (v2) {
-          vm.setProp(descObj, k, v2);
+          ctx.setProp(descObj, k, v2);
         }
       });
-      vm.setProp(descs, keyHandle, descObj);
+      ctx.setProp(descs, keyHandle, descObj);
     });
   };
 
   const desc = Object.getOwnPropertyDescriptors(target);
   Object.entries(desc).forEach(([k, v]) => cb(k, v));
-  Object.getOwnPropertySymbols(desc).forEach(k => cb(k, (desc as any)[k]));
+  Object.getOwnPropertySymbols(desc).forEach((k) => cb(k, (desc as any)[k]));
 
-  call(vm, `Object.defineProperties`, undefined, handle, descs).dispose();
+  call(ctx, `Object.defineProperties`, undefined, handle, descs).dispose();
 
   descs.dispose();
 }

package/src/marshal/symbol.test.ts

@@ -1,22 +1,24 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import marshalSymbol from "./symbol";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const pre = jest.fn();
+  const ctx = (await getQuickJS()).newContext();
+  const pre = vi.fn();
   const sym = Symbol("foobar");
 
-  expect(marshalSymbol(vm, {}, pre)).toBe(undefined);
+  expect(marshalSymbol(ctx, {}, pre)).toBe(undefined);
   expect(pre).toBeCalledTimes(0);
 
-  const handle = marshalSymbol(vm, sym, pre);
+  const handle = marshalSymbol(ctx, sym, pre);
   if (!handle) throw new Error("handle is undefined");
-  expect(vm.typeof(handle)).toBe("symbol");
-  expect(vm.getString(vm.getProp(handle, "description"))).toBe("foobar");
+  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();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/symbol.ts

@@ -1,8 +1,9 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 
 export default function marshalSymbol(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   preMarshal: (
     target: unknown,
@@ -11,10 +12,10 @@ export default function marshalSymbol(
 ): QuickJSHandle | undefined {
   if (typeof target !== "symbol") return;
   const handle = call(
-    vm,
+    ctx,
     "d => Symbol(d)",
     undefined,
-    target.description ? vm.newString(target.description) : vm.undefined
+    target.description ? ctx.newString(target.description) : ctx.undefined
   );
   return preMarshal(target, handle) ?? handle;
 }