quickjs-emscripten-sync 1.8.4 → 1.9.1

package/src/marshal/properties.ts

@@ -7,13 +7,21 @@ export default function marshalProperties(
   target: object | ((...args: any[]) => any),
   handle: QuickJSHandle,
   marshal: (target: unknown) => QuickJSHandle,
+  disposeTransient: (handle: QuickJSHandle) => void = () => {},
 ): void {
   const descs = ctx.newObject();
+  // Property values may be transient (json copies / BigInt) with no owner; once
+  // `Object.defineProperties` has copied them into `handle` the standalone
+  // handles are redundant and disposed below. Owned handles are left untouched.
+  const transient: QuickJSHandle[] = [];
   const cb = (key: string | number | symbol, desc: PropertyDescriptor) => {
     const keyHandle = marshal(key);
     const valueHandle = typeof desc.value === "undefined" ? undefined : marshal(desc.value);
     const getHandle = typeof desc.get === "undefined" ? undefined : marshal(desc.get);
     const setHandle = typeof desc.set === "undefined" ? undefined : marshal(desc.set);
+    if (valueHandle) transient.push(valueHandle);
+    if (getHandle) transient.push(getHandle);
+    if (setHandle) transient.push(setHandle);
 
     ctx.newObject().consume(descObj => {
       Object.entries(desc).forEach(([k, v]) => {
@@ -35,11 +43,16 @@ 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();
+    // Safe only after defineProperties has dup'd the values into `handle`; `descs`
+    // still holds its own references until its own dispose() in the finally.
+    for (const h of transient) disposeTransient(h);
+  } 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();
-    });
+    },
+  );
 }

package/src/vmmap.ts

@@ -1,18 +1,29 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
+import { unwrapResult } from "./vmutil";
+
+/**
+ * Bidirectional map between host values and QuickJS handles.
+ *
+ * Each registered pair gets a numeric id. A value may be registered under two
+ * keys (e.g. a proxy-wrapped object and the underlying object), each with its
+ * own handle, so every lookup direction is backed by an explicit map and id
+ * reverse-lookups, keeping `delete` O(1).
+ */
 export default class VMMap {
   ctx: QuickJSContext;
-  _map1 = new Map<any, number>();
-  _map2 = new Map<any, number>();
-  _map3 = new Map<number, QuickJSHandle>();
-  _map4 = new Map<number, QuickJSHandle>();
-  _counterMap = new Map<number, any>();
+  _keyToId = new Map<any, number>();
+  _key2ToId = new Map<any, number>();
+  _idToHandle = new Map<number, QuickJSHandle>();
+  _idToHandle2 = new Map<number, QuickJSHandle>();
+  _idToKey = new Map<number, any>();
+  _idToKey2 = new Map<number, any>();
   _disposables = new Set<QuickJSHandle>();
   _mapGet: QuickJSHandle;
   _mapSet: QuickJSHandle;
   _mapDelete: QuickJSHandle;
   _mapClear: QuickJSHandle;
-  _counter = Number.MIN_SAFE_INTEGER;
+  _nextId = Number.MIN_SAFE_INTEGER;
 
   constructor(ctx: QuickJSContext) {
     this.ctx = ctx;
@@ -68,18 +79,19 @@ export default class VMMap {
       return v === handle || v === handle2;
     }
 
-    const counter = this._counter++;
-    this._map1.set(key, counter);
-    this._map3.set(counter, handle);
-    this._counterMap.set(counter, key);
+    const id = this._nextId++;
+    this._keyToId.set(key, id);
+    this._idToHandle.set(id, handle);
+    this._idToKey.set(id, key);
     if (key2) {
-      this._map2.set(key2, counter);
+      this._key2ToId.set(key2, id);
+      this._idToKey2.set(id, key2);
       if (handle2) {
-        this._map4.set(counter, handle2);
+        this._idToHandle2.set(id, handle2);
       }
     }
 
-    this.ctx.newNumber(counter).consume(c => {
+    this.ctx.newNumber(id).consume(c => {
       this._call(this._mapSet, undefined, handle, c, handle2 ?? this.ctx.undefined);
     });
 
@@ -104,8 +116,8 @@ export default class VMMap {
   }
 
   get(key: any) {
-    const num = this._map1.get(key) ?? this._map2.get(key);
-    const handle = typeof num === "number" ? this._map3.get(num) : undefined;
+    const id = this._keyToId.get(key) ?? this._key2ToId.get(key);
+    const handle = typeof id === "number" ? this._idToHandle.get(id) : undefined;
 
     if (!handle) return;
     if (!handle.alive) {
@@ -120,7 +132,7 @@ export default class VMMap {
     if (!handle.alive) {
       return;
     }
-    return this._counterMap.get(this.ctx.getNumber(this._call(this._mapGet, undefined, handle)));
+    return this._idToKey.get(this.ctx.getNumber(this._call(this._mapGet, undefined, handle)));
   }
 
   has(key: any) {
@@ -132,46 +144,29 @@ export default class VMMap {
   }
 
   keys() {
-    return this._map1.keys();
+    return this._keyToId.keys();
   }
 
   delete(key: any, dispose?: boolean) {
-    const num = this._map1.get(key) ?? this._map2.get(key);
-    if (typeof num === "undefined") return;
+    const id = this._keyToId.get(key) ?? this._key2ToId.get(key);
+    if (typeof id === "undefined") return;
 
-    const handle = this._map3.get(num);
-    const handle2 = this._map4.get(num);
+    const handle = this._idToHandle.get(id);
+    const handle2 = this._idToHandle2.get(id);
     this._call(
       this._mapDelete,
       undefined,
       ...[handle, handle2].filter((h): h is QuickJSHandle => !!h?.alive),
     );
 
-    this._map1.delete(key);
-    this._map2.delete(key);
-    this._map3.delete(num);
-    this._map4.delete(num);
-
-    for (const [k, v] of this._map1) {
-      if (v === num) {
-        this._map1.delete(k);
-        break;
-      }
-    }
-
-    for (const [k, v] of this._map2) {
-      if (v === num) {
-        this._map2.delete(k);
-        break;
-      }
-    }
-
-    for (const [k, v] of this._counterMap) {
-      if (v === key) {
-        this._counterMap.delete(k);
-        break;
-      }
-    }
+    const key1 = this._idToKey.get(id);
+    const key2 = this._idToKey2.get(id);
+    if (typeof key1 !== "undefined") this._keyToId.delete(key1);
+    if (typeof key2 !== "undefined") this._key2ToId.delete(key2);
+    this._idToHandle.delete(id);
+    this._idToHandle2.delete(id);
+    this._idToKey.delete(id);
+    this._idToKey2.delete(id);
 
     if (dispose) {
       if (handle?.alive) handle.dispose();
@@ -187,12 +182,13 @@ export default class VMMap {
   }
 
   clear() {
-    this._counter = 0;
-    this._map1.clear();
-    this._map2.clear();
-    this._map3.clear();
-    this._map4.clear();
-    this._counterMap.clear();
+    this._nextId = 0;
+    this._keyToId.clear();
+    this._key2ToId.clear();
+    this._idToHandle.clear();
+    this._idToHandle2.clear();
+    this._idToKey.clear();
+    this._idToKey2.clear();
     if (this._mapClear.alive) {
       this._call(this._mapClear, undefined);
     }
@@ -204,12 +200,12 @@ export default class VMMap {
         v.dispose();
       }
     }
-    for (const v of this._map3.values()) {
+    for (const v of this._idToHandle.values()) {
       if (v.alive) {
         v.dispose();
       }
     }
-    for (const v of this._map4.values()) {
+    for (const v of this._idToHandle2.values()) {
       if (v.alive) {
         v.dispose();
       }
@@ -219,37 +215,31 @@ export default class VMMap {
   }
 
   get size() {
-    return this._map1.size;
+    return this._keyToId.size;
   }
 
   [Symbol.iterator](): Iterator<[any, QuickJSHandle, any, QuickJSHandle | undefined]> {
-    const keys = this._map1.keys();
+    const keys = this._keyToId.keys();
     return {
       next: () => {
-         
         while (true) {
           const k1 = keys.next();
           if (k1.done) return { value: undefined, done: true };
-          const n = this._map1.get(k1.value);
-          if (typeof n === "undefined") continue;
-          const v1 = this._map3.get(n);
-          const v2 = this._map4.get(n);
+          const id = this._keyToId.get(k1.value);
+          if (typeof id === "undefined") continue;
+          const v1 = this._idToHandle.get(id);
+          const v2 = this._idToHandle2.get(id);
           if (!v1) continue;
-          const k2 = this._get2(n);
+          const k2 = this._idToKey2.get(id);
           return { value: [k1.value, v1, k2, v2], done: false };
         }
       },
     };
   }
 
-  _get2(num: number) {
-    for (const [k, v] of this._map2) {
-      if (v === num) return k;
-    }
-  }
-
   _call(fn: QuickJSHandle, thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]) {
-    return this.ctx.unwrapResult(
+    return unwrapResult(
+      this.ctx,
       this.ctx.callFunction(
         fn,
         typeof thisArg === "undefined" ? this.ctx.undefined : thisArg,