quickjs-emscripten-sync 1.10.0 → 1.11.0

package/src/unmarshal/function.test.ts

@@ -1,4 +1,5 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import { json } from "../vmutil";
@@ -8,8 +9,11 @@ import unmarshalFunction from "./function";
 test("arrow function", async () => {
   const ctx = (await getQuickJS()).newContext();
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(ctx, v), false]);
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
-  const preUnmarshal = vi.fn(a => a);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.dump(v),
+    false,
+  ]);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = ctx.unwrapResult(ctx.evalCode(`(a, b) => a + b`));
   const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
@@ -49,9 +53,11 @@ test("function", async () => {
     if (ty === "object" || ty === "function") disposables.push(v);
     return [ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = ctx.unwrapResult(ctx.evalCode(`(function (a) { return this.a + a; })`));
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function (a) { return this.a + a; })`),
+  );
 
   const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
@@ -71,7 +77,7 @@ test("function", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(func, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   thatHandle.dispose();
   handle.dispose();
   ctx.dispose();
@@ -89,11 +95,19 @@ test("constructor", async () => {
     if (ty === "object" || ty === "function") disposables.push(v);
     return [ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn(a => a);
-
-  const handle = ctx.unwrapResult(ctx.evalCode(`(function (b) { this.a = b + 2; })`));
-
-  const Cls = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal) as any;
+  const preUnmarshal = vi.fn((a) => a);
+
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function (b) { this.a = b + 2; })`),
+  );
+
+  const Cls = unmarshalFunction(
+    ctx,
+    handle,
+    marshal,
+    unmarshal,
+    preUnmarshal,
+  ) as any;
   if (!Cls) throw new Error("Cls is undefined");
 
   const instance = new Cls(100);
@@ -113,7 +127,7 @@ test("constructor", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
   ctx.dispose();
 });
@@ -130,11 +144,19 @@ test("class", async () => {
     if (ty === "object" || ty === "function") disposables.push(v);
     return [ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn(a => a);
-
-  const handle = ctx.unwrapResult(ctx.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`));
-
-  const Cls = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal) as any;
+  const preUnmarshal = vi.fn((a) => a);
+
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`),
+  );
+
+  const Cls = unmarshalFunction(
+    ctx,
+    handle,
+    marshal,
+    unmarshal,
+    preUnmarshal,
+  ) as any;
   if (!Cls) throw new Error("Cls is undefined");
 
   const instance = new Cls(2);
@@ -154,7 +176,7 @@ test("class", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
   ctx.dispose();
 });
@@ -167,8 +189,12 @@ test("undefined", async () => {
   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(ctx, ctx.newString("hoge"), f, f, f)).toEqual(
+    undefined,
+  );
+  expect(unmarshalFunction(ctx, ctx.newNumber(-10), f, f, f)).toEqual(
+    undefined,
+  );
 
   const obj = ctx.newObject();
   expect(unmarshalFunction(ctx, obj, f, f, f)).toEqual(undefined);

package/src/unmarshal/index.test.ts

@@ -1,4 +1,5 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import VMMap from "../vmmap";
@@ -29,13 +30,19 @@ test("primitive, array, object", async () => {
   });
   expect(map.size).toBe(5);
   expect(map.getByHandle(handle)).toBe(target);
-  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]));
-  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));
+    .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]));
+  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");
@@ -65,7 +72,9 @@ test("object with symbol key", async () => {
 test("function", async () => {
   const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = ctx.unwrapResult(ctx.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" };
   expect(func(arg)).toBe("hoge!");
@@ -156,7 +165,7 @@ const setup = async () => {
     const handle2 =
       typeof target === "function"
         ? ctx.newFunction(target.name, (...handles) => {
-            target(...handles.map(h => ctx.dump(h)));
+            target(...handles.map((h) => ctx.dump(h)));
           })
         : json(ctx, target);
     const ty = ctx.typeof(handle2);
@@ -169,7 +178,7 @@ const setup = async () => {
     map,
     unmarshal: (handle: QuickJSHandle) =>
       unmarshal(handle, {
-        find: h => map.getByHandle(h),
+        find: (h) => map.getByHandle(h),
         marshal,
         pre: (t, h) => {
           map.set(t, h);
@@ -179,7 +188,7 @@ const setup = async () => {
       }),
     marshal,
     dispose: () => {
-      disposables.forEach(d => d.dispose());
+      disposables.forEach((d) => d.dispose());
       map.dispose();
       ctx.dispose();
     },

package/src/unmarshal/mapset.ts

@@ -21,18 +21,33 @@ export default function unmarshalMapSet(
     for (const elResult of iterator) {
       const el = ctx.unwrapResult(elResult);
       if (isMap) {
+        // `disposeKey`/`disposeValue` start true so a mid-flight throw (e.g. OOM
+        // inside `unmarshal`) disposes the property handles instead of orphaning
+        // them; on success they are disposed only when redundant (already owned).
         const keyHandle = ctx.getProp(el, 0);
         const valueHandle = ctx.getProp(el, 1);
-        const [key, disposeKey] = unmarshal(keyHandle);
-        const [value, disposeValue] = unmarshal(valueHandle);
-        if (disposeKey) keyHandle.dispose();
-        if (disposeValue) valueHandle.dispose();
-        (result as Map<any, any>).set(key, value);
-        el.dispose();
+        let disposeKey = true;
+        let disposeValue = true;
+        try {
+          const [key, dk] = unmarshal(keyHandle);
+          disposeKey = dk;
+          const [value, dv] = unmarshal(valueHandle);
+          disposeValue = dv;
+          (result as Map<any, any>).set(key, value);
+        } finally {
+          if (disposeKey && keyHandle.alive) keyHandle.dispose();
+          if (disposeValue && valueHandle.alive) valueHandle.dispose();
+          if (el.alive) el.dispose();
+        }
       } else {
-        const [value, disposeValue] = unmarshal(el);
-        if (disposeValue) el.dispose();
-        (result as Set<any>).add(value);
+        let disposeValue = true;
+        try {
+          const [value, dv] = unmarshal(el);
+          disposeValue = dv;
+          (result as Set<any>).add(value);
+        } finally {
+          if (disposeValue && el.alive) el.dispose();
+        }
       }
     }
   } finally {

package/src/unmarshal/object.test.ts

@@ -1,12 +1,16 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import unmarshalObject from "./object";
 
 test("normal object", async () => {
   const ctx = (await getQuickJS()).newContext();
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
-  const preUnmarshal = vi.fn(a => a);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.dump(v),
+    false,
+  ]);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1, b: true })`));
   const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
@@ -31,7 +35,7 @@ test("properties", async () => {
     disposables.push(v);
     return [ctx.typeof(v) === "function" ? () => {} : ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = ctx.unwrapResult(
     ctx.evalCode(`{
@@ -69,15 +73,18 @@ test("properties", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
   ctx.dispose();
 });
 
 test("array", async () => {
   const ctx = (await getQuickJS()).newContext();
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
-  const preUnmarshal = vi.fn(a => a);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.dump(v),
+    false,
+  ]);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = ctx.unwrapResult(ctx.evalCode(`[1, true, "a"]`));
   const array = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
@@ -103,9 +110,11 @@ test("prototype", async () => {
     ctx.typeof(v) === "object" ? { a: () => 1 } : ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = vi.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = ctx.unwrapResult(ctx.evalCode(`Object.create({ a: () => 1 })`));
+  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) });

package/src/unmarshal/promise.test.ts

@@ -1,4 +1,5 @@
-import { Disposable, getQuickJS, type QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
+import type { Disposable, QuickJSHandle } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import unmarshalPromise from "./promise";
@@ -7,13 +8,13 @@ const testPromise = (reject: boolean) => async () => {
   const ctx = (await getQuickJS()).newContext();
   const disposables: Disposable[] = [];
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => {
-    const f = ctx.newFunction(v.name, h => {
+    const f = ctx.newFunction(v.name, (h) => {
       v(ctx.dump(h));
     });
     disposables.push(f);
     return [f, false];
   });
-  const preUnmarshal = vi.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const deferred = ctx.newPromise();
   disposables.push(deferred);
@@ -36,7 +37,7 @@ const testPromise = (reject: boolean) => async () => {
     await expect(promise).resolves.toBe("hoge");
   }
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   ctx.dispose();
 };
 

package/src/unmarshal/promise.ts

@@ -1,7 +1,7 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { newDeferred } from "../util";
-import { call, instanceOf } from "../vmutil";
+import { call, consume, instanceOf } from "../vmutil";
 
 export default function unmarshalPromise<T = unknown>(
   ctx: QuickJSContext,
@@ -24,7 +24,11 @@ export default function unmarshalPromise<T = unknown>(
 
 function isPromiseHandle(ctx: QuickJSContext, handle: QuickJSHandle): boolean {
   if (!handle.owner) return false;
-  return ctx.unwrapResult(ctx.evalCode("Promise")).consume(promise => {
+  // `consume` disposes the Promise constructor handle even if `instanceOf`
+  // throws mid-flight (e.g. an interrupt or OOM lands in the `a instanceof b`
+  // VM call); the raw `Lifetime.consume` would skip disposal on throw, orphaning
+  // the constructor handle.
+  return consume(ctx.unwrapResult(ctx.evalCode("Promise")), promise => {
     if (!handle.owner) return false;
     return instanceOf(ctx, handle, promise);
   });

package/src/unmarshal/properties.test.ts

@@ -1,4 +1,5 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import unmarshalProperties from "./properties";
@@ -47,7 +48,7 @@ test("works", async () => {
   expect(unmarshal).toReturnWith(["c", false]);
   expect(unmarshal).toReturnWith([expect.any(Function), false]); // get, set
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
   ctx.dispose();
 });

package/src/unmarshal/properties.ts

@@ -2,6 +2,46 @@ import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { call, consume } from "../vmutil";
 
+// The VM-side iterator computes a numeric bitmask per property so the host can
+// rebuild the PropertyDescriptor with at most one `ctx.getProp` (for the single
+// value/get/set entry that is actually present) plus one `ctx.getNumber`,
+// instead of the previous six `getProp` + six `typeof` calls per property.
+//
+// Bit layout (a "present" bit for every field, plus a "value" bit for the three
+// boolean fields whose value we cannot recover from a handle):
+//   bit 0 (1)   value present        (typeof d.value !== "undefined")
+//   bit 1 (2)   get present          (typeof d.get   !== "undefined")
+//   bit 2 (4)   set present          (typeof d.set   !== "undefined")
+//   bit 3 (8)   configurable present (typeof d.configurable === "boolean")
+//   bit 4 (16)  configurable value   (d.configurable === true)
+//   bit 5 (32)  enumerable present   (typeof d.enumerable === "boolean")
+//   bit 6 (64)  enumerable value     (d.enumerable === true)
+//   bit 7 (128) writable present     (typeof d.writable === "boolean")
+//   bit 8 (256) writable value       (d.writable === true)
+//
+// This mirrors the previous logic exactly: value/get/set are copied only when
+// defined (an explicit `value: undefined` is treated as absent, so defaults
+// apply, just as `typeof === "undefined"` skipped it before); a boolean field
+// is copied only when actually a boolean, and absent boolean fields stay absent
+// so `Object.defineProperty` applies its defaults. Data vs accessor descriptors
+// are distinguished naturally: data descriptors carry a `writable` present bit
+// and no get/set, accessors carry get/set and no `writable`.
+const flagsFn = `(o, fn) => {
+  const descs = Object.getOwnPropertyDescriptors(o);
+  const emit = (k, d) => {
+    let f = 0;
+    if (typeof d.value !== "undefined") f |= 1;
+    if (typeof d.get !== "undefined") f |= 2;
+    if (typeof d.set !== "undefined") f |= 4;
+    if (typeof d.configurable === "boolean") { f |= 8; if (d.configurable) f |= 16; }
+    if (typeof d.enumerable === "boolean") { f |= 32; if (d.enumerable) f |= 64; }
+    if (typeof d.writable === "boolean") { f |= 128; if (d.writable) f |= 256; }
+    fn(k, d, f);
+  };
+  Object.entries(descs).forEach(([k, v]) => emit(k, v));
+  Object.getOwnPropertySymbols(descs).forEach(k => emit(k, descs[k]));
+}`;
+
 export default function unmarshalProperties(
   ctx: QuickJSContext,
   handle: QuickJSHandle,
@@ -9,53 +49,47 @@ export default function unmarshalProperties(
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
 ) {
   consume(
-    ctx.newFunction("", (key, value) => {
+    ctx.newFunction("", (key, descHandle, flagsHandle) => {
       const [keyName] = unmarshal(key);
       if (typeof keyName !== "string" && typeof keyName !== "number" && typeof keyName !== "symbol")
         return;
 
-      const desc = (
-        [
-          ["value", true],
-          ["get", true],
-          ["set", true],
-          ["configurable", false],
-          ["enumerable", false],
-          ["writable", false],
-        ] as const
-      ).reduce<PropertyDescriptor>((desc, [key, unmarshable]) => {
-        const h = ctx.getProp(value, key);
-        const ty = ctx.typeof(h);
-
-        if (ty === "undefined") return desc;
-        if (!unmarshable && ty === "boolean") {
-          desc[key] = ctx.dump(ctx.getProp(value, key));
-          return desc;
-        }
+      const flags = ctx.getNumber(flagsHandle);
+      const desc: PropertyDescriptor = {};
 
-        const [v, alreadyExists] = unmarshal(h);
-        if (alreadyExists) {
-          h.dispose();
+      // Obtain value/get/set as host-owned handles via `ctx.getProp` exactly as
+      // before: these must NOT come from the (scope-borrowed, auto-disposed)
+      // callback arguments, because `unmarshal` may retain the handle in the
+      // Arena's VMMap for identity tracking. Dispose only when `unmarshal`
+      // reports the value already existed (so the fresh handle is redundant);
+      // otherwise ownership was transferred to the map and we must keep it.
+      const readHandle = (fieldKey: string): unknown => {
+        const h = ctx.getProp(descHandle, fieldKey);
+        let retained = false;
+        try {
+          const [v, alreadyExists] = unmarshal(h);
+          // When the value already existed, ownership stays with the map and the
+          // fresh handle is redundant; otherwise `unmarshal` transferred it to the
+          // map and we must keep it. A mid-flight throw in `unmarshal` also lands
+          // here with `retained` false, so the orphaned handle is disposed.
+          retained = !alreadyExists;
+          return v;
+        } finally {
+          if (!retained && h.alive) h.dispose();
         }
-        desc[key] = v;
+      };
 
-        return desc;
-      }, {});
+      if (flags & 1) desc.value = readHandle("value");
+      if (flags & 2) desc.get = readHandle("get") as any;
+      if (flags & 4) desc.set = readHandle("set") as any;
+      if (flags & 8) desc.configurable = !!(flags & 16);
+      if (flags & 32) desc.enumerable = !!(flags & 64);
+      if (flags & 128) desc.writable = !!(flags & 256);
 
       Object.defineProperty(target, keyName, desc);
     }),
     fn => {
-      call(
-        ctx,
-        `(o, fn) => {
-        const descs = Object.getOwnPropertyDescriptors(o);
-        Object.entries(descs).forEach(([k, v]) => fn(k, v));
-        Object.getOwnPropertySymbols(descs).forEach(k => fn(k, descs[k]));
-      }`,
-        undefined,
-        handle,
-        fn,
-      ).dispose();
+      call(ctx, flagsFn, undefined, handle, fn).dispose();
     },
   );
 }

package/src/vmmap.ts

@@ -1,6 +1,6 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
-import { unwrapResult } from "./vmutil";
+import { consume, unwrapResult } from "./vmutil";
 
 /**
  * Bidirectional map between host values and QuickJS handles.
@@ -79,7 +79,19 @@ export default class VMMap {
       return v === handle || v === handle2;
     }
 
-    const id = this._nextId++;
+    const id = this._nextId;
+
+    // Register on the VM side FIRST, before mutating any host-side bookkeeping.
+    // If this throws (e.g. an OOM lands inside `_mapSet`), no host map has been
+    // touched and `handle`/`handle2` are NOT retained here, so the caller still
+    // owns them and can dispose them: `set` stays atomic (all-or-nothing).
+    // `consume` disposes the id number handle even when the call throws (the raw
+    // `Lifetime.consume` skips disposal on throw, leaking it).
+    consume(this.ctx.newNumber(id), c => {
+      this._call(this._mapSet, undefined, handle, c, handle2 ?? this.ctx.undefined);
+    });
+
+    this._nextId++;
     this._keyToId.set(key, id);
     this._idToHandle.set(id, handle);
     this._idToKey.set(id, key);
@@ -91,10 +103,6 @@ export default class VMMap {
       }
     }
 
-    this.ctx.newNumber(id).consume(c => {
-      this._call(this._mapSet, undefined, handle, c, handle2 ?? this.ctx.undefined);
-    });
-
     return true;
   }
 

package/src/vmutil.test.ts

@@ -1,4 +1,5 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import {

package/src/wrapper.test.ts

@@ -1,15 +1,17 @@
-import { QuickJSHandle, getQuickJS } from "quickjs-emscripten";
+import type { QuickJSHandle} from "quickjs-emscripten";
+import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import { call, json } from "./vmutil";
+import type {
+  SyncMode} from "./wrapper";
 import {
   wrap,
   unwrap,
   isWrapped,
   wrapHandle,
   unwrapHandle,
-  isHandleWrapped,
-  SyncMode,
+  isHandleWrapped
 } from "./wrapper";
 
 test("wrap, unwrap, isWrapped", async () => {