@jsii/kernel 1.66.0 → 1.68.0

package/lib/disk-cache/digest-file.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function digestFile(path: string, ...comments: readonly string[]): Buffer;
+//# sourceMappingURL=digest-file.d.ts.map

package/lib/disk-cache/digest-file.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestFile = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const ALGORITHM = 'sha256';
+function digestFile(path, ...comments) {
+    const hash = (0, crypto_1.createHash)(ALGORITHM);
+    const buffer = Buffer.alloc(16384);
+    const fd = (0, fs_1.openSync)(path, 'r');
+    try {
+        let bytesRead = 0;
+        while ((bytesRead = (0, fs_1.readSync)(fd, buffer)) > 0) {
+            hash.update(buffer.slice(0, bytesRead));
+        }
+        for (const comment of comments) {
+            hash.update('\0');
+            hash.update(comment);
+        }
+        return hash.digest();
+    }
+    finally {
+        (0, fs_1.closeSync)(fd);
+    }
+}
+exports.digestFile = digestFile;
+//# sourceMappingURL=digest-file.js.map

package/lib/disk-cache/disk-cache.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+export declare class DiskCache {
+    #private;
+    private static readonly CACHE;
+    static inDirectory(path: string): DiskCache;
+    private constructor();
+    entry(...key: readonly string[]): Entry;
+    entryFor(path: string, ...comments: readonly string[]): Entry;
+    pruneExpiredEntries(): void;
+    private entries;
+}
+export declare class Entry {
+    readonly path: string;
+    constructor(path: string);
+    get atime(): Date;
+    get pathExists(): boolean;
+    private get lockFile();
+    private get markerFile();
+    lock<T>(cb: (entry: LockedEntry) => T): T;
+    read(file: string): Buffer | undefined;
+}
+export interface LockedEntry {
+    delete(): void;
+    write(name: string, data: Buffer): void;
+    touch(): void;
+}
+//# sourceMappingURL=disk-cache.d.ts.map

package/lib/disk-cache/disk-cache.js

@@ -0,0 +1,208 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DiskCache_root;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entry = exports.DiskCache = void 0;
+const fs_1 = require("fs");
+const lockfile_1 = require("lockfile");
+const path_1 = require("path");
+const digest_file_1 = require("./digest-file");
+const MARKER_FILE_NAME = '.jsii-runtime-package-cache';
+const ONE_DAY_IN_MS = 86400000;
+const PRUNE_AFTER_MILLISECONDS = process.env.JSII_RUNTIME_PACKAGE_CACHE_TTL
+    ? parseInt(process.env.JSII_RUNTIME_PACKAGE_CACHE_TTL, 10) * ONE_DAY_IN_MS
+    : 30 * ONE_DAY_IN_MS;
+class DiskCache {
+    constructor(root) {
+        _DiskCache_root.set(this, void 0);
+        __classPrivateFieldSet(this, _DiskCache_root, root, "f");
+        process.once('beforeExit', () => this.pruneExpiredEntries());
+    }
+    static inDirectory(path) {
+        const didCreate = (0, fs_1.mkdirSync)(path, { recursive: true }) != null;
+        if (didCreate && process.platform === 'darwin') {
+            // Mark the directories for no iCloud sync, no Spotlight indexing, no TimeMachine backup
+            // @see https://michaelbach.de/2019/03/19/MacOS-nosync-noindex-nobackup.html
+            (0, fs_1.writeFileSync)((0, path_1.join)(path, '.nobackup'), '');
+            (0, fs_1.writeFileSync)((0, path_1.join)(path, '.noindex'), '');
+            (0, fs_1.writeFileSync)((0, path_1.join)(path, '.nosync'), '');
+        }
+        path = (0, fs_1.realpathSync)(path);
+        if (!this.CACHE.has(path)) {
+            this.CACHE.set(path, new DiskCache(path));
+        }
+        return this.CACHE.get(path);
+    }
+    entry(...key) {
+        if (key.length === 0) {
+            throw new Error(`Cache entry key must contain at least 1 element!`);
+        }
+        return new Entry((0, path_1.join)(__classPrivateFieldGet(this, _DiskCache_root, "f"), ...key.flatMap((s) => s
+            .replace(/[^@a-z0-9_.\\/-]+/g, '_')
+            .split(/[\\/]+/)
+            .map((ss) => {
+            if (ss === '..') {
+                throw new Error(`A cache entry key cannot contain a '..' path segment! (${s})`);
+            }
+            return ss;
+        }))));
+    }
+    entryFor(path, ...comments) {
+        const rawDigest = (0, digest_file_1.digestFile)(path, ...comments);
+        return this.entry(...comments, rawDigest.toString('hex'));
+    }
+    pruneExpiredEntries() {
+        const cutOff = new Date(Date.now() - PRUNE_AFTER_MILLISECONDS);
+        for (const entry of this.entries()) {
+            if (entry.atime < cutOff) {
+                entry.lock((lockedEntry) => {
+                    // Check again in case it's been accessed which we waited for the lock...
+                    if (entry.atime > cutOff) {
+                        return;
+                    }
+                    lockedEntry.delete();
+                });
+            }
+        }
+        for (const dir of directoriesUnder(__classPrivateFieldGet(this, _DiskCache_root, "f"), true)) {
+            if (process.platform === 'darwin') {
+                try {
+                    (0, fs_1.rmSync)((0, path_1.join)(dir, '.DS_Store'), { force: true });
+                }
+                catch {
+                    // Ignore errors...
+                }
+            }
+            if ((0, fs_1.readdirSync)(dir).length === 0) {
+                try {
+                    (0, fs_1.rmdirSync)(dir);
+                }
+                catch {
+                    // Ignore errors, directory may no longer be empty...
+                }
+            }
+        }
+    }
+    *entries() {
+        yield* inDirectory(__classPrivateFieldGet(this, _DiskCache_root, "f"));
+        function* inDirectory(dir) {
+            if ((0, fs_1.existsSync)((0, path_1.join)(dir, MARKER_FILE_NAME))) {
+                return yield new Entry(dir);
+            }
+            for (const file of directoriesUnder(dir)) {
+                yield* inDirectory(file);
+            }
+        }
+    }
+}
+exports.DiskCache = DiskCache;
+_DiskCache_root = new WeakMap();
+DiskCache.CACHE = new Map();
+class Entry {
+    constructor(path) {
+        this.path = path;
+    }
+    get atime() {
+        try {
+            const stat = (0, fs_1.statSync)(this.markerFile);
+            return stat.atime;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+            return new Date(0);
+        }
+    }
+    get pathExists() {
+        return (0, fs_1.existsSync)(this.path);
+    }
+    get lockFile() {
+        return `${this.path}.lock`;
+    }
+    get markerFile() {
+        return (0, path_1.join)(this.path, MARKER_FILE_NAME);
+    }
+    lock(cb) {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(this.path), { recursive: true });
+        (0, lockfile_1.lockSync)(this.lockFile, { retries: 12, stale: 5000 });
+        let disposed = false;
+        try {
+            return cb({
+                delete: () => {
+                    if (disposed) {
+                        throw new Error(`Cannot delete ${this.path} once the lock block was returned!`);
+                    }
+                    (0, fs_1.rmSync)(this.path, { force: true, recursive: true });
+                },
+                write: (name, content) => {
+                    if (disposed) {
+                        throw new Error(`Cannot write ${(0, path_1.join)(this.path, name)} once the lock block was returned!`);
+                    }
+                    (0, fs_1.mkdirSync)((0, path_1.dirname)((0, path_1.join)(this.path, name)), { recursive: true });
+                    (0, fs_1.writeFileSync)((0, path_1.join)(this.path, name), content);
+                },
+                touch: () => {
+                    if (disposed) {
+                        throw new Error(`Cannot touch ${this.path} once the lock block was returned!`);
+                    }
+                    if (this.pathExists) {
+                        if ((0, fs_1.existsSync)(this.markerFile)) {
+                            const now = new Date();
+                            (0, fs_1.utimesSync)(this.markerFile, now, now);
+                        }
+                        else {
+                            (0, fs_1.writeFileSync)(this.markerFile, '');
+                        }
+                    }
+                },
+            });
+        }
+        finally {
+            disposed = true;
+            (0, lockfile_1.unlockSync)(this.lockFile);
+        }
+    }
+    read(file) {
+        try {
+            return (0, fs_1.readFileSync)((0, path_1.join)(this.path, file));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+}
+exports.Entry = Entry;
+function* directoriesUnder(root, recursive = false, ignoreErrors = true) {
+    for (const file of (0, fs_1.readdirSync)(root)) {
+        const path = (0, path_1.join)(root, file);
+        try {
+            const stat = (0, fs_1.statSync)(path);
+            if (stat.isDirectory()) {
+                if (recursive) {
+                    yield* directoriesUnder(path, recursive, ignoreErrors);
+                }
+                yield path;
+            }
+        }
+        catch (error) {
+            if (!ignoreErrors) {
+                throw error;
+            }
+        }
+    }
+}
+//# sourceMappingURL=disk-cache.js.map

package/lib/disk-cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './disk-cache';
+//# sourceMappingURL=index.d.ts.map

package/lib/disk-cache/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./disk-cache"), exports);
+//# sourceMappingURL=index.js.map

package/lib/kernel.d.ts

@@ -1,10 +1,29 @@
 import * as api from './api';
+export declare const enum JsiiErrorType {
+    JSII_FAULT = "@jsii/kernel.Fault",
+    RUNTIME_ERROR = "@jsii/kernel.RuntimeError"
+}
+export interface JsiiError extends Error {
+    readonly name: JsiiErrorType;
+}
+export declare class JsiiFault extends Error implements JsiiError {
+    readonly name = JsiiErrorType.JSII_FAULT;
+    constructor(message: string);
+}
+export declare class RuntimeError extends Error implements JsiiError {
+    readonly name = JsiiErrorType.RUNTIME_ERROR;
+    constructor(message: string);
+}
 export declare class Kernel {
     callbackHandler: (callback: api.Callback) => any;
     /**
      * Set to true for verbose debugging.
      */
     traceEnabled: boolean;
+    /**
+     * Set to true for timing data to be emitted.
+     */
+    debugTimingEnabled: boolean;
     private readonly assemblies;
     private readonly objects;
     private readonly cbs;
@@ -24,6 +43,7 @@ export declare class Kernel {
      */
     constructor(callbackHandler: (callback: api.Callback) => any);
     load(req: api.LoadRequest): api.LoadResponse;
+    private _load;
     invokeBinScript(req: api.InvokeScriptRequest): api.InvokeScriptResponse;
     create(req: api.CreateRequest): api.CreateResponse;
     del(req: api.DelRequest): api.DelResponse;
@@ -67,6 +87,7 @@ export declare class Kernel {
     private _fromSandboxValues;
     private _boxUnboxParameters;
     private _debug;
+    private _debugTime;
     /**
      * Ensures that `fn` is called and defends against beginning to invoke
      * async methods until fn finishes (successfully or not).

package/lib/kernel.js

@@ -1,19 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Kernel = void 0;
+exports.Kernel = exports.RuntimeError = exports.JsiiFault = void 0;
 const spec = require("@jsii/spec");
 const spec_1 = require("@jsii/spec");
 const cp = require("child_process");
+const fs_1 = require("fs");
 const fs = require("fs-extra");
 const module_1 = require("module");
 const os = require("os");
 const path = require("path");
-const tar = require("tar");
 const api = require("./api");
 const api_1 = require("./api");
+const link_1 = require("./link");
 const objects_1 = require("./objects");
 const onExit = require("./on-exit");
 const wire = require("./serialization");
+const tar = require("./tar-cache");
+class JsiiFault extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "@jsii/kernel.Fault" /* JsiiErrorType.JSII_FAULT */;
+    }
+}
+exports.JsiiFault = JsiiFault;
+class RuntimeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "@jsii/kernel.RuntimeError" /* JsiiErrorType.RUNTIME_ERROR */;
+    }
+}
+exports.RuntimeError = RuntimeError;
 class Kernel {
     /**
      * Creates a jsii kernel object.
@@ -28,6 +44,10 @@ class Kernel {
          * Set to true for verbose debugging.
          */
         this.traceEnabled = false;
+        /**
+         * Set to true for timing data to be emitted.
+         */
+        this.debugTimingEnabled = false;
         this.assemblies = new Map();
         this.objects = new objects_1.ObjectTable(this._typeInfoForFqn.bind(this));
         this.cbs = new Map();
@@ -36,10 +56,13 @@ class Kernel {
         this.nextid = 20000; // incrementing counter for objid, cbid, promiseid
     }
     load(req) {
-        var _a, _b;
+        return this._debugTime(() => this._load(req), `load(${JSON.stringify(req, null, 2)})`);
+    }
+    _load(req) {
+        var _a, _b, _c;
         this._debug('load', req);
         if ('assembly' in req) {
-            throw new Error('`assembly` field is deprecated for "load", use `name`, `version` and `tarball` instead');
+            throw new JsiiFault('`assembly` field is deprecated for "load", use `name`, `version` and `tarball` instead');
         }
         const pkgname = req.name;
         const pkgver = req.version;
@@ -49,7 +72,7 @@ class Kernel {
             // module exists, verify version
             const epkg = fs.readJsonSync(path.join(packageDir, 'package.json'));
             if (epkg.version !== pkgver) {
-                throw new Error(`Multiple versions ${pkgver} and ${epkg.version} of the ` +
+                throw new JsiiFault(`Multiple versions ${pkgver} and ${epkg.version} of the ` +
                     `package '${pkgname}' cannot be loaded together since this is unsupported by ` +
                     'some runtime environments');
             }
@@ -61,20 +84,26 @@ class Kernel {
                 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)
-        fs.mkdirpSync(packageDir);
         // Force umask to have npm-install-like permissions
         const originalUmask = process.umask(0o022);
         try {
             // untar the archive to its final location
-            tar.extract({
-                cwd: packageDir,
-                file: req.tarball,
+            const { path: extractedTo, cache } = this._debugTime(() => tar.extract(req.tarball, {
                 strict: true,
                 strip: 1,
-                sync: true,
                 unlink: true,
-            });
+            }, req.name, req.version), `tar.extract(${req.tarball}) => ${packageDir}`);
+            // Create the install directory (there may be several path components for @scoped/packages)
+            fs.mkdirSync(path.dirname(packageDir), { recursive: true });
+            if (cache != null) {
+                this._debug(`Package cache enabled, extraction resulted in a cache ${cache}`);
+                // Link the package into place.
+                this._debugTime(() => (0, link_1.link)(extractedTo, packageDir), `link(${extractedTo}, ${packageDir})`);
+            }
+            else {
+                // This is not from cache, so we move it around instead of copying.
+                (0, fs_1.renameSync)(extractedTo, packageDir);
+            }
         }
         finally {
             // Reset umask to the initial value
@@ -83,18 +112,18 @@ class Kernel {
         // read .jsii metadata from the root of the package
         let assmSpec;
         try {
-            assmSpec = (0, spec_1.loadAssemblyFromPath)(packageDir);
+            assmSpec = this._debugTime(() => (0, spec_1.loadAssemblyFromPath)(packageDir), `loadAssemblyFromPath(${packageDir})`);
         }
         catch (e) {
-            throw new Error(`Error for package tarball ${req.tarball}: ${e.message}`);
+            throw new JsiiFault(`Error for package tarball ${req.tarball}: ${e.message}`);
         }
         // load the module and capture its closure
-        const closure = this.require(packageDir);
+        const closure = this._debugTime(() => this.require(packageDir), `require(${packageDir})`);
         const assm = new Assembly(assmSpec, closure);
-        this._addAssembly(assm);
+        this._debugTime(() => this._addAssembly(assm), `registerAssembly({ name: ${assm.metadata.name}, types: ${Object.keys((_b = assm.metadata.types) !== null && _b !== void 0 ? _b : {}).length} })`);
         return {
             assembly: assmSpec.name,
-            types: Object.keys((_b = assmSpec.types) !== null && _b !== void 0 ? _b : {}).length,
+            types: Object.keys((_c = assmSpec.types) !== null && _c !== void 0 ? _c : {}).length,
         };
     }
     invokeBinScript(req) {
@@ -104,11 +133,11 @@ class Kernel {
             // module exists, verify version
             const epkg = fs.readJsonSync(path.join(packageDir, 'package.json'));
             if (!epkg.bin) {
-                throw new Error('There is no bin scripts defined for this package.');
+                throw new JsiiFault('There is no bin scripts defined for this package.');
             }
             const scriptPath = epkg.bin[req.script];
             if (!epkg.bin) {
-                throw new Error(`Script with name ${req.script} was not defined.`);
+                throw new JsiiFault(`Script with name ${req.script} was not defined.`);
             }
             const result = cp.spawnSync(path.join(packageDir, scriptPath), (_a = req.args) !== null && _a !== void 0 ? _a : [], {
                 encoding: 'utf-8',
@@ -128,7 +157,7 @@ class Kernel {
                 signal: result.signal,
             };
         }
-        throw new Error(`Package with name ${req.assembly} was not loaded.`);
+        throw new JsiiFault(`Package with name ${req.assembly} was not loaded.`);
     }
     create(req) {
         return this._create(req);
@@ -145,7 +174,7 @@ class Kernel {
         this._debug('sget', symbol);
         const ti = this._typeInfoForProperty(property, fqn);
         if (!ti.static) {
-            throw new Error(`property ${symbol} is not static`);
+            throw new JsiiFault(`property ${symbol} is not static`);
         }
         const prototype = this._findSymbol(fqn);
         const value = this._ensureSync(`property ${property}`, () => prototype[property]);
@@ -160,10 +189,10 @@ class Kernel {
         this._debug('sset', symbol);
         const ti = this._typeInfoForProperty(property, fqn);
         if (!ti.static) {
-            throw new Error(`property ${symbol} is not static`);
+            throw new JsiiFault(`property ${symbol} is not static`);
         }
         if (ti.immutable) {
-            throw new Error(`static property ${symbol} is readonly`);
+            throw new JsiiFault(`static property ${symbol} is readonly`);
         }
         const prototype = this._findSymbol(fqn);
         this._ensureSync(`property ${property}`, () => (prototype[property] = this._toSandbox(value, ti, `assigned to static property ${symbol}`)));
@@ -194,7 +223,7 @@ class Kernel {
         const { instance, fqn, interfaces } = this.objects.findObject(objref);
         const propInfo = this._typeInfoForProperty(req.property, fqn, interfaces);
         if (propInfo.immutable) {
-            throw new Error(`Cannot set value of immutable property ${req.property} to ${req.value}`);
+            throw new JsiiFault(`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}'`, () => (instance[propertyToSet] = this._toSandbox(value, propInfo, `assigned to property ${fqn}.${property}`)));
@@ -208,7 +237,7 @@ class Kernel {
         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`);
+            throw new JsiiFault(`${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}'`, () => {
@@ -225,11 +254,11 @@ class Kernel {
         this._debug('sinvoke', fqn, method, args);
         const ti = this._typeInfoForMethod(method, fqn);
         if (!ti.static) {
-            throw new Error(`${fqn}.${method} is not a static method`);
+            throw new JsiiFault(`${fqn}.${method} is not a static method`);
         }
         // verify this is not an async method
         if (ti.async) {
-            throw new Error(`${method} is an async method, use "begin" instead`);
+            throw new JsiiFault(`${method} is an async method, use "begin" instead`);
         }
         const prototype = this._findSymbol(fqn);
         const fn = prototype[method];
@@ -247,12 +276,12 @@ class Kernel {
         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`);
+            throw new JsiiFault(`Cannot invoke async method '${req.objref[api_1.TOKEN_REF]}.${req.method}' while sync ${this.syncInProgress} is being processed`);
         }
         const { ti, obj, fn } = this._findInvokeTarget(objref, method, args);
         // verify this is indeed an async method
         if (!ti.async) {
-            throw new Error(`Method ${method} is expected to be an async method`);
+            throw new JsiiFault(`Method ${method} is expected to be an async method`);
         }
         const fqn = (0, objects_1.jsiiTypeFqn)(obj);
         const promise = fn.apply(obj, this._toSandboxValues(args, `async method ${fqn ? `${fqn}#` : ''}${method}`, ti.parameters));
@@ -273,7 +302,7 @@ class Kernel {
         this._debug('end', promiseid);
         const storedPromise = this.promises.get(promiseid);
         if (storedPromise == null) {
-            throw new Error(`Cannot find promise with ID: ${promiseid}`);
+            throw new JsiiFault(`Cannot find promise with ID: ${promiseid}`);
         }
         const { promise, method } = storedPromise;
         let result;
@@ -283,7 +312,7 @@ class Kernel {
         }
         catch (e) {
             this._debug('promise error:', e);
-            throw e;
+            throw new JsiiFault(e.message);
         }
         return {
             result: this._fromSandbox(result, (_a = method.returns) !== null && _a !== void 0 ? _a : 'void', `returned by async method ${method.name}`),
@@ -313,7 +342,7 @@ class Kernel {
         this._debug('complete', cbid, err, result);
         const cb = this.waiting.get(cbid);
         if (!cb) {
-            throw new Error(`Callback ${cbid} not found`);
+            throw new JsiiFault(`Callback ${cbid} not found`);
         }
         if (err) {
             this._debug('completed with error:', err);
@@ -337,7 +366,7 @@ class Kernel {
         const assembly = this._assemblyFor(assemblyName);
         const targets = assembly.metadata.targets;
         if (!targets) {
-            throw new Error(`Unexpected - "targets" for ${assemblyName} is missing!`);
+            throw new JsiiFault(`Unexpected - "targets" for ${assemblyName} is missing!`);
         }
         return { naming: targets };
     }
@@ -378,9 +407,9 @@ class Kernel {
                     parameters: classType.initializer && classType.initializer.parameters,
                 };
             case spec.TypeKind.Interface:
-                throw new Error(`Cannot create an object with an FQN of an interface: ${fqn}`);
+                throw new JsiiFault(`Cannot create an object with an FQN of an interface: ${fqn}`);
             default:
-                throw new Error(`Unexpected FQN kind: ${fqn}`);
+                throw new JsiiFault(`Unexpected FQN kind: ${fqn}`);
         }
     }
     _getPackageDir(pkgname) {
@@ -414,26 +443,26 @@ class Kernel {
             for (const override of overrides) {
                 if (api.isMethodOverride(override)) {
                     if (api.isPropertyOverride(override)) {
-                        throw new Error(overrideTypeErrorMessage);
+                        throw new JsiiFault(overrideTypeErrorMessage);
                     }
                     if (methods.has(override.method)) {
-                        throw new Error(`Duplicate override for method '${override.method}'`);
+                        throw new JsiiFault(`Duplicate override for method '${override.method}'`);
                     }
                     methods.add(override.method);
                     this._applyMethodOverride(obj, objref, fqn, interfaces, override);
                 }
                 else if (api.isPropertyOverride(override)) {
                     if (api.isMethodOverride(override)) {
-                        throw new Error(overrideTypeErrorMessage);
+                        throw new JsiiFault(overrideTypeErrorMessage);
                     }
                     if (properties.has(override.property)) {
-                        throw Error(`Duplicate override for property '${override.property}'`);
+                        throw new JsiiFault(`Duplicate override for property '${override.property}'`);
                     }
                     properties.add(override.property);
                     this._applyPropertyOverride(obj, objref, fqn, interfaces, override);
                 }
                 else {
-                    throw new Error(overrideTypeErrorMessage);
+                    throw new JsiiFault(overrideTypeErrorMessage);
                 }
             }
         }
@@ -445,7 +474,7 @@ class Kernel {
     _applyPropertyOverride(obj, objref, typeFqn, interfaces, override) {
         // error if we can find a method with this name
         if (this._tryTypeInfoForMethod(override.property, typeFqn, interfaces)) {
-            throw new Error(`Trying to override method '${override.property}' as a property`);
+            throw new JsiiFault(`Trying to override method '${override.property}' as a property`);
         }
         let propInfo = this._tryTypeInfoForProperty(override.property, typeFqn, interfaces);
         // if this is a private property (i.e. doesn't have `propInfo` the object has a key)
@@ -531,7 +560,7 @@ class Kernel {
     _applyMethodOverride(obj, objref, typeFqn, interfaces, override) {
         // error if we can find a property with this name
         if (this._tryTypeInfoForProperty(override.method, typeFqn, interfaces)) {
-            throw new Error(`Trying to override property '${override.method}' as a method`);
+            throw new JsiiFault(`Trying to override property '${override.method}' as a method`);
         }
         let methodInfo = this._tryTypeInfoForMethod(override.method, typeFqn, interfaces);
         // If this is a private method (doesn't have methodInfo, key resolves on the object), we
@@ -630,7 +659,7 @@ class Kernel {
         if (!fn) {
             fn = instance[methodName];
             if (!fn) {
-                throw new Error(`Cannot find ${methodName} on object`);
+                throw new JsiiFault(`Cannot find ${methodName} on object`);
             }
         }
         return { ti, obj: instance, fn };
@@ -640,7 +669,7 @@ class Kernel {
         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)`);
+            throw new JsiiFault(`Too many arguments (method accepts ${params.length} parameters, got ${args.length} arguments)`);
         }
         for (let i = 0; i < params.length; ++i) {
             const param = params[i];
@@ -651,19 +680,19 @@ class Kernel {
                 } // No vararg was provided
                 for (let j = i; j < params.length; j++) {
                     if (!param.optional && params[j] === undefined) {
-                        throw new Error(`Unexpected 'undefined' value at index ${j - i} of variadic argument '${param.name}' of type '${spec.describeTypeReference(param.type)}'`);
+                        throw new JsiiFault(`Unexpected 'undefined' value at index ${j - i} of variadic argument '${param.name}' of type '${spec.describeTypeReference(param.type)}'`);
                     }
                 }
             }
             else if (!param.optional && arg === undefined) {
-                throw new Error(`Not enough arguments. Missing argument for the required parameter '${param.name}' of type '${spec.describeTypeReference(param.type)}'`);
+                throw new JsiiFault(`Not enough arguments. Missing argument for the required parameter '${param.name}' of type '${spec.describeTypeReference(param.type)}'`);
             }
         }
     }
     _assemblyFor(assemblyName) {
         const assembly = this.assemblies.get(assemblyName);
         if (!assembly) {
-            throw new Error(`Could not find assembly: ${assemblyName}`);
+            throw new JsiiFault(`Could not find assembly: ${assemblyName}`);
         }
         return assembly;
     }
@@ -679,7 +708,7 @@ class Kernel {
             curr = curr[name];
         }
         if (!curr) {
-            throw new Error(`Could not find symbol ${fqn}`);
+            throw new JsiiFault(`Could not find symbol ${fqn}`);
         }
         return curr;
     }
@@ -689,12 +718,12 @@ class Kernel {
         const moduleName = components[0];
         const assembly = this.assemblies.get(moduleName);
         if (!assembly) {
-            throw new Error(`Module '${moduleName}' not found`);
+            throw new JsiiFault(`Module '${moduleName}' not found`);
         }
         const types = (_a = assembly.metadata.types) !== null && _a !== void 0 ? _a : {};
         const fqnInfo = types[fqn];
         if (!fqnInfo) {
-            throw new Error(`Type '${fqn}' not found`);
+            throw new JsiiFault(`Type '${fqn}' not found`);
         }
         return fqnInfo;
     }
@@ -704,7 +733,7 @@ class Kernel {
             const addendum = interfaces && interfaces.length > 0
                 ? ` or interface(s) ${interfaces.join(', ')}`
                 : '';
-            throw new Error(`Class ${fqn}${addendum} doesn't have a method '${methodName}'`);
+            throw new JsiiFault(`Class ${fqn}${addendum} doesn't have a method '${methodName}'`);
         }
         return ti;
     }
@@ -758,7 +787,7 @@ class Kernel {
                 bases = (_a = interfaceTypeInfo.interfaces) !== null && _a !== void 0 ? _a : [];
             }
             else {
-                throw new Error(`Type of kind ${typeInfo.kind} does not have properties`);
+                throw new JsiiFault(`Type of kind ${typeInfo.kind} does not have properties`);
             }
             for (const p of properties !== null && properties !== void 0 ? properties : []) {
                 if (p.name === property) {
@@ -781,7 +810,7 @@ class Kernel {
             const addendum = interfaces && interfaces.length > 0
                 ? ` or interface(s) ${interfaces.join(', ')}`
                 : '';
-            throw new Error(`Type ${fqn}${addendum} doesn't have a property '${property}'`);
+            throw new JsiiFault(`Type ${fqn}${addendum} doesn't have a property '${property}'`);
         }
         return typeInfo;
     }
@@ -816,7 +845,7 @@ class Kernel {
             parametersCopy.push(parametersCopy[parametersCopy.length - 1]);
         }
         if (xs.length > parametersCopy.length) {
-            throw new Error(`Argument list (${JSON.stringify(xs)}) not same size as expected argument list (length ${parametersCopy.length})`);
+            throw new JsiiFault(`Argument list (${JSON.stringify(xs)}) not same size as expected argument list (length ${parametersCopy.length})`);
         }
         return xs.map((x, i) => boxUnbox(x, parametersCopy[i], `passed to parameter ${parametersCopy[i].name} of ${methodContext}`));
     }
@@ -825,6 +854,20 @@ class Kernel {
             console.error('[@jsii/kernel]', ...args);
         }
     }
+    _debugTime(cb, label) {
+        const fullLabel = `[@jsii/kernel:timing] ${label}`;
+        if (this.debugTimingEnabled) {
+            console.time(fullLabel);
+        }
+        try {
+            return cb();
+        }
+        finally {
+            if (this.debugTimingEnabled) {
+                console.timeEnd(fullLabel);
+            }
+        }
+    }
     /**
      * Ensures that `fn` is called and defends against beginning to invoke
      * async methods until fn finishes (successfully or not).
@@ -834,6 +877,15 @@ class Kernel {
         try {
             return fn();
         }
+        catch (e) {
+            if (e.name === "@jsii/kernel.Fault" /* JsiiErrorType.JSII_FAULT */) {
+                throw new JsiiFault(e);
+            }
+            // This error can be thrown by the kernel directly, or it can be
+            // thrown from user code. If the error comes from the kernel, then its name field will be populated;
+            // if the error comes from user code, the name field will not be populated.
+            throw new RuntimeError(e);
+        }
         finally {
             delete this.syncInProgress;
         }

package/lib/link.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates directories containing hard links if possible, and falls back on
+ * copy otherwise.
+ *
+ * @param existing    is the original file or directory to link.
+ * @param destination is the nbew file or directory to create.
+ */
+export declare function link(existing: string, destination: string): void;
+//# sourceMappingURL=link.d.ts.map

package/lib/link.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.link = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Creates directories containing hard links if possible, and falls back on
+ * copy otherwise.
+ *
+ * @param existing    is the original file or directory to link.
+ * @param destination is the nbew file or directory to create.
+ */
+function link(existing, destination) {
+    const stat = (0, fs_1.statSync)(existing);
+    if (!stat.isDirectory()) {
+        try {
+            (0, fs_1.linkSync)(existing, destination);
+        }
+        catch {
+            (0, fs_1.copyFileSync)(existing, destination);
+        }
+        return;
+    }
+    (0, fs_1.mkdirSync)(destination, { recursive: true });
+    for (const file of (0, fs_1.readdirSync)(existing)) {
+        link((0, path_1.join)(existing, file), (0, path_1.join)(destination, file));
+    }
+}
+exports.link = link;
+//# sourceMappingURL=link.js.map

package/lib/objects.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectTable = exports.tagJsiiConstructor = exports.objectReference = exports.jsiiTypeFqn = void 0;
 const spec = require("@jsii/spec");
+const assert = require("assert");
 const api = require("./api");
+const kernel_1 = require("./kernel");
 const serialization_1 = require("./serialization");
 /**
  * Symbol under which we store the { type -> objid } map on object instances
@@ -13,9 +15,9 @@ const OBJID_SYMBOL = Symbol.for('$__jsii__objid__$');
  */
 const IFACES_SYMBOL = Symbol.for('$__jsii__interfaces__$');
 /**
- * Symbol we use to tag the constructor of a JSII class
+ * Symbol we use to tag constructors that are exported from a JSII module.
  */
-const JSII_SYMBOL = Symbol.for('__jsii__');
+const JSII_TYPE_FQN_SYMBOL = Symbol('$__jsii__fqn__$');
 /**
  * Get the JSII fqn for an object (if available)
  *
@@ -24,8 +26,7 @@ const JSII_SYMBOL = Symbol.for('__jsii__');
  * information.
  */
 function jsiiTypeFqn(obj) {
-    var _a;
-    return (_a = obj.constructor[JSII_SYMBOL]) === null || _a === void 0 ? void 0 : _a.fqn;
+    return obj.constructor[JSII_TYPE_FQN_SYMBOL];
 }
 exports.jsiiTypeFqn = jsiiTypeFqn;
 /**
@@ -73,11 +74,16 @@ function tagObject(obj, objid, interfaces) {
  * Set the JSII FQN for classes produced by a given constructor
  */
 function tagJsiiConstructor(constructor, fqn) {
-    Object.defineProperty(constructor, JSII_SYMBOL, {
+    if (Object.prototype.hasOwnProperty.call(constructor, JSII_TYPE_FQN_SYMBOL)) {
+        return assert(constructor[JSII_TYPE_FQN_SYMBOL] === fqn, `Unable to register ${constructor.name} as ${fqn}: it is already registerd with FQN ${constructor[JSII_TYPE_FQN_SYMBOL]}`);
+    }
+    // Mark this constructor as exported from a jsii module, so we know we
+    // should be considering it's FQN as a valid exported type.
+    Object.defineProperty(constructor, JSII_TYPE_FQN_SYMBOL, {
         configurable: false,
         enumerable: false,
         writable: false,
-        value: { fqn },
+        value: fqn,
     });
 }
 exports.tagJsiiConstructor = tagJsiiConstructor;
@@ -101,7 +107,7 @@ class ObjectTable {
     registerObject(obj, fqn, interfaces) {
         var _a;
         if (fqn === undefined) {
-            throw new Error('FQN cannot be undefined');
+            throw new kernel_1.JsiiFault('FQN cannot be undefined');
         }
         const existingRef = objectReference(obj);
         if (existingRef) {
@@ -135,12 +141,12 @@ class ObjectTable {
     findObject(objref) {
         var _a;
         if (typeof objref !== 'object' || !(api.TOKEN_REF in objref)) {
-            throw new Error(`Malformed object reference: ${JSON.stringify(objref)}`);
+            throw new kernel_1.JsiiFault(`Malformed object reference: ${JSON.stringify(objref)}`);
         }
         const objid = objref[api.TOKEN_REF];
         const obj = this.objects.get(objid);
         if (!obj) {
-            throw new Error(`Object ${objid} not found`);
+            throw new kernel_1.JsiiFault(`Object ${objid} not found`);
         }
         // If there are "additional" interfaces declared on the objref, merge them
         // into the returned object. This is used to support client-side forced
@@ -167,7 +173,7 @@ class ObjectTable {
      */
     deleteObject({ [api.TOKEN_REF]: objid }) {
         if (!this.objects.delete(objid)) {
-            throw new Error(`Object ${objid} not found`);
+            throw new kernel_1.JsiiFault(`Object ${objid} not found`);
         }
     }
     get count() {
@@ -201,7 +207,7 @@ class InterfaceCollection {
     addFromClass(fqn) {
         const ti = this.resolveType(fqn);
         if (!spec.isClassType(ti)) {
-            throw new Error(`Expected a class, but received ${spec.describeTypeReference(ti)}`);
+            throw new kernel_1.JsiiFault(`Expected a class, but received ${spec.describeTypeReference(ti)}`);
         }
         if (ti.base) {
             this.addFromClass(ti.base);
@@ -219,7 +225,7 @@ class InterfaceCollection {
     addFromInterface(fqn) {
         const ti = this.resolveType(fqn);
         if (!spec.isInterfaceType(ti)) {
-            throw new Error(`Expected an interface, but received ${spec.describeTypeReference(ti)}`);
+            throw new kernel_1.JsiiFault(`Expected an interface, but received ${spec.describeTypeReference(ti)}`);
         }
         if (!ti.interfaces) {
             return;

package/lib/recording.js

@@ -47,7 +47,7 @@ function recordInteraction(kernel, inputOutputLogPath) {
                                 ok(value);
                             })
                                 .catch((err) => {
-                                logOutput({ error: err.message });
+                                logOutput({ error: err.message, name: err.name });
                                 fail(err);
                             });
                         });
@@ -56,8 +56,11 @@ function recordInteraction(kernel, inputOutputLogPath) {
                     return ret;
                 }
                 catch (e) {
-                    logOutput({ error: e.message });
-                    throw e;
+                    logOutput({ error: e.message, name: e.name });
+                    if (e.type === "@jsii/kernel.RuntimeError" /* JsiiErrorType.RUNTIME_ERROR */) {
+                        throw new kernel_1.RuntimeError(e.message);
+                    }
+                    throw new kernel_1.JsiiFault(e.message);
                 }
             },
         });

package/lib/tar-cache/default-cache-root.d.ts

@@ -0,0 +1,2 @@
+export declare function defaultCacheRoot(): string;
+//# sourceMappingURL=default-cache-root.d.ts.map

package/lib/tar-cache/default-cache-root.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCacheRoot = void 0;
+const os_1 = require("os");
+const path_1 = require("path");
+function defaultCacheRoot() {
+    switch (process.platform) {
+        case 'darwin':
+            if (process.env.HOME)
+                return (0, path_1.join)(process.env.HOME, 'Library', 'Caches', 'com.amazonaws.jsii', 'package-cache');
+            break;
+        case 'linux':
+            if (process.env.HOME)
+                return (0, path_1.join)(process.env.HOME, '.cache', 'aws', 'jsii', 'package-cache');
+            break;
+        case 'win32':
+            if (process.env.LOCALAPPDATA)
+                return (0, path_1.join)(process.env.LOCALAPPDATA, 'AWS', 'jsii', 'package-cache');
+            break;
+        default:
+        // Fall back on putting in tmpdir()
+    }
+    return (0, path_1.join)((0, os_1.tmpdir)(), 'aws-jsii-package-cache');
+}
+exports.defaultCacheRoot = defaultCacheRoot;
+//# sourceMappingURL=default-cache-root.js.map

package/lib/tar-cache/index.d.ts

@@ -0,0 +1,33 @@
+import * as tar from 'tar';
+export declare type ExtractOptions = Omit<tar.ExtractOptions & tar.FileOptions, 'file' | 'cwd'>;
+export interface ExtractResult {
+    /**
+     * The path in which the extracted files are located
+     */
+    readonly path: string;
+    /**
+     * When `'hit'`, the data was already present in cache and was returned from
+     * cache.
+     *
+     * When `'miss'`, the data was extracted into the caache and returned from
+     * cache.
+     *
+     * When `undefined`, the cache is not enabled.
+     */
+    readonly cache?: 'hit' | 'miss';
+}
+/**
+ * Extracts the content of a tarball, possibly caching it on disk.
+ *
+ * @param file     is the path to the tarball to be extracted.
+ * @param options  are options to pass to `tar.extract`
+ * @param comments are included in the cache key, when caching is enabled.
+ *
+ * @returns the result of the extraction.
+ */
+export declare function extract(file: string, options: ExtractOptions, ...comments: readonly string[]): ExtractResult;
+/** @internal */
+export declare function getPackageCacheEnabled(): boolean;
+/** @internal */
+export declare function setPackageCacheEnabled(value: boolean): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/tar-cache/index.js

@@ -0,0 +1,77 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPackageCacheEnabled = exports.getPackageCacheEnabled = exports.extract = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const tar = require("tar");
+const disk_cache_1 = require("../disk-cache");
+const default_cache_root_1 = require("./default-cache-root");
+let packageCacheEnabled = ((_a = process.env.JSII_RUNTIME_PACKAGE_CACHE) === null || _a === void 0 ? void 0 : _a.toLocaleUpperCase()) === 'enabled';
+/**
+ * Extracts the content of a tarball, possibly caching it on disk.
+ *
+ * @param file     is the path to the tarball to be extracted.
+ * @param options  are options to pass to `tar.extract`
+ * @param comments are included in the cache key, when caching is enabled.
+ *
+ * @returns the result of the extraction.
+ */
+function extract(file, options, ...comments) {
+    return (packageCacheEnabled ? extractToCache : extractToTemporary)(file, options, ...comments);
+}
+exports.extract = extract;
+function extractToCache(file, options = {}, ...comments) {
+    var _a;
+    const cacheRoot = (_a = process.env.JSII_RUNTIME_PACKAGE_CACHE_ROOT) !== null && _a !== void 0 ? _a : (0, default_cache_root_1.defaultCacheRoot)();
+    const cache = disk_cache_1.DiskCache.inDirectory(cacheRoot);
+    const entry = cache.entryFor(file, ...comments);
+    return entry.lock((lock) => {
+        let cache = 'hit';
+        if (!entry.pathExists) {
+            const tmpPath = `${entry.path}.tmp`;
+            (0, fs_1.mkdirSync)(tmpPath, { recursive: true });
+            try {
+                untarInto({
+                    ...options,
+                    cwd: tmpPath,
+                    file,
+                });
+                (0, fs_1.renameSync)(tmpPath, entry.path);
+            }
+            catch (error) {
+                (0, fs_1.rmSync)(entry.path, { force: true, recursive: true });
+                throw error;
+            }
+            cache = 'miss';
+        }
+        lock.touch();
+        return { path: entry.path, cache };
+    });
+}
+function extractToTemporary(file, options = {}) {
+    const path = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'jsii-runtime-untar-'));
+    untarInto({ ...options, cwd: path, file });
+    return { path };
+}
+function untarInto(options) {
+    try {
+        tar.extract({ ...options, sync: true });
+    }
+    catch (error) {
+        (0, fs_1.rmSync)(options.cwd, { force: true, recursive: true });
+        throw error;
+    }
+}
+/** @internal */
+function getPackageCacheEnabled() {
+    return packageCacheEnabled;
+}
+exports.getPackageCacheEnabled = getPackageCacheEnabled;
+/** @internal */
+function setPackageCacheEnabled(value) {
+    packageCacheEnabled = value;
+}
+exports.setPackageCacheEnabled = setPackageCacheEnabled;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsii/kernel",
-  "version": "1.66.0",
+  "version": "1.68.0",
   "description": "kernel for jsii execution environment",
   "license": "Apache-2.0",
   "author": {
@@ -31,17 +31,19 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/spec": "^1.66.0",
+    "@jsii/spec": "^1.68.0",
     "fs-extra": "^10.1.0",
+    "lockfile": "^1.0.4",
     "tar": "^6.1.11"
   },
   "devDependencies": {
-    "@scope/jsii-calc-base": "^1.66.0",
-    "@scope/jsii-calc-lib": "^1.66.0",
+    "@scope/jsii-calc-base": "^1.68.0",
+    "@scope/jsii-calc-lib": "^1.68.0",
     "@types/fs-extra": "^9.0.13",
+    "@types/lockfile": "^1.0.2",
     "@types/tar": "^6.1.2",
-    "jest-expect-message": "^1.0.2",
-    "jsii-build-tools": "^1.66.0",
+    "jest-expect-message": "^1.1.2",
+    "jsii-build-tools": "^1.68.0",
     "jsii-calc": "^3.20.120"
   }
 }