How to define type of object that does not have a specific field, even not set to undefined?

<!-- language-all: typescript -->
I have code like this:

interface BaseType {
    baseField: string;
}

function combine<T extends Object>(base: BaseType, addition: T) {
    if('baseField' in addition)
        throw new Error('addition should not have baseField');
    return {...base, ...addition};
}

const myBase : BaseType = {
    baseField: "xyz"
}

const myAddition = {
    otherField: 123
}

const ret = combine(myBase, myAddition);
// --> ret = { baseField: "xyz", otherField: 123}
console.log(ret);

I would like to use TypeScript's type definition capabilities to trigger a IDE/compiler warning/error if combine()'s addition argument leads to baseField getting overridden. With my current setup, I only get info about it when it's already "too late", i.e. during runtime.

I tried solutions as described in answers to questions like https://stackoverflow.com/questions/73219479/typescript-type-with-prohibited-properties-names. While solutions like this are good in many scenarios, they do not work for addition.baseField = undefined. As example, this does not trigger any warning:

interface BaseType {
    baseField: string;
}

type RestrictionType = Object & {
    baseField?: never
}

function combine<T extends RestrictionType>(base: BaseType, addition: T) {
    return {...base, ...addition};
}

const myBase : BaseType = {
    baseField: "xyz"
}

const myAddition = {
    otherField: 123,
    baseField: undefined // set baseField explicitly to undefined
}

const ret = combine(myBase, myAddition); // no warning because undefined actually seems to match the "never" type
// --> ret = { baseField: undefined, otherField: 123 } // baseField got overridden
console.log(ret);

So how can I specify a type of an object where a field of a specific name must not be set, not even to undefined?

Here's a link to a TypeScript Playground.

As I understand it, an optional property by default is exactly equal to an undefined property; TypeScript's type system simply doesn't distinguish between the two.

TypeScript does offer an option, --exactOptionalPropertyTypes, that changes this. With that option, your code throws a warning, as desired (Playground link).

Unfortunately, based on my limited experience, enabling --exactOptionalPropertyTypes may require pretty invasive code changes. In my ideal world, TypeScript would let you opt in to this behavior for specific types. However, this appears to be a fairly niche request.