@jsii/kernel 1.85.0 → 1.86.0

package/lib/serialization.js

@@ -58,62 +58,62 @@ exports.SERIALIZERS = {
     },
     // ----------------------------------------------------------------------
     ["Date" /* SerializationClass.Date */]: {
-        serialize(value, optionalValue) {
-            if (nullAndOk(value, optionalValue)) {
+        serialize(value, optionalValue, host) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (!isDate(value)) {
-                throw new SerializationError(`Value is not an instance of Date`, value);
+                throw new SerializationError(`Value is not an instance of Date`, value, host);
             }
             return serializeDate(value);
         },
-        deserialize(value, optionalValue) {
-            if (nullAndOk(value, optionalValue)) {
+        deserialize(value, optionalValue, host) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             if (!(0, api_1.isWireDate)(value)) {
-                throw new SerializationError(`Value does not have the "${api_1.TOKEN_DATE}" key`, value);
+                throw new SerializationError(`Value does not have the "${api_1.TOKEN_DATE}" key`, value, host);
             }
             return deserializeDate(value);
         },
     },
     // ----------------------------------------------------------------------
     ["Scalar" /* SerializationClass.Scalar */]: {
-        serialize(value, optionalValue) {
-            if (nullAndOk(value, optionalValue)) {
+        serialize(value, optionalValue, host) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const primitiveType = optionalValue.type;
             if (!isScalar(value)) {
-                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value, host);
             }
             if (typeof value !== primitiveType.primitive) {
-                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value, host);
             }
             return value;
         },
-        deserialize(value, optionalValue) {
-            if (nullAndOk(value, optionalValue)) {
+        deserialize(value, optionalValue, host) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const primitiveType = optionalValue.type;
             if (!isScalar(value)) {
-                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value, host);
             }
             if (typeof value !== primitiveType.primitive) {
-                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value, host);
             }
             return value;
         },
     },
     // ----------------------------------------------------------------------
     ["Json" /* SerializationClass.Json */]: {
-        serialize(value, optionalValue) {
+        serialize(value, optionalValue, host) {
             // /!\ Top-level "null" will turn to undefined, but any null nested in the value is valid JSON, so it'll stay!
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             // Just whatever. Dates will automatically serialize themselves to strings.
@@ -121,7 +121,7 @@ exports.SERIALIZERS = {
         },
         deserialize(value, optionalValue, host) {
             // /!\ Top-level "null" will turn to undefined, but any null nested in the value is valid JSON, so it'll stay!
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             // A mapping object can arrive though here. This would be the case if anything that is valid into a Map<string, ?>
@@ -144,7 +144,7 @@ exports.SERIALIZERS = {
             if (Array.isArray(value)) {
                 return value.map(mapJsonValue);
             }
-            return mapValues(value, mapJsonValue);
+            return mapValues(value, mapJsonValue, host);
             function mapJsonValue(toMap, key) {
                 if (toMap == null) {
                     return toMap;
@@ -156,52 +156,52 @@ exports.SERIALIZERS = {
     // ----------------------------------------------------------------------
     ["Enum" /* SerializationClass.Enum */]: {
         serialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (typeof value !== 'string' && typeof value !== 'number') {
-                throw new SerializationError(`Value is not a string or number`, value);
+                throw new SerializationError(`Value is not a string or number`, value, host);
             }
             host.debug('Serializing enum');
             const enumType = optionalValue.type;
             const enumMap = host.findSymbol(enumType.fqn);
             const enumEntry = Object.entries(enumMap).find(([, v]) => v === value);
             if (!enumEntry) {
-                throw new SerializationError(`Value is not present in enum ${spec.describeTypeReference(enumType)}`, value);
+                throw new SerializationError(`Value is not present in enum ${spec.describeTypeReference(enumType)}`, value, host);
             }
             return { [api_1.TOKEN_ENUM]: `${enumType.fqn}/${enumEntry[0]}` };
         },
         deserialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             if (!(0, api_1.isWireEnum)(value)) {
-                throw new SerializationError(`Value does not have the "${api_1.TOKEN_ENUM}" key`, value);
+                throw new SerializationError(`Value does not have the "${api_1.TOKEN_ENUM}" key`, value, host);
             }
-            return deserializeEnum(value, host.findSymbol);
+            return deserializeEnum(value, host);
         },
     },
     // ----------------------------------------------------------------------
     ["Array" /* SerializationClass.Array */]: {
         serialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (!Array.isArray(value)) {
-                throw new SerializationError(`Value is not an array`, value);
+                throw new SerializationError(`Value is not an array`, value, host);
             }
             const arrayType = optionalValue.type;
             return value.map((x, idx) => process(host, 'serialize', x, { type: arrayType.collection.elementtype }, `index ${(0, util_1.inspect)(idx)}`));
         },
         deserialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (!Array.isArray(value)) {
-                throw new SerializationError(`Value is not an array`, value);
+                throw new SerializationError(`Value is not an array`, value, host);
             }
             const arrayType = optionalValue.type;
             return value.map((x, idx) => process(host, 'deserialize', x, { type: arrayType.collection.elementtype }, `index ${(0, util_1.inspect)(idx)}`));
@@ -210,17 +210,17 @@ exports.SERIALIZERS = {
     // ----------------------------------------------------------------------
     ["Map" /* SerializationClass.Map */]: {
         serialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const mapType = optionalValue.type;
             return {
-                [api_1.TOKEN_MAP]: mapValues(value, (v, key) => process(host, 'serialize', v, { type: mapType.collection.elementtype }, `key ${(0, util_1.inspect)(key)}`)),
+                [api_1.TOKEN_MAP]: mapValues(value, (v, key) => process(host, 'serialize', v, { type: mapType.collection.elementtype }, `key ${(0, util_1.inspect)(key)}`), host),
             };
         },
         deserialize(value, optionalValue, host, { allowNullishMapValue = false } = {}) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
@@ -230,12 +230,12 @@ exports.SERIALIZERS = {
                 return mapValues(value, (v, key) => process(host, 'deserialize', v, {
                     optional: allowNullishMapValue,
                     type: mapType.collection.elementtype,
-                }, `key ${(0, util_1.inspect)(key)}`));
+                }, `key ${(0, util_1.inspect)(key)}`), host);
             }
             const result = mapValues(value[api_1.TOKEN_MAP], (v, key) => process(host, 'deserialize', v, {
                 optional: allowNullishMapValue,
                 type: mapType.collection.elementtype,
-            }, `key ${(0, util_1.inspect)(key)}`));
+            }, `key ${(0, util_1.inspect)(key)}`), host);
             Object.defineProperty(result, exports.SYMBOL_WIRE_TYPE, {
                 configurable: false,
                 enumerable: false,
@@ -248,15 +248,15 @@ exports.SERIALIZERS = {
     // ----------------------------------------------------------------------
     ["Struct" /* SerializationClass.Struct */]: {
         serialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (typeof value !== 'object' || value == null || value instanceof Date) {
-                throw new SerializationError(`Value is not an object`, value);
+                throw new SerializationError(`Value is not an object`, value, host);
             }
             if (Array.isArray(value)) {
-                throw new SerializationError(`Value is an array`, value);
+                throw new SerializationError(`Value is an array`, value, host);
             }
             /*
               This is what we'd like to do, but we can't because at least the Java client
@@ -282,17 +282,17 @@ exports.SERIALIZERS = {
                 // Treat empty structs as `undefined` (see https://github.com/aws/jsii/issues/411)
                 value = undefined;
             }
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (typeof value !== 'object' || value == null) {
-                throw new SerializationError(`Value is not an object`, value);
+                throw new SerializationError(`Value is not an object`, value, host);
             }
             const namedType = host.lookupType(optionalValue.type.fqn);
             const props = propertiesOf(namedType, host.lookupType);
             if (Array.isArray(value)) {
-                throw new SerializationError('Value is an array (varargs may have been incorrectly supplied)', value);
+                throw new SerializationError('Value is an array (varargs may have been incorrectly supplied)', value, host);
             }
             // Similarly to serialization, we might be getting a reference type where we're
             // expecting a value type. Accept this for now (but also validate that object
@@ -300,12 +300,12 @@ exports.SERIALIZERS = {
             if ((0, api_1.isObjRef)(value)) {
                 host.debug('Expected value type but got reference type, accepting for now (awslabs/jsii#400)');
                 // Return same INSTANCE (shouldn't matter but we don't know for sure that it doesn't)
-                return validateRequiredProps(host.objects.findObject(value).instance, namedType.fqn, props);
+                return validateRequiredProps(host.objects.findObject(value).instance, namedType.fqn, props, host);
             }
             if (_1.api.isWireStruct(value)) {
                 const { fqn, data } = value[_1.api.TOKEN_STRUCT];
                 if (!isAssignable(fqn, namedType, host.lookupType)) {
-                    throw new SerializationError(`Wired struct has type '${fqn}', which does not match expected type`, value);
+                    throw new SerializationError(`Wired struct has type '${fqn}', which does not match expected type`, value, host);
                 }
                 value = data;
             }
@@ -313,46 +313,46 @@ exports.SERIALIZERS = {
             if (_1.api.isWireMap(value)) {
                 value = value[_1.api.TOKEN_MAP];
             }
-            value = validateRequiredProps(value, namedType.fqn, props);
+            value = validateRequiredProps(value, namedType.fqn, props, host);
             // Return a dict COPY, we have by-value semantics anyway.
             return mapValues(value, (v, key) => {
                 if (!props[key]) {
                     return undefined;
                 } // Don't map if unknown property
                 return process(host, 'deserialize', v, props[key], `key ${(0, util_1.inspect)(key)}`);
-            });
+            }, host);
         },
     },
     // ----------------------------------------------------------------------
     ["RefType" /* SerializationClass.ReferenceType */]: {
         serialize(value, optionalValue, host) {
             var _a;
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (typeof value !== 'object' || value == null || Array.isArray(value)) {
-                throw new SerializationError(`Value is not an object`, value);
+                throw new SerializationError(`Value is not an object`, value, host);
             }
             if (value instanceof Date) {
-                throw new SerializationError(`Value is a Date`, value);
+                throw new SerializationError(`Value is a Date`, value, host);
             }
             const expectedType = host.lookupType(optionalValue.type.fqn);
             const interfaces = spec.isInterfaceType(expectedType)
                 ? [expectedType.fqn]
                 : undefined;
-            const jsiiType = (_a = (0, objects_1.jsiiTypeFqn)(value)) !== null && _a !== void 0 ? _a : (spec.isClassType(expectedType) ? expectedType.fqn : exports.EMPTY_OBJECT_FQN);
+            const jsiiType = (_a = (0, objects_1.jsiiTypeFqn)(value, host.isVisibleType)) !== null && _a !== void 0 ? _a : (spec.isClassType(expectedType) ? expectedType.fqn : exports.EMPTY_OBJECT_FQN);
             return host.objects.registerObject(value, jsiiType, interfaces);
         },
         deserialize(value, optionalValue, host) {
-            if (nullAndOk(value, optionalValue)) {
+            if (nullAndOk(value, optionalValue, host)) {
                 return undefined;
             }
             assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             // The only way to pass a by-ref object is to have created it
             // previously inside JSII kernel, so it must have an objref already.
             if (!(0, api_1.isObjRef)(value)) {
-                throw new SerializationError(`Value does not have the "${api_1.TOKEN_REF}" key`, value);
+                throw new SerializationError(`Value does not have the "${api_1.TOKEN_REF}" key`, value, host);
             }
             const { instance, fqn } = host.objects.findObject(value);
             const namedTypeRef = optionalValue.type;
@@ -365,7 +365,7 @@ exports.SERIALIZERS = {
                 const declaredType = optionalValue.type;
                 if (spec.isClassType(namedType) &&
                     !isAssignable(fqn, declaredType, host.lookupType)) {
-                    throw new SerializationError(`Object of type '${fqn}' is not convertible to ${spec.describeTypeReference(declaredType)}`, value);
+                    throw new SerializationError(`Object of type '${fqn}' is not convertible to ${spec.describeTypeReference(declaredType)}`, value, host);
                 }
             }
             return instance;
@@ -390,10 +390,10 @@ exports.SERIALIZERS = {
             // Note: no case for "ENUM" here, without type declaration we can't tell the difference
             // between an enum member and a scalar.
             if (typeof value === 'function') {
-                throw new SerializationError('Functions cannot be passed across language boundaries', value);
+                throw new SerializationError('Functions cannot be passed across language boundaries', value, host);
             }
             if (typeof value !== 'object' || value == null) {
-                throw new SerializationError(`A jsii kernel assumption was violated: value is not an object`, value);
+                throw new SerializationError(`A jsii kernel assumption was violated: value is not an object`, value, host);
             }
             if (exports.SYMBOL_WIRE_TYPE in value &&
                 value[exports.SYMBOL_WIRE_TYPE] === api_1.TOKEN_MAP) {
@@ -410,7 +410,7 @@ exports.SERIALIZERS = {
             // those and throw a descriptive error message. We can't detect these cases any other
             // way, and the by-value serialized object will be quite useless.
             if (value instanceof Set || value instanceof Map) {
-                throw new SerializationError('Set and Map instances cannot be sent across the language boundary', value);
+                throw new SerializationError('Set and Map instances cannot be sent across the language boundary', value, host);
             }
             // Use a previous reference to maintain object identity. NOTE: this may cause us to return
             // a different type than requested! This is just how it is right now.
@@ -421,7 +421,7 @@ exports.SERIALIZERS = {
             }
             // If this is or should be a reference type, pass or make the reference
             // (Like regular reftype serialization, but without the type derivation to an interface)
-            const jsiiType = (_a = (0, objects_1.jsiiTypeFqn)(value)) !== null && _a !== void 0 ? _a : (isByReferenceOnly(value) ? exports.EMPTY_OBJECT_FQN : undefined);
+            const jsiiType = (_a = (0, objects_1.jsiiTypeFqn)(value, host.isVisibleType)) !== null && _a !== void 0 ? _a : (isByReferenceOnly(value) ? exports.EMPTY_OBJECT_FQN : undefined);
             if (jsiiType) {
                 return host.objects.registerObject(value, jsiiType);
             }
@@ -430,7 +430,7 @@ exports.SERIALIZERS = {
             // We will serialize by-value, but recurse for serialization so that if
             // the object contains reference objects, they will be serialized appropriately.
             // (Basically, serialize anything else as a map of 'any').
-            return mapValues(value, (v, key) => process(host, 'serialize', v, { type: spec.CANONICAL_ANY }, `key ${(0, util_1.inspect)(key)}`));
+            return mapValues(value, (v, key) => process(host, 'serialize', v, { type: spec.CANONICAL_ANY }, `key ${(0, util_1.inspect)(key)}`), host);
         },
         deserialize(value, _type, host) {
             if (value == null) {
@@ -450,7 +450,7 @@ exports.SERIALIZERS = {
             }
             if ((0, api_1.isWireEnum)(value)) {
                 host.debug('ANY is an Enum');
-                return deserializeEnum(value, host.findSymbol);
+                return deserializeEnum(value, host);
             }
             if ((0, api_1.isWireMap)(value)) {
                 host.debug('ANY is a Map');
@@ -476,7 +476,7 @@ exports.SERIALIZERS = {
             }
             // At this point again, deserialize by-value.
             host.debug('ANY is a Map');
-            return mapValues(value, (v, key) => process(host, 'deserialize', v, { type: spec.CANONICAL_ANY }, `key ${(0, util_1.inspect)(key)}`));
+            return mapValues(value, (v, key) => process(host, 'deserialize', v, { type: spec.CANONICAL_ANY }, `key ${(0, util_1.inspect)(key)}`), host);
         },
     },
 };
@@ -486,17 +486,17 @@ function serializeDate(value) {
 function deserializeDate(value) {
     return new Date(value[api_1.TOKEN_DATE]);
 }
-function deserializeEnum(value, lookup) {
+function deserializeEnum(value, host) {
     const enumLocator = value[api_1.TOKEN_ENUM];
     const sep = enumLocator.lastIndexOf('/');
     if (sep === -1) {
-        throw new SerializationError(`Invalid enum token value ${(0, util_1.inspect)(enumLocator)}`, value);
+        throw new SerializationError(`Invalid enum token value ${(0, util_1.inspect)(enumLocator)}`, value, host);
     }
     const typeName = enumLocator.slice(0, sep);
     const valueName = enumLocator.slice(sep + 1);
-    const enumValue = lookup(typeName)[valueName];
+    const enumValue = host.findSymbol(typeName)[valueName];
     if (enumValue === undefined) {
-        throw new SerializationError(`No such enum member: ${(0, util_1.inspect)(valueName)}`, value);
+        throw new SerializationError(`No such enum member: ${(0, util_1.inspect)(valueName)}`, value, host);
     }
     return enumValue;
 }
@@ -556,12 +556,12 @@ function serializationType(typeRef, lookup) {
     return [{ serializationClass: "RefType" /* SerializationClass.ReferenceType */, typeRef }];
 }
 exports.serializationType = serializationType;
-function nullAndOk(x, type) {
+function nullAndOk(x, type, host) {
     if (x != null) {
         return false;
     }
     if (type !== 'void' && !type.optional) {
-        throw new SerializationError(`A value is required (type is non-optional)`, x);
+        throw new SerializationError(`A value is required (type is non-optional)`, x, host);
     }
     return true;
 }
@@ -582,12 +582,12 @@ function flatMap(xs, fn) {
 /**
  * Map an object's values, skipping 'undefined' values'
  */
-function mapValues(value, fn) {
+function mapValues(value, fn, host) {
     if (typeof value !== 'object' || value == null) {
-        throw new SerializationError(`Value is not an object`, value);
+        throw new SerializationError(`Value is not an object`, value, host);
     }
     if (Array.isArray(value)) {
-        throw new SerializationError(`Value is an array`, value);
+        throw new SerializationError(`Value is an array`, value, host);
     }
     const out = {};
     for (const [k, v] of Object.entries(value)) {
@@ -647,7 +647,7 @@ function isAssignable(actualTypeFqn, requiredType, lookup) {
     }
     return false;
 }
-function validateRequiredProps(actualProps, typeName, specProps) {
+function validateRequiredProps(actualProps, typeName, specProps, host) {
     // Check for required properties
     const missingRequiredProps = Object.keys(specProps)
         .filter((name) => !specProps[name].optional)
@@ -655,7 +655,7 @@ function validateRequiredProps(actualProps, typeName, specProps) {
     if (missingRequiredProps.length > 0) {
         throw new SerializationError(`Missing required properties for ${typeName}: ${missingRequiredProps
             .map((p) => (0, util_1.inspect)(p))
-            .join(', ')}`, actualProps);
+            .join(', ')}`, actualProps, host);
     }
     return actualProps;
 }
@@ -719,7 +719,7 @@ function process(host, serde, value, type, context) {
     }
     const typeDescr = type === VOID ? type : spec.describeTypeReference(type.type);
     const optionalTypeDescr = type !== VOID && type.optional ? `${typeDescr} | undefined` : typeDescr;
-    throw new SerializationError(`${titleize(context)}: Unable to ${serde} value as ${optionalTypeDescr}`, value, errors, { renderValue: true });
+    throw new SerializationError(`${titleize(context)}: Unable to ${serde} value as ${optionalTypeDescr}`, value, host, errors, { renderValue: true });
     function titleize(text) {
         text = text.trim();
         if (text === '') {
@@ -731,12 +731,12 @@ function process(host, serde, value, type, context) {
 }
 exports.process = process;
 class SerializationError extends Error {
-    constructor(message, value, causes = [], { renderValue = false } = {}) {
+    constructor(message, value, { isVisibleType }, causes = [], { renderValue = false } = {}) {
         super([
             message,
             ...(renderValue
                 ? [
-                    `${causes.length > 0 ? '\u{251C}' : '\u{2570}'}\u{2500}\u{2500} \u{1F6D1} Failing value is ${describeTypeOf(value)}`,
+                    `${causes.length > 0 ? '\u{251C}' : '\u{2570}'}\u{2500}\u{2500} \u{1F6D1} Failing value is ${describeTypeOf(value, isVisibleType)}`,
                     ...(value == null
                         ? []
                         : (0, util_1.inspect)(value, false, 0)
@@ -762,7 +762,7 @@ class SerializationError extends Error {
     }
 }
 exports.SerializationError = SerializationError;
-function describeTypeOf(value) {
+function describeTypeOf(value, isVisibleType) {
     const type = typeof value;
     switch (type) {
         case 'object':
@@ -772,7 +772,7 @@ function describeTypeOf(value) {
             if (Array.isArray(value)) {
                 return 'an array';
             }
-            const fqn = (0, objects_1.jsiiTypeFqn)(value);
+            const fqn = (0, objects_1.jsiiTypeFqn)(value, isVisibleType);
             if (fqn != null && fqn !== exports.EMPTY_OBJECT_FQN) {
                 return `an instance of ${fqn}`;
             }

package/lib/tar-cache/index.js

@@ -1,5 +1,5 @@
 "use strict";
-var _a;
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setPackageCacheEnabled = exports.getPackageCacheEnabled = exports.extract = void 0;
 const fs_1 = require("fs");
@@ -7,7 +7,8 @@ const tar = require("tar");
 const disk_cache_1 = require("../disk-cache");
 const link_1 = require("../link");
 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.toLocaleLowerCase()) === 'enabled';
+let packageCacheEnabled = ((_b = (_a = process.env.JSII_RUNTIME_PACKAGE_CACHE) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) !== null && _b !== void 0 ? _b : 'enabled') ===
+    'enabled';
 /**
  * Extracts the content of a tarball, possibly caching it on disk.
  *
@@ -18,7 +19,6 @@ let packageCacheEnabled = ((_a = process.env.JSII_RUNTIME_PACKAGE_CACHE) === nul
  * @returns the result of the extraction.
  */
 function extract(file, outDir, options, ...comments) {
-    (0, fs_1.mkdirSync)(outDir, { recursive: true });
     try {
         return (packageCacheEnabled ? extractViaCache : extractToOutDir)(file, outDir, options, ...comments);
     }
@@ -61,6 +61,8 @@ function extractViaCache(file, outDir, options = {}, ...comments) {
     return { cache };
 }
 function extractToOutDir(file, cwd, options = {}) {
+    // The output directory must already exist...
+    (0, fs_1.mkdirSync)(cwd, { recursive: true });
     // !!!IMPORTANT!!!
     // Extract directly into the final target directory, as certain antivirus
     // software configurations on Windows will make a `renameSync` operation

package/package.json

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