quickjs-emscripten-sync 1.2.0 → 1.3.0

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 { newDeferred } from "../util";
+
+import { fn, json } from "../vmutil";
+import marshalPromise from "./promise";
+
+const testPromise = (reject: boolean) => async () => {
+  const vm = (await getQuickJS()).createVm();
+
+  const disposables: Disposable[] = [];
+  const marshal = vi.fn((v) => {
+    const handle = json(vm, 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 = vm.newFunction("notify", (handle1, handle2) => {
+    const arg1 = vm.dump(handle1);
+    const arg2 = vm.dump(handle2);
+    mockNotify(arg1, arg2);
+  });
+  disposables.push(notify);
+
+  const notifier = fn(
+    vm,
+    `(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(vm, 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(vm.hasPendingJob()).toBe(false);
+
+  if (reject) {
+    deferred.reject("hoge");
+  } else {
+    deferred.resolve("hoge");
+  }
+
+  expect(vm.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(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());
+  vm.dispose();
+};
+
+test("resolve", testPromise(false));
+test("reject", testPromise(true));

package/src/marshal/promise.ts

@@ -0,0 +1,26 @@
+import type {
+  QuickJSDeferredPromise,
+  QuickJSHandle,
+  QuickJSVm,
+} from "quickjs-emscripten";
+
+export default function marshalPromise(
+  vm: QuickJSVm,
+  target: unknown,
+  marshal: (target: unknown) => QuickJSHandle,
+  preMarshal: (
+    target: unknown,
+    handle: QuickJSDeferredPromise
+  ) => QuickJSHandle | undefined
+) {
+  if (!(target instanceof Promise)) return;
+
+  const promise = vm.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,4 +1,6 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { json } from "../vmutil";
 import marshalProperties from "./properties";
 
@@ -20,7 +22,7 @@ test("works", async () => {
   );
 
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((t) => {
+  const marshal = vi.fn((t) => {
     if (typeof t !== "function") return json(vm, t);
     const fn = vm.newFunction("", () => {});
     disposables.push(fn);
@@ -73,7 +75,7 @@ test("works", async () => {
 
 test("empty", async () => {
   const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn();
+  const marshal = vi.fn();
   const handle = vm.newObject();
   const obj = {};
 

package/src/marshal/symbol.test.ts

@@ -1,9 +1,11 @@
 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 pre = vi.fn();
   const sym = Symbol("foobar");
 
   expect(marshalSymbol(vm, {}, pre)).toBe(undefined);

package/src/unmarshal/function.test.ts

@@ -1,18 +1,17 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { json } from "../vmutil";
 import unmarshalFunction from "./function";
 
 test("arrow function", async () => {
   const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
-    json(vm, v),
-    false,
-  ]);
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(vm, v), false]);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(vm.evalCode(`(a, b) => a + b`));
   const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
@@ -42,17 +41,17 @@ test("function", async () => {
   const vm = (await getQuickJS()).createVm();
   const that = { a: 1 };
   const thatHandle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
     v === that ? thatHandle : json(vm, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     const ty = vm.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
     return [vm.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(
     vm.evalCode(`(function (a) { return this.a + a; })`)
@@ -85,16 +84,16 @@ test("function", async () => {
 test("constructor", async () => {
   const vm = (await getQuickJS()).createVm();
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
     typeof v === "object" ? vm.undefined : json(vm, v),
     false,
   ]);
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     const ty = vm.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
     return [vm.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(
     vm.evalCode(`(function (b) { this.a = b + 2; })`)
@@ -133,17 +132,17 @@ test("constructor", async () => {
 
 test("class", async () => {
   const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
     typeof v === "object" ? vm.undefined : json(vm, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     const ty = vm.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
     return [vm.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(
     vm.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`)
@@ -182,7 +181,7 @@ test("class", async () => {
 
 test("undefined", async () => {
   const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
+  const f = vi.fn();
 
   expect(unmarshalFunction(vm, vm.undefined, f, f, f)).toEqual(undefined);
   expect(unmarshalFunction(vm, vm.true, f, f, f)).toEqual(undefined);

package/src/unmarshal/index.test.ts

@@ -1,19 +1,12 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { Disposable, getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import VMMap from "../vmmap";
 import unmarshal from ".";
+import { json } from "../vmutil";
 
 test("primitive, array, object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn((): [QuickJSHandle, boolean] => [
-    vm.undefined,
-    false,
-  ]);
-  const map = new VMMap(vm);
-  const find = jest.fn((h) => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
+  const { vm, unmarshal, marshal, map, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`({
@@ -24,7 +17,7 @@ test("primitive, array, object", async () => {
       bbb: () => "bar"
     })`)
   );
-  const target = unmarshal(handle, { vm, pre, find, marshal });
+  const target = unmarshal(handle);
 
   expect(target).toEqual({
     hoge: "foo",
@@ -53,18 +46,11 @@ test("primitive, array, object", async () => {
   expect(marshal).toBeCalledTimes(1);
   expect(marshal).toBeCalledWith(target); // thisArg of target.bbb()
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
 test("object with symbol key", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
-  const pre = (t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  };
+  const { vm, unmarshal, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`({
@@ -72,79 +58,57 @@ test("object with symbol key", async () => {
       [Symbol("a")]: "bar"
     })`)
   );
-  const target = unmarshal(handle, {
-    vm,
-    pre,
-    find: () => undefined,
-    marshal: () => [vm.undefined, false],
-  });
+  const target = unmarshal(handle);
 
   expect(target.hoge).toBe("foo");
   expect(target[Object.getOwnPropertySymbols(target)[0]]).toBe("bar");
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
-test("func", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((t: unknown): [QuickJSHandle, boolean] => {
-    const h =
-      t === undefined
-        ? vm.undefined
-        : vm.unwrapResult(
-            vm.callFunction(
-              jsonParse,
-              vm.undefined,
-              vm.newString(JSON.stringify(t))
-            )
-          );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return [h, false];
-  });
+test("function", async () => {
+  const { vm, unmarshal, marshal, map, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`(function(a) { return a.a + "!"; })`)
   );
-  const map = new VMMap(vm);
-  const find = jest.fn((h) => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const func = unmarshal(handle, { vm, find, pre, marshal });
+  const func = unmarshal(handle);
   const arg = { a: "hoge" };
   expect(func(arg)).toBe("hoge!");
   expect(marshal).toBeCalledTimes(2);
   expect(marshal).toBeCalledWith(undefined); // this
   expect(marshal).toBeCalledWith(arg); // arg
-  expect(map.size).toBe(2);
+  expect(map.size).toBe(3);
   expect(map.getByHandle(handle)).toBe(func);
+  expect(map.has(func)).toBe(true);
   expect(map.has(func.prototype)).toBe(true);
+  expect(map.has(arg)).toBe(true);
+
+  dispose();
+});
+
+test("promise", async () => {
+  const { vm, unmarshal, dispose } = await setup();
+
+  const deferred = vm.newPromise();
+  const promise = unmarshal(deferred.handle);
+  deferred.resolve(vm.newString("resolved!"));
+  vm.executePendingJobs();
+  await expect(promise).resolves.toBe("resolved!");
 
-  map.dispose();
-  disposables.forEach((d) => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  const deferred2 = vm.newPromise();
+  const promise2 = unmarshal(deferred2.handle);
+  deferred2.reject(vm.newString("rejected!"));
+  vm.executePendingJobs();
+  await expect(promise2).rejects.toBe("rejected!");
+
+  deferred.dispose();
+  deferred2.dispose();
+  dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const map = new VMMap(vm);
-  const marshal = jest.fn((t: unknown): [QuickJSHandle, boolean] => {
-    const h = vm.unwrapResult(
-      vm.callFunction(jsonParse, vm.undefined, vm.newString(JSON.stringify(t)))
-    );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return [h, false];
-  });
+  const { vm, unmarshal, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`{
@@ -160,12 +124,7 @@ test("class", async () => {
       Cls
     }`)
   );
-  const find = jest.fn((h) => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const Cls = unmarshal(handle, { vm, find, pre, marshal });
+  const Cls = unmarshal(handle);
 
   expect(Cls.hoge).toBe("foo");
   expect(Cls.foo instanceof Cls).toBe(true);
@@ -175,8 +134,46 @@ test("class", async () => {
   expect(cls.foo).toBe(4);
 
   handle.dispose();
-  map.dispose();
-  disposables.forEach((d) => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  dispose();
 });
+
+const setup = async () => {
+  const vm = (await getQuickJS()).createVm();
+  const map = new VMMap(vm);
+  const disposables: QuickJSHandle[] = [];
+  const marshal = vi.fn((target: unknown): [QuickJSHandle, boolean] => {
+    const handle = map.get(target);
+    if (handle) return [handle, false];
+
+    const handle2 =
+      typeof target === "function"
+        ? vm.newFunction(target.name, (...handles) => {
+            target(...handles.map((h) => vm.dump(h)));
+          })
+        : json(vm, target);
+    const ty = vm.typeof(handle2);
+    if (ty === "object" || ty === "function") map.set(target, handle2);
+    return [handle2, false];
+  });
+
+  return {
+    vm,
+    map,
+    unmarshal: (handle: QuickJSHandle) =>
+      unmarshal(handle, {
+        find: (h) => map.getByHandle(h),
+        marshal,
+        pre: (t, h) => {
+          map.set(t, h);
+          return t;
+        },
+        vm,
+      }),
+    marshal,
+    dispose: () => {
+      disposables.forEach((d) => d.dispose());
+      map.dispose();
+      vm.dispose();
+    },
+  };
+};

package/src/unmarshal/index.ts

@@ -2,14 +2,15 @@ import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
 import unmarshalFunction from "./function";
 import unmarshalObject from "./object";
 import unmarshalPrimitive from "./primitive";
+import unmarshalPromise from "./promise";
 import unmarshalSymbol from "./symbol";
 
 export type Options = {
   vm: QuickJSVm;
-  // 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: (target: unknown) => [QuickJSHandle, boolean];
   find: (handle: QuickJSHandle) => unknown | undefined;
-  pre: <T>(target: T, handle: QuickJSHandle) => T | undefined;
+  pre: <T = unknown>(target: T, handle: QuickJSHandle) => T | undefined;
 };
 
 export function unmarshal(handle: QuickJSHandle, options: Options): any {
@@ -39,6 +40,7 @@ function unmarshalInner(
 
   const result =
     unmarshalSymbol(vm, handle, pre) ??
+    unmarshalPromise(vm, handle, marshal, pre) ??
     unmarshalFunction(vm, handle, marshal, unmarshal2, pre) ??
     unmarshalObject(vm, handle, unmarshal2, pre);
 

package/src/unmarshal/object.test.ts

@@ -1,13 +1,15 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalObject from "./object";
 
 test("normal object", async () => {
   const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1, b: true })`));
   const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
@@ -28,11 +30,11 @@ test("normal object", async () => {
 test("properties", async () => {
   const vm = (await getQuickJS()).createVm();
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
     return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(
     vm.evalCode(`{
@@ -77,11 +79,11 @@ test("properties", async () => {
 
 test("array", async () => {
   const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(vm.evalCode(`[1, true, "a"]`));
   const array = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
@@ -103,11 +105,11 @@ test("array", async () => {
 
 test("prototype", async () => {
   const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.typeof(v) === "object" ? { a: () => 1 } : vm.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn((a) => a);
+  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;
@@ -125,7 +127,7 @@ test("prototype", async () => {
 
 test("undefined", async () => {
   const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
+  const f = vi.fn();
 
   expect(unmarshalObject(vm, vm.undefined, f, f)).toEqual(undefined);
   expect(unmarshalObject(vm, vm.true, f, f)).toEqual(undefined);

package/src/unmarshal/primitive.test.ts

@@ -1,4 +1,6 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+
 import unmarshalPrimitive from "./primitive";
 
 test("works", async () => {

package/src/unmarshal/promise.test.ts

@@ -0,0 +1,44 @@
+import { Disposable, getQuickJS, type QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import unmarshalPromise from "./promise";
+
+const testPromise = (reject: boolean) => async () => {
+  const vm = (await getQuickJS()).createVm();
+  const disposables: Disposable[] = [];
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => {
+    const f = vm.newFunction(v.name, (h) => {
+      v(vm.dump(h));
+    });
+    disposables.push(f);
+    return [f, false];
+  });
+  const preUnmarshal = vi.fn((a) => a);
+
+  const deferred = vm.newPromise();
+  disposables.push(deferred);
+  const promise = unmarshalPromise(vm, deferred.handle, marshal, preUnmarshal);
+
+  expect(marshal).toBeCalledTimes(2);
+  expect(preUnmarshal).toBeCalledTimes(1);
+  expect(vm.hasPendingJob()).toBe(false);
+
+  if (reject) {
+    deferred.reject(vm.newString("hoge"));
+  } else {
+    deferred.resolve(vm.newString("hoge"));
+  }
+  expect(vm.hasPendingJob()).toBe(true);
+  expect(vm.unwrapResult(vm.executePendingJobs())).toBe(1);
+  if (reject) {
+    expect(promise).rejects.toThrow("hoge");
+  } else {
+    expect(promise).resolves.toBe("hoge");
+  }
+
+  disposables.forEach((d) => d.dispose());
+  vm.dispose();
+};
+
+test("resolve", testPromise(false));
+test("reject", testPromise(true));

package/src/unmarshal/promise.ts

@@ -0,0 +1,40 @@
+import type { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+
+import { newDeferred } from "../util";
+import { call, instanceOf } from "../vmutil";
+
+export default function unmarshalPromise<T = unknown>(
+  vm: QuickJSVm,
+  handle: QuickJSHandle,
+  /** marshal returns handle and boolean indicates that the handle should be disposed after use */
+  marshal: (value: unknown) => [QuickJSHandle, boolean],
+  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
+): Promise<T> | undefined {
+  if (!isPromiseHandle(handle)) return;
+
+  const deferred = newDeferred<T>();
+  const [resHandle, resShouldBeDisposed] = marshal(deferred.resolve);
+  const [rejHandle, rejShouldBeDisposed] = marshal(deferred.reject);
+  call(
+    vm,
+    "(p, res, rej) => { p.then(res, rej); }",
+    undefined,
+    handle,
+    resHandle,
+    rejHandle
+  );
+  if (resShouldBeDisposed) resHandle.dispose();
+  if (rejShouldBeDisposed) rejHandle.dispose();
+
+  return preUnmarshal(deferred.promise, handle) ?? deferred.promise;
+}
+
+function isPromiseHandle(handle: QuickJSHandle): boolean {
+  if (!handle.owner) return false;
+  return handle.owner
+    .unwrapResult(handle.owner.evalCode("Promise"))
+    .consume((promise) => {
+      if (!handle.owner) return false;
+      return instanceOf(handle.owner, handle, promise);
+    });
+}

package/src/unmarshal/properties.test.ts

@@ -1,10 +1,12 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalProperties from "./properties";
 
 test("works", async () => {
   const vm = (await getQuickJS()).createVm();
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
     return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
   });