quickjs-emscripten-sync 1.3.0 → 1.4.0

package/dist/quickjs-emscripten-sync.es.js

@@ -1,5 +1,5 @@
 class VMMap {
-  constructor(vm) {
+  constructor(ctx) {
     this._map1 = /* @__PURE__ */ new Map();
     this._map2 = /* @__PURE__ */ new Map();
     this._map3 = /* @__PURE__ */ new Map();
@@ -7,8 +7,8 @@ class VMMap {
     this._counterMap = /* @__PURE__ */ new Map();
     this._disposables = /* @__PURE__ */ new Set();
     this._counter = 0;
-    this.vm = vm;
-    const result = vm.unwrapResult(vm.evalCode(`() => {
+    this.ctx = ctx;
+    const result = ctx.unwrapResult(ctx.evalCode(`() => {
         const mapSym = new Map();
         let map = new WeakMap();
         let map2 = new WeakMap();
@@ -32,10 +32,10 @@ class VMMap {
           }
         };
       }`)).consume((fn2) => this._call(fn2, void 0));
-    this._mapGet = vm.getProp(result, "get");
-    this._mapSet = vm.getProp(result, "set");
-    this._mapDelete = vm.getProp(result, "delete");
-    this._mapClear = vm.getProp(result, "clear");
+    this._mapGet = ctx.getProp(result, "get");
+    this._mapSet = ctx.getProp(result, "set");
+    this._mapDelete = ctx.getProp(result, "delete");
+    this._mapClear = ctx.getProp(result, "clear");
     result.dispose();
     this._disposables.add(this._mapGet);
     this._disposables.add(this._mapSet);
@@ -60,8 +60,8 @@ class VMMap {
         this._map4.set(counter, handle2);
       }
     }
-    this.vm.newNumber(counter).consume((c) => {
-      this._call(this._mapSet, void 0, handle, c, handle2 != null ? handle2 : this.vm.undefined);
+    this.ctx.newNumber(counter).consume((c) => {
+      this._call(this._mapSet, void 0, handle, c, handle2 != null ? handle2 : this.ctx.undefined);
     });
     return true;
   }
@@ -92,7 +92,7 @@ class VMMap {
     if (!handle.alive) {
       return;
     }
-    return this._counterMap.get(this.vm.getNumber(this._call(this._mapGet, void 0, handle)));
+    return this._counterMap.get(this.ctx.getNumber(this._call(this._mapGet, void 0, handle)));
   }
   has(key) {
     return !!this.get(key);
@@ -207,7 +207,7 @@ class VMMap {
     }
   }
   _call(fn2, thisArg, ...args) {
-    return this.vm.unwrapResult(this.vm.callFunction(fn2, typeof thisArg === "undefined" ? this.vm.undefined : thisArg, ...args));
+    return this.ctx.unwrapResult(this.ctx.callFunction(fn2, typeof thisArg === "undefined" ? this.ctx.undefined : thisArg, ...args));
   }
 }
 function isES2015Class(cls) {
@@ -264,10 +264,10 @@ function newDeferred() {
     reject: rej
   };
 }
-function fn(vm, code) {
-  const handle = vm.unwrapResult(vm.evalCode(code));
+function fn(ctx, code) {
+  const handle = ctx.unwrapResult(ctx.evalCode(code));
   const f = (thisArg, ...args) => {
-    return vm.unwrapResult(vm.callFunction(handle, thisArg != null ? thisArg : vm.undefined, ...args));
+    return ctx.unwrapResult(ctx.callFunction(handle, thisArg != null ? thisArg : ctx.undefined, ...args));
   };
   f.dispose = () => handle.dispose();
   f.alive = true;
@@ -276,28 +276,28 @@ function fn(vm, code) {
   });
   return f;
 }
-function call(vm, code, thisArg, ...args) {
-  const f = fn(vm, code);
+function call(ctx, code, thisArg, ...args) {
+  const f = fn(ctx, code);
   try {
     return f(thisArg, ...args);
   } finally {
     f.dispose();
   }
 }
-function eq(vm, a, b) {
-  return vm.dump(call(vm, "Object.is", void 0, a, b));
+function eq(ctx, a, b) {
+  return ctx.dump(call(ctx, "Object.is", void 0, a, b));
 }
-function instanceOf(vm, a, b) {
-  return vm.dump(call(vm, "(a, b) => a instanceof b", void 0, a, b));
+function instanceOf(ctx, a, b) {
+  return ctx.dump(call(ctx, "(a, b) => a instanceof b", void 0, a, b));
 }
-function isHandleObject(vm, a) {
-  return vm.dump(call(vm, `a => typeof a === "object" && a !== null || typeof a === "function"`, void 0, a));
+function isHandleObject(ctx, h) {
+  return ctx.dump(call(ctx, `a => typeof a === "object" && a !== null || typeof a === "function"`, void 0, h));
 }
-function json(vm, target) {
+function json(ctx, target) {
   const json2 = JSON.stringify(target);
   if (!json2)
-    return vm.undefined;
-  return call(vm, `JSON.parse`, void 0, vm.newString(json2));
+    return ctx.undefined;
+  return call(ctx, `JSON.parse`, void 0, ctx.newString(json2));
 }
 function consumeAll(handles, cb) {
   try {
@@ -335,109 +335,109 @@ function isQuickJSDeferredPromise(d) {
 function handleFrom(d) {
   return isQuickJSDeferredPromise(d) ? d.handle : d;
 }
-function marshalProperties(vm, target, handle, marshal2) {
-  const descs = vm.newObject();
+function marshalProperties(ctx, target, handle, marshal2) {
+  const descs = ctx.newObject();
   const cb = (key, desc2) => {
     const keyHandle = marshal2(key);
     const valueHandle = typeof desc2.value === "undefined" ? void 0 : marshal2(desc2.value);
     const getHandle = typeof desc2.get === "undefined" ? void 0 : marshal2(desc2.get);
     const setHandle = typeof desc2.set === "undefined" ? void 0 : marshal2(desc2.set);
-    vm.newObject().consume((descObj) => {
+    ctx.newObject().consume((descObj) => {
       Object.entries(desc2).forEach(([k, v]) => {
-        const v2 = k === "value" ? valueHandle : k === "get" ? getHandle : k === "set" ? setHandle : v ? vm.true : vm.false;
+        const v2 = k === "value" ? valueHandle : k === "get" ? getHandle : k === "set" ? setHandle : v ? ctx.true : ctx.false;
         if (v2) {
-          vm.setProp(descObj, k, v2);
+          ctx.setProp(descObj, k, v2);
         }
       });
-      vm.setProp(descs, keyHandle, descObj);
+      ctx.setProp(descs, keyHandle, descObj);
     });
   };
   const desc = Object.getOwnPropertyDescriptors(target);
   Object.entries(desc).forEach(([k, v]) => cb(k, v));
   Object.getOwnPropertySymbols(desc).forEach((k) => cb(k, desc[k]));
-  call(vm, `Object.defineProperties`, void 0, handle, descs).dispose();
+  call(ctx, `Object.defineProperties`, void 0, handle, descs).dispose();
   descs.dispose();
 }
-function marshalFunction(vm, target, marshal2, unmarshal2, preMarshal, preApply) {
+function marshalFunction(ctx, target, marshal2, unmarshal2, preMarshal, preApply) {
   var _a;
   if (typeof target !== "function")
     return;
-  const raw = vm.newFunction(target.name, function(...argHandles) {
+  const raw = ctx.newFunction(target.name, function(...argHandles) {
     const that = unmarshal2(this);
     const args = argHandles.map((a) => unmarshal2(a));
     if (isES2015Class(target) && isObject(that)) {
       const result = new target(...args);
       Object.entries(result).forEach(([key, value]) => {
-        vm.setProp(this, key, marshal2(value));
+        ctx.setProp(this, key, marshal2(value));
       });
       return this;
     }
     return marshal2(preApply ? preApply(target, that, args) : target.apply(that, args));
-  }).consume((handle2) => call(vm, `Cls => {
+  }).consume((handle2) => call(ctx, `Cls => {
           const fn = function(...args) { return Cls.apply(this, args); };
           fn.name = Cls.name;
           fn.length = Cls.length;
           return fn;
         }`, void 0, handle2));
   const handle = (_a = preMarshal(target, raw)) != null ? _a : raw;
-  marshalProperties(vm, target, raw, marshal2);
+  marshalProperties(ctx, target, raw, marshal2);
   return handle;
 }
-function marshalObject(vm, target, marshal2, preMarshal) {
+function marshalObject(ctx, target, marshal2, preMarshal) {
   var _a;
   if (typeof target !== "object" || target === null)
     return;
-  const raw = Array.isArray(target) ? vm.newArray() : vm.newObject();
+  const raw = Array.isArray(target) ? ctx.newArray() : ctx.newObject();
   const handle = (_a = preMarshal(target, raw)) != null ? _a : raw;
   const prototype = Object.getPrototypeOf(target);
   const prototypeHandle = prototype && prototype !== Object.prototype && prototype !== Array.prototype ? marshal2(prototype) : void 0;
   if (prototypeHandle) {
-    call(vm, "Object.setPrototypeOf", void 0, handle, prototypeHandle).dispose();
+    call(ctx, "Object.setPrototypeOf", void 0, handle, prototypeHandle).dispose();
   }
-  marshalProperties(vm, target, raw, marshal2);
+  marshalProperties(ctx, target, raw, marshal2);
   return handle;
 }
-function marshalPrimitive(vm, target) {
+function marshalPrimitive(ctx, target) {
   switch (typeof target) {
     case "undefined":
-      return vm.undefined;
+      return ctx.undefined;
     case "number":
-      return vm.newNumber(target);
+      return ctx.newNumber(target);
     case "string":
-      return vm.newString(target);
+      return ctx.newString(target);
     case "boolean":
-      return target ? vm.true : vm.false;
+      return target ? ctx.true : ctx.false;
     case "object":
-      return target === null ? vm.null : void 0;
+      return target === null ? ctx.null : void 0;
   }
   return void 0;
 }
-function marshalSymbol(vm, target, preMarshal) {
+function marshalSymbol(ctx, target, preMarshal) {
   var _a;
   if (typeof target !== "symbol")
     return;
-  const handle = call(vm, "d => Symbol(d)", void 0, target.description ? vm.newString(target.description) : vm.undefined);
+  const handle = call(ctx, "d => Symbol(d)", void 0, target.description ? ctx.newString(target.description) : ctx.undefined);
   return (_a = preMarshal(target, handle)) != null ? _a : handle;
 }
-function marshalJSON(vm, target, preMarshal) {
+function marshalJSON(ctx, target, preMarshal) {
   var _a;
-  const raw = json(vm, target);
+  const raw = json(ctx, target);
   const handle = (_a = preMarshal(target, raw)) != null ? _a : raw;
   return handle;
 }
-function marshalPromise(vm, target, marshal2, preMarshal) {
+function marshalPromise(ctx, target, marshal2, preMarshal) {
   var _a;
   if (!(target instanceof Promise))
     return;
-  const promise = vm.newPromise();
+  const promise = ctx.newPromise();
   target.then((d) => promise.resolve(marshal2(d)), (d) => promise.reject(marshal2(d)));
   return (_a = preMarshal(target, promise)) != null ? _a : promise.handle;
 }
 function marshal(target, options) {
   var _a, _b, _c, _d;
-  const { vm, unmarshal: unmarshal2, isMarshalable, find, pre } = options;
+  const { ctx, unmarshal: unmarshal2, isMarshalable, find, pre } = options;
   {
-    const primitive = marshalPrimitive(vm, target);
+    const primitive = marshalPrimitive(ctx, target);
     if (primitive) {
       return primitive;
     }
@@ -449,17 +449,17 @@ function marshal(target, options) {
   }
   const marshalable = isMarshalable == null ? void 0 : isMarshalable(target);
   if (marshalable === false) {
-    return vm.undefined;
+    return ctx.undefined;
   }
   const pre2 = (target2, handle) => pre(target2, handle, marshalable);
   if (marshalable === "json") {
-    return marshalJSON(vm, target, pre2);
+    return marshalJSON(ctx, target, pre2);
   }
   const marshal2 = (t) => marshal(t, options);
-  return (_d = (_c = (_b = (_a = marshalSymbol(vm, target, pre2)) != null ? _a : marshalPromise(vm, target, marshal2, pre2)) != null ? _b : marshalFunction(vm, target, marshal2, unmarshal2, pre2, options.preApply)) != null ? _c : marshalObject(vm, target, marshal2, pre2)) != null ? _d : vm.undefined;
+  return (_d = (_c = (_b = (_a = marshalSymbol(ctx, target, pre2)) != null ? _a : marshalPromise(ctx, target, marshal2, pre2)) != null ? _b : marshalFunction(ctx, target, marshal2, unmarshal2, pre2, options.preApply)) != null ? _c : marshalObject(ctx, target, marshal2, pre2)) != null ? _d : ctx.undefined;
 }
-function unmarshalProperties(vm, handle, target, unmarshal2) {
-  vm.newFunction("", (key, value) => {
+function unmarshalProperties(ctx, handle, target, unmarshal2) {
+  ctx.newFunction("", (key, value) => {
     const [keyName] = unmarshal2(key);
     if (typeof keyName !== "string" && typeof keyName !== "number" && typeof keyName !== "symbol")
       return;
@@ -471,12 +471,12 @@ function unmarshalProperties(vm, handle, target, unmarshal2) {
       ["enumerable", false],
       ["writable", false]
     ].reduce((desc2, [key2, unmarshable]) => {
-      const h = vm.getProp(value, key2);
-      const ty = vm.typeof(h);
+      const h = ctx.getProp(value, key2);
+      const ty = ctx.typeof(h);
       if (ty === "undefined")
         return desc2;
       if (!unmarshable && ty === "boolean") {
-        desc2[key2] = vm.dump(vm.getProp(value, key2));
+        desc2[key2] = ctx.dump(ctx.getProp(value, key2));
         return desc2;
       }
       const [v, alreadyExists] = unmarshal2(h);
@@ -488,25 +488,25 @@ function unmarshalProperties(vm, handle, target, unmarshal2) {
     }, {});
     Object.defineProperty(target, keyName, desc);
   }).consume((fn2) => {
-    call(vm, `(o, 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]));
       }`, void 0, handle, fn2).dispose();
   });
 }
-function unmarshalFunction(vm, handle, marshal2, unmarshal2, preUnmarshal) {
+function unmarshalFunction(ctx, handle, marshal2, unmarshal2, preUnmarshal) {
   var _a;
-  if (vm.typeof(handle) !== "function")
+  if (ctx.typeof(handle) !== "function")
     return;
   const raw = function(...args) {
     return mayConsumeAll([marshal2(this), ...args.map((a) => marshal2(a))], (thisHandle, ...argHandles) => {
       if (new.target) {
-        const [instance] = unmarshal2(call(vm, `(Cls, ...args) => new Cls(...args)`, thisHandle, handle, ...argHandles));
+        const [instance] = unmarshal2(call(ctx, `(Cls, ...args) => new Cls(...args)`, thisHandle, handle, ...argHandles));
         Object.defineProperties(this, Object.getOwnPropertyDescriptors(instance));
         return this;
       }
-      const resultHandle = vm.unwrapResult(vm.callFunction(handle, thisHandle, ...argHandles));
+      const resultHandle = ctx.unwrapResult(ctx.callFunction(handle, thisHandle, ...argHandles));
       const [result, alreadyExists] = unmarshal2(resultHandle);
       if (alreadyExists)
         resultHandle.dispose();
@@ -514,20 +514,20 @@ function unmarshalFunction(vm, handle, marshal2, unmarshal2, preUnmarshal) {
     });
   };
   const func = (_a = preUnmarshal(raw, handle)) != null ? _a : raw;
-  unmarshalProperties(vm, handle, raw, unmarshal2);
+  unmarshalProperties(ctx, handle, raw, unmarshal2);
   return func;
 }
-function unmarshalObject(vm, handle, unmarshal2, preUnmarshal) {
+function unmarshalObject(ctx, handle, unmarshal2, preUnmarshal) {
   var _a;
-  if (vm.typeof(handle) !== "object" || vm.unwrapResult(vm.evalCode("o => o === null")).consume((n) => vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))))
+  if (ctx.typeof(handle) !== "object" || ctx.unwrapResult(ctx.evalCode("o => o === null")).consume((n) => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle)))))
     return;
-  const raw = call(vm, "Array.isArray", void 0, handle).consume((r) => vm.dump(r)) ? [] : {};
+  const raw = call(ctx, "Array.isArray", void 0, handle).consume((r) => ctx.dump(r)) ? [] : {};
   const obj = (_a = preUnmarshal(raw, handle)) != null ? _a : raw;
-  const prototype = call(vm, `o => {
+  const prototype = call(ctx, `o => {
       const p = Object.getPrototypeOf(o);
       return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
     }`, void 0, handle).consume((prototype2) => {
-    if (vm.typeof(prototype2) === "undefined")
+    if (ctx.typeof(prototype2) === "undefined")
       return;
     const [proto] = unmarshal2(prototype2);
     return proto;
@@ -535,49 +535,49 @@ function unmarshalObject(vm, handle, unmarshal2, preUnmarshal) {
   if (typeof prototype === "object") {
     Object.setPrototypeOf(obj, prototype);
   }
-  unmarshalProperties(vm, handle, raw, unmarshal2);
+  unmarshalProperties(ctx, handle, raw, unmarshal2);
   return obj;
 }
-function unmarshalPrimitive(vm, handle) {
-  const ty = vm.typeof(handle);
+function unmarshalPrimitive(ctx, handle) {
+  const ty = ctx.typeof(handle);
   if (ty === "undefined" || ty === "number" || ty === "string" || ty === "boolean") {
-    return [vm.dump(handle), true];
+    return [ctx.dump(handle), true];
   } else if (ty === "object") {
-    const isNull = vm.unwrapResult(vm.evalCode("a => a === null")).consume((n) => vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle))));
+    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];
     }
   }
   return [void 0, false];
 }
-function unmarshalPromise(vm, handle, marshal2, preUnmarshal) {
+function unmarshalPromise(ctx, handle, marshal2, preUnmarshal) {
   var _a;
-  if (!isPromiseHandle(handle))
+  if (!isPromiseHandle(ctx, handle))
     return;
   const deferred = newDeferred();
   const [resHandle, resShouldBeDisposed] = marshal2(deferred.resolve);
   const [rejHandle, rejShouldBeDisposed] = marshal2(deferred.reject);
-  call(vm, "(p, res, rej) => { p.then(res, rej); }", void 0, handle, resHandle, rejHandle);
+  call(ctx, "(p, res, rej) => { p.then(res, rej); }", void 0, handle, resHandle, rejHandle);
   if (resShouldBeDisposed)
     resHandle.dispose();
   if (rejShouldBeDisposed)
     rejHandle.dispose();
   return (_a = preUnmarshal(deferred.promise, handle)) != null ? _a : deferred.promise;
 }
-function isPromiseHandle(handle) {
+function isPromiseHandle(ctx, handle) {
   if (!handle.owner)
     return false;
-  return handle.owner.unwrapResult(handle.owner.evalCode("Promise")).consume((promise) => {
+  return ctx.unwrapResult(ctx.evalCode("Promise")).consume((promise) => {
     if (!handle.owner)
       return false;
-    return instanceOf(handle.owner, handle, promise);
+    return instanceOf(ctx, handle, promise);
   });
 }
-function unmarshalSymbol(vm, handle, preUnmarshal) {
+function unmarshalSymbol(ctx, handle, preUnmarshal) {
   var _a;
-  if (vm.typeof(handle) !== "symbol")
+  if (ctx.typeof(handle) !== "symbol")
     return;
-  const desc = vm.getString(vm.getProp(handle, "description"));
+  const desc = ctx.getString(ctx.getProp(handle, "description"));
   const sym = Symbol(desc);
   return (_a = preUnmarshal(sym, handle)) != null ? _a : sym;
 }
@@ -587,9 +587,9 @@ function unmarshal(handle, options) {
 }
 function unmarshalInner(handle, options) {
   var _a, _b, _c;
-  const { vm, marshal: marshal2, find, pre } = options;
+  const { ctx, marshal: marshal2, find, pre } = options;
   {
-    const [target, ok] = unmarshalPrimitive(vm, handle);
+    const [target, ok] = unmarshalPrimitive(ctx, handle);
     if (ok)
       return [target, false];
   }
@@ -600,11 +600,11 @@ function unmarshalInner(handle, options) {
     }
   }
   const unmarshal2 = (h) => unmarshalInner(h, options);
-  const result = (_c = (_b = (_a = unmarshalSymbol(vm, handle, pre)) != null ? _a : unmarshalPromise(vm, handle, marshal2, pre)) != null ? _b : unmarshalFunction(vm, handle, marshal2, unmarshal2, pre)) != null ? _c : unmarshalObject(vm, handle, unmarshal2, pre);
+  const result = (_c = (_b = (_a = unmarshalSymbol(ctx, handle, pre)) != null ? _a : unmarshalPromise(ctx, handle, marshal2, pre)) != null ? _b : unmarshalFunction(ctx, handle, marshal2, unmarshal2, pre)) != null ? _c : unmarshalObject(ctx, handle, unmarshal2, pre);
   return [result, false];
 }
-function wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, marshal2, syncMode) {
-  if (!isObject(target))
+function wrap(ctx, target, proxyKeySymbol, proxyKeySymbolHandle, marshal2, syncMode) {
+  if (!isObject(target) || target instanceof Promise)
     return void 0;
   if (isWrapped(target, proxyKeySymbol))
     return target;
@@ -616,14 +616,14 @@ function wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, marshal2, syncMo
       var _a;
       const v = unwrap(value, proxyKeySymbol);
       const sync = (_a = syncMode == null ? void 0 : syncMode(receiver)) != null ? _a : "host";
-      if (sync !== "vm" && !Reflect.set(obj, key, v, receiver) || sync === "host" || !vm.alive)
+      if (sync !== "vm" && !Reflect.set(obj, key, v, receiver) || sync === "host" || !ctx.alive)
         return true;
       mayConsumeAll([marshal2(receiver), marshal2(key), marshal2(v)], (receiverHandle, keyHandle, valueHandle) => {
-        const [handle2, unwrapped] = unwrapHandle(vm, receiverHandle, proxyKeySymbolHandle);
+        const [handle2, unwrapped] = unwrapHandle(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);
         }
       });
       return true;
@@ -632,14 +632,14 @@ function wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, marshal2, syncMo
       var _a;
       const sync = (_a = syncMode == null ? void 0 : syncMode(rec)) != null ? _a : "host";
       return mayConsumeAll([marshal2(rec), marshal2(key)], (recHandle, keyHandle) => {
-        const [handle2, unwrapped] = unwrapHandle(vm, recHandle, proxyKeySymbolHandle);
+        const [handle2, unwrapped] = unwrapHandle(ctx, recHandle, proxyKeySymbolHandle);
         if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
-          if (sync === "host" || !vm.alive)
+          if (sync === "host" || !ctx.alive)
             return true;
           if (unwrapped) {
-            handle2.consume((h) => call(vm, `(a, b) => delete a[b]`, void 0, h, keyHandle));
+            handle2.consume((h) => call(ctx, `(a, b) => delete a[b]`, void 0, h, keyHandle));
           } else {
-            call(vm, `(a, b) => delete a[b]`, void 0, handle2, keyHandle);
+            call(ctx, `(a, b) => delete a[b]`, void 0, handle2, keyHandle);
           }
         }
         return true;
@@ -648,19 +648,19 @@ function wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, marshal2, syncMo
   });
   return rec;
 }
-function wrapHandle(vm, handle, proxyKeySymbol, proxyKeySymbolHandle, unmarshal2, syncMode) {
-  if (!isHandleObject(vm, handle))
+function wrapHandle(ctx, handle, proxyKeySymbol, proxyKeySymbolHandle, unmarshal2, syncMode) {
+  if (!isHandleObject(ctx, handle))
     return [void 0, false];
-  if (isHandleWrapped(vm, handle, proxyKeySymbolHandle))
+  if (isHandleWrapped(ctx, handle, proxyKeySymbolHandle))
     return [handle, false];
   return consumeAll([
-    vm.newFunction("getSyncMode", (h) => {
+    ctx.newFunction("getSyncMode", (h) => {
       const res = syncMode == null ? void 0 : syncMode(unmarshal2(h));
       if (typeof res === "string")
-        return vm.newString(res);
-      return vm.undefined;
+        return ctx.newString(res);
+      return ctx.undefined;
     }),
-    vm.newFunction("setter", (h, keyHandle, valueHandle) => {
+    ctx.newFunction("setter", (h, keyHandle, valueHandle) => {
       const target = unmarshal2(h);
       if (!target)
         return;
@@ -670,7 +670,7 @@ function wrapHandle(vm, handle, proxyKeySymbol, proxyKeySymbolHandle, unmarshal2
       const value = unmarshal2(valueHandle);
       unwrap(target, proxyKeySymbol)[key] = value;
     }),
-    vm.newFunction("deleter", (h, keyHandle) => {
+    ctx.newFunction("deleter", (h, keyHandle) => {
       const target = unmarshal2(h);
       if (!target)
         return;
@@ -678,7 +678,7 @@ function wrapHandle(vm, handle, proxyKeySymbol, proxyKeySymbolHandle, unmarshal2
       delete unwrap(target, proxyKeySymbol)[key];
     })
   ], (args) => [
-    call(vm, `(target, sym, getSyncMode, setter, deleter) => {
+    call(ctx, `(target, sym, getSyncMode, setter, deleter) => {
           const rec =  new Proxy(target, {
             get(obj, key, receiver) {
               return key === sym ? obj : Reflect.get(obj, key, receiver)
@@ -714,16 +714,16 @@ function unwrap(obj, key) {
   var _a;
   return isObject(obj) ? (_a = obj[key]) != null ? _a : obj : obj;
 }
-function unwrapHandle(vm, handle, key) {
-  if (!isHandleWrapped(vm, handle, key))
+function unwrapHandle(ctx, handle, key) {
+  if (!isHandleWrapped(ctx, handle, key))
     return [handle, false];
-  return [vm.getProp(handle, key), true];
+  return [ctx.getProp(handle, key), true];
 }
 function isWrapped(obj, key) {
   return isObject(obj) && !!obj[key];
 }
-function isHandleWrapped(vm, handle, key) {
-  return !!vm.dump(call(vm, `(a, s) => (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`, void 0, handle, key));
+function isHandleWrapped(ctx, handle, key) {
+  return !!ctx.dump(call(ctx, `(a, s) => (a instanceof Promise) || (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`, void 0, handle, key));
 }
 const defaultRegisteredObjects = [
   [Symbol, "Symbol"],
@@ -753,7 +753,7 @@ const defaultRegisteredObjects = [
   ...Object.getOwnPropertyNames(Symbol).filter((k) => typeof Symbol[k] === "symbol").map((k) => [Symbol[k], `Symbol.${k}`])
 ];
 class Arena {
-  constructor(vm, options) {
+  constructor(ctx, options) {
     var _a;
     this._registeredMapDispose = /* @__PURE__ */ new Set();
     this._sync = /* @__PURE__ */ new Set();
@@ -794,7 +794,7 @@ class Arena {
         return [registered, false];
       }
       const handle = marshal((_a2 = this._wrap(target)) != null ? _a2 : target, {
-        vm: this.vm,
+        ctx: this.context,
         unmarshal: this._unmarshal,
         isMarshalable: this._isMarshalable,
         find: this._marshalFind,
@@ -818,7 +818,7 @@ class Arena {
       }
       const [wrappedHandle] = this._wrapHandle(handle);
       return unmarshal(wrappedHandle != null ? wrappedHandle : handle, {
-        vm: this.vm,
+        ctx: this.context,
         marshal: this._marshal,
         find: this._unmarshalFind,
         pre: this._preUnmarshal
@@ -830,13 +830,19 @@ class Arena {
     };
     this._unwrapIfNotSynced = (target) => {
       const unwrapped = this._unwrap(target);
-      return this._sync.has(unwrapped) ? target : unwrapped;
+      return unwrapped instanceof Promise || !this._sync.has(unwrapped) ? unwrapped : target;
     };
-    this.vm = vm;
+    if ((options == null ? void 0 : options.compat) && !("runtime" in ctx)) {
+      ctx.runtime = {
+        hasPendingJob: () => ctx.hasPendingJob(),
+        executePendingJobs: (maxJobsToExecute) => ctx.executePendingJobs(maxJobsToExecute)
+      };
+    }
+    this.context = ctx;
     this._options = options;
-    this._symbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-    this._map = new VMMap(vm);
-    this._registeredMap = new VMMap(vm);
+    this._symbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+    this._map = new VMMap(ctx);
+    this._registeredMap = new VMMap(ctx);
     this.registerAll((_a = options == null ? void 0 : options.registeredObjects) != null ? _a : defaultRegisteredObjects);
   }
   dispose() {
@@ -845,11 +851,11 @@ class Arena {
     this._symbolHandle.dispose();
   }
   evalCode(code) {
-    const handle = this.vm.evalCode(code);
+    const handle = this.context.evalCode(code);
     return this._unwrapResultAndUnmarshal(handle);
   }
   executePendingJobs(maxJobsToExecute) {
-    const result = this.vm.executePendingJobs(maxJobsToExecute);
+    const result = this.context.runtime.executePendingJobs(maxJobsToExecute);
     if ("value" in result) {
       return result.value;
     }
@@ -858,7 +864,7 @@ class Arena {
   expose(obj) {
     for (const [key, value] of Object.entries(obj)) {
       mayConsume(this._marshal(value), (handle) => {
-        this.vm.setProp(this.vm.global, key, handle);
+        this.context.setProp(this.context.global, key, handle);
       });
     }
   }
@@ -867,15 +873,16 @@ class Arena {
     if (typeof wrapped === "undefined")
       return target;
     walkObject(wrapped, (v) => {
-      this._sync.add(this._unwrap(v));
+      const u = this._unwrap(v);
+      this._sync.add(u);
     });
     return wrapped;
   }
   register(target, handleOrCode) {
     if (this._registeredMap.has(target))
       return;
-    const handle = typeof handleOrCode === "string" ? this._unwrapResult(this.vm.evalCode(handleOrCode)) : handleOrCode;
-    if (eq(this.vm, handle, this.vm.undefined))
+    const handle = typeof handleOrCode === "string" ? this._unwrapResult(this.context.evalCode(handleOrCode)) : handleOrCode;
+    if (eq(this.context, handle, this.context.undefined))
       return;
     if (typeof handleOrCode === "string") {
       this._registeredMapDispose.add(target);
@@ -899,7 +906,8 @@ class Arena {
   startSync(target) {
     if (!isObject(target))
       return;
-    this._sync.add(this._unwrap(target));
+    const u = this._unwrap(target);
+    this._sync.add(u);
   }
   endSync(target) {
     this._sync.delete(this._unwrap(target));
@@ -919,10 +927,13 @@ class Arena {
     if (this._registeredMap.has(t) || this._registeredMap.hasHandle(h)) {
       return;
     }
-    const wrappedT = this._wrap(t);
+    let wrappedT = this._wrap(t);
     const [wrappedH] = this._wrapHandle(h);
-    if (!wrappedT || !wrappedH)
+    const isPromise = t instanceof Promise;
+    if (!wrappedH || !wrappedT && !isPromise)
       return;
+    if (isPromise)
+      wrappedT = t;
     const unwrappedT = this._unwrap(t);
     const [unwrappedH, unwrapped] = this._unwrapHandle(h);
     const res = map.set(wrappedT, wrappedH, unwrappedT, unwrappedH);
@@ -936,16 +947,16 @@ class Arena {
     return [wrappedT, wrappedH];
   }
   _wrap(target) {
-    return wrap(this.vm, target, this._symbol, this._symbolHandle, this._marshal, this._syncMode);
+    return wrap(this.context, target, this._symbol, this._symbolHandle, this._marshal, this._syncMode);
   }
   _unwrap(target) {
     return unwrap(target, this._symbol);
   }
   _wrapHandle(handle) {
-    return wrapHandle(this.vm, handle, this._symbol, this._symbolHandle, this._unmarshal, this._syncMode);
+    return wrapHandle(this.context, handle, this._symbol, this._symbolHandle, this._unmarshal, this._syncMode);
   }
   _unwrapHandle(target) {
-    return unwrapHandle(this.vm, target, this._symbolHandle);
+    return unwrapHandle(this.context, target, this._symbolHandle);
   }
 }
 export { Arena, VMMap, call, complexity, consumeAll, defaultRegisteredObjects, eq, isES2015Class, isHandleObject, isObject, json, marshal, unmarshal, walkObject };