quickjs-emscripten-sync 1.3.0 → 1.4.0

package/src/unmarshal/function.test.ts

@@ -5,16 +5,16 @@ import { json } from "../vmutil";
 import unmarshalFunction from "./function";
 
 test("arrow function", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(vm, v), false]);
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(ctx, v), false]);
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
+    ctx.dump(v),
     false,
   ]);
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`(a, b) => a + b`));
-  const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`(a, b) => a + b`));
+  const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
 
   expect(func(1, 2)).toBe(3);
@@ -34,30 +34,30 @@ test("arrow function", async () => {
   handle.dispose();
   expect(() => func(1, 2)).toThrow("Lifetime not alive");
 
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("function", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const that = { a: 1 };
-  const thatHandle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const thatHandle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
-    v === that ? thatHandle : json(vm, v),
+    v === that ? thatHandle : json(ctx, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function (a) { return this.a + a; })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function (a) { return this.a + a; })`)
   );
 
-  const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
+  const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
 
   expect(func.call(that, 2)).toBe(3);
@@ -78,29 +78,29 @@ test("function", async () => {
   disposables.forEach((d) => d.dispose());
   thatHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("constructor", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
-    typeof v === "object" ? vm.undefined : json(vm, v),
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
     false,
   ]);
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function (b) { this.a = b + 2; })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function (b) { this.a = b + 2; })`)
   );
 
   const Cls = unmarshalFunction(
-    vm,
+    ctx,
     handle,
     marshal,
     unmarshal,
@@ -127,29 +127,29 @@ test("constructor", async () => {
 
   disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
-    typeof v === "object" ? vm.undefined : json(vm, v),
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`)
   );
 
   const Cls = unmarshalFunction(
-    vm,
+    ctx,
     handle,
     marshal,
     unmarshal,
@@ -176,30 +176,32 @@ test("class", async () => {
 
   disposables.forEach((d) => d.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(unmarshalFunction(vm, vm.undefined, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.true, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.false, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.null, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.newString("hoge"), f, f, f)).toEqual(
+  expect(unmarshalFunction(ctx, ctx.undefined, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.true, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.false, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.null, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.newString("hoge"), f, f, f)).toEqual(
+    undefined
+  );
+  expect(unmarshalFunction(ctx, ctx.newNumber(-10), f, f, f)).toEqual(
     undefined
   );
-  expect(unmarshalFunction(vm, vm.newNumber(-10), f, f, f)).toEqual(undefined);
 
-  const obj = vm.newObject();
-  expect(unmarshalFunction(vm, obj, f, f, f)).toEqual(undefined);
-  const array = vm.newArray();
-  expect(unmarshalFunction(vm, array, f, f, f)).toEqual(undefined);
+  const obj = ctx.newObject();
+  expect(unmarshalFunction(ctx, obj, f, f, f)).toEqual(undefined);
+  const array = ctx.newArray();
+  expect(unmarshalFunction(ctx, array, f, f, f)).toEqual(undefined);
 
   expect(f).toBeCalledTimes(0);
 
   obj.dispose();
   array.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/function.ts

@@ -1,16 +1,17 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call, mayConsumeAll } from "../vmutil";
 import unmarshalProperties from "./properties";
 
 export default function unmarshalFunction(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
-  // marshal returns handle and boolean indicates that the handle should be disposed after use
+  /** marshal returns handle and boolean indicates that the handle should be disposed after use */
   marshal: (value: unknown) => [QuickJSHandle, boolean],
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
   preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
 ): Function | undefined {
-  if (vm.typeof(handle) !== "function") return;
+  if (ctx.typeof(handle) !== "function") return;
 
   const raw = function (this: any, ...args: any[]) {
     return mayConsumeAll(
@@ -19,7 +20,7 @@ export default function unmarshalFunction(
         if (new.target) {
           const [instance] = unmarshal(
             call(
-              vm,
+              ctx,
               `(Cls, ...args) => new Cls(...args)`,
               thisHandle,
               handle,
@@ -33,8 +34,8 @@ export default function unmarshalFunction(
           return this;
         }
 
-        const resultHandle = vm.unwrapResult(
-          vm.callFunction(handle, thisHandle, ...argHandles)
+        const resultHandle = ctx.unwrapResult(
+          ctx.callFunction(handle, thisHandle, ...argHandles)
         );
 
         const [result, alreadyExists] = unmarshal(resultHandle);
@@ -46,7 +47,7 @@ export default function unmarshalFunction(
   };
 
   const func = preUnmarshal(raw, handle) ?? raw;
-  unmarshalProperties(vm, handle, raw, unmarshal);
+  unmarshalProperties(ctx, handle, raw, unmarshal);
 
   return func;
 }

package/src/unmarshal/index.test.ts

@@ -1,4 +1,4 @@
-import { Disposable, getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import VMMap from "../vmmap";
@@ -6,10 +6,10 @@ import unmarshal from ".";
 import { json } from "../vmutil";
 
 test("primitive, array, object", async () => {
-  const { vm, unmarshal, marshal, map, dispose } = await setup();
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`({
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`({
       hoge: "foo",
       foo: 1,
       aaa: [1, true, {}],
@@ -28,18 +28,19 @@ test("primitive, array, object", async () => {
   });
   expect(map.size).toBe(5);
   expect(map.getByHandle(handle)).toBe(target);
-  vm.getProp(handle, "aaa").consume((h) =>
-    expect(map.getByHandle(h)).toBe(target.aaa)
-  );
-  vm.getProp(handle, "aaa")
-    .consume((h) => vm.getProp(h, 2))
+  ctx
+    .getProp(handle, "aaa")
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.aaa));
+  ctx
+    .getProp(handle, "aaa")
+    .consume((h) => ctx.getProp(h, 2))
     .consume((h) => expect(map.getByHandle(h)).toBe(target.aaa[2]));
-  vm.getProp(handle, "nested").consume((h) =>
-    expect(map.getByHandle(h)).toBe(target.nested)
-  );
-  vm.getProp(handle, "bbb").consume((h) =>
-    expect(map.getByHandle(h)).toBe(target.bbb)
-  );
+  ctx
+    .getProp(handle, "nested")
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.nested));
+  ctx
+    .getProp(handle, "bbb")
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.bbb));
 
   expect(marshal).toBeCalledTimes(0);
   expect(target.bbb()).toBe("bar");
@@ -50,10 +51,10 @@ test("primitive, array, object", async () => {
 });
 
 test("object with symbol key", async () => {
-  const { vm, unmarshal, dispose } = await setup();
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`({
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`({
       hoge: "foo",
       [Symbol("a")]: "bar"
     })`)
@@ -67,10 +68,10 @@ test("object with symbol key", async () => {
 });
 
 test("function", async () => {
-  const { vm, unmarshal, marshal, map, dispose } = await setup();
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function(a) { return a.a + "!"; })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function(a) { return a.a + "!"; })`)
   );
   const func = unmarshal(handle);
   const arg = { a: "hoge" };
@@ -88,18 +89,18 @@ test("function", async () => {
 });
 
 test("promise", async () => {
-  const { vm, unmarshal, dispose } = await setup();
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const deferred = vm.newPromise();
+  const deferred = ctx.newPromise();
   const promise = unmarshal(deferred.handle);
-  deferred.resolve(vm.newString("resolved!"));
-  vm.executePendingJobs();
+  deferred.resolve(ctx.newString("resolved!"));
+  ctx.runtime.executePendingJobs();
   await expect(promise).resolves.toBe("resolved!");
 
-  const deferred2 = vm.newPromise();
+  const deferred2 = ctx.newPromise();
   const promise2 = unmarshal(deferred2.handle);
-  deferred2.reject(vm.newString("rejected!"));
-  vm.executePendingJobs();
+  deferred2.reject(ctx.newString("rejected!"));
+  ctx.runtime.executePendingJobs();
   await expect(promise2).rejects.toBe("rejected!");
 
   deferred.dispose();
@@ -108,10 +109,10 @@ test("promise", async () => {
 });
 
 test("class", async () => {
-  const { vm, unmarshal, dispose } = await setup();
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       class Cls {
         static hoge = "foo";
 
@@ -138,8 +139,8 @@ test("class", async () => {
 });
 
 const setup = async () => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
+  const ctx = (await getQuickJS()).newContext();
+  const map = new VMMap(ctx);
   const disposables: QuickJSHandle[] = [];
   const marshal = vi.fn((target: unknown): [QuickJSHandle, boolean] => {
     const handle = map.get(target);
@@ -147,17 +148,17 @@ const setup = async () => {
 
     const handle2 =
       typeof target === "function"
-        ? vm.newFunction(target.name, (...handles) => {
-            target(...handles.map((h) => vm.dump(h)));
+        ? ctx.newFunction(target.name, (...handles) => {
+            target(...handles.map((h) => ctx.dump(h)));
           })
-        : json(vm, target);
-    const ty = vm.typeof(handle2);
+        : json(ctx, target);
+    const ty = ctx.typeof(handle2);
     if (ty === "object" || ty === "function") map.set(target, handle2);
     return [handle2, false];
   });
 
   return {
-    vm,
+    ctx,
     map,
     unmarshal: (handle: QuickJSHandle) =>
       unmarshal(handle, {
@@ -167,13 +168,13 @@ const setup = async () => {
           map.set(t, h);
           return t;
         },
-        vm,
+        ctx: ctx,
       }),
     marshal,
     dispose: () => {
       disposables.forEach((d) => d.dispose());
       map.dispose();
-      vm.dispose();
+      ctx.dispose();
     },
   };
 };

package/src/unmarshal/index.ts

@@ -1,4 +1,5 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import unmarshalFunction from "./function";
 import unmarshalObject from "./object";
 import unmarshalPrimitive from "./primitive";
@@ -6,7 +7,7 @@ import unmarshalPromise from "./promise";
 import unmarshalSymbol from "./symbol";
 
 export type Options = {
-  vm: QuickJSVm;
+  ctx: QuickJSContext;
   /** marshal returns handle and boolean indicates that the handle should be disposed after use */
   marshal: (target: unknown) => [QuickJSHandle, boolean];
   find: (handle: QuickJSHandle) => unknown | undefined;
@@ -22,10 +23,10 @@ function unmarshalInner(
   handle: QuickJSHandle,
   options: Options
 ): [any, boolean] {
-  const { vm, marshal, find, pre } = options;
+  const { ctx, marshal, find, pre } = options;
 
   {
-    const [target, ok] = unmarshalPrimitive(vm, handle);
+    const [target, ok] = unmarshalPrimitive(ctx, handle);
     if (ok) return [target, false];
   }
 
@@ -39,10 +40,10 @@ function unmarshalInner(
   const unmarshal2 = (h: QuickJSHandle) => unmarshalInner(h, options);
 
   const result =
-    unmarshalSymbol(vm, handle, pre) ??
-    unmarshalPromise(vm, handle, marshal, pre) ??
-    unmarshalFunction(vm, handle, marshal, unmarshal2, pre) ??
-    unmarshalObject(vm, handle, unmarshal2, pre);
+    unmarshalSymbol(ctx, handle, pre) ??
+    unmarshalPromise(ctx, handle, marshal, pre) ??
+    unmarshalFunction(ctx, handle, marshal, unmarshal2, pre) ??
+    unmarshalObject(ctx, handle, unmarshal2, pre);
 
   return [result, false];
 }

package/src/unmarshal/object.test.ts

@@ -4,15 +4,15 @@ import { expect, test, vi } from "vitest";
 import unmarshalObject from "./object";
 
 test("normal object", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
+    ctx.dump(v),
     false,
   ]);
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1, b: true })`));
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1, b: true })`));
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
   expect(obj).toEqual({ a: 1, b: true });
   expect(unmarshal).toReturnTimes(4);
@@ -24,20 +24,20 @@ test("normal object", async () => {
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("properties", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
-    return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
+    return [ctx.typeof(v) === "function" ? () => {} : ctx.dump(v), false];
   });
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       const obj = {};
       Object.defineProperties(obj, {
         a: { value: 1, writable: true, configurable: true, enumerable: true },
@@ -47,7 +47,7 @@ test("properties", async () => {
       obj
     }`)
   );
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
   expect(obj).toEqual({
     a: 1,
@@ -74,19 +74,19 @@ test("properties", async () => {
 
   disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("array", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
+    ctx.dump(v),
     false,
   ]);
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`[1, true, "a"]`));
-  const array = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`[1, true, "a"]`));
+  const array = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   expect((array as any)[0]).toEqual(1);
   expect(Array.isArray(array)).toBe(true);
   expect(unmarshal.mock.results[0].value).toEqual(["0", false]);
@@ -100,19 +100,21 @@ test("array", async () => {
   expect(preUnmarshal).toBeCalledWith(array, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("prototype", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.typeof(v) === "object" ? { a: () => 1 } : vm.dump(v),
+    ctx.typeof(v) === "object" ? { a: () => 1 } : ctx.dump(v),
     false,
   ]);
   const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`Object.create({ a: () => 1 })`));
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal) as any;
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`Object.create({ a: () => 1 })`)
+  );
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal) as any;
   if (!obj) throw new Error("obj is undefined");
   expect(Object.getPrototypeOf(obj)).toEqual({ a: expect.any(Function) });
   expect(obj.a()).toBe(1);
@@ -122,25 +124,25 @@ test("prototype", async () => {
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const f = vi.fn();
 
-  expect(unmarshalObject(vm, vm.undefined, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.true, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.false, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.null, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.newString("hoge"), f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.newNumber(-10), f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.undefined, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.true, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.false, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.null, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.newString("hoge"), f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.newNumber(-10), f, f)).toEqual(undefined);
 
-  const func = vm.newFunction("", () => {});
-  expect(unmarshalObject(vm, func, f, f)).toEqual(undefined);
+  const func = ctx.newFunction("", () => {});
+  expect(unmarshalObject(ctx, func, f, f)).toEqual(undefined);
 
   expect(f).toBeCalledTimes(0);
 
   func.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/object.ts

@@ -1,33 +1,34 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import unmarshalProperties from "./properties";
 import { call } from "../vmutil";
 
 export default function unmarshalObject(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
   preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
 ): object | undefined {
   if (
-    vm.typeof(handle) !== "object" ||
+    ctx.typeof(handle) !== "object" ||
     // null check
-    vm
-      .unwrapResult(vm.evalCode("o => o === null"))
+    ctx
+      .unwrapResult(ctx.evalCode("o => o === null"))
       .consume((n) =>
-        vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
+        ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle)))
       )
   )
     return;
 
-  const raw = call(vm, "Array.isArray", undefined, handle).consume((r) =>
-    vm.dump(r)
+  const raw = call(ctx, "Array.isArray", undefined, handle).consume((r) =>
+    ctx.dump(r)
   )
     ? []
     : {};
   const obj = preUnmarshal(raw, handle) ?? raw;
 
   const prototype = call(
-    vm,
+    ctx,
     `o => {
       const p = Object.getPrototypeOf(o);
       return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
@@ -35,7 +36,7 @@ export default function unmarshalObject(
     undefined,
     handle
   ).consume((prototype) => {
-    if (vm.typeof(prototype) === "undefined") return;
+    if (ctx.typeof(prototype) === "undefined") return;
     const [proto] = unmarshal(prototype);
     return proto;
   });
@@ -43,7 +44,7 @@ export default function unmarshalObject(
     Object.setPrototypeOf(obj, prototype);
   }
 
-  unmarshalProperties(vm, handle, raw, unmarshal);
+  unmarshalProperties(ctx, handle, raw, unmarshal);
 
   return obj;
 }