@jsii/kernel 1.61.0 → 1.62.0

package/lib/serialization.js

@@ -27,11 +27,14 @@
  *  - /R(t) recurse with declared type t
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializationType = exports.SERIALIZERS = exports.SYMBOL_WIRE_TYPE = exports.EMPTY_OBJECT_FQN = void 0;
+exports.SerializationError = exports.process = exports.serializationType = exports.SERIALIZERS = exports.SYMBOL_WIRE_TYPE = exports.EMPTY_OBJECT_FQN = void 0;
 const spec = require("@jsii/spec");
+const assert = require("assert");
+const util_1 = require("util");
 const api_1 = require("./api");
 const objects_1 = require("./objects");
 const _1 = require(".");
+const VOID = 'void';
 /**
  * A special FQN that can be used to create empty javascript objects.
  */
@@ -59,11 +62,9 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (!isDate(value)) {
-                throw new Error(`Expected Date, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not an instance of Date`, value);
             }
             return serializeDate(value);
         },
@@ -72,7 +73,7 @@ exports.SERIALIZERS = {
                 return undefined;
             }
             if (!(0, api_1.isWireDate)(value)) {
-                throw new Error(`Expected Date, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value does not have the "${api_1.TOKEN_DATE}" key`, value);
             }
             return deserializeDate(value);
         },
@@ -83,15 +84,13 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const primitiveType = optionalValue.type;
             if (!isScalar(value)) {
-                throw new Error(`Expected ${spec.describeTypeReference(optionalValue.type)}, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
             }
             if (typeof value !== primitiveType.primitive) {
-                throw new Error(`Expected a ${spec.describeTypeReference(optionalValue.type)}, got ${JSON.stringify(value)} (${typeof value})`);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
             }
             return value;
         },
@@ -99,22 +98,24 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const primitiveType = optionalValue.type;
             if (!isScalar(value)) {
-                throw new Error(`Expected a ${spec.describeTypeReference(optionalValue.type)}, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
             }
             if (typeof value !== primitiveType.primitive) {
-                throw new Error(`Expected a ${spec.describeTypeReference(optionalValue.type)}, got ${JSON.stringify(value)} (${typeof value})`);
+                throw new SerializationError(`Value is not a ${spec.describeTypeReference(optionalValue.type)}`, value);
             }
             return value;
         },
     },
     // ----------------------------------------------------------------------
     ["Json" /* SerializationClass.Json */]: {
-        serialize(value) {
+        serialize(value, optionalValue) {
+            // /!\ 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)) {
+                return undefined;
+            }
             // Just whatever. Dates will automatically serialize themselves to strings.
             return value;
         },
@@ -145,13 +146,13 @@ exports.SERIALIZERS = {
                 return value.map(mapJsonValue);
             }
             return mapValues(value, mapJsonValue);
-            function mapJsonValue(toMap) {
+            function mapJsonValue(toMap, key) {
                 if (toMap == null) {
                     return toMap;
                 }
-                return host.recurse(toMap, {
+                return process(host, 'deserialize', toMap, {
                     type: { primitive: spec.PrimitiveType.Json },
-                });
+                }, typeof key === 'string' ? `key ${(0, util_1.inspect)(key)}` : `index ${key}`);
             }
         },
     },
@@ -161,18 +162,16 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (typeof value !== 'string' && typeof value !== 'number') {
-                throw new Error(`Expected enum value, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not a string or number`, value);
             }
             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 Error(`No entry in ${enumType.fqn} has value ${value}`);
+                throw new SerializationError(`Value is not present in enum ${spec.describeTypeReference(enumType)}`, value);
             }
             return { [api_1.TOKEN_ENUM]: `${enumType.fqn}/${enumEntry[0]}` };
         },
@@ -181,7 +180,7 @@ exports.SERIALIZERS = {
                 return undefined;
             }
             if (!(0, api_1.isWireEnum)(value)) {
-                throw new Error(`Expected enum value, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value does not have the "${api_1.TOKEN_ENUM}" key`, value);
             }
             return deserializeEnum(value, host.findSymbol);
         },
@@ -192,27 +191,23 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (!Array.isArray(value)) {
-                throw new Error(`Expected array type, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not an array`, value);
             }
             const arrayType = optionalValue.type;
-            return value.map((x) => host.recurse(x, { type: arrayType.collection.elementtype }));
+            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)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (!Array.isArray(value)) {
-                throw new Error(`Expected array type, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not an array`, value);
             }
             const arrayType = optionalValue.type;
-            return value.map((x) => host.recurse(x, { type: arrayType.collection.elementtype }));
+            return value.map((x, idx) => process(host, 'deserialize', x, { type: arrayType.collection.elementtype }, `index ${(0, util_1.inspect)(idx)}`));
         },
     },
     // ----------------------------------------------------------------------
@@ -221,27 +216,23 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const mapType = optionalValue.type;
             return {
-                [api_1.TOKEN_MAP]: mapValues(value, (v) => host.recurse(v, { type: mapType.collection.elementtype })),
+                [api_1.TOKEN_MAP]: mapValues(value, (v, key) => process(host, 'serialize', v, { type: mapType.collection.elementtype }, `key ${(0, util_1.inspect)(key)}`)),
             };
         },
         deserialize(value, optionalValue, host) {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             const mapType = optionalValue.type;
             if (!(0, api_1.isWireMap)(value)) {
                 // Compatibility mode with older versions that didn't wrap in [TOKEN_MAP]
-                return mapValues(value, (v) => host.recurse(v, { type: mapType.collection.elementtype }));
+                return mapValues(value, (v, key) => process(host, 'deserialize', v, { type: mapType.collection.elementtype }, `key ${(0, util_1.inspect)(key)}`));
             }
-            const result = mapValues(value[api_1.TOKEN_MAP], (v) => host.recurse(v, { type: mapType.collection.elementtype }));
+            const result = mapValues(value[api_1.TOKEN_MAP], (v, key) => process(host, 'deserialize', v, { type: mapType.collection.elementtype }, `key ${(0, util_1.inspect)(key)}`));
             Object.defineProperty(result, exports.SYMBOL_WIRE_TYPE, {
                 configurable: false,
                 enumerable: false,
@@ -257,11 +248,12 @@ exports.SERIALIZERS = {
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
+            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);
             }
-            if (typeof value !== 'object' || value == null) {
-                throw new Error(`Expected object, got ${JSON.stringify(value)}`);
+            if (Array.isArray(value)) {
+                throw new SerializationError(`Value is an array`, value);
             }
             /*
               This is what we'd like to do, but we can't because at least the Java client
@@ -283,23 +275,21 @@ exports.SERIALIZERS = {
             ]);
         },
         deserialize(value, optionalValue, host) {
-            if (typeof value === 'object' && Object.keys(value ?? {}).length === 0) {
+            if (typeof value === 'object' && Object.keys(value !== null && value !== void 0 ? value : {}).length === 0) {
                 // Treat empty structs as `undefined` (see https://github.com/aws/jsii/issues/411)
                 value = undefined;
             }
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            assert(optionalValue !== VOID, 'Encountered unexpected void type!');
             if (typeof value !== 'object' || value == null) {
-                throw new Error(`Expected object reference, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value is not an object`, value);
             }
             const namedType = host.lookupType(optionalValue.type.fqn);
             const props = propertiesOf(namedType, host.lookupType);
             if (Array.isArray(value)) {
-                throw new Error(`Got an array where a ${namedType.fqn} was expected. Did you mean to pass a variable number of arguments?`);
+                throw new SerializationError('Value is an array (varargs may have been incorrectly supplied)', value);
             }
             // 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
@@ -312,7 +302,7 @@ exports.SERIALIZERS = {
             if (_1.api.isWireStruct(value)) {
                 const { fqn, data } = value[_1.api.TOKEN_STRUCT];
                 if (!isAssignable(fqn, namedType, host.lookupType)) {
-                    throw new Error(`Wire struct type '${fqn}' does not match expected '${namedType.fqn}'`);
+                    throw new SerializationError(`Wired struct has type '${fqn}', which does not match expected type`, value);
                 }
                 value = data;
             }
@@ -326,41 +316,40 @@ exports.SERIALIZERS = {
                 if (!props[key]) {
                     return undefined;
                 } // Don't map if unknown property
-                return host.recurse(v, props[key]);
+                return process(host, 'deserialize', v, props[key], `key ${(0, util_1.inspect)(key)}`);
             });
         },
     },
     // ----------------------------------------------------------------------
     ["RefType" /* SerializationClass.ReferenceType */]: {
         serialize(value, optionalValue, host) {
+            var _a;
             if (nullAndOk(value, optionalValue)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
+            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);
             }
-            if (typeof value !== 'object' || value == null) {
-                throw new Error(`Expected object reference, got ${JSON.stringify(value)}`);
+            if (value instanceof Date) {
+                throw new SerializationError(`Value is a Date`, value);
             }
             const expectedType = host.lookupType(optionalValue.type.fqn);
             const interfaces = spec.isInterfaceType(expectedType)
                 ? [expectedType.fqn]
                 : undefined;
-            const jsiiType = (0, objects_1.jsiiTypeFqn)(value) ??
-                (spec.isClassType(expectedType) ? expectedType.fqn : exports.EMPTY_OBJECT_FQN);
+            const jsiiType = (_a = (0, objects_1.jsiiTypeFqn)(value)) !== 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)) {
                 return undefined;
             }
-            if (optionalValue === 'void') {
-                throw new Error('Encountered unexpected `void` type');
-            }
+            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 Error(`Expected object reference, got ${JSON.stringify(value)}`);
+                throw new SerializationError(`Value does not have the "${api_1.TOKEN_REF}" key`, value);
             }
             const { instance, fqn } = host.objects.findObject(value);
             const namedTypeRef = optionalValue.type;
@@ -373,7 +362,7 @@ exports.SERIALIZERS = {
                 const declaredType = optionalValue.type;
                 if (spec.isClassType(namedType) &&
                     !isAssignable(fqn, declaredType, host.lookupType)) {
-                    throw new Error(`Object of type ${fqn} is not convertible to ${declaredType.fqn}`);
+                    throw new SerializationError(`Object of type '${fqn}' is not convertible to ${spec.describeTypeReference(declaredType)}`, value);
                 }
             }
             return instance;
@@ -382,6 +371,7 @@ exports.SERIALIZERS = {
     // ----------------------------------------------------------------------
     ["Any" /* SerializationClass.Any */]: {
         serialize(value, _type, host) {
+            var _a;
             if (value == null) {
                 return undefined;
             }
@@ -392,15 +382,15 @@ exports.SERIALIZERS = {
                 return value;
             }
             if (Array.isArray(value)) {
-                return value.map((e) => host.recurse(e, { type: spec.CANONICAL_ANY }));
+                return value.map((e, idx) => process(host, 'serialize', e, { type: spec.CANONICAL_ANY }, `index ${(0, util_1.inspect)(idx)}`));
             }
             // 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 Error('JSII Kernel is unable to serialize `function`. An instance with methods might have been returned by an `any` method?');
+                throw new SerializationError('Functions cannot be passed across language boundaries', value);
             }
             if (typeof value !== 'object' || value == null) {
-                throw new Error(`JSII kernel assumption violated, ${JSON.stringify(value)} is not an object`);
+                throw new SerializationError(`A jsii kernel assumption was violated: value is not an object`, value);
             }
             if (exports.SYMBOL_WIRE_TYPE in value &&
                 value[exports.SYMBOL_WIRE_TYPE] === api_1.TOKEN_MAP) {
@@ -417,7 +407,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 Error("Can't return objects of type Set or Map");
+                throw new SerializationError('Set and Map instances cannot be sent across the language boundary', value);
             }
             // 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.
@@ -428,8 +418,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 = (0, objects_1.jsiiTypeFqn)(value) ??
-                (isByReferenceOnly(value) ? exports.EMPTY_OBJECT_FQN : undefined);
+            const jsiiType = (_a = (0, objects_1.jsiiTypeFqn)(value)) !== null && _a !== void 0 ? _a : (isByReferenceOnly(value) ? exports.EMPTY_OBJECT_FQN : undefined);
             if (jsiiType) {
                 return host.objects.registerObject(value, jsiiType);
             }
@@ -438,7 +427,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) => host.recurse(v, { type: spec.CANONICAL_ANY }));
+            return mapValues(value, (v, key) => process(host, 'serialize', v, { type: spec.CANONICAL_ANY }, `key ${(0, util_1.inspect)(key)}`));
         },
         deserialize(value, _type, host) {
             if (value == null) {
@@ -454,7 +443,7 @@ exports.SERIALIZERS = {
             }
             if (Array.isArray(value)) {
                 host.debug('ANY is an Array');
-                return value.map((e) => host.recurse(e, { type: spec.CANONICAL_ANY }));
+                return value.map((e, idx) => process(host, 'deserialize', e, { type: spec.CANONICAL_ANY }, `index ${(0, util_1.inspect)(idx)}`));
             }
             if ((0, api_1.isWireEnum)(value)) {
                 host.debug('ANY is an Enum');
@@ -484,7 +473,7 @@ exports.SERIALIZERS = {
             }
             // At this point again, deserialize by-value.
             host.debug('ANY is a Map');
-            return mapValues(value, (v) => host.recurse(v, { type: spec.CANONICAL_ANY }));
+            return mapValues(value, (v, key) => process(host, 'deserialize', v, { type: spec.CANONICAL_ANY }, `key ${(0, util_1.inspect)(key)}`));
         },
     },
 };
@@ -498,13 +487,13 @@ function deserializeEnum(value, lookup) {
     const enumLocator = value[api_1.TOKEN_ENUM];
     const sep = enumLocator.lastIndexOf('/');
     if (sep === -1) {
-        throw new Error(`Malformed enum value: ${JSON.stringify(value)}`);
+        throw new SerializationError(`Invalid enum token value ${(0, util_1.inspect)(enumLocator)}`, value);
     }
     const typeName = enumLocator.slice(0, sep);
     const valueName = enumLocator.slice(sep + 1);
     const enumValue = lookup(typeName)[valueName];
     if (enumValue === undefined) {
-        throw new Error(`No enum member named ${valueName} in ${typeName}`);
+        throw new SerializationError(`No such enum member: ${(0, util_1.inspect)(valueName)}`, value);
     }
     return enumValue;
 }
@@ -514,9 +503,7 @@ function deserializeEnum(value, lookup) {
  * There can be multiple, because the type can be a type union.
  */
 function serializationType(typeRef, lookup) {
-    if (typeRef == null) {
-        throw new Error("Kernel error: expected type information, got 'undefined'");
-    }
+    assert(typeRef != null, `Kernel error: expected type information, got ${(0, util_1.inspect)(typeRef)}`);
     if (typeRef === 'void') {
         return [{ serializationClass: "Void" /* SerializationClass.Void */, typeRef }];
     }
@@ -533,7 +520,7 @@ function serializationType(typeRef, lookup) {
             case spec.PrimitiveType.String:
                 return [{ serializationClass: "Scalar" /* SerializationClass.Scalar */, typeRef }];
         }
-        throw new Error('Unknown primitive type');
+        assert(false, `Unknown primitive type: ${(0, util_1.inspect)(typeRef.type)}`);
     }
     if (spec.isCollectionTypeReference(typeRef.type)) {
         return [
@@ -571,7 +558,7 @@ function nullAndOk(x, type) {
         return false;
     }
     if (type !== 'void' && !type.optional) {
-        throw new Error(`Got 'undefined' for non-optional instance of ${JSON.stringify(type)}`);
+        throw new SerializationError(`A value is required (type is non-optional)`, x);
     }
     return true;
 }
@@ -594,7 +581,10 @@ function flatMap(xs, fn) {
  */
 function mapValues(value, fn) {
     if (typeof value !== 'object' || value == null) {
-        throw new Error(`Expected object type, got ${JSON.stringify(value)}`);
+        throw new SerializationError(`Value is not an object`, value);
+    }
+    if (Array.isArray(value)) {
+        throw new SerializationError(`Value is an array`, value);
     }
     const out = {};
     for (const [k, v] of Object.entries(value)) {
@@ -607,6 +597,7 @@ function mapValues(value, fn) {
     return out;
 }
 function propertiesOf(t, lookup) {
+    var _a;
     if (!spec.isClassOrInterfaceType(t)) {
         return {};
     }
@@ -619,7 +610,7 @@ function propertiesOf(t, lookup) {
     if (spec.isClassType(t) && t.base) {
         ret = { ...ret, ...propertiesOf(lookup(t.base), lookup) };
     }
-    for (const prop of t.properties ?? []) {
+    for (const prop of (_a = t.properties) !== null && _a !== void 0 ? _a : []) {
         ret[prop.name] = prop;
     }
     return ret;
@@ -659,7 +650,9 @@ function validateRequiredProps(actualProps, typeName, specProps) {
         .filter((name) => !specProps[name].optional)
         .filter((name) => !(name in actualProps));
     if (missingRequiredProps.length > 0) {
-        throw new Error(`Missing required properties for ${typeName}: ${missingRequiredProps.join(', ')}`);
+        throw new SerializationError(`Missing required properties for ${typeName}: ${missingRequiredProps
+            .map((p) => (0, util_1.inspect)(p))
+            .join(', ')}`, actualProps);
     }
     return actualProps;
 }
@@ -697,9 +690,9 @@ function isByReferenceOnly(obj) {
     do {
         for (const prop of Object.getOwnPropertyNames(curr)) {
             const descr = Object.getOwnPropertyDescriptor(curr, prop);
-            if (descr?.get != null ||
-                descr?.set != null ||
-                typeof descr?.value === 'function') {
+            if ((descr === null || descr === void 0 ? void 0 : descr.get) != null ||
+                (descr === null || descr === void 0 ? void 0 : descr.set) != null ||
+                typeof (descr === null || descr === void 0 ? void 0 : descr.value) === 'function') {
                 // Property has a dynamic getter, setter or is a constructor/method, so by-ref required!
                 return true;
             }
@@ -708,4 +701,91 @@ function isByReferenceOnly(obj) {
     } while (Object.getPrototypeOf((curr = Object.getPrototypeOf(curr))) != null);
     return false;
 }
+function process(host, serde, value, type, context) {
+    const wireTypes = serializationType(type, host.lookupType);
+    host.debug(serde, value, wireTypes);
+    const errors = new Array();
+    for (const { serializationClass, typeRef } of wireTypes) {
+        try {
+            return exports.SERIALIZERS[serializationClass][serde](value, typeRef, host);
+        }
+        catch (error) {
+            error.context = `as ${typeRef === VOID ? VOID : spec.describeTypeReference(typeRef.type)}`;
+            errors.push(error);
+        }
+    }
+    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 });
+    function titleize(text) {
+        text = text.trim();
+        if (text === '') {
+            return text;
+        }
+        const [first, ...rest] = text;
+        return [first.toUpperCase(), ...rest].join('');
+    }
+}
+exports.process = process;
+class SerializationError extends Error {
+    constructor(message, value, causes = [], { renderValue = false } = {}) {
+        super([
+            message,
+            ...(renderValue
+                ? [
+                    `${causes.length > 0 ? '\u{251C}' : '\u{2570}'}\u{2500}\u{2500} \u{1F6D1} Failing value is ${describeTypeOf(value)}`,
+                    ...(value == null
+                        ? []
+                        : (0, util_1.inspect)(value, false, 0)
+                            .split('\n')
+                            .map((l) => `${causes.length > 0 ? '\u{2502}' : ' '}      ${l}`)),
+                ]
+                : []),
+            ...(causes.length > 0
+                ? [
+                    '\u{2570}\u{2500}\u{2500} \u{1F50D} Failure reason(s):',
+                    ...causes.map((cause, idx) => {
+                        var _a;
+                        return `    ${idx < causes.length - 1 ? '\u{251C}' : '\u{2570}'}\u{2500}${causes.length > 1
+                            ? ` [${(_a = cause.context) !== null && _a !== void 0 ? _a : (0, util_1.inspect)(idx)}]`
+                            : ''} ${cause.message.split('\n').join('\n        ')}`;
+                    }),
+                ]
+                : []),
+        ].join('\n'));
+        this.value = value;
+        this.causes = causes;
+        this.name = '@jsii/kernel.SerializationError';
+    }
+}
+exports.SerializationError = SerializationError;
+function describeTypeOf(value) {
+    const type = typeof value;
+    switch (type) {
+        case 'object':
+            if (value == null) {
+                return JSON.stringify(value);
+            }
+            if (Array.isArray(value)) {
+                return 'an array';
+            }
+            const fqn = (0, objects_1.jsiiTypeFqn)(value);
+            if (fqn != null && fqn !== exports.EMPTY_OBJECT_FQN) {
+                return `an instance of ${fqn}`;
+            }
+            const ctorName = value.constructor.name;
+            if (ctorName != null && ctorName !== Object.name) {
+                return `an instance of ${ctorName}`;
+            }
+            return `an object`;
+        case 'undefined':
+            return type;
+        case 'boolean':
+        case 'function':
+        case 'number':
+        case 'string':
+        default:
+            return `a ${type}`;
+    }
+}
 //# sourceMappingURL=serialization.js.map

package/package.json

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