Extending type - Trouble getting a table union to resolve / autocomplete (self, generics, and recursion)

[DeveloperBlue]

I have a type BaseType that represent a table with properties. I want to create a subtype that extends that with additional properties. Both type and subtype also take the same generic. I've run into some issues with implementation:

Repro code below.

The self variable and the myHandler variable should have the same type FinalType<MyExtensionSpecificModel> but both seem to resolve differently.

Autocomplete for myHandler works but self does not. If I correctly call a function e.g. self:baseFnOne(model), the checker does not throw an error. But if I try to call a function that doesn't exist, or pass the wrong number or type of arguments, the checker throws a large verbose error on the entire variable. It seems to know what functions I can call, and what parameters they require, but won't autocomplete that or display that when I hover self (just resolves to self: a)

Interestingly, I can see the correct type resolution when hovering myHandler.
It sees all the expected functions; they all resolve correctly and its very readable.

Expand for screenshots

Autocomplete (self vs myHandler)

Autocomplete and resolution working fine, expected behavior (using myHandler)

look ma, all our properties from the unioned table, resolving nicely!

Autocomplete not working (using self)

Missing arguments (self vs myHandler)

a more targeted message for missing argument (using myHandler)

Verbose mess for missing argument, thrown on the entire variable (using self)

Am I just approaching this wrong?

Code

--!strict 

-- The base type I want to extend from
type BaseType<T, M> = {
	baseFnOne : (self : T, model : M) -> (),
	baseFnTwo : (self : T, model : M, otherargs : any) -> (),
}

-- My extensions
type ExtensionType<T, M> = {
	extensionThree : (self : T, model : M, entity : BasePart) -> ()
}

-- Creating the final type of the base type + extension types
type FinalType<M> = BaseType<FinalType<M>, M> & ExtensionType<FinalType<M>, M>

-- The arguments M passed to FinalType<M>
type MyExtensionSpecificModel = Model & {Entity : ObjectValue}


local entity = Instance.new("BasePart")

local myHandler : FinalType<MyExtensionSpecificModel>

myHandler = {
	baseFnOne = function(self, model)
		myHandler:extensionThree(model, entity) -- Autocompletes fine
		self:base -- Not autocompleting
	end,
	baseFnTwo = function(self, model, otherargs)
		
	end,
	extensionThree = function(self, model)
		self:baseFnOne(model) -- Can access base functions just fine, so it knows they're there
	end,
	-- Function was not defined, should be throwing an error but isn't
	undefinedExtension = function(self)
		
	end,
}

---

Mainly I just want to extend a table of functions while keeping self as a reference to that same extended table. (and pass my generics in and keep typesafety and autocomplete)