@jsii/kernel 1.65.0 → 1.67.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

@@ -5,6 +5,10 @@ export declare class Kernel {
      * 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 +28,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 +72,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

@@ -4,16 +4,18 @@ exports.Kernel = 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 Kernel {
     /**
      * Creates a jsii kernel object.
@@ -28,6 +30,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,7 +42,10 @@ 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');
@@ -61,20 +70,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 +98,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}`);
         }
         // 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) {
@@ -359,7 +374,7 @@ class Kernel {
                 case spec.TypeKind.Class:
                 case spec.TypeKind.Enum:
                     const constructor = this._findSymbol(fqn);
-                    (0, objects_1.tagJsiiConstructor)(constructor, fqn);
+                    (0, objects_1.tagJsiiConstructor)(constructor, fqn, assm.metadata.version);
             }
         }
     }
@@ -825,6 +840,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).

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.d.ts

@@ -17,7 +17,7 @@ export declare function objectReference(obj: unknown): api.ObjRef | undefined;
 /**
  * Set the JSII FQN for classes produced by a given constructor
  */
-export declare function tagJsiiConstructor(constructor: any, fqn: string): void;
+export declare function tagJsiiConstructor(constructor: any, fqn: string, version: string): void;
 /**
  * Table of JSII objects
  *

package/lib/objects.js

@@ -15,7 +15,7 @@ const IFACES_SYMBOL = Symbol.for('$__jsii__interfaces__$');
 /**
  * Symbol we use to tag the constructor of a JSII class
  */
-const JSII_SYMBOL = Symbol.for('__jsii__');
+const JSII_RTTI_SYMBOL = Symbol.for('jsii.rtti');
 /**
  * Get the JSII fqn for an object (if available)
  *
@@ -25,7 +25,7 @@ const JSII_SYMBOL = Symbol.for('__jsii__');
  */
 function jsiiTypeFqn(obj) {
     var _a;
-    return (_a = obj.constructor[JSII_SYMBOL]) === null || _a === void 0 ? void 0 : _a.fqn;
+    return (_a = obj.constructor[JSII_RTTI_SYMBOL]) === null || _a === void 0 ? void 0 : _a.fqn;
 }
 exports.jsiiTypeFqn = jsiiTypeFqn;
 /**
@@ -72,12 +72,15 @@ 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, {
+function tagJsiiConstructor(constructor, fqn, version) {
+    if (Object.prototype.hasOwnProperty.call(constructor, JSII_RTTI_SYMBOL)) {
+        return;
+    }
+    Object.defineProperty(constructor, JSII_RTTI_SYMBOL, {
         configurable: false,
         enumerable: false,
         writable: false,
-        value: { fqn },
+        value: { fqn, version },
     });
 }
 exports.tagJsiiConstructor = tagJsiiConstructor;

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.65.0",
+  "version": "1.67.0",
   "description": "kernel for jsii execution environment",
   "license": "Apache-2.0",
   "author": {
@@ -31,17 +31,19 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/spec": "^1.65.0",
+    "@jsii/spec": "^1.67.0",
     "fs-extra": "^10.1.0",
+    "lockfile": "^1.0.4",
     "tar": "^6.1.11"
   },
   "devDependencies": {
-    "@scope/jsii-calc-base": "^1.65.0",
-    "@scope/jsii-calc-lib": "^1.65.0",
+    "@scope/jsii-calc-base": "^1.67.0",
+    "@scope/jsii-calc-lib": "^1.67.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.65.0",
+    "jsii-build-tools": "^1.67.0",
     "jsii-calc": "^3.20.120"
   }
 }