TypedDict accepts an Enum member as a key and reveals the value type, but KeyErrors at runtime

mypy lets you index a TypedDict with an Enum member, and reveal_type gives the correct value type. But it's a KeyError at runtime. Under the hood mypy substitutes the member's .value for the key, a substitution it refuses to make anywhere else.

To Reproduce

from enum import Enum
from typing import Literal, TypedDict

class Foo(Enum):
    One = "One"

class TD(TypedDict):
    One: int

td: TD = {"One": 1}
d: dict[str, int] = {"One": 1}

reveal_type(td[Foo.One])       # Revealed type is "int"  -- accepted
x: Literal["One"] = Foo.One    # error: incompatible types  -- member is not the literal
d[Foo.One]                     # error: invalid index type  -- not a valid str key

Only the TypedDict line gets through. The other two are rejected, and correctly so: Foo.One is Literal[Foo.One], not Literal["One"], and it isn't a str. So mypy already knows the member isn't its value, everywhere except TypedDict subscription.

At runtime a plain Enum member doesn't compare equal to its value, so the "type-safe" access is the thing that breaks:

>>> td[Foo.One]
KeyError: <Foo.One: 'One'>

Expected Behavior

td[Foo.One] should be an error, the same way d[Foo.One] on a dict[str, int] is. pyright rejects it: "Could not access item in TypedDict."

Actual Behavior

Accepted. reveal_type is int. KeyError when you run it.

One wrinkle worth noting: the only case where the runtime agrees with mypy is a str-mixin enum (StrEnum, or class Foo(str, Enum)), because there the member genuinely is the string. So the acceptance happens to be sound for str enums and is a false negative for every other Enum.

Your Environment

• mypy 2.2.0 (compiled). Reproduces with and without --strict.
• Python 3.12.8
• No flags beyond the above; no plugins.
• For comparison: pyright 1.1.411 flags it.

Empieza ejecutando con mypy la reproducción de TypedDict y Enum, y luego sigue la ruta de comprobación de tipos de la suscripción de TypedDict responsable de aceptar Foo.One. Se considera terminado cuando los miembros de Enum normales se rechazan como claves de dict[str, int], mientras que los enums con str-mixin siguen aceptándose; añade o actualiza una prueba de regresión para ambos casos.