quickjs-emscripten-sync 1.8.4 → 1.9.0

package/src/index.ts

@@ -2,6 +2,7 @@ import type {
   QuickJSDeferredPromise,
   QuickJSHandle,
   QuickJSContext,
+  QuickJSAsyncContext,
   SuccessOrFail,
   VmCallResult,
   Intrinsics,
@@ -11,9 +12,20 @@ import { wrapContext, QuickJSContextEx } from "./contextex";
 import { defaultRegisteredObjects } from "./default";
 import marshal from "./marshal";
 import unmarshal from "./unmarshal";
+import unmarshalHostRef from "./unmarshal/hostref";
 import { complexity, isES2015Class, isObject, walkObject } from "./util";
 import VMMap from "./vmmap";
-import { call, isHandleObject, json, consumeAll, mayConsume, handleFrom } from "./vmutil";
+import {
+  call,
+  isHandleObject,
+  json,
+  consume,
+  consumeAll,
+  mayConsume,
+  handleFrom,
+  enableFnCache,
+  disposeFnCache,
+} from "./vmutil";
 import { wrap, wrapHandle, unwrap, unwrapHandle, Wrapped } from "./wrapper";
 
 export {
@@ -53,6 +65,10 @@ export type Options = {
   compat?: boolean;
   /** Experimental: use QuickJSContextEx, which wraps existing QuickJSContext. */
   experimentalContextEx?: boolean;
+  /** Globally enable sync mode (default `true`). When `false`, objects are not wrapped with proxies and marshalled handles are disposed after use, so `arena.sync` has no effect but objects are not retained for their whole lifetime. Useful to avoid memory growth when frequently exchanging short-lived objects. */
+  syncEnabled?: boolean;
+  /** A callback that returns whether an object should be passed to the VM by reference (as an opaque HostRef) instead of being marshalled by value/proxy. The guest cannot read such objects, but can hold them and pass them back to the host, where they resolve to the original object. */
+  marshalByReference?: (target: any) => boolean;
 };
 
 /**
@@ -80,6 +96,7 @@ export class Arena {
     }
 
     this.context = options?.experimentalContextEx ? wrapContext(ctx) : ctx;
+    enableFnCache(this.context);
     this._options = options;
     this._symbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
     this._map = new VMMap(ctx);
@@ -94,9 +111,15 @@ export class Arena {
     this._map.dispose();
     this._registeredMap.dispose();
     this._symbolHandle.dispose();
+    disposeFnCache(this.context);
     this.context.disposeEx?.();
   }
 
+  /** Allows `using arena = new Arena(...)` to dispose the arena automatically. */
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+
   /**
    * Evaluate JS code in the VM and get the result as an object on the host side. It also converts and re-throws error objects when an error is thrown during evaluation.
    */
@@ -150,7 +173,7 @@ export class Arena {
     if ("value" in result) {
       return result.value;
     }
-    throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
+    throw this._unwrapIfNotSynced(consume(result.error, this._unmarshal));
   }
 
   /**
@@ -355,12 +378,12 @@ export class Arena {
     if ("value" in result) {
       return result.value;
     }
-    throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
+    throw this._unwrapIfNotSynced(consume(result.error, this._unmarshal));
   }
 
   _unwrapResultAndUnmarshal(result: VmCallResult<QuickJSHandle> | undefined): any {
     if (!result) return;
-    return this._unwrapIfNotSynced(this._unwrapResult(result).consume(this._unmarshal));
+    return this._unwrapIfNotSynced(consume(this._unwrapResult(result), this._unmarshal));
   }
 
   _isMarshalable = (t: unknown): boolean | "json" => {
@@ -368,6 +391,19 @@ export class Arena {
     return (typeof im === "function" ? im(this._unwrap(t)) : im) ?? "json";
   };
 
+  _marshalByReference = (t: unknown): boolean => {
+    return !!this._options?.marshalByReference?.(this._unwrap(t));
+  };
+
+  // Register an opaque HostRef handle by its host value without wrapping it.
+  _registerHostRef = (t: unknown, handle: QuickJSHandle): QuickJSHandle => {
+    const u = this._unwrap(t);
+    const existing = this._map.get(u);
+    if (existing) return existing;
+    this._map.set(u, handle);
+    return handle;
+  };
+
   _marshalFind = (t: unknown) => {
     const unwrappedT = this._unwrap(t);
     const handle =
@@ -405,21 +441,29 @@ export class Arena {
       return [registered, false];
     }
 
-    const handle = marshal(this._wrap(target) ?? target, {
+    // Pass-by-reference objects must reference the original, not a proxy wrapper.
+    const marshalTarget = this._marshalByReference(target)
+      ? this._unwrap(target)
+      : this._wrap(target) ?? target;
+
+    const handle = marshal(marshalTarget, {
       ctx: this.context,
       unmarshal: this._unmarshal,
       isMarshalable: this._isMarshalable,
+      marshalByReference: this._marshalByReference,
+      registerHostRef: this._registerHostRef,
       find: this._marshalFind,
       pre: this._marshalPre,
       preApply: this._marshalPreApply,
       custom: this._options?.customMarshaller,
     });
 
-    return [handle, !this._map.hasHandle(handle)];
+    const syncEnabled = this._options?.syncEnabled ?? true;
+    return [handle, !syncEnabled || !this._map.hasHandle(handle)];
   };
 
   _preUnmarshal = (t: any, h: QuickJSHandle): Wrapped<any> => {
-    return this._register(t, h, undefined, true)?.[0];
+    return this._register(t, h, undefined, this._options?.syncEnabled ?? true)?.[0];
   };
 
   _unmarshalFind = (h: QuickJSHandle): unknown => {
@@ -432,6 +476,12 @@ export class Arena {
       return registered;
     }
 
+    // Resolve opaque HostRefs before wrapping, since a proxy would hide them.
+    if (this._options?.marshalByReference) {
+      const ref = unmarshalHostRef(this.context, handle);
+      if (ref) return ref.value;
+    }
+
     const [wrappedHandle] = this._wrapHandle(handle);
     return unmarshal(wrappedHandle ?? handle, {
       ctx: this.context,
@@ -439,6 +489,7 @@ export class Arena {
       find: this._unmarshalFind,
       pre: this._preUnmarshal,
       custom: this._options?.customUnmarshaller,
+      hostRef: !!this._options?.marshalByReference,
     });
   };
 
@@ -487,6 +538,7 @@ export class Arena {
       this._marshal,
       this._syncMode,
       this._options?.isWrappable,
+      this._options?.syncEnabled ?? true,
     );
   }
 
@@ -508,6 +560,7 @@ export class Arena {
       this._unmarshal,
       this._syncMode,
       this._options?.isHandleWrappable,
+      this._options?.syncEnabled ?? true,
     );
   }
 
@@ -515,3 +568,28 @@ export class Arena {
     return unwrapHandle(this.context, target, this._symbolHandle);
   }
 }
+
+/**
+ * An Arena backed by a {@link QuickJSAsyncContext}. In addition to everything
+ * `Arena` offers, it can evaluate code asynchronously with `evalCodeAsync`,
+ * which lets the VM await host promises (e.g. async module loaders or async
+ * functions exposed from the host) without manually pumping pending jobs.
+ */
+export class AsyncArena extends Arena {
+  asyncContext: QuickJSAsyncContext;
+
+  constructor(ctx: QuickJSAsyncContext, options?: Options) {
+    super(ctx, options);
+    this.asyncContext = ctx;
+  }
+
+  /**
+   * Evaluate JS code asynchronously in the VM and get the result on the host
+   * side. Like `evalCode`, it converts and re-throws errors thrown during
+   * evaluation. Use this when the code awaits host-provided promises.
+   */
+  async evalCodeAsync<T = any>(code: string, filename?: string): Promise<T> {
+    const result = await this.asyncContext.evalCodeAsync(code, filename);
+    return this._unwrapResultAndUnmarshal(result);
+  }
+}

package/src/marshal/custom.ts

@@ -1,6 +1,6 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
-import { call } from "../vmutil";
+import { call, consumeAll } from "../vmutil";
 
 export default function marshalCustom(
   ctx: QuickJSContext,
@@ -33,4 +33,18 @@ export function date(target: unknown, ctx: QuickJSContext): QuickJSHandle | unde
   return handle;
 }
 
-export const defaultCustom = [symbol, date];
+export function arrayBuffer(target: unknown, ctx: QuickJSContext): QuickJSHandle | undefined {
+  if (target instanceof ArrayBuffer) {
+    return ctx.newArrayBuffer(target.slice(0));
+  }
+  if (ArrayBuffer.isView(target)) {
+    // TypedArray or DataView: copy the viewed bytes and rebuild in the VM.
+    const bytes = new Uint8Array(target.buffer, target.byteOffset, target.byteLength).slice();
+    return consumeAll(
+      [ctx.newArrayBuffer(bytes.buffer), ctx.newString(target.constructor.name)],
+      ([buf, name]) => call(ctx, `(buf, name) => new globalThis[name](buf)`, undefined, buf, name),
+    );
+  }
+}
+
+export const defaultCustom = [symbol, date, arrayBuffer];

package/src/marshal/hostref.ts

@@ -0,0 +1,18 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+/**
+ * Marshal a host object as an opaque HostRef handle instead of deep-copying or
+ * proxying it. The guest cannot read the object, but can hold it and pass it
+ * back to the host, where it unmarshals to the original object by reference.
+ */
+export default function marshalHostRef(
+  ctx: QuickJSContext,
+  target: unknown,
+  // Registers handle <-> target without wrapping (a proxy would hide the opaque
+  // HostRef). Keeps identity and lets the arena dispose the handle on teardown.
+  register: (target: unknown, handle: QuickJSHandle) => QuickJSHandle,
+): QuickJSHandle | undefined {
+  if (typeof target !== "object" && typeof target !== "function") return;
+  if (target === null) return;
+  return register(target, ctx.newHostRef(target as object).handle);
+}

package/src/marshal/index.ts

@@ -2,7 +2,9 @@ import type { QuickJSDeferredPromise, QuickJSHandle, QuickJSContext } from "quic
 
 import marshalCustom, { defaultCustom } from "./custom";
 import marshalFunction from "./function";
+import marshalHostRef from "./hostref";
 import marshalJSON from "./json";
+import marshalMapSet from "./mapset";
 import marshalObject from "./object";
 import marshalPrimitive from "./primitive";
 import marshalPromise from "./promise";
@@ -11,6 +13,8 @@ export type Options = {
   ctx: QuickJSContext;
   unmarshal: (handle: QuickJSHandle) => unknown;
   isMarshalable?: (target: unknown) => boolean | "json";
+  marshalByReference?: (target: unknown) => boolean;
+  registerHostRef?: (target: unknown, handle: QuickJSHandle) => QuickJSHandle;
   find: (target: unknown) => QuickJSHandle | undefined;
   pre: (
     target: unknown,
@@ -36,6 +40,13 @@ export function marshal(target: unknown, options: Options): QuickJSHandle {
     if (handle) return handle;
   }
 
+  // Opt-in pass-by-reference: hand the object to the VM as an opaque HostRef
+  // instead of marshalling its contents. Bypasses isMarshalable on purpose.
+  if (options.marshalByReference?.(target) && options.registerHostRef) {
+    const handle = marshalHostRef(ctx, target, options.registerHostRef);
+    if (handle) return handle;
+  }
+
   const marshalable = isMarshalable?.(target);
   if (marshalable === false) {
     return ctx.undefined;
@@ -52,6 +63,7 @@ export function marshal(target: unknown, options: Options): QuickJSHandle {
     marshalCustom(ctx, target, pre2, [...defaultCustom, ...(options.custom ?? [])]) ??
     marshalPromise(ctx, target, marshal2, pre2) ??
     marshalFunction(ctx, target, marshal2, unmarshal, pre2, options.preApply) ??
+    marshalMapSet(ctx, target, marshal2, pre2) ??
     marshalObject(ctx, target, marshal2, pre2) ??
     ctx.undefined
   );

package/src/marshal/mapset.ts

@@ -0,0 +1,28 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import { call } from "../vmutil";
+
+export default function marshalMapSet(
+  ctx: QuickJSContext,
+  target: unknown,
+  marshal: (target: unknown) => QuickJSHandle,
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
+): QuickJSHandle | undefined {
+  if (target instanceof Map) {
+    const raw = call(ctx, "() => new Map()");
+    const handle = preMarshal(target, raw) ?? raw;
+    for (const [k, v] of target) {
+      call(ctx, "(m, k, v) => m.set(k, v)", undefined, raw, marshal(k), marshal(v)).dispose();
+    }
+    return handle;
+  }
+
+  if (target instanceof Set) {
+    const raw = call(ctx, "() => new Set()");
+    const handle = preMarshal(target, raw) ?? raw;
+    for (const v of target) {
+      call(ctx, "(s, v) => s.add(v)", undefined, raw, marshal(v)).dispose();
+    }
+    return handle;
+  }
+}

package/src/marshal/primitive.ts

@@ -1,7 +1,5 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
-// import { call } from "../vmutil";
-
 export default function marshalPrimitive(
   ctx: QuickJSContext,
   target: unknown,
@@ -15,17 +13,10 @@ export default function marshalPrimitive(
       return ctx.newString(target);
     case "boolean":
       return target ? ctx.true : ctx.false;
+    case "bigint":
+      return ctx.newBigInt(target);
     case "object":
       return target === null ? ctx.null : undefined;
-
-    // BigInt is not supported by quickjs-emscripten
-    // case "bigint":
-    //   return call(
-    //     ctx,
-    //     `s => BigInt(s)`,
-    //     undefined,
-    //     ctx.newString(target.toString())
-    //   );
   }
 
   return undefined;

package/src/marshal/properties.ts

@@ -35,11 +35,13 @@ export default function marshalProperties(
     });
   };
 
-  const desc = Object.getOwnPropertyDescriptors(target);
-  Object.entries(desc).forEach(([k, v]) => cb(k, v));
-  Object.getOwnPropertySymbols(desc).forEach(k => cb(k, (desc as any)[k]));
+  try {
+    const desc = Object.getOwnPropertyDescriptors(target);
+    Object.entries(desc).forEach(([k, v]) => cb(k, v));
+    Object.getOwnPropertySymbols(desc).forEach(k => cb(k, (desc as any)[k]));
 
-  call(ctx, `Object.defineProperties`, undefined, handle, descs).dispose();
-
-  descs.dispose();
+    call(ctx, `Object.defineProperties`, undefined, handle, descs).dispose();
+  } finally {
+    descs.dispose();
+  }
 }

package/src/unmarshal/custom.ts

@@ -1,6 +1,6 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
-import { call } from "../vmutil";
+import { call, consume } from "../vmutil";
 
 export default function unmarshalCustom(
   ctx: QuickJSContext,
@@ -23,9 +23,40 @@ export function symbol(handle: QuickJSHandle, ctx: QuickJSContext): symbol | und
 }
 
 export function date(handle: QuickJSHandle, ctx: QuickJSContext): Date | undefined {
-  if (!ctx.dump(call(ctx, "a => a instanceof Date", undefined, handle))) return;
-  const t = ctx.getNumber(call(ctx, "a => a.getTime()", undefined, handle));
+  if (!consume(call(ctx, "a => a instanceof Date", undefined, handle), h => ctx.dump(h))) return;
+  const t = consume(call(ctx, "a => a.getTime()", undefined, handle), h => ctx.getNumber(h));
   return new Date(t);
 }
 
-export const defaultCustom = [symbol, date];
+export function arrayBuffer(
+  handle: QuickJSHandle,
+  ctx: QuickJSContext,
+): ArrayBuffer | ArrayBufferView | undefined {
+  if (consume(call(ctx, "a => a instanceof ArrayBuffer", undefined, handle), h => ctx.dump(h))) {
+    const lifetime = ctx.getArrayBuffer(handle);
+    const copy = lifetime.value.slice();
+    lifetime.dispose();
+    return copy.buffer;
+  }
+
+  if (consume(call(ctx, "a => ArrayBuffer.isView(a)", undefined, handle), h => ctx.dump(h))) {
+    const name = consume(call(ctx, "a => a.constructor.name", undefined, handle), h =>
+      ctx.getString(h),
+    );
+    const Ctor = (globalThis as any)[name];
+    if (typeof Ctor !== "function") return;
+    const bufHandle = call(
+      ctx,
+      "a => a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength)",
+      undefined,
+      handle,
+    );
+    const lifetime = ctx.getArrayBuffer(bufHandle);
+    const bytes = lifetime.value.slice();
+    lifetime.dispose();
+    bufHandle.dispose();
+    return new Ctor(bytes.buffer);
+  }
+}
+
+export const defaultCustom = [symbol, date, arrayBuffer];

package/src/unmarshal/function.ts

@@ -1,6 +1,6 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
-import { call, mayConsumeAll } from "../vmutil";
+import { call, mayConsumeAll, unwrapResult } from "../vmutil";
 
 import unmarshalProperties from "./properties";
 
@@ -26,7 +26,7 @@ export default function unmarshalFunction(
           return this;
         }
 
-        const resultHandle = ctx.unwrapResult(ctx.callFunction(handle, thisHandle, ...argHandles));
+        const resultHandle = unwrapResult(ctx, ctx.callFunction(handle, thisHandle, ...argHandles));
 
         const [result, alreadyExists] = unmarshal(resultHandle);
         if (alreadyExists) resultHandle.dispose();

package/src/unmarshal/hostref.ts

@@ -0,0 +1,21 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+/**
+ * If `handle` is an opaque HostRef, resolve it back to the original host value.
+ * Returns a wrapper so the caller can tell "resolved to a falsy value" apart
+ * from "not a HostRef". `toHostRef` is cheap for non-HostRef handles.
+ */
+export default function unmarshalHostRef(
+  ctx: QuickJSContext,
+  handle: QuickJSHandle,
+): { value: unknown } | undefined {
+  const ref = ctx.toHostRef(handle);
+  if (!ref) return;
+  try {
+    return { value: ref.value };
+  } finally {
+    // toHostRef returns a HostRef wrapping a *dup* of the handle, so disposing
+    // it does not affect the caller's handle.
+    ref.dispose();
+  }
+}

package/src/unmarshal/index.ts

@@ -2,6 +2,8 @@ import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import unmarshalCustom, { defaultCustom } from "./custom";
 import unmarshalFunction from "./function";
+import unmarshalHostRef from "./hostref";
+import unmarshalMapSet from "./mapset";
 import unmarshalObject from "./object";
 import unmarshalPrimitive from "./primitive";
 import unmarshalPromise from "./promise";
@@ -13,6 +15,8 @@ export type Options = {
   find: (handle: QuickJSHandle) => unknown | undefined;
   pre: <T = unknown>(target: T, handle: QuickJSHandle) => T | undefined;
   custom?: Iterable<(obj: QuickJSHandle, ctx: QuickJSContext) => any>;
+  /** When true, resolve opaque HostRef handles back to their host value. */
+  hostRef?: boolean;
 };
 
 export function unmarshal(handle: QuickJSHandle, options: Options): any {
@@ -37,8 +41,24 @@ function unmarshalInner(handle: QuickJSHandle, options: Options): [any, boolean]
 
   const unmarshal2 = (h: QuickJSHandle) => unmarshalInner(h, options);
 
+  // Opaque HostRef handles resolve back to the original host value by reference.
+  if (options.hostRef) {
+    const ref = unmarshalHostRef(ctx, handle);
+    if (ref) return [ref.value, true];
+  }
+
+  // Custom types (Symbol, Date, ArrayBuffer, TypedArray, ...) are unmarshalled
+  // by value and not tracked in the map, so their source handle is not owned by
+  // anyone else and the caller must dispose it.
+  const custom = unmarshalCustom(ctx, handle, pre, [...defaultCustom, ...(options.custom ?? [])]);
+  if (custom) return [custom, true];
+
+  // Map/Set are unmarshalled by value (snapshot copy), so the source handle is
+  // not tracked and the caller must dispose it.
+  const mapSet = unmarshalMapSet(ctx, handle, unmarshal2, pre);
+  if (mapSet) return [mapSet, true];
+
   const result =
-    unmarshalCustom(ctx, handle, pre, [...defaultCustom, ...(options.custom ?? [])]) ??
     unmarshalPromise(ctx, handle, marshal, pre) ??
     unmarshalFunction(ctx, handle, marshal, unmarshal2, pre) ??
     unmarshalObject(ctx, handle, unmarshal2, pre);

package/src/unmarshal/mapset.ts

@@ -0,0 +1,43 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import { call, consume } from "../vmutil";
+
+export default function unmarshalMapSet(
+  ctx: QuickJSContext,
+  handle: QuickJSHandle,
+  unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
+  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined,
+): Map<any, any> | Set<any> | undefined {
+  const isMap = consume(call(ctx, "a => a instanceof Map", undefined, handle), h => ctx.dump(h));
+  const isSet =
+    !isMap && consume(call(ctx, "a => a instanceof Set", undefined, handle), h => ctx.dump(h));
+  if (!isMap && !isSet) return;
+
+  const result: Map<any, any> | Set<any> = isMap ? new Map() : new Set();
+  preUnmarshal(result, handle);
+
+  const iterator = ctx.unwrapResult(ctx.getIterator(handle));
+  try {
+    for (const elResult of iterator) {
+      const el = ctx.unwrapResult(elResult);
+      if (isMap) {
+        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();
+      } else {
+        const [value, disposeValue] = unmarshal(el);
+        if (disposeValue) el.dispose();
+        (result as Set<any>).add(value);
+      }
+    }
+  } finally {
+    if (iterator.alive) iterator.dispose();
+  }
+
+  return result;
+}

package/src/unmarshal/object.ts

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

package/src/unmarshal/primitive.ts

@@ -7,24 +7,13 @@ export default function unmarshalPrimitive(
   const ty = ctx.typeof(handle);
   if (ty === "undefined" || ty === "number" || ty === "string" || ty === "boolean") {
     return [ctx.dump(handle), true];
-  } else if (ty === "object") {
-    const isNull = ctx
-      .unwrapResult(ctx.evalCode("a => a === null"))
-      .consume(n => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle))));
-    if (isNull) {
-      return [null, true];
-    }
   }
-
-  // BigInt is not supported by quickjs-emscripten
-  // if (ty === "bigint") {
-  //   const str = ctx
-  //     .getProp(handle, "toString")
-  //     .consume(toString => vm.unwrapResult(vm.callFunction(toString, handle)))
-  //     .consume(str => ctx.getString(str));
-  //   const bi = BigInt(str);
-  //   return [bi, true];
-  // }
+  if (ty === "bigint") {
+    return [ctx.getBigInt(handle), true];
+  }
+  if (ty === "object" && ctx.sameValue(handle, ctx.null)) {
+    return [null, true];
+  }
 
   return [undefined, false];
 }

package/src/unmarshal/properties.ts

@@ -1,6 +1,6 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
-import { call } from "../vmutil";
+import { call, consume } from "../vmutil";
 
 export default function unmarshalProperties(
   ctx: QuickJSContext,
@@ -8,8 +8,8 @@ export default function unmarshalProperties(
   target: object | ((...args: any[]) => any),
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
 ) {
-  ctx
-    .newFunction("", (key, value) => {
+  consume(
+    ctx.newFunction("", (key, value) => {
       const [keyName] = unmarshal(key);
       if (typeof keyName !== "string" && typeof keyName !== "number" && typeof keyName !== "symbol")
         return;
@@ -43,8 +43,8 @@ export default function unmarshalProperties(
       }, {});
 
       Object.defineProperty(target, keyName, desc);
-    })
-    .consume(fn => {
+    }),
+    fn => {
       call(
         ctx,
         `(o, fn) => {
@@ -56,5 +56,6 @@ export default function unmarshalProperties(
         handle,
         fn,
       ).dispose();
-    });
+    },
+  );
 }