chore(release): 1.126.0 (#5029)

See [CHANGELOG](https://github.com/aws/jsii/blob/bump/1.126.0/CHANGELOG.md)

Author: mergify[bot]

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.126.0](https://github.com/aws/jsii/compare/v1.125.0...v1.126.0) (2026-01-26)
+
+
+### Features
+
+* **spec:** export list of all jsii features ([#5021](https://github.com/aws/jsii/issues/5021)) ([20111a6](https://github.com/aws/jsii/commit/20111a698aee4de7db21f23f7e2fde686ee149f1))
+
+
+### Bug Fixes
+
+* **jsii-pacmak:** toString() on anonymous classes does not call JavaScript implementation ([#5027](https://github.com/aws/jsii/issues/5027)) ([d6a243b](https://github.com/aws/jsii/commit/d6a243b2cd8369e7cd1347594e2cd73734527e81))
+
 ## [1.125.0](https://github.com/aws/jsii/compare/v1.124.0...v1.125.0) (2026-01-05)
 
 

lerna.json

@@ -12,6 +12,6 @@
       "rejectCycles": true
     }
   },
-  "version": "1.125.0",
+  "version": "1.126.0",
   "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }

packages/@jsii/java-runtime-test/project/src/test/java/software/amazon/jsii/testing/TypeCheckingTest.java

@@ -135,4 +135,25 @@ public void staticMethod()
         });
         assertEquals("Expected struct to be one of: software.amazon.jsii.tests.calculator.StructA, software.amazon.jsii.tests.calculator.StructB; received class java.lang.String", e.getMessage());
     }
+
+    @Test
+    public void canStringifyPublicClassViaInterface() {
+        IStringable s = Stringable.makePublicStringable();
+        assertEquals(s.toString(), s.nativeToString());
+        assertEquals(s.describe(), s.toString());
+    }
+
+    @Test
+    public void canStringifyPrivateClassViaInterface() {
+        IStringable s = Stringable.makePrivateStringable();
+        assertEquals(s.toString(), s.nativeToString());
+        assertEquals(s.describe(), s.toString());
+    }
+
+    @Test
+    public void canStringifyAnonymousClassViaInterface() {
+        IStringable s = Stringable.makeAnonymousStringable();
+        assertEquals(s.toString(), s.nativeToString());
+        assertEquals(s.describe(), s.toString());
+    }
 }

packages/@jsii/kernel/src/kernel.ts

@@ -984,12 +984,60 @@ export class Kernel {
     // if we didn't find the method on the prototype, it could be a literal object
     // that implements an interface, so we look if we have the method on the object
     // itself. if we do, we invoke it.
-    let fn = instance.constructor.prototype[methodName];
+    //
+    //--------------------------------------------------------------
+    //
+    // huijbers@ (2026) -- I'm pretty sure the above logic is wrong. It reads like
+    // looking up methods from the prototype is intended to prevent cyclic calls
+    // when subclassing JS classes from a jsii language. We don't want:
+    //
+    // ```java
+    // class MyClass extends JavaScriptClass {
+    //   public void myMethod() {
+    //     super.myMethod();  <-- should call myMethod on base class
+    //   }
+    // }
+    // ```
+    //
+    // To call the same `myMethod` again and infinitely recurse, which a naive `invoke(this, 'myMethod')`
+    // would do. In order to work around this we seem to be default-ignoring functions
+    // that live directly on an object, *unless* we otherwise can't find it on the class.
+    //
+    // But `#findInvokeTarget()` is used for *all* invokes, and this now finds the wrong
+    // method in situations where both a class and the instance have a method, for whatever
+    // reason; maybe the JS object got patched or something.
+    //
+    // At least one case where I ran into this is when calling `toString()` on an anonymous
+    // object. Because 'Object.prototype' already has an implementation for `toString`, we
+    // never call the one on the anonymous object but always the built-in one which returns
+    // "[object Object]".
+    //
+    // I'm tempted to reverse the logic: look up the method on the instance, *unless* we
+    // have reasons to think the object we're looking at is a proxy for a jsii-client object
+    // in which case we look up on the parent. But even that is wrong because it would also
+    // do the wrong thing in this case:
+    //
+    // ```java
+    // class MyClass extends JavaScriptClass {
+    //   @Override public void myMethod1() {
+    //     this.myMethod2();  <-- should call myMethod2 below, not from parent
+    //   }
+    //   @Override public void myMethod2() {
+    //   }
+    // }
+    // ```
+    //
+    // Pretty sure this is wrong and needs attention, but for now I'll just make an exception
+    // for the one case I need to get working: `toString`.
+    let fn: any;
+    // Prototype first, but only if the method is not 'toString'
+    if (methodName !== 'toString') {
+      fn = instance.constructor.prototype[methodName];
+    }
+    // Then instance
+    fn ??= instance[methodName];
     if (!fn) {
-      fn = instance[methodName];
-      if (!fn) {
-        throw new JsiiFault(`Cannot find ${methodName} on object`);
-      }
+      throw new JsiiFault(`Cannot find ${methodName} on object`);
     }
     return { ti, obj: instance, fn };
   }

packages/@jsii/spec/src/assembly.ts

@@ -1090,9 +1090,17 @@ export function describeTypeReference(type?: TypeReference): string {
 }
 
 /**
- * Predefined constants for a set of jsii extension features
+ * A list of all jsii extension features
  */
-export type JsiiFeature = 'intersection-types' | 'class-covariant-overrides';
+export const ALL_SPEC_FEATURES = [
+  'intersection-types',
+  'class-covariant-overrides',
+] as const;
+
+/**
+ * Predefined type constants of available jsii extension features
+ */
+export type JsiiFeature = (typeof ALL_SPEC_FEATURES)[number];
 
 /**
  * Determines whether an entity is deprecated.

packages/jsii-calc/lib/compliance.ts

@@ -3173,3 +3173,67 @@ export class AnyPropertyAccess {
 
   private constructor() {}
 }
+
+export interface IStringable {
+  describe(): string;
+
+  // Calling toString from JS should produce the same value as calling toString from Java/C#/Python/...
+  nativeToString(): string;
+
+  toString(): string;
+}
+
+export class Stringable implements IStringable {
+  private readonly stringValue = 'string value produced in JS';
+
+  public static makePublicStringable(): IStringable {
+    return new Stringable();
+  }
+
+  public static makePrivateStringable(): IStringable {
+    return new PrivateStringable();
+  }
+
+  public static makeAnonymousStringable(): IStringable {
+    const stringValue = 'string value produced in JS';
+    return {
+      describe() {
+        return stringValue;
+      },
+      toString() {
+        return stringValue;
+      },
+      nativeToString() {
+        return this.toString();
+      },
+    };
+  }
+
+  public describe(): string {
+    return this.stringValue;
+  }
+
+  public toString(): string {
+    return this.stringValue;
+  }
+
+  public nativeToString(): string {
+    return this.toString();
+  }
+}
+
+class PrivateStringable implements IStringable {
+  private readonly stringValue = 'string value produced in JS';
+
+  public describe(): string {
+    return this.stringValue;
+  }
+
+  public toString(): string {
+    return this.stringValue;
+  }
+
+  public nativeToString(): string {
+    return this.toString();
+  }
+}