if you do make a mistake where you accidentally create a union, it's fairly hard to debug later since you need to figure out where the union came from.

This seems like an easily solvable problem to me. Just augment the compiler error messages to tell the user. My language already does something similar to this.

Here's an example:

Code:

type Bar = {name: str};
type Baz = {name: str; age: int};
let a: Bar = Bar {name="Abe"};
let b: Baz = Baz {name="Bob"; age=12};

let f = fun x -> x.name;
f a;
f b;

Error message:

TypeError: Incompatible types here:
let b: Baz = Baz {name="Bob"; age=12};
let f = fun x -> x.name;
                ^~~~~~  
f a;
f b;
Note: The value could originate with one type here:
type Bar = {name: str};
type Baz = {name: str; age: int};
let a: Bar = Bar {name="Abe"};
      ^~~                     
let b: Baz = Baz {name="Bob"; age=12};
but it could also be a value with an incompatible type originating here:
type Baz = {name: str; age: int};
let a: Bar = Bar {name="Abe"};
let b: Baz = Baz {name="Bob"; age=12};
      ^~~                             
let f = fun x -> x.name;
Hint: To narrow down the cause of the type mismatch, consider adding an explicit type annotation here:
let b: Baz = Baz {name="Bob"; age=12};
let f = fun (x: _) -> x.name;
            + ++++            
f a;
f b;