diff --git a/packages/codegen/src/generateEntityCodegenFile.ts b/packages/codegen/src/generateEntityCodegenFile.ts
index 45b01c09f..f176717f8 100644
--- a/packages/codegen/src/generateEntityCodegenFile.ts
+++ b/packages/codegen/src/generateEntityCodegenFile.ts
@@ -24,7 +24,6 @@ import {
   EntityGraphQLFilter,
   EntityManager,
   EntityMetadata,
-  FieldType,
   FieldsOf,
   FilterOf,
   Flavor,
@@ -45,7 +44,6 @@ import {
   ReactiveField,
   ReactiveReference,
   SSAssert,
-  SettableFields,
   TaggedId,
   ValueFilter,
   ValueGraphQLFilter,
@@ -64,12 +62,12 @@ import {
   hasOneToOne,
   isEntity,
   isLoaded,
-  setFieldValue,
   loadLens,
   mustBeSubType,
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "./symbols";
@@ -404,11 +402,13 @@ export function generateEntityCodegenFile(config: Config, dbMeta: DbMetadata, me
   const baseEntity = dbMeta.entities.find((e) => e.name === meta.baseClassName);
   const subEntities = dbMeta.entities.filter((e) => e.baseClassName === meta.name);
   const base = baseEntity?.entity.type ?? code`${BaseEntity}<${EntityManager}, ${idType}>`;
-  const maybeBaseFields = baseEntity ? code`extends ${imp('t:' + baseEntity.name + "Fields@./entities.ts")}` : "";
+  const maybeBaseFields = baseEntity ? code`extends ${imp("t:" + baseEntity.name + "Fields@./entities.ts")}` : "";
   const maybeBaseOpts = baseEntity ? code`extends ${baseEntity.entity.optsType}` : "";
-  const maybeBaseIdOpts = baseEntity ? code`extends ${imp('t:' + baseEntity.name + "IdsOpts@./entities.ts")}` : "";
-  const maybeBaseFilter = baseEntity ? code`extends ${imp('t:' + baseEntity.name + "Filter@./entities.ts")}` : "";
-  const maybeBaseGqlFilter = baseEntity ? code`extends ${imp('t:' + baseEntity.name + "GraphQLFilter@./entities.ts")}` : "";
+  const maybeBaseIdOpts = baseEntity ? code`extends ${imp("t:" + baseEntity.name + "IdsOpts@./entities.ts")}` : "";
+  const maybeBaseFilter = baseEntity ? code`extends ${imp("t:" + baseEntity.name + "Filter@./entities.ts")}` : "";
+  const maybeBaseGqlFilter = baseEntity
+    ? code`extends ${imp("t:" + baseEntity.name + "GraphQLFilter@./entities.ts")}`
+    : "";
   const maybeBaseOrder = baseEntity ? code`extends ${baseEntity.entity.orderType}` : "";
   const maybeBaseId = baseEntity ? code` & Flavor<${idType}, "${baseEntity.name}">` : "";
   const maybePreventBaseTypeInstantiation = meta.abstract
@@ -532,13 +532,13 @@ export function generateEntityCodegenFile(config: Config, dbMeta: DbMetadata, me
 
       getFieldValue<K extends keyof ${entityName}Fields>(
         key: K
-      ): ${FieldType}<${entityName}Fields, K> {
+      ): ${entityName}Fields[K]["value"] {
         return ${getField}(this as any, key);  
       }
 
-      setFieldValue<K extends keyof ${SettableFields}<${entityName}Fields> & keyof ${entityName}Fields>(
+      setFieldValue<K extends keyof ${entityName}Fields>(
         key: K,
-        value: ${FieldType}<${entityName}Fields, K>,
+        value: ${entityName}Fields[K]["value"],
       ): void {
         ${setFieldValue}(this, key, value);
       }
@@ -717,33 +717,34 @@ function generateOptsFields(config: Config, meta: EntityDbMetadata): Code[] {
 
 // Make our fields type
 function generateFieldsType(config: Config, meta: EntityDbMetadata): Code[] {
-  const id = code`id: { kind: "primitive"; type: ${meta.primaryKey.fieldType}; unique: ${true}; nullable: never };`;
+  const id = code`id: { kind: "primitive"; type: ${meta.primaryKey.fieldType}; unique: ${true}; nullable: never; value: never };`;
   const primitives = meta.primitives.map((field) => {
     const { fieldName, fieldType, notNull, unique, derived } = field;
-    return code`${fieldName}: { kind: "primitive"; type: ${fieldType}; unique: ${unique}; nullable: ${undefinedOrNever(
-      notNull,
-    )}, derived: ${derived !== false} };`;
+    const uOrNever = undefinedOrNever(notNull);
+    return code`${fieldName}: { kind: "primitive"; type: ${fieldType}; unique: ${unique}; nullable: ${uOrNever}; value: ${fieldType} | ${uOrNever}; derived: ${derived !== false} };`;
   });
   const enums = meta.enums.map((field) => {
     const { fieldName, enumType, notNull, isArray } = field;
     if (isArray) {
       // Arrays are always optional and we'll default to `[]`
-      return code`${fieldName}: { kind: "enum"; type: ${enumType}[]; nullable: never };`;
+      return code`${fieldName}: { kind: "enum"; type: ${enumType}[]; nullable: never; value: never  };`;
     } else {
-      return code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${undefinedOrNever(notNull)} };`;
+      const uOrNever = undefinedOrNever(notNull);
+      return code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${uOrNever}; value: ${enumType} | ${uOrNever} };`;
     }
   });
   const pgEnums = meta.pgEnums.map(({ fieldName, enumType, notNull }) => {
     const nullable = undefinedOrNever(notNull);
-    return code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${nullable}; native: true };`;
+    return code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${nullable}; native: true; value: never  };`;
   });
   const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull, derived }) => {
-    return code`${fieldName}: { kind: "m2o"; type: ${otherEntity.type}; nullable: ${undefinedOrNever(
-      notNull,
-    )}, derived: ${derived !== false} };`;
+    const uOrNever = undefinedOrNever(notNull);
+    return code`${fieldName}: { kind: "m2o"; type: ${otherEntity.type}; nullable: ${uOrNever}; value: ${otherEntity.idType} | ${uOrNever}; derived: ${derived !== false} };`;
   });
   const polys = meta.polymorphics.map(({ fieldName, notNull, fieldType }) => {
-    return code`${fieldName}: { kind: "poly"; type: ${fieldType}; nullable: ${undefinedOrNever(notNull)} };`;
+    const uOrNever = undefinedOrNever(notNull);
+    const genericIdType = config.idType === "number" ? "number" : "string";
+    return code`${fieldName}: { kind: "poly"; type: ${fieldType}; nullable: ${uOrNever}; value: ${genericIdType} | ${uOrNever}; }`;
   });
   return [id, ...primitives, ...enums, ...pgEnums, ...m2o, ...polys];
 }
diff --git a/packages/codegen/src/index.ts b/packages/codegen/src/index.ts
index 22e39c918..6517629dc 100644
--- a/packages/codegen/src/index.ts
+++ b/packages/codegen/src/index.ts
@@ -71,7 +71,10 @@ export async function generateAndSaveFiles(config: Config, dbMeta: DbMetadata):
     toolName: "joist-codegen",
     directory: config.entitiesDirectory,
     files,
-    toStringOpts: { importExtensions: config.esm ? 'js' : false }
+    toStringOpts: {
+      dprintOptions: { lineWidth: 150 },
+      importExtensions: config.esm ? "js" : false,
+    },
   });
 }
 
diff --git a/packages/codegen/src/symbols.ts b/packages/codegen/src/symbols.ts
index 2e2efbce8..a4f737bbe 100644
--- a/packages/codegen/src/symbols.ts
+++ b/packages/codegen/src/symbols.ts
@@ -28,7 +28,6 @@ export const PrimitiveSerde = imp("PrimitiveSerde@joist-orm");
 export const BigIntSerde = imp("BigIntSerde@joist-orm");
 export const JsonSerde = imp("JsonSerde@joist-orm");
 export const SettableFields = imp("SettableFields@joist-orm");
-export const FieldType = imp("FieldType@joist-orm");
 export const SuperstructSerde = imp("SuperstructSerde@joist-orm");
 export const TaggedId = imp("t:TaggedId@joist-orm");
 export const ZodSerde = imp("ZodSerde@joist-orm");
diff --git a/packages/orm/src/Entity.ts b/packages/orm/src/Entity.ts
index 9e8f62a4c..faaa053b1 100644
--- a/packages/orm/src/Entity.ts
+++ b/packages/orm/src/Entity.ts
@@ -19,7 +19,7 @@ export interface Entity {
   readonly isNewEntity: boolean;
   readonly isDeletedEntity: boolean;
   readonly isDirtyEntity: boolean;
-  getFieldValue(fieldName: string): any;
+  getFieldValue(fieldName: string): unknown;
   setFieldValue(fieldName: string, value: unknown): void;
   set(opts: Partial<OptsOf<this>>): void;
   setPartial(values: PartialOrNull<OptsOf<this>>): void;
diff --git a/packages/orm/src/EntityFields.ts b/packages/orm/src/EntityFields.ts
index 2a8c3126d..3618d0797 100644
--- a/packages/orm/src/EntityFields.ts
+++ b/packages/orm/src/EntityFields.ts
@@ -1,5 +1,3 @@
-import { IdOf } from "./EntityManager";
-
 /** All the fields for an entity in the `FieldsOf` / `EntityField` format. */
 export type EntityFields<T> = {
   [K in keyof T]: EntityField;
@@ -21,11 +19,3 @@ export type SettableFields<F> = {
         ? F[K]
         : never;
 };
-
-export type FieldType<F, K extends keyof F> = F[K] extends { kind: "primitive"; type: infer T; nullable: infer N }
-  ? T | N
-  : F[K] extends { kind: "enum"; type: infer T; nullable: infer N }
-    ? T | N
-    : F[K] extends { kind: "m2o"; type: infer E; nullable: infer N }
-      ? IdOf<E> | N
-      : never;
diff --git a/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts b/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts
index 9ceb9764d..68ed41bae 100644
--- a/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -45,12 +43,12 @@ import type { BookId, Entity } from "../entities.js";
 export type AuthorId = Flavor<string, Author>;
 
 export interface AuthorFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  delete: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  delete: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; value: boolean | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface AuthorOpts {
@@ -166,14 +164,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorFields>(key: K): FieldType<AuthorFields, K> {
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorFields> & keyof AuthorFields>(
-    key: K,
-    value: FieldType<AuthorFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -196,14 +191,8 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Author>>(hint: H): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>, V>(hint: H, fn: (a: Loaded<Author, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (a: Loaded<Author, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    hintOrOpts: any,
-    fn?: (a: Loaded<Author, H>) => V,
-  ): Promise<Loaded<Author, H> | V> {
+  populate<H extends LoadHint<Author>, V>(opts: { hint: H; forceReload?: boolean }, fn: (a: Loaded<Author, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Author>, V>(hintOrOpts: any, fn?: (a: Loaded<Author, H>) => V): Promise<Loaded<Author, H> | V> {
     return this.em.populate(this as any as Author, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/esm-misc/src/entities/codegen/BookCodegen.ts b/packages/tests/esm-misc/src/entities/codegen/BookCodegen.ts
index 44c98c2f3..137d37fe5 100644
--- a/packages/tests/esm-misc/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/esm-misc/src/entities/codegen/BookCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,9 +41,9 @@ import type { AuthorId, AuthorOrder, Entity } from "../entities.js";
 export type BookId = Flavor<string, Book>;
 
 export interface BookFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface BookOpts {
@@ -123,14 +121,11 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     setField(this, "title", cleanStringValue(title));
   }
 
-  getFieldValue<K extends keyof BookFields>(key: K): FieldType<BookFields, K> {
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookFields> & keyof BookFields>(
-    key: K,
-    value: FieldType<BookFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -153,10 +148,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<Book>>(hint: H): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>, V>(hint: H, fn: (b: Loaded<Book, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Book>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (b: Loaded<Book, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Book>, V>(opts: { hint: H; forceReload?: boolean }, fn: (b: Loaded<Book, H>) => V): Promise<V>;
   populate<H extends LoadHint<Book>, V>(hintOrOpts: any, fn?: (b: Loaded<Book, H>) => V): Promise<Loaded<Book, H> | V> {
     return this.em.populate(this as any as Book, hintOrOpts, fn);
   }
diff --git a/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts b/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts
index efe547543..430f62b48 100644
--- a/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts
@@ -2,7 +2,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   isLoaded,
   loadLens,
@@ -11,7 +10,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -35,8 +33,8 @@ import type { Entity, UserFields, UserFilter, UserGraphQLFilter, UserIdsOpts, Us
 export type AdminUserId = Flavor<string, AdminUser> & Flavor<string, "User">;
 
 export interface AdminUserFields extends UserFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  role: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  role: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
 }
 
 export interface AdminUserOpts extends UserOpts {
@@ -105,14 +103,11 @@ export abstract class AdminUserCodegen extends User implements Entity {
     setField(this, "role", cleanStringValue(role));
   }
 
-  getFieldValue<K extends keyof AdminUserFields>(key: K): FieldType<AdminUserFields, K> {
+  getFieldValue<K extends keyof AdminUserFields>(key: K): AdminUserFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AdminUserFields> & keyof AdminUserFields>(
-    key: K,
-    value: FieldType<AdminUserFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AdminUserFields>(key: K, value: AdminUserFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -135,14 +130,8 @@ export abstract class AdminUserCodegen extends User implements Entity {
   populate<H extends LoadHint<AdminUser>>(hint: H): Promise<Loaded<AdminUser, H>>;
   populate<H extends LoadHint<AdminUser>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<AdminUser, H>>;
   populate<H extends LoadHint<AdminUser>, V>(hint: H, fn: (u: Loaded<AdminUser, H>) => V): Promise<V>;
-  populate<H extends LoadHint<AdminUser>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (u: Loaded<AdminUser, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<AdminUser>, V>(
-    hintOrOpts: any,
-    fn?: (u: Loaded<AdminUser, H>) => V,
-  ): Promise<Loaded<AdminUser, H> | V> {
+  populate<H extends LoadHint<AdminUser>, V>(opts: { hint: H; forceReload?: boolean }, fn: (u: Loaded<AdminUser, H>) => V): Promise<V>;
+  populate<H extends LoadHint<AdminUser>, V>(hintOrOpts: any, fn?: (u: Loaded<AdminUser, H>) => V): Promise<Loaded<AdminUser, H> | V> {
     return this.em.populate(this as any as AdminUser, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/AuthorCodegen.ts b/packages/tests/integration/src/entities/codegen/AuthorCodegen.ts
index 67dc0ee97..d4e13a4b8 100644
--- a/packages/tests/integration/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AuthorCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -17,7 +16,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -93,43 +91,44 @@ import type {
 export type AuthorId = Flavor<string, Author>;
 
 export interface AuthorFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  ssn: { kind: "primitive"; type: string; unique: true; nullable: undefined; derived: false };
-  initials: { kind: "primitive"; type: string; unique: false; nullable: never; derived: true };
-  numberOfBooks: { kind: "primitive"; type: number; unique: false; nullable: never; derived: true };
-  bookComments: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: true };
-  isPopular: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; derived: false };
-  age: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: false };
-  graduated: { kind: "primitive"; type: Date; unique: false; nullable: undefined; derived: false };
-  nickNames: { kind: "primitive"; type: string[]; unique: false; nullable: undefined; derived: false };
-  nickNamesUpper: { kind: "primitive"; type: string[]; unique: false; nullable: undefined; derived: true };
-  wasEverPopular: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; derived: false };
-  address: { kind: "primitive"; type: Address; unique: false; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  ssn: { kind: "primitive"; type: string; unique: true; nullable: undefined; value: string | undefined; derived: false };
+  initials: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: true };
+  numberOfBooks: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: true };
+  bookComments: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: true };
+  isPopular: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; value: boolean | undefined; derived: false };
+  age: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: false };
+  graduated: { kind: "primitive"; type: Date; unique: false; nullable: undefined; value: Date | undefined; derived: false };
+  nickNames: { kind: "primitive"; type: string[]; unique: false; nullable: undefined; value: string[] | undefined; derived: false };
+  nickNamesUpper: { kind: "primitive"; type: string[]; unique: false; nullable: undefined; value: string[] | undefined; derived: true };
+  wasEverPopular: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; value: boolean | undefined; derived: false };
+  address: { kind: "primitive"; type: Address; unique: false; nullable: undefined; value: Address | undefined; derived: false };
   businessAddress: {
     kind: "primitive";
     type: z.input<typeof AddressSchema>;
     unique: false;
     nullable: undefined;
+    value: z.input<typeof AddressSchema> | undefined;
     derived: false;
   };
-  quotes: { kind: "primitive"; type: Quotes; unique: false; nullable: undefined; derived: false };
-  numberOfAtoms: { kind: "primitive"; type: bigint; unique: false; nullable: undefined; derived: false };
-  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; derived: false };
-  numberOfPublicReviews: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: true };
-  numberOfPublicReviews2: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: true };
-  tagsOfAllBooks: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: true };
-  search: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: true };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  rangeOfBooks: { kind: "enum"; type: BookRange; nullable: undefined };
-  favoriteColors: { kind: "enum"; type: Color[]; nullable: never };
-  favoriteShape: { kind: "enum"; type: FavoriteShape; nullable: undefined; native: true };
-  mentor: { kind: "m2o"; type: Author; nullable: undefined; derived: false };
-  currentDraftBook: { kind: "m2o"; type: Book; nullable: undefined; derived: false };
-  favoriteBook: { kind: "m2o"; type: Book; nullable: undefined; derived: true };
-  publisher: { kind: "m2o"; type: Publisher; nullable: undefined; derived: false };
+  quotes: { kind: "primitive"; type: Quotes; unique: false; nullable: undefined; value: Quotes | undefined; derived: false };
+  numberOfAtoms: { kind: "primitive"; type: bigint; unique: false; nullable: undefined; value: bigint | undefined; derived: false };
+  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; value: Date | undefined; derived: false };
+  numberOfPublicReviews: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: true };
+  numberOfPublicReviews2: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: true };
+  tagsOfAllBooks: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: true };
+  search: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: true };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  rangeOfBooks: { kind: "enum"; type: BookRange; nullable: undefined; value: BookRange | undefined };
+  favoriteColors: { kind: "enum"; type: Color[]; nullable: never; value: never };
+  favoriteShape: { kind: "enum"; type: FavoriteShape; nullable: undefined; native: true; value: never };
+  mentor: { kind: "m2o"; type: Author; nullable: undefined; value: AuthorId | undefined; derived: false };
+  currentDraftBook: { kind: "m2o"; type: Book; nullable: undefined; value: BookId | undefined; derived: false };
+  favoriteBook: { kind: "m2o"; type: Book; nullable: undefined; value: BookId | undefined; derived: true };
+  publisher: { kind: "m2o"; type: Publisher; nullable: undefined; value: PublisherId | undefined; derived: false };
 }
 
 export interface AuthorOpts {
@@ -531,14 +530,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return this.favoriteShape === FavoriteShape.Triangle;
   }
 
-  getFieldValue<K extends keyof AuthorFields>(key: K): FieldType<AuthorFields, K> {
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorFields> & keyof AuthorFields>(
-    key: K,
-    value: FieldType<AuthorFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -565,14 +561,8 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Author>>(hint: H): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>, V>(hint: H, fn: (a: Loaded<Author, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (a: Loaded<Author, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    hintOrOpts: any,
-    fn?: (a: Loaded<Author, H>) => V,
-  ): Promise<Loaded<Author, H> | V> {
+  populate<H extends LoadHint<Author>, V>(opts: { hint: H; forceReload?: boolean }, fn: (a: Loaded<Author, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Author>, V>(hintOrOpts: any, fn?: (a: Loaded<Author, H>) => V): Promise<Loaded<Author, H> | V> {
     return this.em.populate(this as any as Author, hintOrOpts, fn);
   }
 
@@ -582,58 +572,27 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
 
   get authors(): Collection<Author, Author> {
     const { relations } = getInstanceData(this);
-    return relations.authors ??= hasMany(
-      this as any as Author,
-      authorMeta,
-      "authors",
-      "mentor",
-      "mentor_id",
-      undefined,
-    );
+    return relations.authors ??= hasMany(this as any as Author, authorMeta, "authors", "mentor", "mentor_id", undefined);
   }
 
   get schedules(): Collection<Author, AuthorSchedule> {
     const { relations } = getInstanceData(this);
-    return relations.schedules ??= hasMany(
-      this as any as Author,
-      authorScheduleMeta,
-      "schedules",
-      "author",
-      "author_id",
-      undefined,
-    );
+    return relations.schedules ??= hasMany(this as any as Author, authorScheduleMeta, "schedules", "author", "author_id", undefined);
   }
 
   get books(): Collection<Author, Book> {
     const { relations } = getInstanceData(this);
-    return relations.books ??= hasMany(this as any as Author, bookMeta, "books", "author", "author_id", {
-      "field": "order",
-      "direction": "ASC",
-    });
+    return relations.books ??= hasMany(this as any as Author, bookMeta, "books", "author", "author_id", { "field": "order", "direction": "ASC" });
   }
 
   get comments(): Collection<Author, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comments ??= hasMany(
-      this as any as Author,
-      commentMeta,
-      "comments",
-      "parent",
-      "parent_author_id",
-      undefined,
-    );
+    return relations.comments ??= hasMany(this as any as Author, commentMeta, "comments", "parent", "parent_author_id", undefined);
   }
 
   get tasks(): Collection<Author, TaskNew> {
     const { relations } = getInstanceData(this);
-    return relations.tasks ??= hasMany(
-      this as any as Author,
-      taskNewMeta,
-      "tasks",
-      "specialNewAuthor",
-      "special_new_author_id",
-      undefined,
-    );
+    return relations.tasks ??= hasMany(this as any as Author, taskNewMeta, "tasks", "specialNewAuthor", "special_new_author_id", undefined);
   }
 
   get mentor(): ManyToOneReference<Author, Author, undefined> {
@@ -643,12 +602,7 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
 
   get currentDraftBook(): ManyToOneReference<Author, Book, undefined> {
     const { relations } = getInstanceData(this);
-    return relations.currentDraftBook ??= hasOne(
-      this as any as Author,
-      bookMeta,
-      "currentDraftBook",
-      "currentDraftAuthor",
-    );
+    return relations.currentDraftBook ??= hasOne(this as any as Author, bookMeta, "currentDraftBook", "currentDraftAuthor");
   }
 
   get publisher(): ManyToOneReference<Author, Publisher, undefined> {
@@ -663,25 +617,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
 
   get userOneToOne(): OneToOneReference<Author, User> {
     const { relations } = getInstanceData(this);
-    return relations.userOneToOne ??= hasOneToOne(
-      this as any as Author,
-      userMeta,
-      "userOneToOne",
-      "authorManyToOne",
-      "author_id",
-    );
+    return relations.userOneToOne ??= hasOneToOne(this as any as Author, userMeta, "userOneToOne", "authorManyToOne", "author_id");
   }
 
   get tags(): Collection<Author, Tag> {
     const { relations } = getInstanceData(this);
-    return relations.tags ??= hasManyToMany(
-      this as any as Author,
-      "authors_to_tags",
-      "tags",
-      "author_id",
-      tagMeta,
-      "authors",
-      "tag_id",
-    );
+    return relations.tags ??= hasManyToMany(this as any as Author, "authors_to_tags", "tags", "author_id", tagMeta, "authors", "tag_id");
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/AuthorScheduleCodegen.ts b/packages/tests/integration/src/entities/codegen/AuthorScheduleCodegen.ts
index 624abd5ed..baaae86e1 100644
--- a/packages/tests/integration/src/entities/codegen/AuthorScheduleCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AuthorScheduleCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { AuthorId, AuthorOrder, Entity } from "../entities";
 export type AuthorScheduleId = Flavor<string, AuthorSchedule>;
 
 export interface AuthorScheduleFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  overview: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  overview: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface AuthorScheduleOpts {
@@ -140,14 +138,11 @@ export abstract class AuthorScheduleCodegen extends BaseEntity<EntityManager, st
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorScheduleFields>(key: K): FieldType<AuthorScheduleFields, K> {
+  getFieldValue<K extends keyof AuthorScheduleFields>(key: K): AuthorScheduleFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorScheduleFields> & keyof AuthorScheduleFields>(
-    key: K,
-    value: FieldType<AuthorScheduleFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorScheduleFields>(key: K, value: AuthorScheduleFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -168,13 +163,8 @@ export abstract class AuthorScheduleCodegen extends BaseEntity<EntityManager, st
   }
 
   populate<H extends LoadHint<AuthorSchedule>>(hint: H): Promise<Loaded<AuthorSchedule, H>>;
-  populate<H extends LoadHint<AuthorSchedule>>(
-    opts: { hint: H; forceReload?: boolean },
-  ): Promise<Loaded<AuthorSchedule, H>>;
-  populate<H extends LoadHint<AuthorSchedule>, V>(
-    hint: H,
-    fn: (authorSchedule: Loaded<AuthorSchedule, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<AuthorSchedule>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<AuthorSchedule, H>>;
+  populate<H extends LoadHint<AuthorSchedule>, V>(hint: H, fn: (authorSchedule: Loaded<AuthorSchedule, H>) => V): Promise<V>;
   populate<H extends LoadHint<AuthorSchedule>, V>(
     opts: { hint: H; forceReload?: boolean },
     fn: (authorSchedule: Loaded<AuthorSchedule, H>) => V,
diff --git a/packages/tests/integration/src/entities/codegen/AuthorStatCodegen.ts b/packages/tests/integration/src/entities/codegen/AuthorStatCodegen.ts
index 1f6c55650..ded755804 100644
--- a/packages/tests/integration/src/entities/codegen/AuthorStatCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AuthorStatCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   isLoaded,
   loadLens,
@@ -12,7 +11,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -36,21 +34,21 @@ import type { Entity } from "../entities";
 export type AuthorStatId = Flavor<string, AuthorStat>;
 
 export interface AuthorStatFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  smallint: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  integer: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  nullableInteger: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: false };
-  bigint: { kind: "primitive"; type: bigint; unique: false; nullable: never; derived: false };
-  decimal: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  real: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  smallserial: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  serial: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  bigserial: { kind: "primitive"; type: bigint; unique: false; nullable: never; derived: false };
-  doublePrecision: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  nullableText: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  json: { kind: "primitive"; type: Object; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  smallint: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  integer: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  nullableInteger: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: false };
+  bigint: { kind: "primitive"; type: bigint; unique: false; nullable: never; value: bigint | never; derived: false };
+  decimal: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  real: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  smallserial: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  serial: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  bigserial: { kind: "primitive"; type: bigint; unique: false; nullable: never; value: bigint | never; derived: false };
+  doublePrecision: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  nullableText: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  json: { kind: "primitive"; type: Object; unique: false; nullable: undefined; value: Object | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface AuthorStatOpts {
@@ -278,14 +276,11 @@ export abstract class AuthorStatCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorStatFields>(key: K): FieldType<AuthorStatFields, K> {
+  getFieldValue<K extends keyof AuthorStatFields>(key: K): AuthorStatFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorStatFields> & keyof AuthorStatFields>(
-    key: K,
-    value: FieldType<AuthorStatFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorStatFields>(key: K, value: AuthorStatFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -308,14 +303,8 @@ export abstract class AuthorStatCodegen extends BaseEntity<EntityManager, string
   populate<H extends LoadHint<AuthorStat>>(hint: H): Promise<Loaded<AuthorStat, H>>;
   populate<H extends LoadHint<AuthorStat>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<AuthorStat, H>>;
   populate<H extends LoadHint<AuthorStat>, V>(hint: H, fn: (as: Loaded<AuthorStat, H>) => V): Promise<V>;
-  populate<H extends LoadHint<AuthorStat>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (as: Loaded<AuthorStat, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<AuthorStat>, V>(
-    hintOrOpts: any,
-    fn?: (as: Loaded<AuthorStat, H>) => V,
-  ): Promise<Loaded<AuthorStat, H> | V> {
+  populate<H extends LoadHint<AuthorStat>, V>(opts: { hint: H; forceReload?: boolean }, fn: (as: Loaded<AuthorStat, H>) => V): Promise<V>;
+  populate<H extends LoadHint<AuthorStat>, V>(hintOrOpts: any, fn?: (as: Loaded<AuthorStat, H>) => V): Promise<Loaded<AuthorStat, H> | V> {
     return this.em.populate(this as any as AuthorStat, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/BookAdvanceCodegen.ts b/packages/tests/integration/src/entities/codegen/BookAdvanceCodegen.ts
index 24eb70684..78cfaa672 100644
--- a/packages/tests/integration/src/entities/codegen/BookAdvanceCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/BookAdvanceCodegen.ts
@@ -2,7 +2,6 @@ import {
   BaseEntity,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -13,7 +12,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -54,12 +52,12 @@ import type { BookId, BookOrder, Entity, PublisherId, PublisherOrder } from "../
 export type BookAdvanceId = Flavor<string, BookAdvance>;
 
 export interface BookAdvanceFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  status: { kind: "enum"; type: AdvanceStatus; nullable: never };
-  book: { kind: "m2o"; type: Book; nullable: never; derived: false };
-  publisher: { kind: "m2o"; type: Publisher; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  status: { kind: "enum"; type: AdvanceStatus; nullable: never; value: AdvanceStatus | never };
+  book: { kind: "m2o"; type: Book; nullable: never; value: BookId | never; derived: false };
+  publisher: { kind: "m2o"; type: Publisher; nullable: never; value: PublisherId | never; derived: false };
 }
 
 export interface BookAdvanceOpts {
@@ -175,14 +173,11 @@ export abstract class BookAdvanceCodegen extends BaseEntity<EntityManager, strin
     return getField(this, "status") === AdvanceStatus.Paid;
   }
 
-  getFieldValue<K extends keyof BookAdvanceFields>(key: K): FieldType<BookAdvanceFields, K> {
+  getFieldValue<K extends keyof BookAdvanceFields>(key: K): BookAdvanceFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookAdvanceFields> & keyof BookAdvanceFields>(
-    key: K,
-    value: FieldType<BookAdvanceFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookAdvanceFields>(key: K, value: BookAdvanceFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -205,14 +200,8 @@ export abstract class BookAdvanceCodegen extends BaseEntity<EntityManager, strin
   populate<H extends LoadHint<BookAdvance>>(hint: H): Promise<Loaded<BookAdvance, H>>;
   populate<H extends LoadHint<BookAdvance>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<BookAdvance, H>>;
   populate<H extends LoadHint<BookAdvance>, V>(hint: H, fn: (ba: Loaded<BookAdvance, H>) => V): Promise<V>;
-  populate<H extends LoadHint<BookAdvance>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (ba: Loaded<BookAdvance, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<BookAdvance>, V>(
-    hintOrOpts: any,
-    fn?: (ba: Loaded<BookAdvance, H>) => V,
-  ): Promise<Loaded<BookAdvance, H> | V> {
+  populate<H extends LoadHint<BookAdvance>, V>(opts: { hint: H; forceReload?: boolean }, fn: (ba: Loaded<BookAdvance, H>) => V): Promise<V>;
+  populate<H extends LoadHint<BookAdvance>, V>(hintOrOpts: any, fn?: (ba: Loaded<BookAdvance, H>) => V): Promise<Loaded<BookAdvance, H> | V> {
     return this.em.populate(this as any as BookAdvance, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/BookCodegen.ts b/packages/tests/integration/src/entities/codegen/BookCodegen.ts
index b8556f3fc..758a75ca9 100644
--- a/packages/tests/integration/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/BookCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -17,7 +16,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -60,29 +58,20 @@ import {
   Tag,
   tagMeta,
 } from "../entities";
-import type {
-  AuthorId,
-  AuthorOrder,
-  BookAdvanceId,
-  BookReviewId,
-  CommentId,
-  Entity,
-  ImageId,
-  TagId,
-} from "../entities";
+import type { AuthorId, AuthorOrder, BookAdvanceId, BookReviewId, CommentId, Entity, ImageId, TagId } from "../entities";
 
 export type BookId = Flavor<string, Book>;
 
 export interface BookFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  order: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  notes: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  acknowledgements: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  order: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  notes: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  acknowledgements: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; value: Date | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface BookOpts {
@@ -251,14 +240,11 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof BookFields>(key: K): FieldType<BookFields, K> {
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookFields> & keyof BookFields>(
-    key: K,
-    value: FieldType<BookFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -285,10 +271,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<Book>>(hint: H): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>, V>(hint: H, fn: (b: Loaded<Book, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Book>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (b: Loaded<Book, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Book>, V>(opts: { hint: H; forceReload?: boolean }, fn: (b: Loaded<Book, H>) => V): Promise<V>;
   populate<H extends LoadHint<Book>, V>(hintOrOpts: any, fn?: (b: Loaded<Book, H>) => V): Promise<Loaded<Book, H> | V> {
     return this.em.populate(this as any as Book, hintOrOpts, fn);
   }
@@ -299,14 +282,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
 
   get advances(): Collection<Book, BookAdvance> {
     const { relations } = getInstanceData(this);
-    return relations.advances ??= hasMany(
-      this as any as Book,
-      bookAdvanceMeta,
-      "advances",
-      "book",
-      "book_id",
-      undefined,
-    );
+    return relations.advances ??= hasMany(this as any as Book, bookAdvanceMeta, "advances", "book", "book_id", undefined);
   }
 
   get reviews(): Collection<Book, BookReview> {
@@ -316,14 +292,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
 
   get comments(): Collection<Book, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comments ??= hasMany(
-      this as any as Book,
-      commentMeta,
-      "comments",
-      "parent",
-      "parent_book_id",
-      undefined,
-    );
+    return relations.comments ??= hasMany(this as any as Book, commentMeta, "comments", "parent", "parent_book_id", undefined);
   }
 
   get author(): ManyToOneReference<Book, Author, never> {
@@ -349,14 +318,6 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
 
   get tags(): Collection<Book, Tag> {
     const { relations } = getInstanceData(this);
-    return relations.tags ??= hasManyToMany(
-      this as any as Book,
-      "books_to_tags",
-      "tags",
-      "book_id",
-      tagMeta,
-      "books",
-      "tag_id",
-    );
+    return relations.tags ??= hasManyToMany(this as any as Book, "books_to_tags", "tags", "book_id", tagMeta, "books", "tag_id");
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/BookReviewCodegen.ts b/packages/tests/integration/src/entities/codegen/BookReviewCodegen.ts
index e6fb3b7d6..c0a441404 100644
--- a/packages/tests/integration/src/entities/codegen/BookReviewCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/BookReviewCodegen.ts
@@ -2,7 +2,6 @@ import {
   BaseEntity,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -41,31 +39,20 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Book,
-  bookMeta,
-  BookReview,
-  bookReviewMeta,
-  Comment,
-  commentMeta,
-  Critic,
-  criticMeta,
-  EntityManager,
-  newBookReview,
-} from "../entities";
+import { Book, bookMeta, BookReview, bookReviewMeta, Comment, commentMeta, Critic, criticMeta, EntityManager, newBookReview } from "../entities";
 import type { BookId, BookOrder, CommentId, CriticId, CriticOrder, Entity } from "../entities";
 
 export type BookReviewId = Flavor<string, BookReview>;
 
 export interface BookReviewFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  rating: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  isPublic: { kind: "primitive"; type: boolean; unique: false; nullable: never; derived: true };
-  isTest: { kind: "primitive"; type: boolean; unique: false; nullable: never; derived: true };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  book: { kind: "m2o"; type: Book; nullable: never; derived: false };
-  critic: { kind: "m2o"; type: Critic; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  rating: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  isPublic: { kind: "primitive"; type: boolean; unique: false; nullable: never; value: boolean | never; derived: true };
+  isTest: { kind: "primitive"; type: boolean; unique: false; nullable: never; value: boolean | never; derived: true };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  book: { kind: "m2o"; type: Book; nullable: never; value: BookId | never; derived: false };
+  critic: { kind: "m2o"; type: Critic; nullable: undefined; value: CriticId | undefined; derived: false };
 }
 
 export interface BookReviewOpts {
@@ -180,14 +167,11 @@ export abstract class BookReviewCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof BookReviewFields>(key: K): FieldType<BookReviewFields, K> {
+  getFieldValue<K extends keyof BookReviewFields>(key: K): BookReviewFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookReviewFields> & keyof BookReviewFields>(
-    key: K,
-    value: FieldType<BookReviewFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookReviewFields>(key: K, value: BookReviewFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -210,14 +194,8 @@ export abstract class BookReviewCodegen extends BaseEntity<EntityManager, string
   populate<H extends LoadHint<BookReview>>(hint: H): Promise<Loaded<BookReview, H>>;
   populate<H extends LoadHint<BookReview>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<BookReview, H>>;
   populate<H extends LoadHint<BookReview>, V>(hint: H, fn: (br: Loaded<BookReview, H>) => V): Promise<V>;
-  populate<H extends LoadHint<BookReview>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (br: Loaded<BookReview, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<BookReview>, V>(
-    hintOrOpts: any,
-    fn?: (br: Loaded<BookReview, H>) => V,
-  ): Promise<Loaded<BookReview, H> | V> {
+  populate<H extends LoadHint<BookReview>, V>(opts: { hint: H; forceReload?: boolean }, fn: (br: Loaded<BookReview, H>) => V): Promise<V>;
+  populate<H extends LoadHint<BookReview>, V>(hintOrOpts: any, fn?: (br: Loaded<BookReview, H>) => V): Promise<Loaded<BookReview, H> | V> {
     return this.em.populate(this as any as BookReview, hintOrOpts, fn);
   }
 
@@ -237,12 +215,6 @@ export abstract class BookReviewCodegen extends BaseEntity<EntityManager, string
 
   get comment(): OneToOneReference<BookReview, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comment ??= hasOneToOne(
-      this as any as BookReview,
-      commentMeta,
-      "comment",
-      "parent",
-      "parent_book_review_id",
-    );
+    return relations.comment ??= hasOneToOne(this as any as BookReview, commentMeta, "comment", "parent", "parent_book_review_id");
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/ChildCodegen.ts b/packages/tests/integration/src/entities/codegen/ChildCodegen.ts
index 7f4f86acd..d67e3c845 100644
--- a/packages/tests/integration/src/entities/codegen/ChildCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ChildCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,10 +41,10 @@ import type { ChildGroupId, Entity } from "../entities";
 export type ChildId = Flavor<string, Child>;
 
 export interface ChildFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface ChildOpts {
@@ -137,14 +135,11 @@ export abstract class ChildCodegen extends BaseEntity<EntityManager, string> imp
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof ChildFields>(key: K): FieldType<ChildFields, K> {
+  getFieldValue<K extends keyof ChildFields>(key: K): ChildFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ChildFields> & keyof ChildFields>(
-    key: K,
-    value: FieldType<ChildFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ChildFields>(key: K, value: ChildFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -167,14 +162,8 @@ export abstract class ChildCodegen extends BaseEntity<EntityManager, string> imp
   populate<H extends LoadHint<Child>>(hint: H): Promise<Loaded<Child, H>>;
   populate<H extends LoadHint<Child>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Child, H>>;
   populate<H extends LoadHint<Child>, V>(hint: H, fn: (child: Loaded<Child, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Child>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (child: Loaded<Child, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Child>, V>(
-    hintOrOpts: any,
-    fn?: (child: Loaded<Child, H>) => V,
-  ): Promise<Loaded<Child, H> | V> {
+  populate<H extends LoadHint<Child>, V>(opts: { hint: H; forceReload?: boolean }, fn: (child: Loaded<Child, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Child>, V>(hintOrOpts: any, fn?: (child: Loaded<Child, H>) => V): Promise<Loaded<Child, H> | V> {
     return this.em.populate(this as any as Child, hintOrOpts, fn);
   }
 
@@ -184,13 +173,6 @@ export abstract class ChildCodegen extends BaseEntity<EntityManager, string> imp
 
   get groups(): Collection<Child, ChildGroup> {
     const { relations } = getInstanceData(this);
-    return relations.groups ??= hasMany(
-      this as any as Child,
-      childGroupMeta,
-      "groups",
-      "childGroupId",
-      "child_id_group_id",
-      undefined,
-    );
+    return relations.groups ??= hasMany(this as any as Child, childGroupMeta, "groups", "childGroupId", "child_id_group_id", undefined);
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/ChildGroupCodegen.ts b/packages/tests/integration/src/entities/codegen/ChildGroupCodegen.ts
index fb1a570f1..bf4541013 100644
--- a/packages/tests/integration/src/entities/codegen/ChildGroupCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ChildGroupCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -56,12 +54,12 @@ import type { ChildId, ChildItemId, ChildOrder, Entity, ParentGroupId, ParentGro
 export type ChildGroupId = Flavor<string, ChildGroup>;
 
 export interface ChildGroupFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  childGroupId: { kind: "m2o"; type: Child; nullable: never; derived: false };
-  parentGroup: { kind: "m2o"; type: ParentGroup; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  childGroupId: { kind: "m2o"; type: Child; nullable: never; value: ChildId | never; derived: false };
+  parentGroup: { kind: "m2o"; type: ParentGroup; nullable: never; value: ParentGroupId | never; derived: false };
 }
 
 export interface ChildGroupOpts {
@@ -164,14 +162,11 @@ export abstract class ChildGroupCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof ChildGroupFields>(key: K): FieldType<ChildGroupFields, K> {
+  getFieldValue<K extends keyof ChildGroupFields>(key: K): ChildGroupFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ChildGroupFields> & keyof ChildGroupFields>(
-    key: K,
-    value: FieldType<ChildGroupFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ChildGroupFields>(key: K, value: ChildGroupFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -194,14 +189,8 @@ export abstract class ChildGroupCodegen extends BaseEntity<EntityManager, string
   populate<H extends LoadHint<ChildGroup>>(hint: H): Promise<Loaded<ChildGroup, H>>;
   populate<H extends LoadHint<ChildGroup>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<ChildGroup, H>>;
   populate<H extends LoadHint<ChildGroup>, V>(hint: H, fn: (cg: Loaded<ChildGroup, H>) => V): Promise<V>;
-  populate<H extends LoadHint<ChildGroup>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (cg: Loaded<ChildGroup, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<ChildGroup>, V>(
-    hintOrOpts: any,
-    fn?: (cg: Loaded<ChildGroup, H>) => V,
-  ): Promise<Loaded<ChildGroup, H> | V> {
+  populate<H extends LoadHint<ChildGroup>, V>(opts: { hint: H; forceReload?: boolean }, fn: (cg: Loaded<ChildGroup, H>) => V): Promise<V>;
+  populate<H extends LoadHint<ChildGroup>, V>(hintOrOpts: any, fn?: (cg: Loaded<ChildGroup, H>) => V): Promise<Loaded<ChildGroup, H> | V> {
     return this.em.populate(this as any as ChildGroup, hintOrOpts, fn);
   }
 
@@ -211,14 +200,7 @@ export abstract class ChildGroupCodegen extends BaseEntity<EntityManager, string
 
   get childItems(): Collection<ChildGroup, ChildItem> {
     const { relations } = getInstanceData(this);
-    return relations.childItems ??= hasMany(
-      this as any as ChildGroup,
-      childItemMeta,
-      "childItems",
-      "childGroup",
-      "child_group_id",
-      undefined,
-    );
+    return relations.childItems ??= hasMany(this as any as ChildGroup, childItemMeta, "childItems", "childGroup", "child_group_id", undefined);
   }
 
   get childGroupId(): ManyToOneReference<ChildGroup, Child, never> {
diff --git a/packages/tests/integration/src/entities/codegen/ChildItemCodegen.ts b/packages/tests/integration/src/entities/codegen/ChildItemCodegen.ts
index 5de1bf29c..ee52bbb0d 100644
--- a/packages/tests/integration/src/entities/codegen/ChildItemCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ChildItemCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -37,27 +35,18 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  ChildGroup,
-  childGroupMeta,
-  ChildItem,
-  childItemMeta,
-  EntityManager,
-  newChildItem,
-  ParentItem,
-  parentItemMeta,
-} from "../entities";
+import { ChildGroup, childGroupMeta, ChildItem, childItemMeta, EntityManager, newChildItem, ParentItem, parentItemMeta } from "../entities";
 import type { ChildGroupId, ChildGroupOrder, Entity, ParentItemId, ParentItemOrder } from "../entities";
 
 export type ChildItemId = Flavor<string, ChildItem>;
 
 export interface ChildItemFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  childGroup: { kind: "m2o"; type: ChildGroup; nullable: never; derived: false };
-  parentItem: { kind: "m2o"; type: ParentItem; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  childGroup: { kind: "m2o"; type: ChildGroup; nullable: never; value: ChildGroupId | never; derived: false };
+  parentItem: { kind: "m2o"; type: ParentItem; nullable: never; value: ParentItemId | never; derived: false };
 }
 
 export interface ChildItemOpts {
@@ -156,14 +145,11 @@ export abstract class ChildItemCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof ChildItemFields>(key: K): FieldType<ChildItemFields, K> {
+  getFieldValue<K extends keyof ChildItemFields>(key: K): ChildItemFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ChildItemFields> & keyof ChildItemFields>(
-    key: K,
-    value: FieldType<ChildItemFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ChildItemFields>(key: K, value: ChildItemFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -186,14 +172,8 @@ export abstract class ChildItemCodegen extends BaseEntity<EntityManager, string>
   populate<H extends LoadHint<ChildItem>>(hint: H): Promise<Loaded<ChildItem, H>>;
   populate<H extends LoadHint<ChildItem>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<ChildItem, H>>;
   populate<H extends LoadHint<ChildItem>, V>(hint: H, fn: (ci: Loaded<ChildItem, H>) => V): Promise<V>;
-  populate<H extends LoadHint<ChildItem>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (ci: Loaded<ChildItem, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<ChildItem>, V>(
-    hintOrOpts: any,
-    fn?: (ci: Loaded<ChildItem, H>) => V,
-  ): Promise<Loaded<ChildItem, H> | V> {
+  populate<H extends LoadHint<ChildItem>, V>(opts: { hint: H; forceReload?: boolean }, fn: (ci: Loaded<ChildItem, H>) => V): Promise<V>;
+  populate<H extends LoadHint<ChildItem>, V>(hintOrOpts: any, fn?: (ci: Loaded<ChildItem, H>) => V): Promise<Loaded<ChildItem, H> | V> {
     return this.em.populate(this as any as ChildItem, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/CommentCodegen.ts b/packages/tests/integration/src/entities/codegen/CommentCodegen.ts
index 82b8493ab..741b24fde 100644
--- a/packages/tests/integration/src/entities/codegen/CommentCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/CommentCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasManyToMany,
@@ -17,7 +16,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -44,19 +42,7 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Author,
-  Book,
-  BookReview,
-  Comment,
-  commentMeta,
-  EntityManager,
-  newComment,
-  Publisher,
-  TaskOld,
-  User,
-  userMeta,
-} from "../entities";
+import { Author, Book, BookReview, Comment, commentMeta, EntityManager, newComment, Publisher, TaskOld, User, userMeta } from "../entities";
 import type { Entity, UserId, UserOrder } from "../entities";
 
 export type CommentId = Flavor<string, Comment>;
@@ -70,12 +56,12 @@ export function isCommentParent(maybeEntity: unknown): maybeEntity is CommentPar
 }
 
 export interface CommentFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  text: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  user: { kind: "m2o"; type: User; nullable: undefined; derived: false };
-  parent: { kind: "poly"; type: CommentParent; nullable: never };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  text: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  user: { kind: "m2o"; type: User; nullable: undefined; value: UserId | undefined; derived: false };
+  parent: { kind: "poly"; type: CommentParent; nullable: never; value: string | never };
 }
 
 export interface CommentOpts {
@@ -176,14 +162,11 @@ export abstract class CommentCodegen extends BaseEntity<EntityManager, string> i
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof CommentFields>(key: K): FieldType<CommentFields, K> {
+  getFieldValue<K extends keyof CommentFields>(key: K): CommentFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<CommentFields> & keyof CommentFields>(
-    key: K,
-    value: FieldType<CommentFields, K>,
-  ): void {
+  setFieldValue<K extends keyof CommentFields>(key: K, value: CommentFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -206,14 +189,8 @@ export abstract class CommentCodegen extends BaseEntity<EntityManager, string> i
   populate<H extends LoadHint<Comment>>(hint: H): Promise<Loaded<Comment, H>>;
   populate<H extends LoadHint<Comment>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Comment, H>>;
   populate<H extends LoadHint<Comment>, V>(hint: H, fn: (comment: Loaded<Comment, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Comment>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (comment: Loaded<Comment, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Comment>, V>(
-    hintOrOpts: any,
-    fn?: (comment: Loaded<Comment, H>) => V,
-  ): Promise<Loaded<Comment, H> | V> {
+  populate<H extends LoadHint<Comment>, V>(opts: { hint: H; forceReload?: boolean }, fn: (comment: Loaded<Comment, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Comment>, V>(hintOrOpts: any, fn?: (comment: Loaded<Comment, H>) => V): Promise<Loaded<Comment, H> | V> {
     return this.em.populate(this as any as Comment, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/CriticCodegen.ts b/packages/tests/integration/src/entities/codegen/CriticCodegen.ts
index e0fdaf292..086c9dcc0 100644
--- a/packages/tests/integration/src/entities/codegen/CriticCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/CriticCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -16,7 +15,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -55,25 +53,17 @@ import {
   PublisherGroup,
   publisherGroupMeta,
 } from "../entities";
-import type {
-  BookReviewId,
-  CriticColumnId,
-  Entity,
-  LargePublisherId,
-  LargePublisherOrder,
-  PublisherGroupId,
-  PublisherGroupOrder,
-} from "../entities";
+import type { BookReviewId, CriticColumnId, Entity, LargePublisherId, LargePublisherOrder, PublisherGroupId, PublisherGroupOrder } from "../entities";
 
 export type CriticId = Flavor<string, Critic>;
 
 export interface CriticFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  favoriteLargePublisher: { kind: "m2o"; type: LargePublisher; nullable: undefined; derived: false };
-  group: { kind: "m2o"; type: PublisherGroup; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  favoriteLargePublisher: { kind: "m2o"; type: LargePublisher; nullable: undefined; value: LargePublisherId | undefined; derived: false };
+  group: { kind: "m2o"; type: PublisherGroup; nullable: undefined; value: PublisherGroupId | undefined; derived: false };
 }
 
 export interface CriticOpts {
@@ -179,14 +169,11 @@ export abstract class CriticCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof CriticFields>(key: K): FieldType<CriticFields, K> {
+  getFieldValue<K extends keyof CriticFields>(key: K): CriticFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<CriticFields> & keyof CriticFields>(
-    key: K,
-    value: FieldType<CriticFields, K>,
-  ): void {
+  setFieldValue<K extends keyof CriticFields>(key: K, value: CriticFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -209,14 +196,8 @@ export abstract class CriticCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Critic>>(hint: H): Promise<Loaded<Critic, H>>;
   populate<H extends LoadHint<Critic>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Critic, H>>;
   populate<H extends LoadHint<Critic>, V>(hint: H, fn: (c: Loaded<Critic, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Critic>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (c: Loaded<Critic, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Critic>, V>(
-    hintOrOpts: any,
-    fn?: (c: Loaded<Critic, H>) => V,
-  ): Promise<Loaded<Critic, H> | V> {
+  populate<H extends LoadHint<Critic>, V>(opts: { hint: H; forceReload?: boolean }, fn: (c: Loaded<Critic, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Critic>, V>(hintOrOpts: any, fn?: (c: Loaded<Critic, H>) => V): Promise<Loaded<Critic, H> | V> {
     return this.em.populate(this as any as Critic, hintOrOpts, fn);
   }
 
@@ -226,24 +207,12 @@ export abstract class CriticCodegen extends BaseEntity<EntityManager, string> im
 
   get bookReviews(): Collection<Critic, BookReview> {
     const { relations } = getInstanceData(this);
-    return relations.bookReviews ??= hasMany(
-      this as any as Critic,
-      bookReviewMeta,
-      "bookReviews",
-      "critic",
-      "critic_id",
-      undefined,
-    );
+    return relations.bookReviews ??= hasMany(this as any as Critic, bookReviewMeta, "bookReviews", "critic", "critic_id", undefined);
   }
 
   get favoriteLargePublisher(): ManyToOneReference<Critic, LargePublisher, undefined> {
     const { relations } = getInstanceData(this);
-    return relations.favoriteLargePublisher ??= hasOne(
-      this as any as Critic,
-      largePublisherMeta,
-      "favoriteLargePublisher",
-      "critics",
-    );
+    return relations.favoriteLargePublisher ??= hasOne(this as any as Critic, largePublisherMeta, "favoriteLargePublisher", "critics");
   }
 
   get group(): ManyToOneReference<Critic, PublisherGroup, undefined> {
@@ -253,12 +222,6 @@ export abstract class CriticCodegen extends BaseEntity<EntityManager, string> im
 
   get criticColumn(): OneToOneReference<Critic, CriticColumn> {
     const { relations } = getInstanceData(this);
-    return relations.criticColumn ??= hasOneToOne(
-      this as any as Critic,
-      criticColumnMeta,
-      "criticColumn",
-      "critic",
-      "critic_id",
-    );
+    return relations.criticColumn ??= hasOneToOne(this as any as Critic, criticColumnMeta, "criticColumn", "critic", "critic_id");
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/CriticColumnCodegen.ts b/packages/tests/integration/src/entities/codegen/CriticColumnCodegen.ts
index 28d4f8ac2..307b78771 100644
--- a/packages/tests/integration/src/entities/codegen/CriticColumnCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/CriticColumnCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { CriticId, CriticOrder, Entity } from "../entities";
 export type CriticColumnId = Flavor<string, CriticColumn>;
 
 export interface CriticColumnFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  critic: { kind: "m2o"; type: Critic; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  critic: { kind: "m2o"; type: Critic; nullable: never; value: CriticId | never; derived: false };
 }
 
 export interface CriticColumnOpts {
@@ -141,14 +139,11 @@ export abstract class CriticColumnCodegen extends BaseEntity<EntityManager, stri
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof CriticColumnFields>(key: K): FieldType<CriticColumnFields, K> {
+  getFieldValue<K extends keyof CriticColumnFields>(key: K): CriticColumnFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<CriticColumnFields> & keyof CriticColumnFields>(
-    key: K,
-    value: FieldType<CriticColumnFields, K>,
-  ): void {
+  setFieldValue<K extends keyof CriticColumnFields>(key: K, value: CriticColumnFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -169,18 +164,10 @@ export abstract class CriticColumnCodegen extends BaseEntity<EntityManager, stri
   }
 
   populate<H extends LoadHint<CriticColumn>>(hint: H): Promise<Loaded<CriticColumn, H>>;
-  populate<H extends LoadHint<CriticColumn>>(
-    opts: { hint: H; forceReload?: boolean },
-  ): Promise<Loaded<CriticColumn, H>>;
+  populate<H extends LoadHint<CriticColumn>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<CriticColumn, H>>;
   populate<H extends LoadHint<CriticColumn>, V>(hint: H, fn: (cc: Loaded<CriticColumn, H>) => V): Promise<V>;
-  populate<H extends LoadHint<CriticColumn>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (cc: Loaded<CriticColumn, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<CriticColumn>, V>(
-    hintOrOpts: any,
-    fn?: (cc: Loaded<CriticColumn, H>) => V,
-  ): Promise<Loaded<CriticColumn, H> | V> {
+  populate<H extends LoadHint<CriticColumn>, V>(opts: { hint: H; forceReload?: boolean }, fn: (cc: Loaded<CriticColumn, H>) => V): Promise<V>;
+  populate<H extends LoadHint<CriticColumn>, V>(hintOrOpts: any, fn?: (cc: Loaded<CriticColumn, H>) => V): Promise<Loaded<CriticColumn, H> | V> {
     return this.em.populate(this as any as CriticColumn, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/ImageCodegen.ts b/packages/tests/integration/src/entities/codegen/ImageCodegen.ts
index 8db06a786..1f895b72b 100644
--- a/packages/tests/integration/src/entities/codegen/ImageCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ImageCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -57,14 +55,14 @@ import type { AuthorId, AuthorOrder, BookId, BookOrder, Entity, PublisherId, Pub
 export type ImageId = Flavor<string, Image>;
 
 export interface ImageFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  fileName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  type: { kind: "enum"; type: ImageType; nullable: never };
-  author: { kind: "m2o"; type: Author; nullable: undefined; derived: false };
-  book: { kind: "m2o"; type: Book; nullable: undefined; derived: false };
-  publisher: { kind: "m2o"; type: Publisher; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  fileName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  type: { kind: "enum"; type: ImageType; nullable: never; value: ImageType | never };
+  author: { kind: "m2o"; type: Author; nullable: undefined; value: AuthorId | undefined; derived: false };
+  book: { kind: "m2o"; type: Book; nullable: undefined; value: BookId | undefined; derived: false };
+  publisher: { kind: "m2o"; type: Publisher; nullable: undefined; value: PublisherId | undefined; derived: false };
 }
 
 export interface ImageOpts {
@@ -196,14 +194,11 @@ export abstract class ImageCodegen extends BaseEntity<EntityManager, string> imp
     return getField(this, "type") === ImageType.PublisherImage;
   }
 
-  getFieldValue<K extends keyof ImageFields>(key: K): FieldType<ImageFields, K> {
+  getFieldValue<K extends keyof ImageFields>(key: K): ImageFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ImageFields> & keyof ImageFields>(
-    key: K,
-    value: FieldType<ImageFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ImageFields>(key: K, value: ImageFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -226,14 +221,8 @@ export abstract class ImageCodegen extends BaseEntity<EntityManager, string> imp
   populate<H extends LoadHint<Image>>(hint: H): Promise<Loaded<Image, H>>;
   populate<H extends LoadHint<Image>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Image, H>>;
   populate<H extends LoadHint<Image>, V>(hint: H, fn: (i: Loaded<Image, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Image>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (i: Loaded<Image, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Image>, V>(
-    hintOrOpts: any,
-    fn?: (i: Loaded<Image, H>) => V,
-  ): Promise<Loaded<Image, H> | V> {
+  populate<H extends LoadHint<Image>, V>(opts: { hint: H; forceReload?: boolean }, fn: (i: Loaded<Image, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Image>, V>(hintOrOpts: any, fn?: (i: Loaded<Image, H>) => V): Promise<Loaded<Image, H> | V> {
     return this.em.populate(this as any as Image, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/LargePublisherCodegen.ts b/packages/tests/integration/src/entities/codegen/LargePublisherCodegen.ts
index 36cbe8c7b..0f79ecf1f 100644
--- a/packages/tests/integration/src/entities/codegen/LargePublisherCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/LargePublisherCodegen.ts
@@ -2,7 +2,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -12,7 +11,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -35,17 +33,7 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Critic,
-  criticMeta,
-  EntityManager,
-  LargePublisher,
-  largePublisherMeta,
-  newLargePublisher,
-  Publisher,
-  User,
-  userMeta,
-} from "../entities";
+import { Critic, criticMeta, EntityManager, LargePublisher, largePublisherMeta, newLargePublisher, Publisher, User, userMeta } from "../entities";
 import type {
   CriticId,
   Entity,
@@ -61,9 +49,9 @@ import type {
 export type LargePublisherId = Flavor<string, LargePublisher> & Flavor<string, "Publisher">;
 
 export interface LargePublisherFields extends PublisherFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  sharedColumn: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  country: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  sharedColumn: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  country: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
 }
 
 export interface LargePublisherOpts extends PublisherOpts {
@@ -150,14 +138,11 @@ export abstract class LargePublisherCodegen extends Publisher implements Entity
     setField(this, "country", cleanStringValue(country));
   }
 
-  getFieldValue<K extends keyof LargePublisherFields>(key: K): FieldType<LargePublisherFields, K> {
+  getFieldValue<K extends keyof LargePublisherFields>(key: K): LargePublisherFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<LargePublisherFields> & keyof LargePublisherFields>(
-    key: K,
-    value: FieldType<LargePublisherFields, K>,
-  ): void {
+  setFieldValue<K extends keyof LargePublisherFields>(key: K, value: LargePublisherFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -178,18 +163,10 @@ export abstract class LargePublisherCodegen extends Publisher implements Entity
   }
 
   populate<H extends LoadHint<LargePublisher>>(hint: H): Promise<Loaded<LargePublisher, H>>;
-  populate<H extends LoadHint<LargePublisher>>(
-    opts: { hint: H; forceReload?: boolean },
-  ): Promise<Loaded<LargePublisher, H>>;
+  populate<H extends LoadHint<LargePublisher>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<LargePublisher, H>>;
   populate<H extends LoadHint<LargePublisher>, V>(hint: H, fn: (p: Loaded<LargePublisher, H>) => V): Promise<V>;
-  populate<H extends LoadHint<LargePublisher>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (p: Loaded<LargePublisher, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<LargePublisher>, V>(
-    hintOrOpts: any,
-    fn?: (p: Loaded<LargePublisher, H>) => V,
-  ): Promise<Loaded<LargePublisher, H> | V> {
+  populate<H extends LoadHint<LargePublisher>, V>(opts: { hint: H; forceReload?: boolean }, fn: (p: Loaded<LargePublisher, H>) => V): Promise<V>;
+  populate<H extends LoadHint<LargePublisher>, V>(hintOrOpts: any, fn?: (p: Loaded<LargePublisher, H>) => V): Promise<Loaded<LargePublisher, H> | V> {
     return this.em.populate(this as any as LargePublisher, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/ParentGroupCodegen.ts b/packages/tests/integration/src/entities/codegen/ParentGroupCodegen.ts
index 4140c2e80..bba038e41 100644
--- a/packages/tests/integration/src/entities/codegen/ParentGroupCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ParentGroupCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -37,25 +35,16 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  ChildGroup,
-  childGroupMeta,
-  EntityManager,
-  newParentGroup,
-  ParentGroup,
-  parentGroupMeta,
-  ParentItem,
-  parentItemMeta,
-} from "../entities";
+import { ChildGroup, childGroupMeta, EntityManager, newParentGroup, ParentGroup, parentGroupMeta, ParentItem, parentItemMeta } from "../entities";
 import type { ChildGroupId, Entity, ParentItemId } from "../entities";
 
 export type ParentGroupId = Flavor<string, ParentGroup>;
 
 export interface ParentGroupFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface ParentGroupOpts {
@@ -150,14 +139,11 @@ export abstract class ParentGroupCodegen extends BaseEntity<EntityManager, strin
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof ParentGroupFields>(key: K): FieldType<ParentGroupFields, K> {
+  getFieldValue<K extends keyof ParentGroupFields>(key: K): ParentGroupFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ParentGroupFields> & keyof ParentGroupFields>(
-    key: K,
-    value: FieldType<ParentGroupFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ParentGroupFields>(key: K, value: ParentGroupFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -180,10 +166,7 @@ export abstract class ParentGroupCodegen extends BaseEntity<EntityManager, strin
   populate<H extends LoadHint<ParentGroup>>(hint: H): Promise<Loaded<ParentGroup, H>>;
   populate<H extends LoadHint<ParentGroup>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<ParentGroup, H>>;
   populate<H extends LoadHint<ParentGroup>, V>(hint: H, fn: (parentGroup: Loaded<ParentGroup, H>) => V): Promise<V>;
-  populate<H extends LoadHint<ParentGroup>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (parentGroup: Loaded<ParentGroup, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<ParentGroup>, V>(opts: { hint: H; forceReload?: boolean }, fn: (parentGroup: Loaded<ParentGroup, H>) => V): Promise<V>;
   populate<H extends LoadHint<ParentGroup>, V>(
     hintOrOpts: any,
     fn?: (parentGroup: Loaded<ParentGroup, H>) => V,
@@ -197,25 +180,11 @@ export abstract class ParentGroupCodegen extends BaseEntity<EntityManager, strin
 
   get childGroups(): Collection<ParentGroup, ChildGroup> {
     const { relations } = getInstanceData(this);
-    return relations.childGroups ??= hasMany(
-      this as any as ParentGroup,
-      childGroupMeta,
-      "childGroups",
-      "parentGroup",
-      "parent_group_id",
-      undefined,
-    );
+    return relations.childGroups ??= hasMany(this as any as ParentGroup, childGroupMeta, "childGroups", "parentGroup", "parent_group_id", undefined);
   }
 
   get parentItems(): Collection<ParentGroup, ParentItem> {
     const { relations } = getInstanceData(this);
-    return relations.parentItems ??= hasMany(
-      this as any as ParentGroup,
-      parentItemMeta,
-      "parentItems",
-      "parentGroup",
-      "parent_group_id",
-      undefined,
-    );
+    return relations.parentItems ??= hasMany(this as any as ParentGroup, parentItemMeta, "parentItems", "parentGroup", "parent_group_id", undefined);
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/ParentItemCodegen.ts b/packages/tests/integration/src/entities/codegen/ParentItemCodegen.ts
index dd9a8cdc8..e13e26dc8 100644
--- a/packages/tests/integration/src/entities/codegen/ParentItemCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ParentItemCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -39,26 +37,17 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  ChildItem,
-  childItemMeta,
-  EntityManager,
-  newParentItem,
-  ParentGroup,
-  parentGroupMeta,
-  ParentItem,
-  parentItemMeta,
-} from "../entities";
+import { ChildItem, childItemMeta, EntityManager, newParentItem, ParentGroup, parentGroupMeta, ParentItem, parentItemMeta } from "../entities";
 import type { ChildItemId, Entity, ParentGroupId, ParentGroupOrder } from "../entities";
 
 export type ParentItemId = Flavor<string, ParentItem>;
 
 export interface ParentItemFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  parentGroup: { kind: "m2o"; type: ParentGroup; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  parentGroup: { kind: "m2o"; type: ParentGroup; nullable: never; value: ParentGroupId | never; derived: false };
 }
 
 export interface ParentItemOpts {
@@ -155,14 +144,11 @@ export abstract class ParentItemCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof ParentItemFields>(key: K): FieldType<ParentItemFields, K> {
+  getFieldValue<K extends keyof ParentItemFields>(key: K): ParentItemFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ParentItemFields> & keyof ParentItemFields>(
-    key: K,
-    value: FieldType<ParentItemFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ParentItemFields>(key: K, value: ParentItemFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -185,14 +171,8 @@ export abstract class ParentItemCodegen extends BaseEntity<EntityManager, string
   populate<H extends LoadHint<ParentItem>>(hint: H): Promise<Loaded<ParentItem, H>>;
   populate<H extends LoadHint<ParentItem>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<ParentItem, H>>;
   populate<H extends LoadHint<ParentItem>, V>(hint: H, fn: (pi: Loaded<ParentItem, H>) => V): Promise<V>;
-  populate<H extends LoadHint<ParentItem>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (pi: Loaded<ParentItem, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<ParentItem>, V>(
-    hintOrOpts: any,
-    fn?: (pi: Loaded<ParentItem, H>) => V,
-  ): Promise<Loaded<ParentItem, H> | V> {
+  populate<H extends LoadHint<ParentItem>, V>(opts: { hint: H; forceReload?: boolean }, fn: (pi: Loaded<ParentItem, H>) => V): Promise<V>;
+  populate<H extends LoadHint<ParentItem>, V>(hintOrOpts: any, fn?: (pi: Loaded<ParentItem, H>) => V): Promise<Loaded<ParentItem, H> | V> {
     return this.em.populate(this as any as ParentItem, hintOrOpts, fn);
   }
 
@@ -202,14 +182,7 @@ export abstract class ParentItemCodegen extends BaseEntity<EntityManager, string
 
   get childItems(): Collection<ParentItem, ChildItem> {
     const { relations } = getInstanceData(this);
-    return relations.childItems ??= hasMany(
-      this as any as ParentItem,
-      childItemMeta,
-      "childItems",
-      "parentItem",
-      "parent_item_id",
-      undefined,
-    );
+    return relations.childItems ??= hasMany(this as any as ParentItem, childItemMeta, "childItems", "parentItem", "parent_item_id", undefined);
   }
 
   get parentGroup(): ManyToOneReference<ParentItem, ParentGroup, never> {
diff --git a/packages/tests/integration/src/entities/codegen/PublisherCodegen.ts b/packages/tests/integration/src/entities/codegen/PublisherCodegen.ts
index 84180fda7..0a868063e 100644
--- a/packages/tests/integration/src/entities/codegen/PublisherCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/PublisherCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -16,7 +15,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -70,33 +68,23 @@ import {
   TaskOld,
   taskOldMeta,
 } from "../entities";
-import type {
-  AuthorId,
-  BookAdvanceId,
-  CommentId,
-  Entity,
-  ImageId,
-  PublisherGroupId,
-  PublisherGroupOrder,
-  TagId,
-  TaskOldId,
-} from "../entities";
+import type { AuthorId, BookAdvanceId, CommentId, Entity, ImageId, PublisherGroupId, PublisherGroupOrder, TagId, TaskOldId } from "../entities";
 
 export type PublisherId = Flavor<string, Publisher>;
 
 export interface PublisherFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  latitude: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: false };
-  longitude: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: false };
-  hugeNumber: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: false };
-  numberOfBookReviews: { kind: "primitive"; type: number; unique: false; nullable: never; derived: true };
-  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  size: { kind: "enum"; type: PublisherSize; nullable: undefined };
-  type: { kind: "enum"; type: PublisherType; nullable: never };
-  group: { kind: "m2o"; type: PublisherGroup; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  latitude: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: false };
+  longitude: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: false };
+  hugeNumber: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: false };
+  numberOfBookReviews: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: true };
+  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; value: Date | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  size: { kind: "enum"; type: PublisherSize; nullable: undefined; value: PublisherSize | undefined };
+  type: { kind: "enum"; type: PublisherType; nullable: never; value: PublisherType | never };
+  group: { kind: "m2o"; type: PublisherGroup; nullable: undefined; value: PublisherGroupId | undefined; derived: false };
 }
 
 export interface PublisherOpts {
@@ -322,14 +310,11 @@ export abstract class PublisherCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "type") === PublisherType.Big;
   }
 
-  getFieldValue<K extends keyof PublisherFields>(key: K): FieldType<PublisherFields, K> {
+  getFieldValue<K extends keyof PublisherFields>(key: K): PublisherFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<PublisherFields> & keyof PublisherFields>(
-    key: K,
-    value: FieldType<PublisherFields, K>,
-  ): void {
+  setFieldValue<K extends keyof PublisherFields>(key: K, value: PublisherFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -341,10 +326,7 @@ export abstract class PublisherCodegen extends BaseEntity<EntityManager, string>
     setOpts(this as any, opts as OptsOf<Publisher>, { partial: true });
   }
 
-  get changes(): Changes<
-    Publisher,
-    keyof FieldsOf<Publisher> | keyof FieldsOf<LargePublisher> | keyof FieldsOf<SmallPublisher>
-  > {
+  get changes(): Changes<Publisher, keyof FieldsOf<Publisher> | keyof FieldsOf<LargePublisher> | keyof FieldsOf<SmallPublisher>> {
     return newChangesProxy(this) as any;
   }
 
@@ -359,14 +341,8 @@ export abstract class PublisherCodegen extends BaseEntity<EntityManager, string>
   populate<H extends LoadHint<Publisher>>(hint: H): Promise<Loaded<Publisher, H>>;
   populate<H extends LoadHint<Publisher>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Publisher, H>>;
   populate<H extends LoadHint<Publisher>, V>(hint: H, fn: (p: Loaded<Publisher, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Publisher>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (p: Loaded<Publisher, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Publisher>, V>(
-    hintOrOpts: any,
-    fn?: (p: Loaded<Publisher, H>) => V,
-  ): Promise<Loaded<Publisher, H> | V> {
+  populate<H extends LoadHint<Publisher>, V>(opts: { hint: H; forceReload?: boolean }, fn: (p: Loaded<Publisher, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Publisher>, V>(hintOrOpts: any, fn?: (p: Loaded<Publisher, H>) => V): Promise<Loaded<Publisher, H> | V> {
     return this.em.populate(this as any as Publisher, hintOrOpts, fn);
   }
 
@@ -376,50 +352,22 @@ export abstract class PublisherCodegen extends BaseEntity<EntityManager, string>
 
   get authors(): Collection<Publisher, Author> {
     const { relations } = getInstanceData(this);
-    return relations.authors ??= hasMany(
-      this as any as Publisher,
-      authorMeta,
-      "authors",
-      "publisher",
-      "publisher_id",
-      undefined,
-    );
+    return relations.authors ??= hasMany(this as any as Publisher, authorMeta, "authors", "publisher", "publisher_id", undefined);
   }
 
   get bookAdvances(): Collection<Publisher, BookAdvance> {
     const { relations } = getInstanceData(this);
-    return relations.bookAdvances ??= hasMany(
-      this as any as Publisher,
-      bookAdvanceMeta,
-      "bookAdvances",
-      "publisher",
-      "publisher_id",
-      undefined,
-    );
+    return relations.bookAdvances ??= hasMany(this as any as Publisher, bookAdvanceMeta, "bookAdvances", "publisher", "publisher_id", undefined);
   }
 
   get comments(): Collection<Publisher, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comments ??= hasMany(
-      this as any as Publisher,
-      commentMeta,
-      "comments",
-      "parent",
-      "parent_publisher_id",
-      undefined,
-    );
+    return relations.comments ??= hasMany(this as any as Publisher, commentMeta, "comments", "parent", "parent_publisher_id", undefined);
   }
 
   get images(): Collection<Publisher, Image> {
     const { relations } = getInstanceData(this);
-    return relations.images ??= hasMany(
-      this as any as Publisher,
-      imageMeta,
-      "images",
-      "publisher",
-      "publisher_id",
-      undefined,
-    );
+    return relations.images ??= hasMany(this as any as Publisher, imageMeta, "images", "publisher", "publisher_id", undefined);
   }
 
   get group(): ManyToOneReference<Publisher, PublisherGroup, undefined> {
@@ -429,15 +377,7 @@ export abstract class PublisherCodegen extends BaseEntity<EntityManager, string>
 
   get tags(): Collection<Publisher, Tag> {
     const { relations } = getInstanceData(this);
-    return relations.tags ??= hasManyToMany(
-      this as any as Publisher,
-      "publishers_to_tags",
-      "tags",
-      "publisher_id",
-      tagMeta,
-      "publishers",
-      "tag_id",
-    );
+    return relations.tags ??= hasManyToMany(this as any as Publisher, "publishers_to_tags", "tags", "publisher_id", tagMeta, "publishers", "tag_id");
   }
 
   get tasks(): Collection<Publisher, TaskOld> {
diff --git a/packages/tests/integration/src/entities/codegen/PublisherGroupCodegen.ts b/packages/tests/integration/src/entities/codegen/PublisherGroupCodegen.ts
index bd5cf54a0..0e12c0757 100644
--- a/packages/tests/integration/src/entities/codegen/PublisherGroupCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/PublisherGroupCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasLargeMany,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -40,26 +38,17 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Critic,
-  criticMeta,
-  EntityManager,
-  newPublisherGroup,
-  Publisher,
-  PublisherGroup,
-  publisherGroupMeta,
-  publisherMeta,
-} from "../entities";
+import { Critic, criticMeta, EntityManager, newPublisherGroup, Publisher, PublisherGroup, publisherGroupMeta, publisherMeta } from "../entities";
 import type { Entity, PublisherId } from "../entities";
 
 export type PublisherGroupId = Flavor<string, PublisherGroup>;
 
 export interface PublisherGroupFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  numberOfBookReviews: { kind: "primitive"; type: number; unique: false; nullable: never; derived: true };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  numberOfBookReviews: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: true };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface PublisherGroupOpts {
@@ -156,14 +145,11 @@ export abstract class PublisherGroupCodegen extends BaseEntity<EntityManager, st
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof PublisherGroupFields>(key: K): FieldType<PublisherGroupFields, K> {
+  getFieldValue<K extends keyof PublisherGroupFields>(key: K): PublisherGroupFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<PublisherGroupFields> & keyof PublisherGroupFields>(
-    key: K,
-    value: FieldType<PublisherGroupFields, K>,
-  ): void {
+  setFieldValue<K extends keyof PublisherGroupFields>(key: K, value: PublisherGroupFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -184,14 +170,9 @@ export abstract class PublisherGroupCodegen extends BaseEntity<EntityManager, st
   }
 
   populate<H extends LoadHint<PublisherGroup>>(hint: H): Promise<Loaded<PublisherGroup, H>>;
-  populate<H extends LoadHint<PublisherGroup>>(
-    opts: { hint: H; forceReload?: boolean },
-  ): Promise<Loaded<PublisherGroup, H>>;
+  populate<H extends LoadHint<PublisherGroup>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<PublisherGroup, H>>;
   populate<H extends LoadHint<PublisherGroup>, V>(hint: H, fn: (pg: Loaded<PublisherGroup, H>) => V): Promise<V>;
-  populate<H extends LoadHint<PublisherGroup>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (pg: Loaded<PublisherGroup, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<PublisherGroup>, V>(opts: { hint: H; forceReload?: boolean }, fn: (pg: Loaded<PublisherGroup, H>) => V): Promise<V>;
   populate<H extends LoadHint<PublisherGroup>, V>(
     hintOrOpts: any,
     fn?: (pg: Loaded<PublisherGroup, H>) => V,
@@ -205,24 +186,11 @@ export abstract class PublisherGroupCodegen extends BaseEntity<EntityManager, st
 
   get publishers(): Collection<PublisherGroup, Publisher> {
     const { relations } = getInstanceData(this);
-    return relations.publishers ??= hasMany(
-      this as any as PublisherGroup,
-      publisherMeta,
-      "publishers",
-      "group",
-      "group_id",
-      undefined,
-    );
+    return relations.publishers ??= hasMany(this as any as PublisherGroup, publisherMeta, "publishers", "group", "group_id", undefined);
   }
 
   get critics(): LargeCollection<PublisherGroup, Critic> {
     const { relations } = getInstanceData(this);
-    return relations.critics ??= hasLargeMany(
-      this as any as PublisherGroup,
-      criticMeta,
-      "critics",
-      "group",
-      "group_id",
-    );
+    return relations.critics ??= hasLargeMany(this as any as PublisherGroup, criticMeta, "critics", "group", "group_id");
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/SmallPublisherCodegen.ts b/packages/tests/integration/src/entities/codegen/SmallPublisherCodegen.ts
index dfd29277f..56a4f17d8 100644
--- a/packages/tests/integration/src/entities/codegen/SmallPublisherCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/SmallPublisherCodegen.ts
@@ -2,7 +2,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -13,7 +12,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -37,15 +35,7 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  EntityManager,
-  newSmallPublisher,
-  Publisher,
-  SmallPublisher,
-  smallPublisherMeta,
-  User,
-  userMeta,
-} from "../entities";
+import { EntityManager, newSmallPublisher, Publisher, SmallPublisher, smallPublisherMeta, User, userMeta } from "../entities";
 import type {
   Entity,
   PublisherFields,
@@ -60,10 +50,10 @@ import type {
 export type SmallPublisherId = Flavor<string, SmallPublisher> & Flavor<string, "Publisher">;
 
 export interface SmallPublisherFields extends PublisherFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  city: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  sharedColumn: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  allAuthorNames: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  city: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  sharedColumn: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  allAuthorNames: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: true };
 }
 
 export interface SmallPublisherOpts extends PublisherOpts {
@@ -153,14 +143,11 @@ export abstract class SmallPublisherCodegen extends Publisher implements Entity
 
   abstract readonly allAuthorNames: ReactiveField<SmallPublisher, string | undefined>;
 
-  getFieldValue<K extends keyof SmallPublisherFields>(key: K): FieldType<SmallPublisherFields, K> {
+  getFieldValue<K extends keyof SmallPublisherFields>(key: K): SmallPublisherFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<SmallPublisherFields> & keyof SmallPublisherFields>(
-    key: K,
-    value: FieldType<SmallPublisherFields, K>,
-  ): void {
+  setFieldValue<K extends keyof SmallPublisherFields>(key: K, value: SmallPublisherFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -181,18 +168,10 @@ export abstract class SmallPublisherCodegen extends Publisher implements Entity
   }
 
   populate<H extends LoadHint<SmallPublisher>>(hint: H): Promise<Loaded<SmallPublisher, H>>;
-  populate<H extends LoadHint<SmallPublisher>>(
-    opts: { hint: H; forceReload?: boolean },
-  ): Promise<Loaded<SmallPublisher, H>>;
+  populate<H extends LoadHint<SmallPublisher>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<SmallPublisher, H>>;
   populate<H extends LoadHint<SmallPublisher>, V>(hint: H, fn: (p: Loaded<SmallPublisher, H>) => V): Promise<V>;
-  populate<H extends LoadHint<SmallPublisher>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (p: Loaded<SmallPublisher, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<SmallPublisher>, V>(
-    hintOrOpts: any,
-    fn?: (p: Loaded<SmallPublisher, H>) => V,
-  ): Promise<Loaded<SmallPublisher, H> | V> {
+  populate<H extends LoadHint<SmallPublisher>, V>(opts: { hint: H; forceReload?: boolean }, fn: (p: Loaded<SmallPublisher, H>) => V): Promise<V>;
+  populate<H extends LoadHint<SmallPublisher>, V>(hintOrOpts: any, fn?: (p: Loaded<SmallPublisher, H>) => V): Promise<Loaded<SmallPublisher, H> | V> {
     return this.em.populate(this as any as SmallPublisher, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/TagCodegen.ts b/packages/tests/integration/src/entities/codegen/TagCodegen.ts
index 5bf221e12..41805b6c4 100644
--- a/packages/tests/integration/src/entities/codegen/TagCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TagCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasLargeManyToMany,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -39,27 +37,16 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Author,
-  authorMeta,
-  Book,
-  bookMeta,
-  EntityManager,
-  newTag,
-  Publisher,
-  publisherMeta,
-  Tag,
-  tagMeta,
-} from "../entities";
+import { Author, authorMeta, Book, bookMeta, EntityManager, newTag, Publisher, publisherMeta, Tag, tagMeta } from "../entities";
 import type { BookId, Entity, PublisherId } from "../entities";
 
 export type TagId = Flavor<string, Tag>;
 
 export interface TagFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface TagOpts {
@@ -155,14 +142,11 @@ export abstract class TagCodegen extends BaseEntity<EntityManager, string> imple
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof TagFields>(key: K): FieldType<TagFields, K> {
+  getFieldValue<K extends keyof TagFields>(key: K): TagFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<TagFields> & keyof TagFields>(
-    key: K,
-    value: FieldType<TagFields, K>,
-  ): void {
+  setFieldValue<K extends keyof TagFields>(key: K, value: TagFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -185,10 +169,7 @@ export abstract class TagCodegen extends BaseEntity<EntityManager, string> imple
   populate<H extends LoadHint<Tag>>(hint: H): Promise<Loaded<Tag, H>>;
   populate<H extends LoadHint<Tag>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Tag, H>>;
   populate<H extends LoadHint<Tag>, V>(hint: H, fn: (t: Loaded<Tag, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Tag>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (t: Loaded<Tag, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Tag>, V>(opts: { hint: H; forceReload?: boolean }, fn: (t: Loaded<Tag, H>) => V): Promise<V>;
   populate<H extends LoadHint<Tag>, V>(hintOrOpts: any, fn?: (t: Loaded<Tag, H>) => V): Promise<Loaded<Tag, H> | V> {
     return this.em.populate(this as any as Tag, hintOrOpts, fn);
   }
@@ -199,15 +180,7 @@ export abstract class TagCodegen extends BaseEntity<EntityManager, string> imple
 
   get books(): Collection<Tag, Book> {
     const { relations } = getInstanceData(this);
-    return relations.books ??= hasManyToMany(
-      this as any as Tag,
-      "books_to_tags",
-      "books",
-      "tag_id",
-      bookMeta,
-      "tags",
-      "book_id",
-    );
+    return relations.books ??= hasManyToMany(this as any as Tag, "books_to_tags", "books", "tag_id", bookMeta, "tags", "book_id");
   }
 
   get publishers(): Collection<Tag, Publisher> {
@@ -225,14 +198,6 @@ export abstract class TagCodegen extends BaseEntity<EntityManager, string> imple
 
   get authors(): LargeCollection<Tag, Author> {
     const { relations } = getInstanceData(this);
-    return relations.authors ??= hasLargeManyToMany(
-      this as any as Tag,
-      "authors_to_tags",
-      "authors",
-      "tag_id",
-      authorMeta,
-      "tags",
-      "author_id",
-    );
+    return relations.authors ??= hasLargeManyToMany(this as any as Tag, "authors_to_tags", "authors", "tag_id", authorMeta, "tags", "author_id");
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/TaskCodegen.ts b/packages/tests/integration/src/entities/codegen/TaskCodegen.ts
index 57eb7ddcf..c49ff5c94 100644
--- a/packages/tests/integration/src/entities/codegen/TaskCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskCodegen.ts
@@ -3,7 +3,6 @@ import {
   cannotBeUpdated,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -38,30 +36,18 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  EntityManager,
-  newTask,
-  Task,
-  TaskItem,
-  taskItemMeta,
-  taskMeta,
-  TaskNew,
-  TaskOld,
-  TaskType,
-  TaskTypeDetails,
-  TaskTypes,
-} from "../entities";
+import { EntityManager, newTask, Task, TaskItem, taskItemMeta, taskMeta, TaskNew, TaskOld, TaskType, TaskTypeDetails, TaskTypes } from "../entities";
 import type { Entity, TaskItemId } from "../entities";
 
 export type TaskId = Flavor<string, Task>;
 
 export interface TaskFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  durationInDays: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  type: { kind: "enum"; type: TaskType; nullable: undefined };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  durationInDays: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  deletedAt: { kind: "primitive"; type: Date; unique: false; nullable: undefined; value: Date | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  type: { kind: "enum"; type: TaskType; nullable: undefined; value: TaskType | undefined };
 }
 
 export interface TaskOpts {
@@ -189,14 +175,11 @@ export abstract class TaskCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "type") === TaskType.New;
   }
 
-  getFieldValue<K extends keyof TaskFields>(key: K): FieldType<TaskFields, K> {
+  getFieldValue<K extends keyof TaskFields>(key: K): TaskFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<TaskFields> & keyof TaskFields>(
-    key: K,
-    value: FieldType<TaskFields, K>,
-  ): void {
+  setFieldValue<K extends keyof TaskFields>(key: K, value: TaskFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -223,14 +206,8 @@ export abstract class TaskCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<Task>>(hint: H): Promise<Loaded<Task, H>>;
   populate<H extends LoadHint<Task>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Task, H>>;
   populate<H extends LoadHint<Task>, V>(hint: H, fn: (task: Loaded<Task, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Task>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (task: Loaded<Task, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Task>, V>(
-    hintOrOpts: any,
-    fn?: (task: Loaded<Task, H>) => V,
-  ): Promise<Loaded<Task, H> | V> {
+  populate<H extends LoadHint<Task>, V>(opts: { hint: H; forceReload?: boolean }, fn: (task: Loaded<Task, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Task>, V>(hintOrOpts: any, fn?: (task: Loaded<Task, H>) => V): Promise<Loaded<Task, H> | V> {
     return this.em.populate(this as any as Task, hintOrOpts, fn);
   }
 
@@ -240,13 +217,6 @@ export abstract class TaskCodegen extends BaseEntity<EntityManager, string> impl
 
   get taskTaskItems(): Collection<Task, TaskItem> {
     const { relations } = getInstanceData(this);
-    return relations.taskTaskItems ??= hasMany(
-      this as any as Task,
-      taskItemMeta,
-      "taskTaskItems",
-      "task",
-      "task_id",
-      undefined,
-    );
+    return relations.taskTaskItems ??= hasMany(this as any as Task, taskItemMeta, "taskTaskItems", "task", "task_id", undefined);
   }
 }
diff --git a/packages/tests/integration/src/entities/codegen/TaskItemCodegen.ts b/packages/tests/integration/src/entities/codegen/TaskItemCodegen.ts
index 10c8c837f..45d816b64 100644
--- a/packages/tests/integration/src/entities/codegen/TaskItemCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskItemCodegen.ts
@@ -2,7 +2,6 @@ import {
   BaseEntity,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -13,7 +12,6 @@ import {
   newRequiredRule,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -36,29 +34,18 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  EntityManager,
-  newTaskItem,
-  Task,
-  TaskItem,
-  taskItemMeta,
-  taskMeta,
-  TaskNew,
-  taskNewMeta,
-  TaskOld,
-  taskOldMeta,
-} from "../entities";
+import { EntityManager, newTaskItem, Task, TaskItem, taskItemMeta, taskMeta, TaskNew, taskNewMeta, TaskOld, taskOldMeta } from "../entities";
 import type { Entity, TaskId, TaskNewId, TaskNewOrder, TaskOldId, TaskOldOrder, TaskOrder } from "../entities";
 
 export type TaskItemId = Flavor<string, TaskItem>;
 
 export interface TaskItemFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  newTask: { kind: "m2o"; type: TaskNew; nullable: undefined; derived: false };
-  oldTask: { kind: "m2o"; type: TaskOld; nullable: undefined; derived: false };
-  task: { kind: "m2o"; type: Task; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  newTask: { kind: "m2o"; type: TaskNew; nullable: undefined; value: TaskNewId | undefined; derived: false };
+  oldTask: { kind: "m2o"; type: TaskOld; nullable: undefined; value: TaskOldId | undefined; derived: false };
+  task: { kind: "m2o"; type: Task; nullable: undefined; value: TaskId | undefined; derived: false };
 }
 
 export interface TaskItemOpts {
@@ -150,14 +137,11 @@ export abstract class TaskItemCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof TaskItemFields>(key: K): FieldType<TaskItemFields, K> {
+  getFieldValue<K extends keyof TaskItemFields>(key: K): TaskItemFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<TaskItemFields> & keyof TaskItemFields>(
-    key: K,
-    value: FieldType<TaskItemFields, K>,
-  ): void {
+  setFieldValue<K extends keyof TaskItemFields>(key: K, value: TaskItemFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -180,14 +164,8 @@ export abstract class TaskItemCodegen extends BaseEntity<EntityManager, string>
   populate<H extends LoadHint<TaskItem>>(hint: H): Promise<Loaded<TaskItem, H>>;
   populate<H extends LoadHint<TaskItem>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<TaskItem, H>>;
   populate<H extends LoadHint<TaskItem>, V>(hint: H, fn: (ti: Loaded<TaskItem, H>) => V): Promise<V>;
-  populate<H extends LoadHint<TaskItem>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (ti: Loaded<TaskItem, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<TaskItem>, V>(
-    hintOrOpts: any,
-    fn?: (ti: Loaded<TaskItem, H>) => V,
-  ): Promise<Loaded<TaskItem, H> | V> {
+  populate<H extends LoadHint<TaskItem>, V>(opts: { hint: H; forceReload?: boolean }, fn: (ti: Loaded<TaskItem, H>) => V): Promise<V>;
+  populate<H extends LoadHint<TaskItem>, V>(hintOrOpts: any, fn?: (ti: Loaded<TaskItem, H>) => V): Promise<Loaded<TaskItem, H> | V> {
     return this.em.populate(this as any as TaskItem, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/integration/src/entities/codegen/TaskNewCodegen.ts b/packages/tests/integration/src/entities/codegen/TaskNewCodegen.ts
index 9c071efc9..a4506a187 100644
--- a/packages/tests/integration/src/entities/codegen/TaskNewCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskNewCodegen.ts
@@ -1,7 +1,6 @@
 import {
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -12,7 +11,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -36,17 +34,7 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Author,
-  authorMeta,
-  EntityManager,
-  newTaskNew,
-  Task,
-  TaskItem,
-  taskItemMeta,
-  TaskNew,
-  taskNewMeta,
-} from "../entities";
+import { Author, authorMeta, EntityManager, newTaskNew, Task, TaskItem, taskItemMeta, TaskNew, taskNewMeta } from "../entities";
 import type {
   AuthorId,
   AuthorOrder,
@@ -63,9 +51,9 @@ import type {
 export type TaskNewId = Flavor<string, TaskNew> & Flavor<string, "Task">;
 
 export interface TaskNewFields extends TaskFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  specialNewField: { kind: "primitive"; type: number; unique: false; nullable: undefined; derived: false };
-  specialNewAuthor: { kind: "m2o"; type: Author; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  specialNewField: { kind: "primitive"; type: number; unique: false; nullable: undefined; value: number | undefined; derived: false };
+  specialNewAuthor: { kind: "m2o"; type: Author; nullable: undefined; value: AuthorId | undefined; derived: false };
 }
 
 export interface TaskNewOpts extends TaskOpts {
@@ -141,14 +129,11 @@ export abstract class TaskNewCodegen extends Task implements Entity {
     setField(this, "specialNewField", specialNewField);
   }
 
-  getFieldValue<K extends keyof TaskNewFields>(key: K): FieldType<TaskNewFields, K> {
+  getFieldValue<K extends keyof TaskNewFields>(key: K): TaskNewFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<TaskNewFields> & keyof TaskNewFields>(
-    key: K,
-    value: FieldType<TaskNewFields, K>,
-  ): void {
+  setFieldValue<K extends keyof TaskNewFields>(key: K, value: TaskNewFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -171,14 +156,8 @@ export abstract class TaskNewCodegen extends Task implements Entity {
   populate<H extends LoadHint<TaskNew>>(hint: H): Promise<Loaded<TaskNew, H>>;
   populate<H extends LoadHint<TaskNew>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<TaskNew, H>>;
   populate<H extends LoadHint<TaskNew>, V>(hint: H, fn: (task: Loaded<TaskNew, H>) => V): Promise<V>;
-  populate<H extends LoadHint<TaskNew>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (task: Loaded<TaskNew, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<TaskNew>, V>(
-    hintOrOpts: any,
-    fn?: (task: Loaded<TaskNew, H>) => V,
-  ): Promise<Loaded<TaskNew, H> | V> {
+  populate<H extends LoadHint<TaskNew>, V>(opts: { hint: H; forceReload?: boolean }, fn: (task: Loaded<TaskNew, H>) => V): Promise<V>;
+  populate<H extends LoadHint<TaskNew>, V>(hintOrOpts: any, fn?: (task: Loaded<TaskNew, H>) => V): Promise<Loaded<TaskNew, H> | V> {
     return this.em.populate(this as any as TaskNew, hintOrOpts, fn);
   }
 
@@ -188,14 +167,7 @@ export abstract class TaskNewCodegen extends Task implements Entity {
 
   get newTaskTaskItems(): Collection<TaskNew, TaskItem> {
     const { relations } = getInstanceData(this);
-    return relations.newTaskTaskItems ??= hasMany(
-      this as any as TaskNew,
-      taskItemMeta,
-      "newTaskTaskItems",
-      "newTask",
-      "new_task_id",
-      undefined,
-    );
+    return relations.newTaskTaskItems ??= hasMany(this as any as TaskNew, taskItemMeta, "newTaskTaskItems", "newTask", "new_task_id", undefined);
   }
 
   get specialNewAuthor(): ManyToOneReference<TaskNew, Author, undefined> {
diff --git a/packages/tests/integration/src/entities/codegen/TaskOldCodegen.ts b/packages/tests/integration/src/entities/codegen/TaskOldCodegen.ts
index 78bdd4bf6..140460581 100644
--- a/packages/tests/integration/src/entities/codegen/TaskOldCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskOldCodegen.ts
@@ -1,7 +1,6 @@
 import {
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -68,9 +66,9 @@ import type {
 export type TaskOldId = Flavor<string, TaskOld> & Flavor<string, "Task">;
 
 export interface TaskOldFields extends TaskFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  specialOldField: { kind: "primitive"; type: number; unique: false; nullable: never; derived: false };
-  parentOldTask: { kind: "m2o"; type: TaskOld; nullable: undefined; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  specialOldField: { kind: "primitive"; type: number; unique: false; nullable: never; value: number | never; derived: false };
+  parentOldTask: { kind: "m2o"; type: TaskOld; nullable: undefined; value: TaskOldId | undefined; derived: false };
 }
 
 export interface TaskOldOpts extends TaskOpts {
@@ -161,14 +159,11 @@ export abstract class TaskOldCodegen extends Task implements Entity {
     setField(this, "specialOldField", specialOldField);
   }
 
-  getFieldValue<K extends keyof TaskOldFields>(key: K): FieldType<TaskOldFields, K> {
+  getFieldValue<K extends keyof TaskOldFields>(key: K): TaskOldFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<TaskOldFields> & keyof TaskOldFields>(
-    key: K,
-    value: FieldType<TaskOldFields, K>,
-  ): void {
+  setFieldValue<K extends keyof TaskOldFields>(key: K, value: TaskOldFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -191,14 +186,8 @@ export abstract class TaskOldCodegen extends Task implements Entity {
   populate<H extends LoadHint<TaskOld>>(hint: H): Promise<Loaded<TaskOld, H>>;
   populate<H extends LoadHint<TaskOld>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<TaskOld, H>>;
   populate<H extends LoadHint<TaskOld>, V>(hint: H, fn: (task: Loaded<TaskOld, H>) => V): Promise<V>;
-  populate<H extends LoadHint<TaskOld>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (task: Loaded<TaskOld, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<TaskOld>, V>(
-    hintOrOpts: any,
-    fn?: (task: Loaded<TaskOld, H>) => V,
-  ): Promise<Loaded<TaskOld, H> | V> {
+  populate<H extends LoadHint<TaskOld>, V>(opts: { hint: H; forceReload?: boolean }, fn: (task: Loaded<TaskOld, H>) => V): Promise<V>;
+  populate<H extends LoadHint<TaskOld>, V>(hintOrOpts: any, fn?: (task: Loaded<TaskOld, H>) => V): Promise<Loaded<TaskOld, H> | V> {
     return this.em.populate(this as any as TaskOld, hintOrOpts, fn);
   }
 
@@ -208,38 +197,17 @@ export abstract class TaskOldCodegen extends Task implements Entity {
 
   get comments(): Collection<TaskOld, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comments ??= hasMany(
-      this as any as TaskOld,
-      commentMeta,
-      "comments",
-      "parent",
-      "parent_task_id",
-      undefined,
-    );
+    return relations.comments ??= hasMany(this as any as TaskOld, commentMeta, "comments", "parent", "parent_task_id", undefined);
   }
 
   get oldTaskTaskItems(): Collection<TaskOld, TaskItem> {
     const { relations } = getInstanceData(this);
-    return relations.oldTaskTaskItems ??= hasMany(
-      this as any as TaskOld,
-      taskItemMeta,
-      "oldTaskTaskItems",
-      "oldTask",
-      "old_task_id",
-      undefined,
-    );
+    return relations.oldTaskTaskItems ??= hasMany(this as any as TaskOld, taskItemMeta, "oldTaskTaskItems", "oldTask", "old_task_id", undefined);
   }
 
   get tasks(): Collection<TaskOld, TaskOld> {
     const { relations } = getInstanceData(this);
-    return relations.tasks ??= hasMany(
-      this as any as TaskOld,
-      taskOldMeta,
-      "tasks",
-      "parentOldTask",
-      "parent_old_task_id",
-      undefined,
-    );
+    return relations.tasks ??= hasMany(this as any as TaskOld, taskOldMeta, "tasks", "parentOldTask", "parent_old_task_id", undefined);
   }
 
   get parentOldTask(): ManyToOneReference<TaskOld, TaskOld, undefined> {
diff --git a/packages/tests/integration/src/entities/codegen/UserCodegen.ts b/packages/tests/integration/src/entities/codegen/UserCodegen.ts
index 50222fe47..f36998cc5 100644
--- a/packages/tests/integration/src/entities/codegen/UserCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/UserCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -18,7 +17,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -73,17 +71,17 @@ export function isUserFavoritePublisher(maybeEntity: unknown): maybeEntity is Us
 }
 
 export interface UserFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  email: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  ipAddress: { kind: "primitive"; type: IpAddress; unique: false; nullable: undefined; derived: false };
-  password: { kind: "primitive"; type: PasswordValue; unique: false; nullable: undefined; derived: false };
-  bio: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  originalEmail: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  authorManyToOne: { kind: "m2o"; type: Author; nullable: undefined; derived: false };
-  favoritePublisher: { kind: "poly"; type: UserFavoritePublisher; nullable: undefined };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  email: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  ipAddress: { kind: "primitive"; type: IpAddress; unique: false; nullable: undefined; value: IpAddress | undefined; derived: false };
+  password: { kind: "primitive"; type: PasswordValue; unique: false; nullable: undefined; value: PasswordValue | undefined; derived: false };
+  bio: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  originalEmail: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  authorManyToOne: { kind: "m2o"; type: Author; nullable: undefined; value: AuthorId | undefined; derived: false };
+  favoritePublisher: { kind: "poly"; type: UserFavoritePublisher; nullable: undefined; value: string | undefined };
 }
 
 export interface UserOpts {
@@ -252,14 +250,11 @@ export abstract class UserCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof UserFields>(key: K): FieldType<UserFields, K> {
+  getFieldValue<K extends keyof UserFields>(key: K): UserFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<UserFields> & keyof UserFields>(
-    key: K,
-    value: FieldType<UserFields, K>,
-  ): void {
+  setFieldValue<K extends keyof UserFields>(key: K, value: UserFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -282,10 +277,7 @@ export abstract class UserCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<User>>(hint: H): Promise<Loaded<User, H>>;
   populate<H extends LoadHint<User>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<User, H>>;
   populate<H extends LoadHint<User>, V>(hint: H, fn: (u: Loaded<User, H>) => V): Promise<V>;
-  populate<H extends LoadHint<User>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (u: Loaded<User, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<User>, V>(opts: { hint: H; forceReload?: boolean }, fn: (u: Loaded<User, H>) => V): Promise<V>;
   populate<H extends LoadHint<User>, V>(hintOrOpts: any, fn?: (u: Loaded<User, H>) => V): Promise<Loaded<User, H> | V> {
     return this.em.populate(this as any as User, hintOrOpts, fn);
   }
@@ -296,14 +288,7 @@ export abstract class UserCodegen extends BaseEntity<EntityManager, string> impl
 
   get createdComments(): Collection<User, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.createdComments ??= hasMany(
-      this as any as User,
-      commentMeta,
-      "createdComments",
-      "user",
-      "user_id",
-      undefined,
-    );
+    return relations.createdComments ??= hasMany(this as any as User, commentMeta, "createdComments", "user", "user_id", undefined);
   }
 
   get authorManyToOne(): ManyToOneReference<User, Author, undefined> {
diff --git a/packages/tests/integration/src/entities/enums/ImageType.ts b/packages/tests/integration/src/entities/enums/ImageType.ts
index ff27a61d1..773969b25 100644
--- a/packages/tests/integration/src/entities/enums/ImageType.ts
+++ b/packages/tests/integration/src/entities/enums/ImageType.ts
@@ -16,22 +16,8 @@ export type ImageTypeDetails = {
 };
 
 const details: Record<ImageType, ImageTypeDetails> = {
-  [ImageType.BookImage]: {
-    id: 1,
-    code: ImageType.BookImage,
-    name: "Book Image",
-    sortOrder: 100,
-    visible: true,
-    nickname: "book_image",
-  },
-  [ImageType.AuthorImage]: {
-    id: 2,
-    code: ImageType.AuthorImage,
-    name: "Author Image",
-    sortOrder: 200,
-    visible: true,
-    nickname: "author_image",
-  },
+  [ImageType.BookImage]: { id: 1, code: ImageType.BookImage, name: "Book Image", sortOrder: 100, visible: true, nickname: "book_image" },
+  [ImageType.AuthorImage]: { id: 2, code: ImageType.AuthorImage, name: "Author Image", sortOrder: 200, visible: true, nickname: "author_image" },
   [ImageType.PublisherImage]: {
     id: 3,
     code: ImageType.PublisherImage,
diff --git a/packages/tests/integration/src/resolvers/enumResolvers.ts b/packages/tests/integration/src/resolvers/enumResolvers.ts
index 10f6f7e96..eee8fdb30 100644
--- a/packages/tests/integration/src/resolvers/enumResolvers.ts
+++ b/packages/tests/integration/src/resolvers/enumResolvers.ts
@@ -1,12 +1,4 @@
-import {
-  AdvanceStatuses,
-  BookRanges,
-  Colors,
-  ImageTypes,
-  PublisherSizes,
-  PublisherTypes,
-  TaskTypes,
-} from "src/entities";
+import { AdvanceStatuses, BookRanges, Colors, ImageTypes, PublisherSizes, PublisherTypes, TaskTypes } from "src/entities";
 import { Resolvers } from "src/generated/graphql-types";
 
 type EnumDetails =
diff --git a/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts b/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts
index c4a86877c..539515510 100644
--- a/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { BookId, Entity } from "../entities";
 export type AuthorId = Flavor<number, Author>;
 
 export interface AuthorFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface AuthorOpts {
@@ -151,14 +149,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, number> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorFields>(key: K): FieldType<AuthorFields, K> {
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorFields> & keyof AuthorFields>(
-    key: K,
-    value: FieldType<AuthorFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -181,14 +176,8 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, number> im
   populate<H extends LoadHint<Author>>(hint: H): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>, V>(hint: H, fn: (a: Loaded<Author, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (a: Loaded<Author, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    hintOrOpts: any,
-    fn?: (a: Loaded<Author, H>) => V,
-  ): Promise<Loaded<Author, H> | V> {
+  populate<H extends LoadHint<Author>, V>(opts: { hint: H; forceReload?: boolean }, fn: (a: Loaded<Author, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Author>, V>(hintOrOpts: any, fn?: (a: Loaded<Author, H>) => V): Promise<Loaded<Author, H> | V> {
     return this.em.populate(this as any as Author, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/number-ids/src/entities/codegen/BookCodegen.ts b/packages/tests/number-ids/src/entities/codegen/BookCodegen.ts
index d9654f406..9b808f8ed 100644
--- a/packages/tests/number-ids/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/number-ids/src/entities/codegen/BookCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { AuthorId, AuthorOrder, Entity } from "../entities";
 export type BookId = Flavor<number, Book>;
 
 export interface BookFields {
-  id: { kind: "primitive"; type: bigint; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: bigint; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface BookOpts {
@@ -141,14 +139,11 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, number> impl
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof BookFields>(key: K): FieldType<BookFields, K> {
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookFields> & keyof BookFields>(
-    key: K,
-    value: FieldType<BookFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -171,10 +166,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, number> impl
   populate<H extends LoadHint<Book>>(hint: H): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>, V>(hint: H, fn: (b: Loaded<Book, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Book>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (b: Loaded<Book, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Book>, V>(opts: { hint: H; forceReload?: boolean }, fn: (b: Loaded<Book, H>) => V): Promise<V>;
   populate<H extends LoadHint<Book>, V>(hintOrOpts: any, fn?: (b: Loaded<Book, H>) => V): Promise<Loaded<Book, H> | V> {
     return this.em.populate(this as any as Book, hintOrOpts, fn);
   }
diff --git a/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts b/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts
index 90c53fd46..0d0310913 100644
--- a/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { Entity, PaintingId } from "../entities";
 export type ArtistId = Flavor<string, Artist>;
 
 export interface ArtistFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface ArtistOpts {
@@ -152,14 +150,11 @@ export abstract class ArtistCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof ArtistFields>(key: K): FieldType<ArtistFields, K> {
+  getFieldValue<K extends keyof ArtistFields>(key: K): ArtistFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<ArtistFields> & keyof ArtistFields>(
-    key: K,
-    value: FieldType<ArtistFields, K>,
-  ): void {
+  setFieldValue<K extends keyof ArtistFields>(key: K, value: ArtistFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -182,14 +177,8 @@ export abstract class ArtistCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Artist>>(hint: H): Promise<Loaded<Artist, H>>;
   populate<H extends LoadHint<Artist>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Artist, H>>;
   populate<H extends LoadHint<Artist>, V>(hint: H, fn: (artist: Loaded<Artist, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Artist>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (artist: Loaded<Artist, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Artist>, V>(
-    hintOrOpts: any,
-    fn?: (artist: Loaded<Artist, H>) => V,
-  ): Promise<Loaded<Artist, H> | V> {
+  populate<H extends LoadHint<Artist>, V>(opts: { hint: H; forceReload?: boolean }, fn: (artist: Loaded<Artist, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Artist>, V>(hintOrOpts: any, fn?: (artist: Loaded<Artist, H>) => V): Promise<Loaded<Artist, H> | V> {
     return this.em.populate(this as any as Artist, hintOrOpts, fn);
   }
 
@@ -199,13 +188,6 @@ export abstract class ArtistCodegen extends BaseEntity<EntityManager, string> im
 
   get paintings(): Collection<Artist, Painting> {
     const { relations } = getInstanceData(this);
-    return relations.paintings ??= hasMany(
-      this as any as Artist,
-      paintingMeta,
-      "paintings",
-      "artist",
-      "artistId",
-      undefined,
-    );
+    return relations.paintings ??= hasMany(this as any as Artist, paintingMeta, "paintings", "artist", "artistId", undefined);
   }
 }
diff --git a/packages/tests/schema-misc/src/entities/codegen/AuthorCodegen.ts b/packages/tests/schema-misc/src/entities/codegen/AuthorCodegen.ts
index 53857c421..6986725c7 100644
--- a/packages/tests/schema-misc/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/AuthorCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -45,12 +43,12 @@ import type { BookId, Entity } from "../entities";
 export type AuthorId = Flavor<string, Author>;
 
 export interface AuthorFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  delete: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  delete: { kind: "primitive"; type: boolean; unique: false; nullable: undefined; value: boolean | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface AuthorOpts {
@@ -166,14 +164,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorFields>(key: K): FieldType<AuthorFields, K> {
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorFields> & keyof AuthorFields>(
-    key: K,
-    value: FieldType<AuthorFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -196,14 +191,8 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Author>>(hint: H): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>, V>(hint: H, fn: (a: Loaded<Author, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (a: Loaded<Author, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    hintOrOpts: any,
-    fn?: (a: Loaded<Author, H>) => V,
-  ): Promise<Loaded<Author, H> | V> {
+  populate<H extends LoadHint<Author>, V>(opts: { hint: H; forceReload?: boolean }, fn: (a: Loaded<Author, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Author>, V>(hintOrOpts: any, fn?: (a: Loaded<Author, H>) => V): Promise<Loaded<Author, H> | V> {
     return this.em.populate(this as any as Author, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/schema-misc/src/entities/codegen/BookCodegen.ts b/packages/tests/schema-misc/src/entities/codegen/BookCodegen.ts
index 8e4bda76e..e50627df1 100644
--- a/packages/tests/schema-misc/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/BookCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,9 +41,9 @@ import type { AuthorId, AuthorOrder, Entity } from "../entities";
 export type BookId = Flavor<string, Book>;
 
 export interface BookFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface BookOpts {
@@ -123,14 +121,11 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     setField(this, "title", cleanStringValue(title));
   }
 
-  getFieldValue<K extends keyof BookFields>(key: K): FieldType<BookFields, K> {
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookFields> & keyof BookFields>(
-    key: K,
-    value: FieldType<BookFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -153,10 +148,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<Book>>(hint: H): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>, V>(hint: H, fn: (b: Loaded<Book, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Book>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (b: Loaded<Book, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Book>, V>(opts: { hint: H; forceReload?: boolean }, fn: (b: Loaded<Book, H>) => V): Promise<V>;
   populate<H extends LoadHint<Book>, V>(hintOrOpts: any, fn?: (b: Loaded<Book, H>) => V): Promise<Loaded<Book, H> | V> {
     return this.em.populate(this as any as Book, hintOrOpts, fn);
   }
diff --git a/packages/tests/schema-misc/src/entities/codegen/DatabaseOwnerCodegen.ts b/packages/tests/schema-misc/src/entities/codegen/DatabaseOwnerCodegen.ts
index 9eef3afc6..f4525f6ae 100644
--- a/packages/tests/schema-misc/src/entities/codegen/DatabaseOwnerCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/DatabaseOwnerCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   isLoaded,
   loadLens,
@@ -12,7 +11,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -36,8 +34,8 @@ import type { Entity } from "../entities";
 export type DatabaseOwnerId = Flavor<string, DatabaseOwner>;
 
 export interface DatabaseOwnerFields {
-  id: { kind: "primitive"; type: number; unique: true; nullable: never };
-  name: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
+  id: { kind: "primitive"; type: number; unique: true; nullable: never; value: never };
+  name: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
 }
 
 export interface DatabaseOwnerOpts {
@@ -109,14 +107,11 @@ export abstract class DatabaseOwnerCodegen extends BaseEntity<EntityManager, str
     setField(this, "name", cleanStringValue(name));
   }
 
-  getFieldValue<K extends keyof DatabaseOwnerFields>(key: K): FieldType<DatabaseOwnerFields, K> {
+  getFieldValue<K extends keyof DatabaseOwnerFields>(key: K): DatabaseOwnerFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<DatabaseOwnerFields> & keyof DatabaseOwnerFields>(
-    key: K,
-    value: FieldType<DatabaseOwnerFields, K>,
-  ): void {
+  setFieldValue<K extends keyof DatabaseOwnerFields>(key: K, value: DatabaseOwnerFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -137,13 +132,8 @@ export abstract class DatabaseOwnerCodegen extends BaseEntity<EntityManager, str
   }
 
   populate<H extends LoadHint<DatabaseOwner>>(hint: H): Promise<Loaded<DatabaseOwner, H>>;
-  populate<H extends LoadHint<DatabaseOwner>>(
-    opts: { hint: H; forceReload?: boolean },
-  ): Promise<Loaded<DatabaseOwner, H>>;
-  populate<H extends LoadHint<DatabaseOwner>, V>(
-    hint: H,
-    fn: (databaseOwner: Loaded<DatabaseOwner, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<DatabaseOwner>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<DatabaseOwner, H>>;
+  populate<H extends LoadHint<DatabaseOwner>, V>(hint: H, fn: (databaseOwner: Loaded<DatabaseOwner, H>) => V): Promise<V>;
   populate<H extends LoadHint<DatabaseOwner>, V>(
     opts: { hint: H; forceReload?: boolean },
     fn: (databaseOwner: Loaded<DatabaseOwner, H>) => V,
diff --git a/packages/tests/schema-misc/src/entities/codegen/PaintingCodegen.ts b/packages/tests/schema-misc/src/entities/codegen/PaintingCodegen.ts
index 8b26b5ed6..d2f5478cc 100644
--- a/packages/tests/schema-misc/src/entities/codegen/PaintingCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/PaintingCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { ArtistId, ArtistOrder, Entity } from "../entities";
 export type PaintingId = Flavor<string, Painting>;
 
 export interface PaintingFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  artist: { kind: "m2o"; type: Artist; nullable: never; derived: false };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  artist: { kind: "m2o"; type: Artist; nullable: never; value: ArtistId | never; derived: false };
 }
 
 export interface PaintingOpts {
@@ -141,14 +139,11 @@ export abstract class PaintingCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof PaintingFields>(key: K): FieldType<PaintingFields, K> {
+  getFieldValue<K extends keyof PaintingFields>(key: K): PaintingFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<PaintingFields> & keyof PaintingFields>(
-    key: K,
-    value: FieldType<PaintingFields, K>,
-  ): void {
+  setFieldValue<K extends keyof PaintingFields>(key: K, value: PaintingFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -171,14 +166,8 @@ export abstract class PaintingCodegen extends BaseEntity<EntityManager, string>
   populate<H extends LoadHint<Painting>>(hint: H): Promise<Loaded<Painting, H>>;
   populate<H extends LoadHint<Painting>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Painting, H>>;
   populate<H extends LoadHint<Painting>, V>(hint: H, fn: (p: Loaded<Painting, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Painting>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (p: Loaded<Painting, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Painting>, V>(
-    hintOrOpts: any,
-    fn?: (p: Loaded<Painting, H>) => V,
-  ): Promise<Loaded<Painting, H> | V> {
+  populate<H extends LoadHint<Painting>, V>(opts: { hint: H; forceReload?: boolean }, fn: (p: Loaded<Painting, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Painting>, V>(hintOrOpts: any, fn?: (p: Loaded<Painting, H>) => V): Promise<Loaded<Painting, H> | V> {
     return this.em.populate(this as any as Painting, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts b/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts
index 59d65e990..c96e9532d 100644
--- a/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { BookId, CommentId, Entity } from "../entities";
 export type AuthorId = Flavor<string, Author>;
 
 export interface AuthorFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface AuthorOpts {
@@ -155,14 +153,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorFields>(key: K): FieldType<AuthorFields, K> {
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorFields> & keyof AuthorFields>(
-    key: K,
-    value: FieldType<AuthorFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -185,14 +180,8 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Author>>(hint: H): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>, V>(hint: H, fn: (a: Loaded<Author, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (a: Loaded<Author, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    hintOrOpts: any,
-    fn?: (a: Loaded<Author, H>) => V,
-  ): Promise<Loaded<Author, H> | V> {
+  populate<H extends LoadHint<Author>, V>(opts: { hint: H; forceReload?: boolean }, fn: (a: Loaded<Author, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Author>, V>(hintOrOpts: any, fn?: (a: Loaded<Author, H>) => V): Promise<Loaded<Author, H> | V> {
     return this.em.populate(this as any as Author, hintOrOpts, fn);
   }
 
@@ -207,13 +196,6 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
 
   get comments(): Collection<Author, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comments ??= hasMany(
-      this as any as Author,
-      commentMeta,
-      "comments",
-      "parent",
-      "parent_author_id",
-      undefined,
-    );
+    return relations.comments ??= hasMany(this as any as Author, commentMeta, "comments", "parent", "parent_author_id", undefined);
   }
 }
diff --git a/packages/tests/untagged-ids/src/entities/codegen/BookCodegen.ts b/packages/tests/untagged-ids/src/entities/codegen/BookCodegen.ts
index 8753c67e7..7fb0a2537 100644
--- a/packages/tests/untagged-ids/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/untagged-ids/src/entities/codegen/BookCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -45,11 +43,11 @@ import type { AuthorId, AuthorOrder, CommentId, Entity } from "../entities";
 export type BookId = Flavor<string, Book>;
 
 export interface BookFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface BookOpts {
@@ -147,14 +145,11 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof BookFields>(key: K): FieldType<BookFields, K> {
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookFields> & keyof BookFields>(
-    key: K,
-    value: FieldType<BookFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -177,10 +172,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<Book>>(hint: H): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>, V>(hint: H, fn: (b: Loaded<Book, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Book>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (b: Loaded<Book, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Book>, V>(opts: { hint: H; forceReload?: boolean }, fn: (b: Loaded<Book, H>) => V): Promise<V>;
   populate<H extends LoadHint<Book>, V>(hintOrOpts: any, fn?: (b: Loaded<Book, H>) => V): Promise<Loaded<Book, H> | V> {
     return this.em.populate(this as any as Book, hintOrOpts, fn);
   }
@@ -191,14 +183,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
 
   get comments(): Collection<Book, Comment> {
     const { relations } = getInstanceData(this);
-    return relations.comments ??= hasMany(
-      this as any as Book,
-      commentMeta,
-      "comments",
-      "parent",
-      "parent_book_id",
-      undefined,
-    );
+    return relations.comments ??= hasMany(this as any as Book, commentMeta, "comments", "parent", "parent_book_id", undefined);
   }
 
   get author(): ManyToOneReference<Book, Author, never> {
diff --git a/packages/tests/untagged-ids/src/entities/codegen/CommentCodegen.ts b/packages/tests/untagged-ids/src/entities/codegen/CommentCodegen.ts
index f86350e2a..e6f409838 100644
--- a/packages/tests/untagged-ids/src/entities/codegen/CommentCodegen.ts
+++ b/packages/tests/untagged-ids/src/entities/codegen/CommentCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOnePolymorphic,
@@ -15,7 +14,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -52,11 +50,11 @@ export function isCommentParent(maybeEntity: unknown): maybeEntity is CommentPar
 }
 
 export interface CommentFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  text: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  parent: { kind: "poly"; type: CommentParent; nullable: never };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  text: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  parent: { kind: "poly"; type: CommentParent; nullable: never; value: string | never };
 }
 
 export interface CommentOpts {
@@ -149,14 +147,11 @@ export abstract class CommentCodegen extends BaseEntity<EntityManager, string> i
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof CommentFields>(key: K): FieldType<CommentFields, K> {
+  getFieldValue<K extends keyof CommentFields>(key: K): CommentFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<CommentFields> & keyof CommentFields>(
-    key: K,
-    value: FieldType<CommentFields, K>,
-  ): void {
+  setFieldValue<K extends keyof CommentFields>(key: K, value: CommentFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -179,14 +174,8 @@ export abstract class CommentCodegen extends BaseEntity<EntityManager, string> i
   populate<H extends LoadHint<Comment>>(hint: H): Promise<Loaded<Comment, H>>;
   populate<H extends LoadHint<Comment>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Comment, H>>;
   populate<H extends LoadHint<Comment>, V>(hint: H, fn: (c: Loaded<Comment, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Comment>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (c: Loaded<Comment, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Comment>, V>(
-    hintOrOpts: any,
-    fn?: (c: Loaded<Comment, H>) => V,
-  ): Promise<Loaded<Comment, H> | V> {
+  populate<H extends LoadHint<Comment>, V>(opts: { hint: H; forceReload?: boolean }, fn: (c: Loaded<Comment, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Comment>, V>(hintOrOpts: any, fn?: (c: Loaded<Comment, H>) => V): Promise<Loaded<Comment, H> | V> {
     return this.em.populate(this as any as Comment, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts b/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts
index 222a7f986..8a3c4fa20 100644
--- a/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasMany,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -43,11 +41,11 @@ import type { BookId, Entity } from "../entities";
 export type AuthorId = Flavor<string, Author>;
 
 export interface AuthorFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  firstName: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  lastName: { kind: "primitive"; type: string; unique: false; nullable: undefined; value: string | undefined; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
 }
 
 export interface AuthorOpts {
@@ -151,14 +149,11 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
-  getFieldValue<K extends keyof AuthorFields>(key: K): FieldType<AuthorFields, K> {
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<AuthorFields> & keyof AuthorFields>(
-    key: K,
-    value: FieldType<AuthorFields, K>,
-  ): void {
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -181,14 +176,8 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
   populate<H extends LoadHint<Author>>(hint: H): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Author, H>>;
   populate<H extends LoadHint<Author>, V>(hint: H, fn: (a: Loaded<Author, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (a: Loaded<Author, H>) => V,
-  ): Promise<V>;
-  populate<H extends LoadHint<Author>, V>(
-    hintOrOpts: any,
-    fn?: (a: Loaded<Author, H>) => V,
-  ): Promise<Loaded<Author, H> | V> {
+  populate<H extends LoadHint<Author>, V>(opts: { hint: H; forceReload?: boolean }, fn: (a: Loaded<Author, H>) => V): Promise<V>;
+  populate<H extends LoadHint<Author>, V>(hintOrOpts: any, fn?: (a: Loaded<Author, H>) => V): Promise<Loaded<Author, H> | V> {
     return this.em.populate(this as any as Author, hintOrOpts, fn);
   }
 
diff --git a/packages/tests/uuid-ids/src/entities/codegen/BookCodegen.ts b/packages/tests/uuid-ids/src/entities/codegen/BookCodegen.ts
index 07b3ef41d..883d29e73 100644
--- a/packages/tests/uuid-ids/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/uuid-ids/src/entities/codegen/BookCodegen.ts
@@ -3,7 +3,6 @@ import {
   cleanStringValue,
   ConfigApi,
   failNoIdYet,
-  FieldType,
   getField,
   getInstanceData,
   hasOne,
@@ -14,7 +13,6 @@ import {
   setField,
   setFieldValue,
   setOpts,
-  SettableFields,
   toIdOf,
 } from "joist-orm";
 import type {
@@ -37,28 +35,18 @@ import type {
   ValueGraphQLFilter,
 } from "joist-orm";
 import type { Context } from "src/context";
-import {
-  Author,
-  authorMeta,
-  Book,
-  bookMeta,
-  BookStatus,
-  BookStatusDetails,
-  BookStatuses,
-  EntityManager,
-  newBook,
-} from "../entities";
+import { Author, authorMeta, Book, bookMeta, BookStatus, BookStatusDetails, BookStatuses, EntityManager, newBook } from "../entities";
 import type { AuthorId, AuthorOrder, Entity } from "../entities";
 
 export type BookId = Flavor<string, Book>;
 
 export interface BookFields {
-  id: { kind: "primitive"; type: string; unique: true; nullable: never };
-  title: { kind: "primitive"; type: string; unique: false; nullable: never; derived: false };
-  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; derived: true };
-  status: { kind: "enum"; type: BookStatus; nullable: never };
-  author: { kind: "m2o"; type: Author; nullable: never; derived: false };
+  id: { kind: "primitive"; type: string; unique: true; nullable: never; value: never };
+  title: { kind: "primitive"; type: string; unique: false; nullable: never; value: string | never; derived: false };
+  createdAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  updatedAt: { kind: "primitive"; type: Date; unique: false; nullable: never; value: Date | never; derived: true };
+  status: { kind: "enum"; type: BookStatus; nullable: never; value: BookStatus | never };
+  author: { kind: "m2o"; type: Author; nullable: never; value: AuthorId | never; derived: false };
 }
 
 export interface BookOpts {
@@ -177,14 +165,11 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "status") === BookStatus.Published;
   }
 
-  getFieldValue<K extends keyof BookFields>(key: K): FieldType<BookFields, K> {
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
     return getField(this as any, key);
   }
 
-  setFieldValue<K extends keyof SettableFields<BookFields> & keyof BookFields>(
-    key: K,
-    value: FieldType<BookFields, K>,
-  ): void {
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
     setFieldValue(this, key, value);
   }
 
@@ -207,10 +192,7 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
   populate<H extends LoadHint<Book>>(hint: H): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>>(opts: { hint: H; forceReload?: boolean }): Promise<Loaded<Book, H>>;
   populate<H extends LoadHint<Book>, V>(hint: H, fn: (b: Loaded<Book, H>) => V): Promise<V>;
-  populate<H extends LoadHint<Book>, V>(
-    opts: { hint: H; forceReload?: boolean },
-    fn: (b: Loaded<Book, H>) => V,
-  ): Promise<V>;
+  populate<H extends LoadHint<Book>, V>(opts: { hint: H; forceReload?: boolean }, fn: (b: Loaded<Book, H>) => V): Promise<V>;
   populate<H extends LoadHint<Book>, V>(hintOrOpts: any, fn?: (b: Loaded<Book, H>) => V): Promise<Loaded<Book, H> | V> {
     return this.em.populate(this as any as Book, hintOrOpts, fn);
   }