How to remap the object types of a function argument to produce a desired type shape

I am trying to resolve an issue with forcing a certain "pattern" in the framework, for the lack of a better word, that I am making. The framework in question is a form of Redux store composer (give or take).

The TS playground links:

1. The full complex, all types included (this is the one I'd need, but its a doozy)
2. Siplified (minimum reproducable example - showcasing the same issue)

The gist is as follows:

I have a function which is used to create a "bundle" or a plugin for the framework named "createBundle" this function is of the type BundleInitializer which is a complex type but suffice it to say that the return type of this functions is a Bundle type.

The goal is to allow developers to call a "createBundle" function, which would then have intelliSense support and allow for an easier adherence to the pattern that this function requires for the argument it recieves.

The BundleInitializer signature semantically is as follows (simplified for clarity):

type BundleInitializer = <
  Name extends string,
  Selectors extends Record<string, Selector>, //
>(
  content: {
    name: Name
    selectors: Selectors
  }
) => Bundle<Name, Selectors>

Where the type of a selector is (again for the sake of simplicity) Selector = () => unknown. This would then allow us to pass an argument that is shaped like such:

const arg = {
   name: "Example",
   selectors: {
      foo: () => {},
      bar: () => {}
   }
}

But my goal is to enforce the naming of selectors to follow a pattern of select${Capitalize<string>}. So I tried to use the following types to achieve that (the types that follow are all in the "simplified" version of the TS playground link):

type Selector = <S>(state: S) => unknown


interface Bundle<
  Name extends string,
  Selectors extends BundleSelectors<Record<string, any>>,
> {
  name: Name
  selectors: Selectors
}

type BundleInitializer = <
  Name extends string,
  Selectors extends BundleSelectors<Record<string, any>>,
>(
  content: {
    name: Name
    selectors: Selectors
  }
) => Bundle<Name, Selectors>


declare const Init: BundleInitializer

const bun = Init({
  name: "Foo", selectors: {
    wrongname: 'wrongtype',                 // CASE 1 (name incorrect, type incorrect)
    selectCorrectName: 'wrongtype',         // CASE 2 (name correct, type incorrect)
    wrongName: () => { },                   // CASE 3 (name incorrect, type correct)
    selectCorrectAll: () => { },            // CASE 4 (name correct, type correct)
  }
})

How are we suppose to define a BundleSelectors type to make sure all 4 cases are covered,
I've tried these two versions, each has its own problems but neither works fully

version 1

type BundleSelectors<T> = { [I in keyof T]: Selector }

version 2

type argument will be missing here, just add it if you want to check the types, its not used anymore but other types need to be updated to reflect

type BundleSelectors = Record<`select${string}`, Selector>

Both of these do not produced the desired effect.

One approach is to define BundleInitializer so that the generic type parameter corresponding to selectors is recursively constrained so that any property key that doesn't match `select${string}` is rejected in some way. That would involve mapping the type so that properties with good keys have type Selector, while those with bad keys have a type like the impossible never type which is not compatible with any value likely to be passed in. Let's call that type BadKey<K> which takes a key of type K and produces an incompatible type.

Then BundleInitializer would be defined as

type BundleInitializer = <
  N extends string,
  S extends { [K in keyof S]: K extends `select${string}` ? Selector : BadKey<K> }
>(content: { name: N; selectors: S }) => Bundle<N, S>

and you'd get the desired behavior:

const bun = Init({
  name: "Foo", selectors: {
    wrongname: 'wrongtype',                 // error
    selectCorrectName: 'wrongtype',         // error
    wrongName: () => { },                   // error
    selectCorrectAll: () => { },            // okay
  }
})

So all that remains is defining BadKey. We can trivially define it as never,

type BadKey<K extends PropertyKey> = never;

but then the error message just says that the property isn't never as expected, which is confusing. Ideally TypeScript would provide an "invalid" type whose type is never-like but which provides a user-friendly error message, but TypeScript doesn't currently have such a facility. There's an open feature request for it at microsoft/TypeScript#23689. If it existed maybe we could write

type BadKey<K extends PropertyKey> = Invalid<
  `You provided a key of "${Exclude<K, symbol>}" \
  but the keys all need to be of the form \`select${string}\``
>;

but it doesn't. For now, all we can do is something like

type BadKey<K extends PropertyKey> = `You provided a key of "${Exclude<K, symbol>}" \
  but the keys all need to be of the form \`select${string}\``;

and rely on the fact that whatever the property value passed in is very unlikely to be that error string. So we get errors like:

Type '() => void' is not assignable to type 
  '`You provided a key of "wrongName" but the keys all 
  need to be of the form \`select${string}\``'.(2322)

which is hopefully enough for people to understand what to do.

Playground link to code