Regression: yup.ObjectSchema<T> no longer assignable to ObjectSchema<any> (20260423.1)

[modosc]

apologies in advance for the claude output - lmk if there's anything else i can provide.

Versions

• Last good: @typescript/native-preview@7.0.0-dev.20260422.1
• First bad: @typescript/native-preview@7.0.0-dev.20260423.1
• Stock tsc 5.x / 6.0 beta: accepts the program

Repro (2 files + 1 dep)

package.json

{
  "name": "tsgo-yup-repro",
  "private": true,
  "dependencies": { "yup": "1.7.1" },
  "devDependencies": { "@typescript/native-preview": "7.0.0-dev.20260423.1" }
}

tsconfig.json

{
  "compilerOptions": {
    "strict": true,
    "noEmit": true,
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "Bundler"
  },
  "include": ["repro.ts"]
}

repro.ts

import * as yup from 'yup';

const schema = yup.object({
  name: yup.string().required(),
});

declare function accepts<T extends yup.ObjectSchema<any>>(s: T): void;

accepts(schema);

Run npx tsgo -p tsconfig.json.

Observed (20260423.1)

repro.ts(9,9): error TS2345: Argument of type 'ObjectSchema<{ name: string; }, AnyObject, { name: undefined; }, "">' is not assignable to parameter of type 'ObjectSchema<any, AnyObject, any, "">'.
  The types returned by 'optional().strip(...).partial().__outputType' are incompatible between these types.
    Type '{ name?: string | undefined; } | undefined' is not assignable to type '{ [x: string]: any; [x: number]: any; [x: symbol]: any; }'.
      Type 'undefined' is not assignable to type '{ [x: string]: any; [x: number]: any; [x: symbol]: any; }'.

Exit code 2.

Expected
Clean exit, same as 20260422.1 and stock tsc.

Real-world impact
Breaks every call of @hookform/resolvers/yup's yupResolver, whose signature is <T extends Yup.ObjectSchema<any>>(schema: T, ...). In our codebase: 103 call sites across 40+ files, zero before the bump.

Analysis
The RHS __outputType in the error message resolves to {[x: string]: any; [x: number]: any; [x: symbol]: any} (yup's AnyObject) rather than any. undefined (from optional()) doesn't fit AnyObject, hence the error.

Likely cause: when instantiating ObjectSchema<any> where the type parameter is TIn extends Maybe<AnyObject> (= AnyObject | null | undefined), 20260423.1 resolves the any argument up to its constraint (AnyObject) somewhere along the optional().strip().partial() method chain, where 20260422.1 kept it as any.

[Andarist]

Self-isolated repro:

type Maybe<T> = T | undefined;
type AnyObject = { [k: string]: any };

interface ISchema<T> {
  __outputType: T;
}

declare class Schema<TType = any> implements ISchema<TType> {
  readonly __outputType: TType;
  optional(): any;
}

interface StringSchema<TType extends string | undefined = string | undefined>
  extends Schema<TType> {
  optional(): StringSchema<TType | undefined>;
}

declare class StringSchema<
  TType extends string | undefined = string | undefined,
> extends Schema<TType> {
  required(): StringSchema<NonNullable<TType>>;
}

declare function string(): StringSchema;

type ObjectShape = { [k: string]: ISchema<any> };

type TypeFromShape<S extends ObjectShape> = {
  [K in keyof S]: S[K]["__outputType"];
};

type Shape<T extends Maybe<AnyObject>> = {
  [K in keyof T]-?: ISchema<T[K]>;
};

interface ObjectSchema<TIn extends Maybe<AnyObject>> extends Schema<TIn> {
  optional(): ObjectSchema<TIn | undefined>;
}

declare class ObjectSchema<TIn extends Maybe<AnyObject>> extends Schema<TIn> {
  fields: Shape<NonNullable<TIn>>;
  partial(): ObjectSchema<Partial<TIn>>;
}

declare function object<S extends ObjectShape>(
  spec?: S,
): ObjectSchema<TypeFromShape<S>>;

const schema = object({
  name: string().required(),
});

declare function accepts<T extends ObjectSchema<any>>(s: T): void;

accepts(schema);

[Andarist]

This changed in #3445 . This PR improved correctness - effectively, the real issue was always masked in your code.

It is a little bit funny because using any here creates the problem because, in some sense, the type becomes less permissive.

The problem is that Partial<{ foo: string } | undefined> distributes, it's { foo?: string } | undefined. But any | undefined becomes just any and then Partial<any> becomes just { [x: string]: any; }. So effectively, the target side here can "lose" the | undefined when Partial<Maybe<any>> gets applied.

The solution here is to use a different constraint in your accepts, it works fine with:

declare function accepts<T extends ObjectSchema<AnyObject>>(s: T): void;

[modosc]

thanks @Andarist - should i close this out and open an issue upstream with yup? nm, i see. closing out.