fix(generate-types): preserve infer inside tuple types in extends clause

generate-types/index.js

@@ -2397,6 +2397,39 @@ const printError = (diagnostic) => {
 						return symbol ? symbol.getName() : getCode(t, typeArgs, state);
 					}
 
+					// Tuples in `extends` position must be rendered element-wise so that
+					// `infer` in an element/rest slot survives (getCode collapses it).
+					const objectFlags =
+						t.flags & ts.TypeFlags.Object
+							? /** @type {ts.ObjectType} */ (t).objectFlags
+							: 0;
+					if (objectFlags & ts.ObjectFlags.Reference) {
+						const target = /** @type {ts.TypeReference} */ (t).target;
+						if (
+							target &&
+							/** @type {ts.ObjectType} */ (target).objectFlags &
+								ts.ObjectFlags.Tuple
+						) {
+							const tupleTarget = /** @type {ts.TupleType} */ (target);
+							const elements = checker.getTypeArguments(
+								/** @type {ts.TypeReference} */ (t),
+							);
+							const parts = elements.map((el, i) => {
+								const flag = tupleTarget.elementFlags[i];
+								const inner = getExtendsString(el);
+								// Rest `...x[]` carries the element type; Variadic `...x`
+								// (incl. `...infer R`) carries the whole spread type.
+								if (flag & ts.ElementFlags.Rest) return `...(${inner})[]`;
+								if (flag & ts.ElementFlags.Variadic) return `...${inner}`;
+								if (flag & ts.ElementFlags.Optional) return `${inner}?`;
+								return inner;
+							});
+							return `${tupleTarget.readonly ? "readonly " : ""}[${parts.join(
+								", ",
+							)}]`;
+						}
+					}
+
 					if (checker.isArrayType(t)) {
 						const elementType = t.typeArguments[0];
 						return "(" + getExtendsString(elementType) + ")[]";