I'm working on a TypeScript builder pattern where a ParentBuilder creates a ChildBuilder. The ParentBuilder has a mod method to store a transformation function, and child method which creates a ChildBuilder with a concrete value. The ChildBuilder stores the ParentBuilder transformation function by default, but supports overriding the transformation function with its own mod method.

I'm struggling with the type for the transformer in the ParentBuilder in order for transformation types to propagate correctly to the ChildBuilder.

Here's the code:

type ParentBuilder<M = any> = {
  mod: <M2>(transformer: (val: any) => M2) => ParentBuilder<M2>;
  child: <V>(value: V) => ChildBuilder<V, M>;
};

type ParentBuilderDef = {
  transformer: (val: any) => any;
};

const parentBuilder = (def: ParentBuilderDef): ParentBuilder => ({
  mod: (transformer) =>
    parentBuilder({
      ...def,
      transformer,
    }),
  child: (value) =>
    childBuilder({
      transformer: def.transformer,
      value,
    }),
});

type ChildBuilder<V, M> = {
  build: () => M;
  mod: <M2>(transformer: (val: V) => M2) => ChildBuilder<V, M2>;
};

type ChildBuilderDef<V, M> = {
  value: V;
  transformer: (val: V) => M;
};

const childBuilder = <V, M>(def: ChildBuilderDef<V, M>): ChildBuilder<V, M> => ({
  mod: (transformer) =>
    childBuilder({
      ...def,
      transformer,
    }),
  build: () => def.transformer(def.value),
});

const myBuilder = parentBuilder({
  transformer: (val) => val,
});

function xform<T>(x: T) {
  return { output: x };
}

const configuredBuilder1 = myBuilder
  .child('hello' as const)
  .mod(xform)
  .build();
// ✅ Expected: { output: 'hello'; } (Works correctly)

const configuredBuilder2 = myBuilder
  .mod(xform)
  .child('hello' as const)
  .build();
// ❌ Expected: { output: 'hello'; } but got { output: any }

Question: what can I do to get {output: "hello"} instead of {output: any}

The types for a new ChildBuilder transformer are straightforward as the V generic value is already known, however I can't figure out how to represent the ParentBuilder transformer where the V function is not yet known.

I've stumbled across the concept of Higher Kinded Types (effect-ts seems like a solid choice library to use here) and I think this might be the only way to achieve what I'm looking for, but I'm not sure how to implement.

Would anyone be able to help solve this using HKTs (effect-ts) or otherwise?