@jsii/kernel 1.60.1 → 1.63.0

package/jest.config.mjs

@@ -0,0 +1,3 @@
+import config from '../../../jest.config.mjs';
+
+export default config;

package/lib/kernel.d.ts

@@ -5,15 +5,16 @@ export declare class Kernel {
      * Set to true for verbose debugging.
      */
     traceEnabled: boolean;
-    private assemblies;
+    private readonly assemblies;
     private readonly objects;
-    private cbs;
-    private waiting;
-    private promises;
+    private readonly cbs;
+    private readonly waiting;
+    private readonly promises;
     private nextid;
     private syncInProgress?;
     private installDir?;
-    private readonly sandbox;
+    /** The internal require function, used instead of the global "require" so that webpack does not transform it... */
+    private require?;
     /**
      * Creates a jsii kernel object.
      *
@@ -74,17 +75,5 @@ export declare class Kernel {
     private _findPropertyTarget;
     private _makecbid;
     private _makeprid;
-    private _wrapSandboxCode;
-    /**
-     * Executes arbitrary code in a VM sandbox.
-     *
-     * @param code       JavaScript code to be executed in the VM
-     * @param sandbox    a VM context to use for running the code
-     * @param sourceMaps source maps to be used in case an exception is thrown
-     * @param filename   the file name to use for the executed code
-     *
-     * @returns the result of evaluating the code
-     */
-    private _execute;
 }
 //# sourceMappingURL=kernel.d.ts.map

package/lib/kernel.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Kernel = void 0;
 const spec = require("@jsii/spec");
+const spec_1 = require("@jsii/spec");
 const cp = require("child_process");
 const fs = require("fs-extra");
+const module_1 = require("module");
 const os = require("os");
 const path = require("path");
 const tar = require("tar");
-const vm = require("vm");
 const api = require("./api");
 const api_1 = require("./api");
 const objects_1 = require("./objects");
@@ -22,35 +23,20 @@ class Kernel {
      *                        result (or throw an error).
      */
     constructor(callbackHandler) {
-        // `setImmediate` is required for tests to pass (it is otherwise
-        // impossible to wait for in-VM promises to complete)
         this.callbackHandler = callbackHandler;
         /**
          * Set to true for verbose debugging.
          */
         this.traceEnabled = false;
-        this.assemblies = {};
+        this.assemblies = new Map();
         this.objects = new objects_1.ObjectTable(this._typeInfoForFqn.bind(this));
-        this.cbs = {};
-        this.waiting = {};
-        this.promises = {};
+        this.cbs = new Map();
+        this.waiting = new Map();
+        this.promises = new Map();
         this.nextid = 20000; // incrementing counter for objid, cbid, promiseid
-        // `Buffer` is required when using simple-resource-bundler.
-        // HACK: when we webpack @jsii/runtime, all "require" statements get transpiled,
-        // so modules can be resolved within the pack. However, here we actually want to
-        // let loaded modules to use the native node "require" method.
-        // I wonder if webpack has some pragma that allows opting-out at certain points
-        // in the code.
-        // eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/no-var-requires
-        const moduleLoad = require('module').Module._load;
-        const nodeRequire = (p) => moduleLoad(p, module, false);
-        this.sandbox = vm.createContext({
-            Buffer,
-            setImmediate,
-            require: nodeRequire, // modules need to "require"
-        });
     }
     load(req) {
+        var _a, _b;
         this._debug('load', req);
         if ('assembly' in req) {
             throw new Error('`assembly` field is deprecated for "load", use `name`, `version` and `tarball` instead');
@@ -69,10 +55,10 @@ class Kernel {
             }
             // same version, no-op
             this._debug('look up already-loaded assembly', pkgname);
-            const assm = this.assemblies[pkgname];
+            const assm = this.assemblies.get(pkgname);
             return {
                 assembly: assm.metadata.name,
-                types: Object.keys(assm.metadata.types ?? {}).length,
+                types: Object.keys((_a = assm.metadata.types) !== null && _a !== void 0 ? _a : {}).length,
             };
         }
         // Create the install directory (there may be several path components for @scoped/packages)
@@ -95,21 +81,24 @@ class Kernel {
             process.umask(originalUmask);
         }
         // read .jsii metadata from the root of the package
-        const jsiiMetadataFile = path.join(packageDir, spec.SPEC_FILE_NAME);
-        if (!fs.pathExistsSync(jsiiMetadataFile)) {
-            throw new Error(`Package tarball ${req.tarball} must have a file named ${spec.SPEC_FILE_NAME} at the root`);
+        let assmSpec;
+        try {
+            assmSpec = (0, spec_1.loadAssemblyFromPath)(packageDir);
+        }
+        catch (e) {
+            throw new Error(`Error for package tarball ${req.tarball}: ${e.message}`);
         }
-        const assmSpec = fs.readJsonSync(jsiiMetadataFile);
-        // load the module and capture it's closure
-        const closure = this._execute(`require(String.raw\`${packageDir}\`)`, packageDir);
+        // load the module and capture its closure
+        const closure = this.require(packageDir);
         const assm = new Assembly(assmSpec, closure);
         this._addAssembly(assm);
         return {
             assembly: assmSpec.name,
-            types: Object.keys(assmSpec.types ?? {}).length,
+            types: Object.keys((_b = assmSpec.types) !== null && _b !== void 0 ? _b : {}).length,
         };
     }
     invokeBinScript(req) {
+        var _a;
         const packageDir = this._getPackageDir(req.assembly);
         if (fs.pathExistsSync(packageDir)) {
             // module exists, verify version
@@ -121,7 +110,7 @@ class Kernel {
             if (!epkg.bin) {
                 throw new Error(`Script with name ${req.script} was not defined.`);
             }
-            const result = cp.spawnSync(path.join(packageDir, scriptPath), req.args ?? [], {
+            const result = cp.spawnSync(path.join(packageDir, scriptPath), (_a = req.args) !== null && _a !== void 0 ? _a : [], {
                 encoding: 'utf-8',
                 env: {
                     ...process.env,
@@ -159,9 +148,9 @@ class Kernel {
             throw new Error(`property ${symbol} is not static`);
         }
         const prototype = this._findSymbol(fqn);
-        const value = this._ensureSync(`property ${property}`, () => this._wrapSandboxCode(() => prototype[property]));
+        const value = this._ensureSync(`property ${property}`, () => prototype[property]);
         this._debug('value:', value);
-        const ret = this._fromSandbox(value, ti);
+        const ret = this._fromSandbox(value, ti, `of static property ${symbol}`);
         this._debug('ret', ret);
         return { value: ret };
     }
@@ -177,7 +166,7 @@ class Kernel {
             throw new Error(`static property ${symbol} is readonly`);
         }
         const prototype = this._findSymbol(fqn);
-        this._ensureSync(`property ${property}`, () => this._wrapSandboxCode(() => (prototype[property] = this._toSandbox(value, ti))));
+        this._ensureSync(`property ${property}`, () => (prototype[property] = this._toSandbox(value, ti, `assigned to static property ${symbol}`)));
         return {};
     }
     get(req) {
@@ -193,9 +182,9 @@ class Kernel {
         const propertyToGet = this._findPropertyTarget(instance, property);
         // make the actual "get", and block any async calls that might be performed
         // by jsii overrides.
-        const value = this._ensureSync(`property '${objref[api_1.TOKEN_REF]}.${propertyToGet}'`, () => this._wrapSandboxCode(() => instance[propertyToGet]));
+        const value = this._ensureSync(`property '${objref[api_1.TOKEN_REF]}.${propertyToGet}'`, () => instance[propertyToGet]);
         this._debug('value:', value);
-        const ret = this._fromSandbox(value, ti);
+        const ret = this._fromSandbox(value, ti, `of property ${fqn}.${property}`);
         this._debug('ret:', ret);
         return { value: ret };
     }
@@ -208,28 +197,31 @@ class Kernel {
             throw new Error(`Cannot set value of immutable property ${req.property} to ${req.value}`);
         }
         const propertyToSet = this._findPropertyTarget(instance, property);
-        this._ensureSync(`property '${objref[api_1.TOKEN_REF]}.${propertyToSet}'`, () => this._wrapSandboxCode(() => (instance[propertyToSet] = this._toSandbox(value, propInfo))));
+        this._ensureSync(`property '${objref[api_1.TOKEN_REF]}.${propertyToSet}'`, () => (instance[propertyToSet] = this._toSandbox(value, propInfo, `assigned to property ${fqn}.${property}`)));
         return {};
     }
     invoke(req) {
+        var _a, _b;
         const { objref, method } = req;
-        const args = req.args ?? [];
+        const args = (_a = req.args) !== null && _a !== void 0 ? _a : [];
         this._debug('invoke', objref, method, args);
         const { ti, obj, fn } = this._findInvokeTarget(objref, method, args);
         // verify this is not an async method
         if (ti.async) {
             throw new Error(`${method} is an async method, use "begin" instead`);
         }
+        const fqn = (0, objects_1.jsiiTypeFqn)(obj);
         const ret = this._ensureSync(`method '${objref[api_1.TOKEN_REF]}.${method}'`, () => {
-            return this._wrapSandboxCode(() => fn.apply(obj, this._toSandboxValues(args, ti.parameters)));
+            return fn.apply(obj, this._toSandboxValues(args, `method ${fqn ? `${fqn}#` : ''}${method}`, ti.parameters));
         });
-        const result = this._fromSandbox(ret, ti.returns ?? 'void');
+        const result = this._fromSandbox(ret, (_b = ti.returns) !== null && _b !== void 0 ? _b : 'void', `returned by method ${fqn ? `${fqn}#` : ''}${method}`);
         this._debug('invoke result', result);
         return { result };
     }
     sinvoke(req) {
+        var _a, _b;
         const { fqn, method } = req;
-        const args = req.args ?? [];
+        const args = (_a = req.args) !== null && _a !== void 0 ? _a : [];
         this._debug('sinvoke', fqn, method, args);
         const ti = this._typeInfoForMethod(method, fqn);
         if (!ti.static) {
@@ -242,14 +234,17 @@ class Kernel {
         const prototype = this._findSymbol(fqn);
         const fn = prototype[method];
         const ret = this._ensureSync(`method '${fqn}.${method}'`, () => {
-            return this._wrapSandboxCode(() => fn.apply(prototype, this._toSandboxValues(args, ti.parameters)));
+            return fn.apply(prototype, this._toSandboxValues(args, `static method ${fqn}.${method}`, ti.parameters));
         });
         this._debug('method returned:', ret);
-        return { result: this._fromSandbox(ret, ti.returns ?? 'void') };
+        return {
+            result: this._fromSandbox(ret, (_b = ti.returns) !== null && _b !== void 0 ? _b : 'void', `returned by static method ${fqn}.${method}`),
+        };
     }
     begin(req) {
+        var _a;
         const { objref, method } = req;
-        const args = req.args ?? [];
+        const args = (_a = req.args) !== null && _a !== void 0 ? _a : [];
         this._debug('begin', objref, method, args);
         if (this.syncInProgress) {
             throw new Error(`Cannot invoke async method '${req.objref[api_1.TOKEN_REF]}.${req.method}' while sync ${this.syncInProgress} is being processed`);
@@ -259,25 +254,28 @@ class Kernel {
         if (!ti.async) {
             throw new Error(`Method ${method} is expected to be an async method`);
         }
-        const promise = this._wrapSandboxCode(() => fn.apply(obj, this._toSandboxValues(args, ti.parameters)));
+        const fqn = (0, objects_1.jsiiTypeFqn)(obj);
+        const promise = fn.apply(obj, this._toSandboxValues(args, `async method ${fqn ? `${fqn}#` : ''}${method}`, ti.parameters));
         // since we are planning to resolve this promise in a different scope
         // we need to handle rejections here [1]
         // [1]: https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously/40921505
         promise.catch((_) => undefined);
         const prid = this._makeprid();
-        this.promises[prid] = {
+        this.promises.set(prid, {
             promise,
             method: ti,
-        };
+        });
         return { promiseid: prid };
     }
     async end(req) {
+        var _a;
         const { promiseid } = req;
         this._debug('end', promiseid);
-        const { promise, method } = this.promises[promiseid];
-        if (promise == null) {
+        const storedPromise = this.promises.get(promiseid);
+        if (storedPromise == null) {
             throw new Error(`Cannot find promise with ID: ${promiseid}`);
         }
+        const { promise, method } = storedPromise;
         let result;
         try {
             result = await promise;
@@ -287,13 +285,15 @@ class Kernel {
             this._debug('promise error:', e);
             throw e;
         }
-        return { result: this._fromSandbox(result, method.returns ?? 'void') };
+        return {
+            result: this._fromSandbox(result, (_a = method.returns) !== null && _a !== void 0 ? _a : 'void', `returned by async method ${method.name}`),
+        };
     }
     callbacks(_req) {
         this._debug('callbacks');
-        const ret = Object.keys(this.cbs).map((cbid) => {
-            const cb = this.cbs[cbid];
-            this.waiting[cbid] = cb; // move to waiting
+        const ret = Array.from(this.cbs.entries()).map(([cbid, cb]) => {
+            this.waiting.set(cbid, cb); // move to waiting
+            this.cbs.delete(cbid); // remove from created
             const callback = {
                 cbid,
                 cookie: cb.override.cookie,
@@ -305,27 +305,26 @@ class Kernel {
             };
             return callback;
         });
-        // move all callbacks to the wait queue and clean the callback queue.
-        this.cbs = {};
         return { callbacks: ret };
     }
     complete(req) {
+        var _a;
         const { cbid, err, result } = req;
         this._debug('complete', cbid, err, result);
-        if (!(cbid in this.waiting)) {
+        const cb = this.waiting.get(cbid);
+        if (!cb) {
             throw new Error(`Callback ${cbid} not found`);
         }
-        const cb = this.waiting[cbid];
         if (err) {
             this._debug('completed with error:', err);
             cb.fail(new Error(err));
         }
         else {
-            const sandoxResult = this._toSandbox(result, cb.expectedReturnType ?? 'void');
+            const sandoxResult = this._toSandbox(result, (_a = cb.expectedReturnType) !== null && _a !== void 0 ? _a : 'void', `returned by callback ${cb.toString()}`);
             this._debug('completed with result:', sandoxResult);
             cb.succeed(sandoxResult);
         }
-        delete this.waiting[cbid];
+        this.waiting.delete(cbid);
         return { cbid };
     }
     /**
@@ -348,10 +347,11 @@ class Kernel {
         };
     }
     _addAssembly(assm) {
-        this.assemblies[assm.metadata.name] = assm;
+        var _a;
+        this.assemblies.set(assm.metadata.name, assm);
         // add the __jsii__.fqn property on every constructor. this allows
         // traversing between the javascript and jsii worlds given any object.
-        for (const fqn of Object.keys(assm.metadata.types ?? {})) {
+        for (const fqn of Object.keys((_a = assm.metadata.types) !== null && _a !== void 0 ? _a : {})) {
             const typedef = assm.metadata.types[fqn];
             switch (typedef.kind) {
                 case spec.TypeKind.Interface:
@@ -386,6 +386,7 @@ class Kernel {
     _getPackageDir(pkgname) {
         if (!this.installDir) {
             this.installDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsii-kernel-'));
+            this.require = (0, module_1.createRequire)(this.installDir);
             fs.mkdirpSync(path.join(this.installDir, 'node_modules'));
             this._debug('creating jsii-kernel modules workdir:', this.installDir);
             onExit.removeSync(this.installDir);
@@ -395,13 +396,14 @@ class Kernel {
     // prefixed with _ to allow calling this method internally without
     // getting it recorded for testing.
     _create(req) {
+        var _a, _b;
         this._debug('create', req);
         const { fqn, interfaces, overrides } = req;
-        const requestArgs = req.args ?? [];
+        const requestArgs = (_a = req.args) !== null && _a !== void 0 ? _a : [];
         const ctorResult = this._findCtor(fqn, requestArgs);
         const ctor = ctorResult.ctor;
-        const obj = this._wrapSandboxCode(() => new ctor(...this._toSandboxValues(requestArgs, ctorResult.parameters)));
-        const objref = this.objects.registerObject(obj, fqn, req.interfaces ?? []);
+        const obj = new ctor(...this._toSandboxValues(requestArgs, `new ${fqn}`, ctorResult.parameters));
+        const objref = this.objects.registerObject(obj, fqn, (_b = req.interfaces) !== null && _b !== void 0 ? _b : []);
         // overrides: for each one of the override method names, installs a
         // method on the newly created object which represents the remote "reverse proxy".
         if (overrides) {
@@ -466,11 +468,12 @@ class Kernel {
         this._defineOverridenProperty(obj, objref, override, propInfo);
     }
     _defineOverridenProperty(obj, objref, override, propInfo) {
+        var _a;
         const propertyName = override.property;
         this._debug('apply override', propertyName);
         // save the old property under $jsii$super$<prop>$ so that property overrides
         // can still access it via `super.<prop>`.
-        const prev = getPropertyDescriptor(obj, propertyName) ?? {
+        const prev = (_a = getPropertyDescriptor(obj, propertyName)) !== null && _a !== void 0 ? _a : {
             value: obj[propertyName],
             writable: true,
             enumerable: true,
@@ -495,7 +498,7 @@ class Kernel {
                     get: { objref, property: propertyName },
                 });
                 this._debug('callback returned', result);
-                return this._toSandbox(result, propInfo);
+                return this._toSandbox(result, propInfo, `returned by callback property ${propertyName}`);
             },
             set: (value) => {
                 this._debug('virtual set', objref, propertyName, {
@@ -507,7 +510,7 @@ class Kernel {
                     set: {
                         objref,
                         property: propertyName,
-                        value: this._fromSandbox(value, propInfo),
+                        value: this._fromSandbox(value, propInfo, `assigned to callback property ${propertyName}`),
                     },
                 });
             },
@@ -558,6 +561,8 @@ class Kernel {
     }
     _defineOverridenMethod(obj, objref, override, methodInfo) {
         const methodName = override.method;
+        const fqn = (0, objects_1.jsiiTypeFqn)(obj);
+        const methodContext = `${methodInfo.async ? 'async ' : ''}method${fqn ? `${fqn}#` : methodName}`;
         if (methodInfo.async) {
             // async method override
             Object.defineProperty(obj, methodName, {
@@ -566,18 +571,19 @@ class Kernel {
                 writable: false,
                 value: (...methodArgs) => {
                     this._debug('invoke async method override', override);
-                    const args = this._toSandboxValues(methodArgs, methodInfo.parameters);
+                    const args = this._toSandboxValues(methodArgs, methodContext, methodInfo.parameters);
                     return new Promise((succeed, fail) => {
+                        var _a;
                         const cbid = this._makecbid();
                         this._debug('adding callback to queue', cbid);
-                        this.cbs[cbid] = {
+                        this.cbs.set(cbid, {
                             objref,
                             override,
                             args,
-                            expectedReturnType: methodInfo.returns ?? 'void',
+                            expectedReturnType: (_a = methodInfo.returns) !== null && _a !== void 0 ? _a : 'void',
                             succeed,
                             fail,
-                        };
+                        });
                     });
                 },
             });
@@ -589,6 +595,7 @@ class Kernel {
                 configurable: false,
                 writable: false,
                 value: (...methodArgs) => {
+                    var _a;
                     this._debug('invoke sync method override', override, 'args', methodArgs);
                     // We should be validating the actual arguments according to the
                     // declared parameters here, but let's just assume the JSII runtime on the
@@ -599,11 +606,11 @@ class Kernel {
                         invoke: {
                             objref,
                             method: methodName,
-                            args: this._fromSandboxValues(methodArgs, methodInfo.parameters),
+                            args: this._fromSandboxValues(methodArgs, methodContext, methodInfo.parameters),
                         },
                     });
                     this._debug('Result', result);
-                    return this._toSandbox(result, methodInfo.returns ?? 'void');
+                    return this._toSandbox(result, (_a = methodInfo.returns) !== null && _a !== void 0 ? _a : 'void', `returned by callback method ${methodName}`);
                 },
             });
         }
@@ -629,7 +636,8 @@ class Kernel {
         return { ti, obj: instance, fn };
     }
     _validateMethodArguments(method, args) {
-        const params = method?.parameters ?? [];
+        var _a;
+        const params = (_a = method === null || method === void 0 ? void 0 : method.parameters) !== null && _a !== void 0 ? _a : [];
         // error if args > params
         if (args.length > params.length && !(method && method.variadic)) {
             throw new Error(`Too many arguments (method accepts ${params.length} parameters, got ${args.length} arguments)`);
@@ -653,7 +661,7 @@ class Kernel {
         }
     }
     _assemblyFor(assemblyName) {
-        const assembly = this.assemblies[assemblyName];
+        const assembly = this.assemblies.get(assemblyName);
         if (!assembly) {
             throw new Error(`Could not find assembly: ${assemblyName}`);
         }
@@ -676,13 +684,14 @@ class Kernel {
         return curr;
     }
     _typeInfoForFqn(fqn) {
+        var _a;
         const components = fqn.split('.');
         const moduleName = components[0];
-        const assembly = this.assemblies[moduleName];
+        const assembly = this.assemblies.get(moduleName);
         if (!assembly) {
             throw new Error(`Module '${moduleName}' not found`);
         }
-        const types = assembly.metadata.types ?? {};
+        const types = (_a = assembly.metadata.types) !== null && _a !== void 0 ? _a : {};
         const fqnInfo = types[fqn];
         if (!fqnInfo) {
             throw new Error(`Type '${fqn}' not found`);
@@ -700,12 +709,13 @@ class Kernel {
         return ti;
     }
     _tryTypeInfoForMethod(methodName, classFqn, interfaces = []) {
+        var _a, _b;
         for (const fqn of [classFqn, ...interfaces]) {
             if (fqn === wire.EMPTY_OBJECT_FQN) {
                 continue;
             }
             const typeinfo = this._typeInfoForFqn(fqn);
-            const methods = typeinfo.methods ?? [];
+            const methods = (_a = typeinfo.methods) !== null && _a !== void 0 ? _a : [];
             for (const m of methods) {
                 if (m.name === methodName) {
                     return m;
@@ -714,7 +724,7 @@ class Kernel {
             // recursion to parent type (if exists)
             const bases = [
                 typeinfo.base,
-                ...(typeinfo.interfaces ?? []),
+                ...((_b = typeinfo.interfaces) !== null && _b !== void 0 ? _b : []),
             ];
             for (const base of bases) {
                 if (!base) {
@@ -729,6 +739,7 @@ class Kernel {
         return undefined;
     }
     _tryTypeInfoForProperty(property, classFqn, interfaces = []) {
+        var _a;
         for (const fqn of [classFqn, ...interfaces]) {
             if (fqn === wire.EMPTY_OBJECT_FQN) {
                 continue;
@@ -744,12 +755,12 @@ class Kernel {
             else if (spec.isInterfaceType(typeInfo)) {
                 const interfaceTypeInfo = typeInfo;
                 properties = interfaceTypeInfo.properties;
-                bases = interfaceTypeInfo.interfaces ?? [];
+                bases = (_a = interfaceTypeInfo.interfaces) !== null && _a !== void 0 ? _a : [];
             }
             else {
                 throw new Error(`Type of kind ${typeInfo.kind} does not have properties`);
             }
-            for (const p of properties ?? []) {
+            for (const p of properties !== null && properties !== void 0 ? properties : []) {
                 if (p.name === property) {
                     return p;
                 }
@@ -774,73 +785,40 @@ class Kernel {
         }
         return typeInfo;
     }
-    _toSandbox(v, expectedType) {
-        const serTypes = wire.serializationType(expectedType, this._typeInfoForFqn.bind(this));
-        this._debug('toSandbox', v, JSON.stringify(serTypes));
-        const host = {
+    _toSandbox(v, expectedType, context) {
+        return wire.process({
             objects: this.objects,
             debug: this._debug.bind(this),
             findSymbol: this._findSymbol.bind(this),
             lookupType: this._typeInfoForFqn.bind(this),
-            recurse: this._toSandbox.bind(this),
-        };
-        const errors = new Array();
-        for (const { serializationClass, typeRef } of serTypes) {
-            try {
-                return wire.SERIALIZERS[serializationClass].deserialize(v, typeRef, host);
-            }
-            catch (e) {
-                // If no union (99% case), rethrow immediately to preserve stack trace
-                if (serTypes.length === 1) {
-                    throw e;
-                }
-                errors.push(e.message);
-            }
-        }
-        throw new Error(`Value did not match any type in union: ${errors.join(', ')}`);
+        }, 'deserialize', v, expectedType, context);
     }
-    _fromSandbox(v, targetType) {
-        const serTypes = wire.serializationType(targetType, this._typeInfoForFqn.bind(this));
-        this._debug('fromSandbox', v, JSON.stringify(serTypes));
-        const host = {
+    _fromSandbox(v, targetType, context) {
+        return wire.process({
             objects: this.objects,
             debug: this._debug.bind(this),
             findSymbol: this._findSymbol.bind(this),
             lookupType: this._typeInfoForFqn.bind(this),
-            recurse: this._fromSandbox.bind(this),
-        };
-        const errors = new Array();
-        for (const { serializationClass, typeRef } of serTypes) {
-            try {
-                return wire.SERIALIZERS[serializationClass].serialize(v, typeRef, host);
-            }
-            catch (e) {
-                // If no union (99% case), rethrow immediately to preserve stack trace
-                if (serTypes.length === 1) {
-                    throw e;
-                }
-                errors.push(e.message);
-            }
-        }
-        throw new Error(`Value did not match any type in union: ${errors.join(', ')}`);
+        }, 'serialize', v, targetType, context);
     }
-    _toSandboxValues(xs, parameters) {
-        return this._boxUnboxParameters(xs, parameters, this._toSandbox.bind(this));
+    _toSandboxValues(xs, methodContext, parameters) {
+        return this._boxUnboxParameters(xs, methodContext, parameters, this._toSandbox.bind(this));
     }
-    _fromSandboxValues(xs, parameters) {
-        return this._boxUnboxParameters(xs, parameters, this._fromSandbox.bind(this));
+    _fromSandboxValues(xs, methodContext, parameters) {
+        return this._boxUnboxParameters(xs, methodContext, parameters, this._fromSandbox.bind(this));
     }
-    _boxUnboxParameters(xs, parameters, boxUnbox) {
-        parameters = [...(parameters ?? [])];
-        const variadic = parameters.length > 0 && !!parameters[parameters.length - 1].variadic;
+    _boxUnboxParameters(xs, methodContext, parameters = [], boxUnbox) {
+        const parametersCopy = [...parameters];
+        const variadic = parametersCopy.length > 0 &&
+            !!parametersCopy[parametersCopy.length - 1].variadic;
         // Repeat the last (variadic) type to match the number of actual arguments
-        while (variadic && parameters.length < xs.length) {
-            parameters.push(parameters[parameters.length - 1]);
+        while (variadic && parametersCopy.length < xs.length) {
+            parametersCopy.push(parametersCopy[parametersCopy.length - 1]);
         }
-        if (xs.length > parameters.length) {
-            throw new Error(`Argument list (${JSON.stringify(xs)}) not same size as expected argument list (length ${parameters.length})`);
+        if (xs.length > parametersCopy.length) {
+            throw new Error(`Argument list (${JSON.stringify(xs)}) not same size as expected argument list (length ${parametersCopy.length})`);
         }
-        return xs.map((x, i) => boxUnbox(x, parameters[i]));
+        return xs.map((x, i) => boxUnbox(x, parametersCopy[i], `passed to parameter ${parametersCopy[i].name} of ${methodContext}`));
     }
     _debug(...args) {
         if (this.traceEnabled) {
@@ -876,23 +854,6 @@ class Kernel {
     _makeprid() {
         return `jsii::promise::${this.nextid++}`;
     }
-    _wrapSandboxCode(fn) {
-        return fn();
-    }
-    /**
-     * Executes arbitrary code in a VM sandbox.
-     *
-     * @param code       JavaScript code to be executed in the VM
-     * @param sandbox    a VM context to use for running the code
-     * @param sourceMaps source maps to be used in case an exception is thrown
-     * @param filename   the file name to use for the executed code
-     *
-     * @returns the result of evaluating the code
-     */
-    _execute(code, filename) {
-        const script = new vm.Script(code, { filename });
-        return script.runInContext(this.sandbox, { displayErrors: true });
-    }
 }
 exports.Kernel = Kernel;
 class Assembly {

package/lib/objects.d.ts

@@ -26,7 +26,7 @@ export declare function tagJsiiConstructor(constructor: any, fqn: string): void;
  */
 export declare class ObjectTable {
     private readonly resolveType;
-    private objects;
+    private readonly objects;
     private nextid;
     constructor(resolveType: (fqn: string) => spec.Type);
     /**
@@ -42,7 +42,7 @@ export declare class ObjectTable {
     /**
      * Delete the registration with the given objref
      */
-    deleteObject(objref: api.ObjRef): void;
+    deleteObject({ [api.TOKEN_REF]: objid }: api.ObjRef): void;
     get count(): number;
     private makeId;
     private removeRedundant;