The following pattern allows one to define run-time structures that also have a compile-time representation:

type FieldMetadata = {}; // omitted;
type Field<T> = {
  instance: T;
  metadata: FieldMetadata;
};
  
export type QuerySpec<D extends {[P in keyof D]: Field<any>}> = {[P in keyof D]: D[P]["instance"]};

However, because Field<T> instances would be effectively singletons, the instance field is never going to be filled in because it's only used for compile-time type checking/inference.

Therefore, I propose to have "type-only" members, e.g.:

readonly inspiration

type Field<T> = {
  typeonly instance: T;
  metadata: FieldMetadata;
};

This would mean that accessing the instance member in an expression context would result in an error (only type indexing is allowed).

member types

type Field<T> = {
  type InstanceType = T;
  metadata: FieldMetadata;
};