Remove key from object after `delete object.key`

Suggestion

🔍 Search Terms

delete
delete key
narrowing
narrowing delete

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

In TypeScript, it's already possible to have objects add keys to their types using if ("key" in object) // object: { key: unknown }. It is not currently possible to do the exact opposite: deleting a key off of an object.

This could be achieved in two ways:

• Guaranteed: type { key: string }; delete object.key; type { }.
• Optional: type { key?: string | undefined }; if (object.key === undefined) delete object.key; type { key?: string }.

The guaranteed way is pretty straight forward: it removes the key entirely.
The optional way is slightly more tricky: it should only remove the type information checked in the if statement. Remaining type options should still exist after the if statement. If the last remaining type option is removed, then it should function the same as the guaranteed way.

Naturally, if the key didn't exist on the object in the first place, the type information should remain the exact same as before.

📃 Motivating Example

I'm using the zod library, with which I set a value on object user as { givenName: string; infix?: string | undefined; surname: string; }.
I wrote a factory function toUser({ givenName, infix, surname }: { givenName: string; infix?: string; surname: string; }): User { ... }.
The type infix?: string | undefined is not compatible with type infix?: string.

--- EDIT: Extra example ---
After executing delete object.key, I'm expecting the type information to no longer contain this key:

  const myObject: { key1?: string | undefined, key2?: string | undefined } = { ... };
  delete myObject.key1; // Type should now become: { key2?: string | undefined}
  myObject.key1 // Should error, key was deleted

Now, if I want to remove a key under certain conditions:

  const myObject: { key1?: string | number | undefined } = { ... };
  if (typeof myObject.key1 === "number") delete myObject.key1; // Removes "number" from types. This already works.
  if (typeof myObject.key1 === "undefined") delete myObject.key1; // Removes "undefined" from type definition. This does not work yet.
  if (typeof myObject.key1 === "string") delete myObject.key1; // Removes the last type; "key1" will no longer exist on object.

In the above example, the native types "number" and "string" get stripped off as expected. The type "undefined" however, does not. This breaks the tsconfig option exactOptionalPropertyTypes as the key should now no longer be able to exist. It cannot exist with literal value undefined.

💻 Use Cases

This is purely type information, but it seems essential if the typing system is to remain correct after the delete keyword.
For the time being, I'll have to set the type to infix?: string | undefined, knowing it's not entirely accurate (key "infix" should not be permitted with value "undefined").

No implementation files or tests are named. Start by reproducing the guaranteed and optional delete examples in a TypeScript test, then compare current narrowing behavior with the requested post-delete types; done means the checker handles those cases without changing emitted JavaScript.