My first instinct was that I should re-wrap the result of narrowing with NoInfer but quoting the original NoInfer PR:

Other than blocking inference, NoInfer markers have no effect on T. Indeed, T and NoInfer are considered identical types in all other contexts.

So I don't see a reason why that would be necessary. I also tested something like this (TS playground) to see if this would be needed and I don't think it is:

declare function inner<T>(arg: T): T;
declare function outer<T>(a: T, cb: (arg: NoInfer<T>) => void): void;

outer({ foo: "bar" }, (arg) => {
  arg
  // ^? (parameter) arg: NoInfer<{ foo: string; }>
  const result = inner(arg); // inferred despite `arg` being a `NoInfer` type!
  //    ^? const result: NoInfer<{ foo: string; }>
});

I agree it's fine to erase NoInfer in variable, parameter, and property references, but I think it would be simpler and more consistent to do it first thing in the getNarrowableTypeForReference function. I think that's all you'd need.

moved it to getNarrowableTypeForReference, works like a charm - thanks!