quickjs-emscripten-sync 1.3.0 → 1.4.0

package/src/marshal/object.test.ts

@@ -5,68 +5,68 @@ 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 = 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 = 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 = 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"],
   ]);
@@ -75,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 = 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 = 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],
@@ -111,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 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 === proto
         ? protoHandle
         : typeof v === "string"
-        ? vm.newString(v)
-        : vm.null,
+        ? ctx.newString(v)
+        : ctx.null,
     preMarshal
   );
   if (!handle) throw new Error("handle is undefined");
@@ -145,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

@@ -5,32 +5,36 @@ 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(vm, marshalPrimitive(vm, -100) ?? vm.undefined, vm.newNumber(-100))
+    eq(ctx, marshalPrimitive(ctx, 1) ?? ctx.undefined, ctx.newNumber(1))
   ).toBe(true);
   expect(
-    eq(vm, marshalPrimitive(vm, "hoge") ?? vm.undefined, vm.newString("hoge"))
+    eq(ctx, marshalPrimitive(ctx, -100) ?? ctx.undefined, ctx.newNumber(-100))
+  ).toBe(true);
+  expect(
+    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

@@ -5,17 +5,17 @@ import {
   type QuickJSHandle,
 } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
-import { newDeferred } from "../util";
 
-import { fn, json } from "../vmutil";
 import marshalPromise from "./promise";
+import { newDeferred } from "../util";
+import { fn, json } from "../vmutil";
 
 const testPromise = (reject: boolean) => async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const disposables: Disposable[] = [];
   const marshal = vi.fn((v) => {
-    const handle = json(vm, v);
+    const handle = json(ctx, v);
     disposables.push(handle);
     return handle;
   });
@@ -27,15 +27,15 @@ const testPromise = (reject: boolean) => async () => {
   );
 
   const mockNotify = vi.fn();
-  const notify = vm.newFunction("notify", (handle1, handle2) => {
-    const arg1 = vm.dump(handle1);
-    const arg2 = vm.dump(handle2);
+  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(
-    vm,
+    ctx,
     `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`
   );
   disposables.push(notifier);
@@ -44,7 +44,7 @@ const testPromise = (reject: boolean) => async () => {
   if (reject) {
     deferred.promise.catch(() => {});
   }
-  const handle = marshalPromise(vm, deferred.promise, marshal, preMarshal);
+  const handle = marshalPromise(ctx, deferred.promise, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
   expect(marshal).toBeCalledTimes(0);
@@ -56,7 +56,7 @@ const testPromise = (reject: boolean) => async () => {
 
   expect(mockNotify).toBeCalledTimes(0);
   expect(deferred.resolve).not.toBeUndefined();
-  expect(vm.hasPendingJob()).toBe(false);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
 
   if (reject) {
     deferred.reject("hoge");
@@ -64,14 +64,14 @@ const testPromise = (reject: boolean) => async () => {
     deferred.resolve("hoge");
   }
 
-  expect(vm.hasPendingJob()).toBe(false);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
   if (reject) {
     await expect(deferred.promise).rejects.toBe("hoge");
   } else {
     await expect(deferred.promise).resolves.toBe("hoge");
   }
-  expect(vm.hasPendingJob()).toBe(true);
-  const executed = vm.unwrapResult(vm.executePendingJobs());
+  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");
@@ -79,7 +79,7 @@ const testPromise = (reject: boolean) => async () => {
   expect(marshal.mock.calls).toEqual([["hoge"]]);
 
   disposables.forEach((h) => h.dispose());
-  vm.dispose();
+  ctx.dispose();
 };
 
 test("resolve", testPromise(false));

package/src/marshal/promise.ts

@@ -1,11 +1,11 @@
 import type {
   QuickJSDeferredPromise,
   QuickJSHandle,
-  QuickJSVm,
+  QuickJSContext,
 } from "quickjs-emscripten";
 
 export default function marshalPromise(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   marshal: (target: unknown) => QuickJSHandle,
   preMarshal: (
@@ -15,7 +15,7 @@ export default function marshalPromise(
 ) {
   if (!(target instanceof Promise)) return;
 
-  const promise = vm.newPromise();
+  const promise = ctx.newPromise();
 
   target.then(
     (d) => promise.resolve(marshal(d)),

package/src/marshal/properties.test.ts

@@ -5,9 +5,9 @@ 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];
@@ -23,13 +23,13 @@ test("works", async () => {
 
   const disposables: QuickJSHandle[] = [];
   const marshal = vi.fn((t) => {
-    if (typeof t !== "function") return json(vm, t);
-    const fn = vm.newFunction("", () => {});
+    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 = () => {};
@@ -49,7 +49,7 @@ test("works", async () => {
     },
   });
 
-  marshalProperties(vm, obj, handle, marshal);
+  marshalProperties(ctx, obj, handle, marshal);
   expect(marshal.mock.calls).toEqual([
     ["bar"],
     [bar],
@@ -58,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());
   handle.dispose();
   descTester.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("empty", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const marshal = vi.fn();
-  const handle = vm.newObject();
+  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,13 +28,13 @@ 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);
     });
   };
 
@@ -41,7 +42,7 @@ export default function marshalProperties(
   Object.entries(desc).forEach(([k, v]) => cb(k, v));
   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

@@ -4,21 +4,21 @@ import { expect, test, vi } from "vitest";
 import marshalSymbol from "./symbol";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  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;
 }