quickjs-emscripten-sync 1.3.0 → 1.4.0

package/src/wrapper.test.ts

@@ -13,11 +13,11 @@ import {
 import { call, eq, json } from "./vmutil";
 
 test("wrap, unwrap, isWrapped", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const marshal = vi.fn();
   const syncMode = vi.fn();
 
@@ -25,7 +25,7 @@ test("wrap, unwrap, isWrapped", async () => {
   expect(unwrap(target, proxyKeySymbol)).toBe(target);
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -39,25 +39,37 @@ test("wrap, unwrap, isWrapped", async () => {
   expect(unwrap(wrapped, proxyKeySymbol)).toBe(target);
 
   expect(
-    wrap(vm, wrapped, proxyKeySymbol, proxyKeySymbolHandle, marshal, syncMode)
+    wrap(ctx, wrapped, proxyKeySymbol, proxyKeySymbolHandle, marshal, syncMode)
   ).toBe(wrapped);
 
+  // promise cannot be wrapped
+  expect(
+    wrap(
+      ctx,
+      Promise.resolve(1),
+      proxyKeySymbol,
+      proxyKeySymbolHandle,
+      marshal,
+      syncMode
+    )
+  ).toBeUndefined();
+
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrap without sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const marshal = vi.fn();
   const syncMode = vi.fn();
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -72,33 +84,33 @@ test("wrap without sync", async () => {
   wrapped.a = 2;
 
   expect(target.a).toBe(2);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(1); // not synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(1); // not synced
   expect(marshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(1);
   expect(syncMode).toBeCalledWith(wrapped);
 
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 
   wrapped.a = 3; // no error even if vm is disposed
   expect(wrapped.a).toBe(3);
 });
 
 test("wrap with both sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 } as { a?: number };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
-    t === wrapped ? handle : json(vm, t),
+    t === wrapped ? handle : json(ctx, t),
     false,
   ]);
   const syncMode = vi.fn((): SyncMode => "both");
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -113,7 +125,7 @@ test("wrap with both sync", async () => {
   wrapped.a = 2;
 
   expect(target.a).toBe(2);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2); // synced
   expect(marshal).toBeCalledTimes(3);
   expect(marshal).toBeCalledWith(2);
   expect(marshal).toBeCalledWith("a");
@@ -122,30 +134,30 @@ test("wrap with both sync", async () => {
 
   delete wrapped.a;
   expect(target.a).toBe(undefined);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined); // synced
 
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 
   wrapped.a = 3; // no error even if vm is disposed
   expect(wrapped.a).toBe(3);
 });
 
 test("wrap with vm sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 } as { a?: number };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
-    t === wrapped ? handle : json(vm, t),
+    t === wrapped ? handle : json(ctx, t),
     false,
   ]);
   const syncMode = vi.fn((): SyncMode => "vm");
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -160,7 +172,7 @@ test("wrap with vm sync", async () => {
   wrapped.a = 2;
 
   expect(target.a).toBe(1); // not set
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2); // synced
   expect(marshal).toBeCalledTimes(3);
   expect(marshal).toBeCalledWith(2);
   expect(marshal).toBeCalledWith("a");
@@ -169,33 +181,33 @@ test("wrap with vm sync", async () => {
 
   delete wrapped.a;
   expect(target.a).toBe(1); // not deleted
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined); // synced
 
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 
   wrapped.a = 3; // no error even after vm is disposed
   expect(wrapped.a).toBe(1); // vm mode cannot modify obj in host
 });
 
 test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const unmarshal = vi.fn();
   const syncMode = vi.fn();
 
-  expect(isHandleWrapped(vm, handle, proxyKeySymbolHandle)).toBe(false);
-  expect(unwrapHandle(vm, handle, proxyKeySymbolHandle)).toEqual([
+  expect(isHandleWrapped(ctx, handle, proxyKeySymbolHandle)).toBe(false);
+  expect(unwrapHandle(ctx, handle, proxyKeySymbolHandle)).toEqual([
     handle,
     false,
   ]);
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -204,18 +216,22 @@ test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
   );
   if (!wrapped || !w) throw new Error("wrapped is undefined");
 
-  expect(vm.dump(wrapped)).toEqual(target); // vm.dump does not support proxies
-  expect(vm.dump(vm.getProp(wrapped, "a"))).toBe(1);
-  expect(isHandleWrapped(vm, wrapped, proxyKeySymbolHandle)).toBe(true);
+  expect(ctx.dump(wrapped)).toEqual(target); // vm.dump does not support proxies
+  expect(ctx.dump(ctx.getProp(wrapped, "a"))).toBe(1);
+  expect(isHandleWrapped(ctx, wrapped, proxyKeySymbolHandle)).toBe(true);
 
-  const [handle2, unwrapped2] = unwrapHandle(vm, wrapped, proxyKeySymbolHandle);
+  const [handle2, unwrapped2] = unwrapHandle(
+    ctx,
+    wrapped,
+    proxyKeySymbolHandle
+  );
   expect(unwrapped2).toBe(true);
   handle2.consume((h) => {
-    expect(eq(vm, handle, h)).toBe(true);
+    expect(eq(ctx, handle, h)).toBe(true);
   });
 
   const [wrapped2] = wrapHandle(
-    vm,
+    ctx,
     wrapped,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -224,25 +240,32 @@ test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
   );
   expect(wrapped2 === wrapped).toBe(true);
 
+  // promise cannot be wrapped
+  const deferred = ctx.newPromise();
+  expect(isHandleWrapped(ctx, deferred.handle, proxyKeySymbolHandle)).toBe(
+    true
+  );
+
+  deferred.dispose();
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrapHandle without sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const unmarshal = vi.fn((h: QuickJSHandle) =>
-    wrapped && eq(vm, h, wrapped) ? target : vm.dump(h)
+    wrapped && eq(ctx, h, wrapped) ? target : ctx.dump(h)
   );
   const syncMode = vi.fn();
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -254,9 +277,9 @@ test("wrapHandle without sync", async () => {
   expect(unmarshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(0);
 
-  call(vm, `a => a.a = 2`, undefined, wrapped);
+  call(ctx, `a => a.a = 2`, undefined, wrapped);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2);
   expect(target.a).toBe(1); // not synced
   expect(unmarshal).toBeCalledTimes(1);
   expect(unmarshal).toReturnWith(target);
@@ -266,22 +289,22 @@ test("wrapHandle without sync", async () => {
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrapHandle with both sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const unmarshal = vi.fn((h: QuickJSHandle) => {
-    return wrapped && eq(vm, h, wrapped) ? target : vm.dump(h);
+    return wrapped && eq(ctx, h, wrapped) ? target : ctx.dump(h);
   });
   const syncMode = vi.fn((): SyncMode => "both");
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -293,9 +316,9 @@ test("wrapHandle with both sync", async () => {
   expect(unmarshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(0);
 
-  call(vm, `a => a.a = 2`, undefined, wrapped);
+  call(ctx, `a => a.a = 2`, undefined, wrapped);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2);
   expect(target.a).toBe(2); // synced
   expect(unmarshal).toBeCalledTimes(4);
   expect(unmarshal).toReturnWith(target); // twice
@@ -304,13 +327,13 @@ test("wrapHandle with both sync", async () => {
   expect(syncMode).toBeCalledTimes(1);
   expect(syncMode).toBeCalledWith(target);
 
-  call(vm, `a => { delete a.a; }`, undefined, wrapped);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined);
+  call(ctx, `a => { delete a.a; }`, undefined, wrapped);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined);
   expect(target.a).toBe(undefined); // synced
 
   // changing __proto__ will be blocked
-  call(vm, `a => { a.__proto__ = null; }`, undefined, wrapped);
-  expect(vm.dump(call(vm, `Object.getPrototypeOf`, undefined, handle))).toBe(
+  call(ctx, `a => { a.__proto__ = null; }`, undefined, wrapped);
+  expect(ctx.dump(call(ctx, `Object.getPrototypeOf`, undefined, handle))).toBe(
     null
   );
   expect(Object.getPrototypeOf(target)).toBe(Object.prototype); // not changed
@@ -318,22 +341,22 @@ test("wrapHandle with both sync", async () => {
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrapHandle with host sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const unmarshal = vi.fn((handle: QuickJSHandle) =>
-    wrapped && eq(vm, handle, wrapped) ? target : vm.dump(handle)
+    wrapped && eq(ctx, handle, wrapped) ? target : ctx.dump(handle)
   );
   const syncMode = vi.fn((): SyncMode => "host");
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -345,9 +368,9 @@ test("wrapHandle with host sync", async () => {
   expect(unmarshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(0);
 
-  call(vm, `a => a.a = 2`, undefined, wrapped);
+  call(ctx, `a => a.a = 2`, undefined, wrapped);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(1); // not set
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(1); // not set
   expect(target.a).toBe(2); // synced
   expect(unmarshal).toBeCalledTimes(4);
   expect(unmarshal).toReturnWith(target); // twice
@@ -356,33 +379,33 @@ test("wrapHandle with host sync", async () => {
   expect(syncMode).toBeCalledTimes(1);
   expect(syncMode).toBeCalledWith(target);
 
-  call(vm, `a => delete a.a`, undefined, handle);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined);
+  call(ctx, `a => delete a.a`, undefined, handle);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined);
   expect(target.a).toBe(2); // not synced
 
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrap and wrapHandle", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
   const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
-    wrappedHandle && t === wrapped ? wrappedHandle : json(vm, t),
+    wrappedHandle && t === wrapped ? wrappedHandle : json(ctx, t),
     false,
   ]);
   const unmarshal = vi.fn((handle: QuickJSHandle) =>
-    wrappedHandle && eq(vm, handle, wrappedHandle) ? wrapped : vm.dump(handle)
+    wrappedHandle && eq(ctx, handle, wrappedHandle) ? wrapped : ctx.dump(handle)
   );
   const syncMode = vi.fn((): SyncMode => "both");
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -391,7 +414,7 @@ test("wrap and wrapHandle", async () => {
   );
   if (!wrapped) throw new Error("wrapped is undefined");
   const [wrappedHandle, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -400,9 +423,9 @@ test("wrap and wrapHandle", async () => {
   );
   if (!wrappedHandle || !w) throw new Error("wrappedHandle is undefined");
 
-  call(vm, `a => a.a = 2`, undefined, wrappedHandle);
+  call(ctx, `a => a.a = 2`, undefined, wrappedHandle);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2);
   expect(target.a).toBe(2);
   expect(marshal).toBeCalledTimes(0);
   expect(unmarshal).toBeCalledTimes(4);
@@ -415,7 +438,7 @@ test("wrap and wrapHandle", async () => {
 
   wrapped.a = 3;
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(3);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(3);
   expect(target.a).toBe(3);
   expect(marshal).toBeCalledTimes(3);
   expect(marshal).toBeCalledWith(wrapped);
@@ -426,23 +449,23 @@ test("wrap and wrapHandle", async () => {
   wrappedHandle.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("non object", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = 1;
-  const handle = vm.newNumber(1);
+  const handle = ctx.newNumber(1);
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
 
   expect(
-    wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, vi.fn(), vi.fn())
+    wrap(ctx, target, proxyKeySymbol, proxyKeySymbolHandle, vi.fn(), vi.fn())
   ).toBe(undefined);
 
   expect(
     wrapHandle(
-      vm,
+      ctx,
       handle,
       proxyKeySymbol,
       proxyKeySymbolHandle,
@@ -452,5 +475,5 @@ test("non object", async () => {
   ).toEqual([undefined, false]);
 
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/wrapper.ts

@@ -1,4 +1,5 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
+
 import { isObject } from "./util";
 import { call, isHandleObject, consumeAll, mayConsumeAll } from "./vmutil";
 
@@ -7,14 +8,15 @@ export type SyncMode = "both" | "vm" | "host";
 export type Wrapped<T> = T & { __qes_wrapped: never };
 
 export function wrap<T = any>(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: T,
   proxyKeySymbol: symbol,
   proxyKeySymbolHandle: QuickJSHandle,
   marshal: (target: any) => [QuickJSHandle, boolean],
   syncMode?: (target: T) => SyncMode | undefined
 ): Wrapped<T> | undefined {
-  if (!isObject(target)) return undefined;
+  // promise cannot be wrapped
+  if (!isObject(target) || target instanceof Promise) return undefined;
   if (isWrapped(target, proxyKeySymbol)) return target;
 
   const rec = new Proxy(target as any, {
@@ -27,7 +29,7 @@ export function wrap<T = any>(
       if (
         (sync !== "vm" && !Reflect.set(obj, key, v, receiver)) ||
         sync === "host" ||
-        !vm.alive
+        !ctx.alive
       )
         return true;
 
@@ -35,14 +37,14 @@ export function wrap<T = any>(
         [marshal(receiver), marshal(key), marshal(v)],
         (receiverHandle, keyHandle, valueHandle) => {
           const [handle2, unwrapped] = unwrapHandle(
-            vm,
+            ctx,
             receiverHandle,
             proxyKeySymbolHandle
           );
           if (unwrapped) {
-            handle2.consume((h) => vm.setProp(h, keyHandle, valueHandle));
+            handle2.consume((h) => ctx.setProp(h, keyHandle, valueHandle));
           } else {
-            vm.setProp(handle2, keyHandle, valueHandle);
+            ctx.setProp(handle2, keyHandle, valueHandle);
           }
         }
       );
@@ -55,20 +57,20 @@ export function wrap<T = any>(
         [marshal(rec), marshal(key)],
         (recHandle, keyHandle) => {
           const [handle2, unwrapped] = unwrapHandle(
-            vm,
+            ctx,
             recHandle,
             proxyKeySymbolHandle
           );
 
           if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
-            if (sync === "host" || !vm.alive) return true;
+            if (sync === "host" || !ctx.alive) return true;
 
             if (unwrapped) {
               handle2.consume((h) =>
-                call(vm, `(a, b) => delete a[b]`, undefined, h, keyHandle)
+                call(ctx, `(a, b) => delete a[b]`, undefined, h, keyHandle)
               );
             } else {
-              call(vm, `(a, b) => delete a[b]`, undefined, handle2, keyHandle);
+              call(ctx, `(a, b) => delete a[b]`, undefined, handle2, keyHandle);
             }
           }
           return true;
@@ -80,24 +82,25 @@ export function wrap<T = any>(
 }
 
 export function wrapHandle(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   proxyKeySymbol: symbol,
   proxyKeySymbolHandle: QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => any,
   syncMode?: (target: QuickJSHandle) => SyncMode | undefined
 ): [Wrapped<QuickJSHandle> | undefined, boolean] {
-  if (!isHandleObject(vm, handle)) return [undefined, false];
-  if (isHandleWrapped(vm, handle, proxyKeySymbolHandle)) return [handle, false];
+  if (!isHandleObject(ctx, handle)) return [undefined, false];
+  if (isHandleWrapped(ctx, handle, proxyKeySymbolHandle))
+    return [handle, false];
 
   return consumeAll(
     [
-      vm.newFunction("getSyncMode", (h) => {
+      ctx.newFunction("getSyncMode", (h) => {
         const res = syncMode?.(unmarshal(h));
-        if (typeof res === "string") return vm.newString(res);
-        return vm.undefined;
+        if (typeof res === "string") return ctx.newString(res);
+        return ctx.undefined;
       }),
-      vm.newFunction("setter", (h, keyHandle, valueHandle) => {
+      ctx.newFunction("setter", (h, keyHandle, valueHandle) => {
         const target = unmarshal(h);
         if (!target) return;
         const key = unmarshal(keyHandle);
@@ -105,7 +108,7 @@ export function wrapHandle(
         const value = unmarshal(valueHandle);
         unwrap(target, proxyKeySymbol)[key] = value;
       }),
-      vm.newFunction("deleter", (h, keyHandle) => {
+      ctx.newFunction("deleter", (h, keyHandle) => {
         const target = unmarshal(h);
         if (!target) return;
         const key = unmarshal(keyHandle);
@@ -114,7 +117,7 @@ export function wrapHandle(
     ],
     (args) => [
       call(
-        vm,
+        ctx,
         `(target, sym, getSyncMode, setter, deleter) => {
           const rec =  new Proxy(target, {
             get(obj, key, receiver) {
@@ -159,12 +162,12 @@ export function unwrap<T>(obj: T, key: string | symbol): T {
 }
 
 export function unwrapHandle(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   key: QuickJSHandle
 ): [QuickJSHandle, boolean] {
-  if (!isHandleWrapped(vm, handle, key)) return [handle, false];
-  return [vm.getProp(handle, key), true];
+  if (!isHandleWrapped(ctx, handle, key)) return [handle, false];
+  return [ctx.getProp(handle, key), true];
 }
 
 export function isWrapped<T>(obj: T, key: string | symbol): obj is Wrapped<T> {
@@ -172,14 +175,15 @@ export function isWrapped<T>(obj: T, key: string | symbol): obj is Wrapped<T> {
 }
 
 export function isHandleWrapped(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   key: QuickJSHandle
 ): handle is Wrapped<QuickJSHandle> {
-  return !!vm.dump(
+  return !!ctx.dump(
     call(
-      vm,
-      `(a, s) => (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`,
+      ctx,
+      // promise cannot be wrapped
+      `(a, s) => (a instanceof Promise) || (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`,
       undefined,
       handle,
       key