jsii-pacmak 1.120.0 → 1.121.0

package/lib/targets/java.js

@@ -1795,7 +1795,7 @@ class JavaGenerator extends generator_1.Generator {
         }
         this.code.line();
         this.code.line('@Override');
-        this.code.openBlock('public final boolean equals(final Object o)');
+        this.code.openBlock('public final boolean equals(final java.lang.Object o)');
         this.code.line('if (this == o) return true;');
         // This was already checked by `super.equals(o)`, so we skip it here...
         this.code.line('if (o == null || getClass() != o.getClass()) return false;');

package/lib/targets/python/type-name.d.ts

@@ -1,10 +1,21 @@
 import { Assembly, OptionalValue, TypeReference, Type } from '@jsii/spec';
 import { CodeMaker } from 'codemaker';
+/**
+ * The position of a type
+ *
+ * Types are rendered differently depending on what position they're in:
+ *
+ * - `type`: a type annotation; these are not evaluated during execution.
+ * - `value`: a value in a function body; these are evaluated when the function is called.
+ * - `decl`: a value in a class declaration; these are evaluated when a class is being
+ *   instantiated, before it's done.
+ */
+export type TypePosition = 'type' | 'value' | 'decl';
 /**
  * Actually more of a TypeNameFactory than a TypeName
  */
 export interface TypeName {
-    pythonType(context: NamingContext): string;
+    pythonType(pos: TypePosition, context: NamingContext): string;
     requiredImports(context: NamingContext): PythonImports;
 }
 export interface PythonImports {
@@ -27,12 +38,6 @@ export interface NamingContext {
     readonly submodule: string;
     /** Holds the set of intersection types used in the current module */
     readonly intersectionTypes: IntersectionTypesRegistry;
-    /**
-     * The declaration is made in the context of a type annotation (so it can be quoted)
-     *
-     * @default true
-     */
-    readonly typeAnnotation?: boolean;
     /**
      * A an array representing the stack of declarations currently being
      * initialized. All of these names can only be referred to using a forward
@@ -40,6 +45,8 @@ export interface NamingContext {
      * they can be used safely from implementations so long as those are not *run*
      * as part of the declaration).
      *
+     * Closest to the current type is at the end.
+     *
      * @default []
      */
     readonly surroundingTypeFqns?: readonly string[];
@@ -49,12 +56,6 @@ export interface NamingContext {
      * @internal
      */
     readonly ignoreOptional?: boolean;
-    /**
-     * The set of jsii type FQNs that have already been emitted so far. This is
-     * used to determine whether a given type reference is a forward declaration
-     * or not when emitting type signatures.
-     */
-    readonly emittedTypes: Set<string>;
     /**
      * Whether the type is emitted for a parameter or not. This may change the
      * exact type signature being emitted (e.g: Arrays are typing.Sequence[T] for

package/lib/targets/python/type-name.js

@@ -87,8 +87,8 @@ class Dict {
         _Dict_element.set(this, void 0);
         __classPrivateFieldSet(this, _Dict_element, element, "f");
     }
-    pythonType(context) {
-        return `typing.Mapping[builtins.str, ${__classPrivateFieldGet(this, _Dict_element, "f").pythonType(context)}]`;
+    pythonType(pos, context) {
+        return `typing.Mapping[builtins.str, ${__classPrivateFieldGet(this, _Dict_element, "f").pythonType(pos, context)}]`;
     }
     requiredImports(context) {
         return __classPrivateFieldGet(this, _Dict_element, "f").requiredImports(context);
@@ -101,9 +101,9 @@ class List {
         _List_element.set(this, void 0);
         __classPrivateFieldSet(this, _List_element, element, "f");
     }
-    pythonType(context) {
+    pythonType(pos, context) {
         const type = context.parameterType ? 'Sequence' : 'List';
-        return `typing.${type}[${__classPrivateFieldGet(this, _List_element, "f").pythonType(context)}]`;
+        return `typing.${type}[${__classPrivateFieldGet(this, _List_element, "f").pythonType(pos, context)}]`;
     }
     requiredImports(context) {
         return __classPrivateFieldGet(this, _List_element, "f").requiredImports(context);
@@ -116,8 +116,8 @@ class Optional {
         _Optional_wrapped.set(this, void 0);
         __classPrivateFieldSet(this, _Optional_wrapped, wrapped, "f");
     }
-    pythonType(context) {
-        const optionalType = __classPrivateFieldGet(this, _Optional_wrapped, "f").pythonType({
+    pythonType(pos, context) {
+        const optionalType = __classPrivateFieldGet(this, _Optional_wrapped, "f").pythonType(pos, {
             ...context,
             ignoreOptional: true,
         });
@@ -176,9 +176,9 @@ class Union {
         _Union_options.set(this, void 0);
         __classPrivateFieldSet(this, _Union_options, options, "f");
     }
-    pythonType(context) {
+    pythonType(pos, context) {
         return `typing.Union[${__classPrivateFieldGet(this, _Union_options, "f")
-            .map((o) => o.pythonType(context))
+            .map((o) => o.pythonType(pos, context))
             .join(', ')}]`;
     }
     requiredImports(context) {
@@ -192,9 +192,9 @@ class Intersection {
         _Intersection_types.set(this, void 0);
         __classPrivateFieldSet(this, _Intersection_types, types, "f");
     }
-    pythonType(context) {
+    pythonType(pos, context) {
         // We will be generating a special type to represent the intersection
-        const name = context.intersectionTypes.obtain(__classPrivateFieldGet(this, _Intersection_types, "f").map((t) => t.pythonType(context)).map(stripQuotes));
+        const name = context.intersectionTypes.obtain(__classPrivateFieldGet(this, _Intersection_types, "f").map((t) => t.pythonType(pos, context)).map(stripQuotes));
         // This will never be in scope already, so always render between quotes
         return `'${name}'`;
     }
@@ -209,24 +209,32 @@ class UserType {
         _UserType_fqn.set(this, void 0);
         __classPrivateFieldSet(this, _UserType_fqn, fqn, "f");
     }
-    pythonType(context) {
-        return this.resolve(context).pythonType;
+    pythonType(pos, context) {
+        return this.resolve(pos, context).pythonType;
     }
     requiredImports(context) {
-        const requiredImport = this.resolve(context).requiredImport;
+        const requiredImport = this.resolve('value', context).requiredImport;
         if (requiredImport == null) {
             return {};
         }
         return { [requiredImport.sourcePackage]: new Set([requiredImport.item]) };
     }
-    resolve({ assembly, emittedTypes, submodule, surroundingTypeFqns, typeAnnotation = true, parameterType, typeResolver, }) {
+    resolve(pos, { assembly, submodule, surroundingTypeFqns, parameterType, typeResolver, }) {
         const { assemblyName, packageName, pythonFqn } = toPythonFqn(__classPrivateFieldGet(this, _UserType_fqn, "f"), assembly);
-        // If this is a type annotation for a parameter, allow dicts to be passed where structs are expected.
+        // If this is a type annotation for a parameter, allow dicts to be passed
+        // where structs are expected for backwards compatibility with the very
+        // first versions of jsii (dicts need to be in jsii-casing).
         const type = typeResolver(__classPrivateFieldGet(this, _UserType_fqn, "f"));
         const isStruct = (0, spec_1.isInterfaceType)(type) && !!type.datatype;
-        const wrapType = typeAnnotation && parameterType && isStruct
-            ? (pyType) => `typing.Union[${pyType}, typing.Dict[builtins.str, typing.Any]]`
-            : (pyType) => pyType;
+        // Make a function that quotes the string based on whether we're using it as a type annotation or not.
+        // It's never wrong to quote type annotations, and it never fails and evaluates faster because it avoids
+        // object lookups at eval time.
+        const maybeQuote = (x) => (pos === 'type' ? `"${x}"` : x);
+        const wrapType = pos === 'type' && parameterType && isStruct
+            ? (pyType) => `typing.Union[${maybeQuote(pyType)}, typing.Dict[builtins.str, typing.Any]]`
+            : maybeQuote;
+        /////////////////////////////////
+        // Type from other assembly
         // Emit aliased imports for dependencies (this avoids name collisions)
         if (assemblyName !== assembly.name) {
             const aliasSuffix = (0, crypto_1.createHash)('sha256')
@@ -247,50 +255,69 @@ class UserType {
         }
         const submodulePythonName = toPythonFqn(submodule, assembly).pythonFqn;
         const typeSubmodulePythonName = toPythonFqn(findParentSubmodule(type, assembly), assembly).pythonFqn;
-        if (typeSubmodulePythonName === submodulePythonName) {
-            // Identify declarations that are not yet initialized and hence cannot be
-            // used as part of a type qualification. Since this is not a forward
-            // reference, the type was already emitted and its un-qualified name must
-            // be used instead of its locally qualified name.
+        //////////////////////////////////////////////
+        // Type from same assembly, other submodule
+        if (typeSubmodulePythonName !== submodulePythonName) {
+            const [toImport, ...nested] = pythonFqn
+                .substring(typeSubmodulePythonName.length + 1)
+                .split('.');
+            const aliasSuffix = (0, crypto_1.createHash)('sha256')
+                .update(typeSubmodulePythonName)
+                .update('.')
+                .update(toImport)
+                .digest('hex')
+                .substring(0, 8);
+            const alias = `_${toImport}_${aliasSuffix}`;
+            return {
+                pythonType: wrapType([alias, ...nested].join('.')),
+                requiredImport: {
+                    sourcePackage: relativeImportPath(submodulePythonName, typeSubmodulePythonName),
+                    item: `${toImport} as ${alias}`,
+                },
+            };
+            // Have the 'else' here to minimize the diff.
+            // eslint-disable-next-line no-else-return
+        }
+        else {
+            //////////////////////////////////////////////
+            // Type from same submodule
+            //
+            // Considerations:
+            // - We could be in the same nested class or in a different nested class here.
+            // - We could also be trying to reference types that will be below
+            //   ourselves in the source code order, which we will need to render as
+            //   type reference strings.
             const nestingParent = surroundingTypeFqns
                 ?.map((fqn) => toPythonFqn(fqn, assembly).pythonFqn)
                 ?.reverse()
                 ?.find((parent) => pythonFqn.startsWith(`${parent}.`));
-            if (typeAnnotation &&
-                (!emittedTypes.has(__classPrivateFieldGet(this, _UserType_fqn, "f")) || nestingParent != null)) {
-                // Possibly a forward reference, outputting the stringifierd python FQN
+            if (nestingParent && pos === 'decl') {
+                // In normal function bodies etc. we must use the fully-qualified name,
+                // but while executing the class declarations we must use the shorter name
+                // of the local variable we're defining.
+                //
+                // An example is most clear:
+                //
+                // ```py
+                // class A:
+                //     class B: pass
+                //     class C(B):                         # <-- note
+                //        def some_method(self, b: "A.B"): # <-- note
+                //           return A.B()                  # <-- note
+                // ```
+                //
+                // The FQN is separated by `.` and we would
+                // also use `.` to access subtypes in Python and have the same names, so we
+                // can just use a substring.
                 return {
-                    pythonType: wrapType(JSON.stringify(pythonFqn.substring(submodulePythonName.length + 1))),
+                    pythonType: wrapType(pythonFqn.slice(nestingParent.length + 1)),
                 };
             }
-            if (!typeAnnotation && nestingParent) {
-                // This is not for a type annotation, so we should be at a point in time
-                // where the surrounding symbol has been defined entirely, so we can
-                // refer to it "normally" now.
-                return { pythonType: pythonFqn.slice(packageName.length + 1) };
-            }
             // We'll just make a module-qualified reference at this point.
             return {
                 pythonType: wrapType(pythonFqn.substring(submodulePythonName.length + 1)),
             };
         }
-        const [toImport, ...nested] = pythonFqn
-            .substring(typeSubmodulePythonName.length + 1)
-            .split('.');
-        const aliasSuffix = (0, crypto_1.createHash)('sha256')
-            .update(typeSubmodulePythonName)
-            .update('.')
-            .update(toImport)
-            .digest('hex')
-            .substring(0, 8);
-        const alias = `_${toImport}_${aliasSuffix}`;
-        return {
-            pythonType: wrapType([alias, ...nested].join('.')),
-            requiredImport: {
-                sourcePackage: relativeImportPath(submodulePythonName, typeSubmodulePythonName),
-                item: `${toImport} as ${alias}`,
-            },
-        };
     }
 }
 _UserType_fqn = new WeakMap();

package/lib/targets/python.js

@@ -341,9 +341,6 @@ class BasePythonClassType {
             code.line('pass');
         }
         code.closeBlock();
-        if (this.fqn != null) {
-            context.emittedTypes.add(this.fqn);
-        }
     }
     /**
      * Sort the this.bases array for proper Python MRO.
@@ -469,7 +466,9 @@ class BaseMethod {
     }
     emit(code, context, opts) {
         const { renderAbstract = true, forceEmitBody = false } = opts ?? {};
-        const returnType = (0, type_name_1.toTypeName)(this.returns).pythonType(context);
+        const returnType = (0, type_name_1.toTypeName)(this.returns).pythonType('type', {
+            ...context,
+        });
         // We cannot (currently?) blindly use the names given to us by the JSII for
         // initializers, because our keyword lifting will allow two names to clash.
         // This can hopefully be removed once we get https://github.com/aws/jsii/issues/288
@@ -492,7 +491,7 @@ class BaseMethod {
             // This can hopefully be removed once we get https://github.com/aws/jsii/issues/288
             // resolved.
             const paramName = toPythonParameterName(param.name, liftedPropNames);
-            const paramType = typeFac.pythonType({
+            const paramType = typeFac.pythonType('type', {
                 ...context,
                 parameterType: true,
             });
@@ -525,10 +524,9 @@ class BaseMethod {
                 // Iterate over all of our props, and reflect them into our params.
                 for (const prop of liftedProperties) {
                     const paramName = toPythonParameterName(prop.prop.name);
-                    const paramType = (0, type_name_1.toTypeName)(prop.prop).pythonType({
+                    const paramType = (0, type_name_1.toTypeName)(prop.prop).pythonType('type', {
                         ...context,
                         parameterType: true,
-                        typeAnnotation: true,
                     });
                     const paramDefault = prop.prop.optional ? ' = None' : '';
                     pythonParams.push(`${paramName}: ${paramType}${paramDefault}`);
@@ -549,7 +547,7 @@ class BaseMethod {
             pythonParams.pop();
             const lastParameter = this.parameters.slice(-1)[0];
             const paramName = toPythonParameterName(lastParameter.name);
-            const paramType = (0, type_name_1.toTypeName)(lastParameter.type).pythonType(context);
+            const paramType = (0, type_name_1.toTypeName)(lastParameter.type).pythonType('type', context);
             pythonParams.push(`*${paramName}: ${paramType}`);
         }
         const decorators = new Array();
@@ -595,10 +593,7 @@ class BaseMethod {
     emitAutoProps(code, context, liftedPropNames) {
         const lastParameter = this.parameters.slice(-1)[0];
         const argName = toPythonParameterName(lastParameter.name, liftedPropNames);
-        const typeName = (0, type_name_1.toTypeName)(lastParameter.type).pythonType({
-            ...context,
-            typeAnnotation: false,
-        });
+        const typeName = (0, type_name_1.toTypeName)(lastParameter.type).pythonType('value', context);
         // We need to build up a list of properties, which are mandatory, these are the
         // ones we will specify to start with in our dictionary literal.
         const liftedProps = this.getLiftedProperties(context.resolver).map((p) => new StructField(this.generator, p.prop, p.definingType));
@@ -616,10 +611,7 @@ class BaseMethod {
                 throw new Error('Parent not known.');
             }
             if (this.isStatic) {
-                jsiiMethodParams.push((0, type_name_1.toTypeName)(this.parent).pythonType({
-                    ...context,
-                    typeAnnotation: false,
-                }));
+                jsiiMethodParams.push((0, type_name_1.toTypeName)(this.parent).pythonType('value', context));
             }
             else {
                 // Using the dynamic class of `self`.
@@ -698,7 +690,7 @@ class BaseProperty {
     }
     emit(code, context, opts) {
         const { renderAbstract = true, forceEmitBody = false } = opts ?? {};
-        const pythonType = (0, type_name_1.toTypeName)(this.type).pythonType(context);
+        const pythonType = (0, type_name_1.toTypeName)(this.type).pythonType('type', context);
         code.line(`@${this.decorator}`);
         code.line(`@jsii.member(jsii_name="${this.jsName}")`);
         if (renderAbstract && this.abstract) {
@@ -758,10 +750,7 @@ class Interface extends BasePythonClassType {
         // Then, we have to emit a Proxy class which implements our proxy interface.
         const proxyBases = this.bases.map((b) => 
         // "# type: ignore[misc]" because MyPy cannot check dynamic base classes (naturally)
-        `jsii.proxy_for(${(0, type_name_1.toTypeName)(b).pythonType({
-            ...context,
-            typeAnnotation: false,
-        })}) # type: ignore[misc]`);
+        `jsii.proxy_for(${(0, type_name_1.toTypeName)(b).pythonType('value', context)}) # type: ignore[misc]`);
         openSignature(code, 'class', this.proxyClassName, proxyBases);
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
             documentableItem: `class-${this.pythonName}`,
@@ -783,12 +772,9 @@ class Interface extends BasePythonClassType {
         code.line();
         code.line('# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface');
         code.line(`typing.cast(typing.Any, ${this.pythonName}).__jsii_proxy_class__ = lambda : ${this.proxyClassName}`);
-        if (this.fqn != null) {
-            context.emittedTypes.add(this.fqn);
-        }
     }
     getClassParams(context) {
-        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
         params.push('typing_extensions.Protocol');
         return params;
     }
@@ -842,15 +828,12 @@ class Struct extends BasePythonClassType {
         }
         this.emitMagicMethods(code);
         code.closeBlock();
-        if (this.fqn != null) {
-            context.emittedTypes.add(this.fqn);
-        }
     }
     requiredImports(context) {
         return (0, type_name_1.mergePythonImports)(super.requiredImports(context), ...this.allMembers.map((mem) => mem.requiredImports(context)));
     }
     getClassParams(context) {
-        return this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+        return this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
     }
     /**
      * Find all fields (inherited as well)
@@ -876,10 +859,7 @@ class Struct extends BasePythonClassType {
         // Re-type struct arguments that were passed as "dict". Do this before validating argument types...
         for (const member of members.filter((m) => m.isStruct(this.generator))) {
             // Note that "None" is NOT an instance of dict (that's convenient!)
-            const typeName = (0, type_name_1.toTypeName)(member.type.type).pythonType({
-                ...context,
-                typeAnnotation: false,
-            });
+            const typeName = (0, type_name_1.toTypeName)(member.type.type).pythonType('value', context);
             code.openBlock(`if isinstance(${member.pythonName}, dict)`);
             code.line(`${member.pythonName} = ${typeName}(**${member.pythonName})`);
             code.closeBlock();
@@ -987,7 +967,7 @@ class StructField {
      * Return the Python type annotation for this type
      */
     typeAnnotation(context) {
-        return (0, type_name_1.toTypeName)(this.type).pythonType(context);
+        return (0, type_name_1.toTypeName)(this.type).pythonType('type', context);
     }
     emitDocString(code) {
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
@@ -1042,7 +1022,7 @@ class Class extends BasePythonClassType {
     emit(code, context) {
         // First we emit our implments decorator
         if (this.interfaces.length > 0) {
-            const interfaces = this.interfaces.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+            const interfaces = this.interfaces.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
             code.line(`@jsii.implements(${interfaces.join(', ')})`);
         }
         // Then we do our normal class logic for emitting our members.
@@ -1055,10 +1035,7 @@ class Class extends BasePythonClassType {
             const proxyBases = [this.pythonName];
             for (const base of this.abstractBases) {
                 // "# type: ignore[misc]" because MyPy cannot check dynamic base classes (naturally)
-                proxyBases.push(`jsii.proxy_for(${(0, type_name_1.toTypeName)(base).pythonType({
-                    ...context,
-                    typeAnnotation: false,
-                })}) # type: ignore[misc]`);
+                proxyBases.push(`jsii.proxy_for(${(0, type_name_1.toTypeName)(base).pythonType('value', context)}) # type: ignore[misc]`);
             }
             code.line();
             code.line();
@@ -1090,7 +1067,7 @@ class Class extends BasePythonClassType {
         }
     }
     getClassParams(context) {
-        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
         const metaclass = this.abstract ? 'JSIIAbstractClass' : 'JSIIMeta';
         params.push(`metaclass=jsii.${metaclass}`);
         params.push(`jsii_type="${this.fqn}"`);
@@ -1948,7 +1925,6 @@ class PythonGenerator extends generator_1.Generator {
         const resolver = new TypeResolver(this.types, assm, (fqn) => this.findModule(fqn), (fqn) => this.findType(fqn));
         this.package.write(this.code, {
             assembly: assm,
-            emittedTypes: new Set(),
             resolver,
             runtimeTypeChecking: this.runtimeTypeChecking,
             submodule: assm.name,

package/lib/version.d.ts

@@ -1,5 +1,5 @@
 /** The short version number for this jsii-pacmak release (e.g: `X.Y.Z`) */
 export declare const VERSION: string;
 /** The qualified version number for this jsii-pacmak release (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.120.0 (build 192dc88)";
+export declare const VERSION_DESC = "1.121.0 (build d7af9b9)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,10 +1,10 @@
 "use strict";
-// Generated at 2025-11-24T11:51:54Z by generate.sh
+// Generated at 2025-12-09T17:15:28Z by generate.sh
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION_DESC = exports.VERSION = void 0;
 /** The short version number for this jsii-pacmak release (e.g: `X.Y.Z`) */
 // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-exports.VERSION = '1.120.0';
+exports.VERSION = '1.121.0';
 /** The qualified version number for this jsii-pacmak release (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.120.0 (build 192dc88)';
+exports.VERSION_DESC = '1.121.0 (build d7af9b9)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.120.0",
+  "version": "1.121.0",
   "description": "A code generation framework for jsii backend languages",
   "license": "Apache-2.0",
   "author": {
@@ -37,24 +37,24 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.120.0",
-    "@jsii/spec": "1.120.0",
+    "@jsii/check-node": "1.121.0",
+    "@jsii/spec": "1.121.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.120.0",
+    "codemaker": "^1.121.0",
     "commonmark": "^0.31.2",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.120.0",
+    "jsii-reflect": "^1.121.0",
     "semver": "^7.7.2",
     "spdx-license-list": "^6.10.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.120.0",
-    "@jsii/go-runtime": "^1.120.0",
-    "@jsii/java-runtime": "^1.120.0",
-    "@scope/jsii-calc-lib": "^1.120.0",
+    "@jsii/dotnet-runtime": "^1.121.0",
+    "@jsii/go-runtime": "^1.121.0",
+    "@jsii/java-runtime": "^1.121.0",
+    "@scope/jsii-calc-lib": "^1.121.0",
     "@types/clone": "^2.1.4",
     "@types/commonmark": "^0.27.10",
     "@types/diff": "^5.2.3",
@@ -63,7 +63,7 @@
     "@types/yargs": "^17.0.33",
     "diff": "^5.2.0",
     "jsii": "^5.9.10",
-    "jsii-build-tools": "^1.120.0",
+    "jsii-build-tools": "^1.121.0",
     "jsii-calc": "^3.20.120",
     "jsii-rosetta": "~5.9.10",
     "pyright": "^1.1.403"