diff --git a/packages/codegen/src/generateEntityCodegenFile.ts b/packages/codegen/src/generateEntityCodegenFile.ts
index f85d60117..f176717f8 100644
--- a/packages/codegen/src/generateEntityCodegenFile.ts
+++ b/packages/codegen/src/generateEntityCodegenFile.ts
@@ -67,6 +67,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "./symbols";
@@ -401,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
@@ -527,12 +530,25 @@ export function generateEntityCodegenFile(config: Config, dbMeta: DbMetadata, me
 
       ${primitives}
 
+      getFieldValue<K extends keyof ${entityName}Fields>(
+        key: K
+      ): ${entityName}Fields[K]["value"] {
+        return ${getField}(this as any, key);  
+      }
+
+      setFieldValue<K extends keyof ${entityName}Fields>(
+        key: K,
+        value: ${entityName}Fields[K]["value"],
+      ): void {
+        ${setFieldValue}(this, key, value);
+      }
+
       set(opts: Partial<${entityName}Opts>): void {
-        ${setOpts}(this as any as ${entityName}, opts);
+        ${setOpts}(this as any, opts);
       }
 
       setPartial(opts: ${PartialOrNull}<${entityName}Opts>): void {
-        ${setOpts}(this as any as ${entityName}, opts as ${OptsOf}<${entityName}>, { partial: true });
+        ${setOpts}(this as any, opts as ${OptsOf}<${entityName}>, { partial: true });
       }
 
       get changes(): ${Changes}<${entityName}${maybeOtherTypeChanges}> {
@@ -701,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 f9bd253c8..a4f737bbe 100644
--- a/packages/codegen/src/symbols.ts
+++ b/packages/codegen/src/symbols.ts
@@ -27,6 +27,7 @@ export const PolymorphicKeySerde = imp("PolymorphicKeySerde@joist-orm");
 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 SuperstructSerde = imp("SuperstructSerde@joist-orm");
 export const TaggedId = imp("t:TaggedId@joist-orm");
 export const ZodSerde = imp("ZodSerde@joist-orm");
@@ -73,6 +74,7 @@ export const hasOneToOne = imp("hasOneToOne@joist-orm");
 export const hasManyToMany = imp("hasManyToMany@joist-orm");
 export const hasLargeManyToMany = imp("hasLargeManyToMany@joist-orm");
 export const newTestInstance = imp("newTestInstance@joist-orm");
+export const setFieldValue = imp("setFieldValue@joist-orm");
 export const New = imp("t:New@joist-orm");
 export const DeepNew = imp("t:DeepNew@joist-orm");
 export const FactoryOpts = imp("t:FactoryOpts@joist-orm");
diff --git a/packages/orm/src/BaseEntity.ts b/packages/orm/src/BaseEntity.ts
index 1ee2786ca..3143cdfcd 100644
--- a/packages/orm/src/BaseEntity.ts
+++ b/packages/orm/src/BaseEntity.ts
@@ -3,6 +3,7 @@ import { getField } from "./fields";
 import {
   Entity,
   EntityManager,
+  FieldsOf,
   InstanceData,
   OptsOf,
   PartialOrNull,
@@ -70,6 +71,10 @@ export abstract class BaseEntity<EM extends EntityManager, I extends IdType = Id
     return deTagId(getMetadata(this), this.id);
   }
 
+  abstract getFieldValue(key: string): any;
+
+  abstract setFieldValue(fieldName: string, value: unknown): void;
+
   abstract set(values: Partial<OptsOf<Entity>>): void;
 
   /**
diff --git a/packages/orm/src/Entity.ts b/packages/orm/src/Entity.ts
index b9b6d1fef..faaa053b1 100644
--- a/packages/orm/src/Entity.ts
+++ b/packages/orm/src/Entity.ts
@@ -1,4 +1,4 @@
-import { EntityManager, OptsOf, TaggedId } from "./EntityManager";
+import { EntityManager, FieldsOf, OptsOf, TaggedId } from "./EntityManager";
 import { BaseEntity, PartialOrNull } from "./index";
 
 export function isEntity(maybeEntity: unknown): maybeEntity is Entity {
@@ -19,6 +19,8 @@ export interface Entity {
   readonly isNewEntity: boolean;
   readonly isDeletedEntity: boolean;
   readonly isDirtyEntity: boolean;
+  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/fields.ts b/packages/orm/src/fields.ts
index d4065df38..aba08d581 100644
--- a/packages/orm/src/fields.ts
+++ b/packages/orm/src/fields.ts
@@ -2,7 +2,21 @@ import { getInstanceData } from "./BaseEntity";
 import { Entity, isEntity } from "./Entity";
 import { getEmInternalApi } from "./EntityManager";
 import { getMetadata } from "./EntityMetadata";
-import { ensureNotDeleted, maybeResolveReferenceToId } from "./index";
+import {ensureNotDeleted, fail, isManyToOneReference, maybeResolveReferenceToId} from "./index";
+
+/**
+ * Sets the current value of `fieldName` to `value`, while also ensuring that any relations
+ * are properly set.
+ */
+export function setFieldValue(entity: Entity, fieldName: string, value: any): void {
+  getField(entity, fieldName);
+  const maybeRef = (entity as any)[fieldName];
+  if (isManyToOneReference(maybeRef)) {
+    maybeRef.set(value);
+  } else {
+    setField(entity, fieldName, value);
+  }
+}
 
 /**
  * Returns the current value of `fieldName`, this is an internal method that should
@@ -17,7 +31,7 @@ export function getField(entity: Entity, fieldName: string): any {
   if (fieldName in data) {
     return data[fieldName];
   } else {
-    const serde = getMetadata(entity).allFields[fieldName].serde ?? fail(`Missing serde for ${fieldName}`);
+    const serde = getMetadata(entity).allFields[fieldName]?.serde ?? fail(`Invalid field ${fieldName}`);
     serde.setOnEntity(data, row);
     return data[fieldName];
   }
diff --git a/packages/orm/src/index.ts b/packages/orm/src/index.ts
index 3ef857891..6157790ed 100644
--- a/packages/orm/src/index.ts
+++ b/packages/orm/src/index.ts
@@ -29,7 +29,7 @@ export { ConfigApi, EntityHook } from "./config";
 export { configureMetadata, getConstructorFromTaggedId, maybeGetConstructorFromReference } from "./configure";
 export { DeepPartialOrNull } from "./createOrUpdatePartial";
 export * from "./drivers";
-export { getField, isChangeableField, isFieldSet, setField } from "./fields";
+export { getField, isChangeableField, isFieldSet, setField, setFieldValue } from "./fields";
 export * from "./getProperties";
 export * from "./keys";
 export { kq, kqDot, kqStar } from "./keywords";
diff --git a/packages/tests/esm-misc/joist-config.json b/packages/tests/esm-misc/joist-config.json
index 022f9a535..592f9989a 100644
--- a/packages/tests/esm-misc/joist-config.json
+++ b/packages/tests/esm-misc/joist-config.json
@@ -10,5 +10,5 @@
     "createdAt": { "names": ["created_at", "createdAt"], "required": false },
     "updatedAt": { "names": ["updated_at", "updatedAt"], "required": false }
   },
-  "version": "1.155.2"
+  "version": "1.156.0"
 }
diff --git a/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts b/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts
index f4d344b5a..68ed41bae 100644
--- a/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/esm-misc/src/entities/codegen/AuthorCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -42,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 {
@@ -163,12 +164,20 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorOpts>): void {
-    setOpts(this as any as Author, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorOpts>): void {
-    setOpts(this as any as Author, opts as OptsOf<Author>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Author>, { partial: true });
   }
 
   get changes(): Changes<Author> {
@@ -182,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 b9192ab4a..137d37fe5 100644
--- a/packages/tests/esm-misc/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/esm-misc/src/entities/codegen/BookCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -120,12 +121,20 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     setField(this, "title", cleanStringValue(title));
   }
 
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookOpts>): void {
-    setOpts(this as any as Book, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookOpts>): void {
-    setOpts(this as any as Book, opts as OptsOf<Book>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Book>, { partial: true });
   }
 
   get changes(): Changes<Book> {
@@ -139,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/joist-config.json b/packages/tests/integration/joist-config.json
index 9fd27e4c9..eec68635b 100644
--- a/packages/tests/integration/joist-config.json
+++ b/packages/tests/integration/joist-config.json
@@ -90,5 +90,5 @@
     }
   },
   "entitiesDirectory": "./src/entities",
-  "version": "1.155.2"
+  "version": "1.156.0"
 }
diff --git a/packages/tests/integration/src/Fields.test.ts b/packages/tests/integration/src/Fields.test.ts
new file mode 100644
index 000000000..2fd71bc55
--- /dev/null
+++ b/packages/tests/integration/src/Fields.test.ts
@@ -0,0 +1,82 @@
+import { Author, LargePublisher } from "src/entities";
+import { insertAuthor, insertLargePublisher, insertPublisher, select } from "src/entities/inserts";
+import { newEntityManager } from "src/testEm";
+
+describe("Fields", () => {
+  it("can use get/set to copy values", async () => {
+    // Given an existing author
+    await insertPublisher({ name: "p" });
+    await insertAuthor({ first_name: "f", publisher_id: 1 });
+    const em = newEntityManager();
+    const a1 = await em.load(Author, "a:1");
+    // And we create a new author
+    const a2 = em.create(Author, { firstName: "b" });
+    // When we iterate for both primitive fields & relations
+    for (const fieldName of ["firstName", "publisher"] as const) {
+      // And use get/set to copy the value, even if the relation isn't loaded
+      a2.setFieldValue(fieldName, a1.getFieldValue(fieldName));
+    }
+    await em.flush();
+    // Then it worked
+    expect((await select("authors"))[1]).toMatchObject({
+      first_name: "f",
+      publisher_id: 1,
+    });
+  });
+
+  it("can use get on base or subtype fields", async () => {
+    // Given we have a CTI subtype entity
+    await insertLargePublisher({ name: "p" });
+    const em = newEntityManager();
+    const p1 = await em.load(LargePublisher, "p:1");
+    // Then we can get fields from the subtype
+    expect(p1.getFieldValue("country")).toBe("country");
+    // Or the base type
+    expect(p1.getFieldValue("name")).toBe("p");
+    // And not fields from the other subtype
+    // @ts-expect-error
+    expect(() => p1.getFieldValue("city")).toThrow("Invalid field city");
+  });
+
+  it("setting derived fields causes a type error", async () => {
+    // Given an existing author
+    await insertAuthor({ first_name: "f" });
+    const em = newEntityManager();
+    const a1 = await em.load(Author, "a:1");
+    // When we try to set the num of books
+    a1.setFieldValue("numberOfBooks", 1);
+    await em.flush();
+    // Then it worked
+    expect((await select("authors"))[0]).toMatchObject({
+      first_name: "f",
+      number_of_books: 1,
+    });
+  });
+
+  it("can use get on loaded relations", async () => {
+    // Given an existing author
+    await insertPublisher({ name: "p" });
+    await insertAuthor({ first_name: "f", publisher_id: 1 });
+    const em = newEntityManager();
+    const a1 = await em.load(Author, "a:1");
+    expect(a1.getFieldValue("publisher")).toBe("p:1");
+  });
+
+  it("can use set on loaded relations", async () => {
+    // Given an existing author
+    await insertPublisher({ name: "p1" });
+    await insertPublisher({ id: 2, name: "p2" });
+    await insertAuthor({ first_name: "f", publisher_id: 1 });
+    const em = newEntityManager();
+    const a1 = await em.load(Author, "a:1", "publisher");
+    expect(a1.publisher.id).toBe("p:1");
+    a1.setFieldValue("publisher", "p:2");
+    expect(a1.publisher.id).toBe("p:2");
+    expect(a1.publisher.isLoaded).toBe(false);
+    await em.flush();
+    expect((await select("authors"))[0]).toMatchObject({
+      first_name: "f",
+      publisher_id: 2,
+    });
+  });
+});
diff --git a/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts b/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts
index c0de4a3a0..430f62b48 100644
--- a/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AdminUserCodegen.ts
@@ -8,6 +8,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -32,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 {
@@ -102,12 +103,20 @@ export abstract class AdminUserCodegen extends User implements Entity {
     setField(this, "role", cleanStringValue(role));
   }
 
+  getFieldValue<K extends keyof AdminUserFields>(key: K): AdminUserFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AdminUserFields>(key: K, value: AdminUserFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AdminUserOpts>): void {
-    setOpts(this as any as AdminUser, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AdminUserOpts>): void {
-    setOpts(this as any as AdminUser, opts as OptsOf<AdminUser>, { partial: true });
+    setOpts(this as any, opts as OptsOf<AdminUser>, { partial: true });
   }
 
   get changes(): Changes<AdminUser> {
@@ -121,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 00e0a0acc..d4e13a4b8 100644
--- a/packages/tests/integration/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AuthorCodegen.ts
@@ -14,6 +14,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -90,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 {
@@ -528,12 +530,20 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return this.favoriteShape === FavoriteShape.Triangle;
   }
 
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorOpts>): void {
-    setOpts(this as any as Author, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorOpts>): void {
-    setOpts(this as any as Author, opts as OptsOf<Author>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Author>, { partial: true });
   }
 
   get changes(): Changes<Author> {
@@ -551,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);
   }
 
@@ -568,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> {
@@ -629,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> {
@@ -649,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 7555c0a08..baaae86e1 100644
--- a/packages/tests/integration/src/entities/codegen/AuthorScheduleCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AuthorScheduleCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -137,12 +138,20 @@ export abstract class AuthorScheduleCodegen extends BaseEntity<EntityManager, st
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorScheduleFields>(key: K): AuthorScheduleFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorScheduleFields>(key: K, value: AuthorScheduleFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorScheduleOpts>): void {
-    setOpts(this as any as AuthorSchedule, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorScheduleOpts>): void {
-    setOpts(this as any as AuthorSchedule, opts as OptsOf<AuthorSchedule>, { partial: true });
+    setOpts(this as any, opts as OptsOf<AuthorSchedule>, { partial: true });
   }
 
   get changes(): Changes<AuthorSchedule> {
@@ -154,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 c865871ba..ded755804 100644
--- a/packages/tests/integration/src/entities/codegen/AuthorStatCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/AuthorStatCodegen.ts
@@ -9,6 +9,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -33,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 {
@@ -275,12 +276,20 @@ export abstract class AuthorStatCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorStatFields>(key: K): AuthorStatFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorStatFields>(key: K, value: AuthorStatFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorStatOpts>): void {
-    setOpts(this as any as AuthorStat, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorStatOpts>): void {
-    setOpts(this as any as AuthorStat, opts as OptsOf<AuthorStat>, { partial: true });
+    setOpts(this as any, opts as OptsOf<AuthorStat>, { partial: true });
   }
 
   get changes(): Changes<AuthorStat> {
@@ -294,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 dd5057393..78cfaa672 100644
--- a/packages/tests/integration/src/entities/codegen/BookAdvanceCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/BookAdvanceCodegen.ts
@@ -10,6 +10,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -51,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 {
@@ -172,12 +173,20 @@ export abstract class BookAdvanceCodegen extends BaseEntity<EntityManager, strin
     return getField(this, "status") === AdvanceStatus.Paid;
   }
 
+  getFieldValue<K extends keyof BookAdvanceFields>(key: K): BookAdvanceFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookAdvanceFields>(key: K, value: BookAdvanceFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookAdvanceOpts>): void {
-    setOpts(this as any as BookAdvance, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookAdvanceOpts>): void {
-    setOpts(this as any as BookAdvance, opts as OptsOf<BookAdvance>, { partial: true });
+    setOpts(this as any, opts as OptsOf<BookAdvance>, { partial: true });
   }
 
   get changes(): Changes<BookAdvance> {
@@ -191,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 509eb6551..758a75ca9 100644
--- a/packages/tests/integration/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/BookCodegen.ts
@@ -14,6 +14,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -57,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 {
@@ -248,12 +240,20 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookOpts>): void {
-    setOpts(this as any as Book, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookOpts>): void {
-    setOpts(this as any as Book, opts as OptsOf<Book>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Book>, { partial: true });
   }
 
   get changes(): Changes<Book> {
@@ -271,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);
   }
@@ -285,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> {
@@ -302,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> {
@@ -335,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 17160b729..c0a441404 100644
--- a/packages/tests/integration/src/entities/codegen/BookReviewCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/BookReviewCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -38,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 {
@@ -177,12 +167,20 @@ export abstract class BookReviewCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof BookReviewFields>(key: K): BookReviewFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookReviewFields>(key: K, value: BookReviewFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookReviewOpts>): void {
-    setOpts(this as any as BookReview, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookReviewOpts>): void {
-    setOpts(this as any as BookReview, opts as OptsOf<BookReview>, { partial: true });
+    setOpts(this as any, opts as OptsOf<BookReview>, { partial: true });
   }
 
   get changes(): Changes<BookReview> {
@@ -196,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);
   }
 
@@ -223,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 2d70936b9..d67e3c845 100644
--- a/packages/tests/integration/src/entities/codegen/ChildCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ChildCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -134,12 +135,20 @@ export abstract class ChildCodegen extends BaseEntity<EntityManager, string> imp
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof ChildFields>(key: K): ChildFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ChildFields>(key: K, value: ChildFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ChildOpts>): void {
-    setOpts(this as any as Child, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ChildOpts>): void {
-    setOpts(this as any as Child, opts as OptsOf<Child>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Child>, { partial: true });
   }
 
   get changes(): Changes<Child> {
@@ -153,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);
   }
 
@@ -170,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 85c009b99..bf4541013 100644
--- a/packages/tests/integration/src/entities/codegen/ChildGroupCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ChildGroupCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -53,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 {
@@ -161,12 +162,20 @@ export abstract class ChildGroupCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof ChildGroupFields>(key: K): ChildGroupFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ChildGroupFields>(key: K, value: ChildGroupFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ChildGroupOpts>): void {
-    setOpts(this as any as ChildGroup, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ChildGroupOpts>): void {
-    setOpts(this as any as ChildGroup, opts as OptsOf<ChildGroup>, { partial: true });
+    setOpts(this as any, opts as OptsOf<ChildGroup>, { partial: true });
   }
 
   get changes(): Changes<ChildGroup> {
@@ -180,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);
   }
 
@@ -197,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 f3f2dc5b1..ee52bbb0d 100644
--- a/packages/tests/integration/src/entities/codegen/ChildItemCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ChildItemCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -34,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 {
@@ -153,12 +145,20 @@ export abstract class ChildItemCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof ChildItemFields>(key: K): ChildItemFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ChildItemFields>(key: K, value: ChildItemFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ChildItemOpts>): void {
-    setOpts(this as any as ChildItem, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ChildItemOpts>): void {
-    setOpts(this as any as ChildItem, opts as OptsOf<ChildItem>, { partial: true });
+    setOpts(this as any, opts as OptsOf<ChildItem>, { partial: true });
   }
 
   get changes(): Changes<ChildItem> {
@@ -172,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 0fb132dd5..741b24fde 100644
--- a/packages/tests/integration/src/entities/codegen/CommentCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/CommentCodegen.ts
@@ -14,6 +14,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -41,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>;
@@ -67,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 {
@@ -173,12 +162,20 @@ export abstract class CommentCodegen extends BaseEntity<EntityManager, string> i
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof CommentFields>(key: K): CommentFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof CommentFields>(key: K, value: CommentFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<CommentOpts>): void {
-    setOpts(this as any as Comment, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<CommentOpts>): void {
-    setOpts(this as any as Comment, opts as OptsOf<Comment>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Comment>, { partial: true });
   }
 
   get changes(): Changes<Comment> {
@@ -192,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 1b1d8485e..086c9dcc0 100644
--- a/packages/tests/integration/src/entities/codegen/CriticCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/CriticCodegen.ts
@@ -13,6 +13,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -52,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 {
@@ -176,12 +169,20 @@ export abstract class CriticCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof CriticFields>(key: K): CriticFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof CriticFields>(key: K, value: CriticFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<CriticOpts>): void {
-    setOpts(this as any as Critic, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<CriticOpts>): void {
-    setOpts(this as any as Critic, opts as OptsOf<Critic>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Critic>, { partial: true });
   }
 
   get changes(): Changes<Critic> {
@@ -195,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);
   }
 
@@ -212,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> {
@@ -239,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 21a06d4db..307b78771 100644
--- a/packages/tests/integration/src/entities/codegen/CriticColumnCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/CriticColumnCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -138,12 +139,20 @@ export abstract class CriticColumnCodegen extends BaseEntity<EntityManager, stri
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof CriticColumnFields>(key: K): CriticColumnFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof CriticColumnFields>(key: K, value: CriticColumnFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<CriticColumnOpts>): void {
-    setOpts(this as any as CriticColumn, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<CriticColumnOpts>): void {
-    setOpts(this as any as CriticColumn, opts as OptsOf<CriticColumn>, { partial: true });
+    setOpts(this as any, opts as OptsOf<CriticColumn>, { partial: true });
   }
 
   get changes(): Changes<CriticColumn> {
@@ -155,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 61f963e13..1f895b72b 100644
--- a/packages/tests/integration/src/entities/codegen/ImageCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ImageCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -54,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 {
@@ -193,12 +194,20 @@ export abstract class ImageCodegen extends BaseEntity<EntityManager, string> imp
     return getField(this, "type") === ImageType.PublisherImage;
   }
 
+  getFieldValue<K extends keyof ImageFields>(key: K): ImageFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ImageFields>(key: K, value: ImageFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ImageOpts>): void {
-    setOpts(this as any as Image, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ImageOpts>): void {
-    setOpts(this as any as Image, opts as OptsOf<Image>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Image>, { partial: true });
   }
 
   get changes(): Changes<Image> {
@@ -212,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 e8aa949ff..0f79ecf1f 100644
--- a/packages/tests/integration/src/entities/codegen/LargePublisherCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/LargePublisherCodegen.ts
@@ -9,6 +9,7 @@ import {
   loadLens,
   newChangesProxy,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -32,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,
@@ -58,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 {
@@ -147,12 +138,20 @@ export abstract class LargePublisherCodegen extends Publisher implements Entity
     setField(this, "country", cleanStringValue(country));
   }
 
+  getFieldValue<K extends keyof LargePublisherFields>(key: K): LargePublisherFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof LargePublisherFields>(key: K, value: LargePublisherFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<LargePublisherOpts>): void {
-    setOpts(this as any as LargePublisher, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<LargePublisherOpts>): void {
-    setOpts(this as any as LargePublisher, opts as OptsOf<LargePublisher>, { partial: true });
+    setOpts(this as any, opts as OptsOf<LargePublisher>, { partial: true });
   }
 
   get changes(): Changes<LargePublisher> {
@@ -164,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 aaa9cb6ce..bba038e41 100644
--- a/packages/tests/integration/src/entities/codegen/ParentGroupCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ParentGroupCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -34,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 {
@@ -147,12 +139,20 @@ export abstract class ParentGroupCodegen extends BaseEntity<EntityManager, strin
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof ParentGroupFields>(key: K): ParentGroupFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ParentGroupFields>(key: K, value: ParentGroupFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ParentGroupOpts>): void {
-    setOpts(this as any as ParentGroup, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ParentGroupOpts>): void {
-    setOpts(this as any as ParentGroup, opts as OptsOf<ParentGroup>, { partial: true });
+    setOpts(this as any, opts as OptsOf<ParentGroup>, { partial: true });
   }
 
   get changes(): Changes<ParentGroup> {
@@ -166,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,
@@ -183,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 b0e12ee79..e13e26dc8 100644
--- a/packages/tests/integration/src/entities/codegen/ParentItemCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/ParentItemCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -36,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 {
@@ -152,12 +144,20 @@ export abstract class ParentItemCodegen extends BaseEntity<EntityManager, string
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof ParentItemFields>(key: K): ParentItemFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ParentItemFields>(key: K, value: ParentItemFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ParentItemOpts>): void {
-    setOpts(this as any as ParentItem, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ParentItemOpts>): void {
-    setOpts(this as any as ParentItem, opts as OptsOf<ParentItem>, { partial: true });
+    setOpts(this as any, opts as OptsOf<ParentItem>, { partial: true });
   }
 
   get changes(): Changes<ParentItem> {
@@ -171,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);
   }
 
@@ -188,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 9f4b85746..0a868063e 100644
--- a/packages/tests/integration/src/entities/codegen/PublisherCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/PublisherCodegen.ts
@@ -13,6 +13,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -67,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 {
@@ -319,18 +310,23 @@ export abstract class PublisherCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "type") === PublisherType.Big;
   }
 
+  getFieldValue<K extends keyof PublisherFields>(key: K): PublisherFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof PublisherFields>(key: K, value: PublisherFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<PublisherOpts>): void {
-    setOpts(this as any as Publisher, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<PublisherOpts>): void {
-    setOpts(this as any as Publisher, opts as OptsOf<Publisher>, { partial: true });
+    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;
   }
 
@@ -345,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);
   }
 
@@ -362,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> {
@@ -415,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 2f76d093f..0e12c0757 100644
--- a/packages/tests/integration/src/entities/codegen/PublisherGroupCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/PublisherGroupCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -37,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 {
@@ -153,12 +145,20 @@ export abstract class PublisherGroupCodegen extends BaseEntity<EntityManager, st
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof PublisherGroupFields>(key: K): PublisherGroupFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof PublisherGroupFields>(key: K, value: PublisherGroupFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<PublisherGroupOpts>): void {
-    setOpts(this as any as PublisherGroup, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<PublisherGroupOpts>): void {
-    setOpts(this as any as PublisherGroup, opts as OptsOf<PublisherGroup>, { partial: true });
+    setOpts(this as any, opts as OptsOf<PublisherGroup>, { partial: true });
   }
 
   get changes(): Changes<PublisherGroup> {
@@ -170,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,
@@ -191,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 e84c7c3d5..56a4f17d8 100644
--- a/packages/tests/integration/src/entities/codegen/SmallPublisherCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/SmallPublisherCodegen.ts
@@ -10,6 +10,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -34,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,
@@ -57,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 {
@@ -150,12 +143,20 @@ export abstract class SmallPublisherCodegen extends Publisher implements Entity
 
   abstract readonly allAuthorNames: ReactiveField<SmallPublisher, string | undefined>;
 
+  getFieldValue<K extends keyof SmallPublisherFields>(key: K): SmallPublisherFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof SmallPublisherFields>(key: K, value: SmallPublisherFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<SmallPublisherOpts>): void {
-    setOpts(this as any as SmallPublisher, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<SmallPublisherOpts>): void {
-    setOpts(this as any as SmallPublisher, opts as OptsOf<SmallPublisher>, { partial: true });
+    setOpts(this as any, opts as OptsOf<SmallPublisher>, { partial: true });
   }
 
   get changes(): Changes<SmallPublisher> {
@@ -167,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 df7cb5c82..41805b6c4 100644
--- a/packages/tests/integration/src/entities/codegen/TagCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TagCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -36,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 {
@@ -152,12 +142,20 @@ export abstract class TagCodegen extends BaseEntity<EntityManager, string> imple
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof TagFields>(key: K): TagFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof TagFields>(key: K, value: TagFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<TagOpts>): void {
-    setOpts(this as any as Tag, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<TagOpts>): void {
-    setOpts(this as any as Tag, opts as OptsOf<Tag>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Tag>, { partial: true });
   }
 
   get changes(): Changes<Tag> {
@@ -171,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);
   }
@@ -185,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> {
@@ -211,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 3deb0818f..c49ff5c94 100644
--- a/packages/tests/integration/src/entities/codegen/TaskCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -35,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 {
@@ -186,12 +175,20 @@ export abstract class TaskCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "type") === TaskType.New;
   }
 
+  getFieldValue<K extends keyof TaskFields>(key: K): TaskFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof TaskFields>(key: K, value: TaskFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<TaskOpts>): void {
-    setOpts(this as any as Task, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<TaskOpts>): void {
-    setOpts(this as any as Task, opts as OptsOf<Task>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Task>, { partial: true });
   }
 
   get changes(): Changes<Task, keyof FieldsOf<Task> | keyof FieldsOf<TaskNew> | keyof FieldsOf<TaskOld>> {
@@ -209,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);
   }
 
@@ -226,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 2dc377ac2..45d816b64 100644
--- a/packages/tests/integration/src/entities/codegen/TaskItemCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskItemCodegen.ts
@@ -10,6 +10,7 @@ import {
   mustBeSubType,
   newChangesProxy,
   newRequiredRule,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -33,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 {
@@ -147,12 +137,20 @@ export abstract class TaskItemCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof TaskItemFields>(key: K): TaskItemFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof TaskItemFields>(key: K, value: TaskItemFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<TaskItemOpts>): void {
-    setOpts(this as any as TaskItem, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<TaskItemOpts>): void {
-    setOpts(this as any as TaskItem, opts as OptsOf<TaskItem>, { partial: true });
+    setOpts(this as any, opts as OptsOf<TaskItem>, { partial: true });
   }
 
   get changes(): Changes<TaskItem> {
@@ -166,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 0cc0c67f2..a4506a187 100644
--- a/packages/tests/integration/src/entities/codegen/TaskNewCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskNewCodegen.ts
@@ -9,6 +9,7 @@ import {
   loadLens,
   newChangesProxy,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -33,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,
@@ -60,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 {
@@ -138,12 +129,20 @@ export abstract class TaskNewCodegen extends Task implements Entity {
     setField(this, "specialNewField", specialNewField);
   }
 
+  getFieldValue<K extends keyof TaskNewFields>(key: K): TaskNewFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof TaskNewFields>(key: K, value: TaskNewFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<TaskNewOpts>): void {
-    setOpts(this as any as TaskNew, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<TaskNewOpts>): void {
-    setOpts(this as any as TaskNew, opts as OptsOf<TaskNew>, { partial: true });
+    setOpts(this as any, opts as OptsOf<TaskNew>, { partial: true });
   }
 
   get changes(): Changes<TaskNew> {
@@ -157,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);
   }
 
@@ -174,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 261550549..140460581 100644
--- a/packages/tests/integration/src/entities/codegen/TaskOldCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/TaskOldCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -65,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 {
@@ -158,12 +159,20 @@ export abstract class TaskOldCodegen extends Task implements Entity {
     setField(this, "specialOldField", specialOldField);
   }
 
+  getFieldValue<K extends keyof TaskOldFields>(key: K): TaskOldFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof TaskOldFields>(key: K, value: TaskOldFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<TaskOldOpts>): void {
-    setOpts(this as any as TaskOld, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<TaskOldOpts>): void {
-    setOpts(this as any as TaskOld, opts as OptsOf<TaskOld>, { partial: true });
+    setOpts(this as any, opts as OptsOf<TaskOld>, { partial: true });
   }
 
   get changes(): Changes<TaskOld> {
@@ -177,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);
   }
 
@@ -194,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 cb33c63fd..f36998cc5 100644
--- a/packages/tests/integration/src/entities/codegen/UserCodegen.ts
+++ b/packages/tests/integration/src/entities/codegen/UserCodegen.ts
@@ -15,6 +15,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -70,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 {
@@ -249,12 +250,20 @@ export abstract class UserCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof UserFields>(key: K): UserFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof UserFields>(key: K, value: UserFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<UserOpts>): void {
-    setOpts(this as any as User, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<UserOpts>): void {
-    setOpts(this as any as User, opts as OptsOf<User>, { partial: true });
+    setOpts(this as any, opts as OptsOf<User>, { partial: true });
   }
 
   get changes(): Changes<User, keyof FieldsOf<User> | keyof FieldsOf<AdminUser>> {
@@ -268,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);
   }
@@ -282,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/joist-config.json b/packages/tests/number-ids/joist-config.json
index b4fd86d40..42ad794be 100644
--- a/packages/tests/number-ids/joist-config.json
+++ b/packages/tests/number-ids/joist-config.json
@@ -4,5 +4,5 @@
   "entities": { "Author": { "tag": "a" }, "Book": { "tag": "b" } },
   "entitiesDirectory": "./src/entities",
   "idType": "number",
-  "version": "1.155.2"
+  "version": "1.156.0"
 }
diff --git a/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts b/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts
index 1f49dabba..539515510 100644
--- a/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/number-ids/src/entities/codegen/AuthorCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -148,12 +149,20 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, number> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorOpts>): void {
-    setOpts(this as any as Author, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorOpts>): void {
-    setOpts(this as any as Author, opts as OptsOf<Author>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Author>, { partial: true });
   }
 
   get changes(): Changes<Author> {
@@ -167,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 19698a4c9..9b808f8ed 100644
--- a/packages/tests/number-ids/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/number-ids/src/entities/codegen/BookCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -138,12 +139,20 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, number> impl
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookOpts>): void {
-    setOpts(this as any as Book, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookOpts>): void {
-    setOpts(this as any as Book, opts as OptsOf<Book>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Book>, { partial: true });
   }
 
   get changes(): Changes<Book> {
@@ -157,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/joist-config.json b/packages/tests/schema-misc/joist-config.json
index 045189ce0..c9852d83f 100644
--- a/packages/tests/schema-misc/joist-config.json
+++ b/packages/tests/schema-misc/joist-config.json
@@ -15,5 +15,5 @@
     "createdAt": { "names": ["created_at", "createdAt"], "required": false },
     "updatedAt": { "names": ["updated_at", "updatedAt"], "required": false }
   },
-  "version": "1.155.2"
+  "version": "1.156.0"
 }
diff --git a/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts b/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts
index 4a38c7e33..0d0310913 100644
--- a/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/ArtistCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -149,12 +150,20 @@ export abstract class ArtistCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof ArtistFields>(key: K): ArtistFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof ArtistFields>(key: K, value: ArtistFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<ArtistOpts>): void {
-    setOpts(this as any as Artist, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<ArtistOpts>): void {
-    setOpts(this as any as Artist, opts as OptsOf<Artist>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Artist>, { partial: true });
   }
 
   get changes(): Changes<Artist> {
@@ -168,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);
   }
 
@@ -185,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 a329777e6..6986725c7 100644
--- a/packages/tests/schema-misc/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/AuthorCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -42,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 {
@@ -163,12 +164,20 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorOpts>): void {
-    setOpts(this as any as Author, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorOpts>): void {
-    setOpts(this as any as Author, opts as OptsOf<Author>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Author>, { partial: true });
   }
 
   get changes(): Changes<Author> {
@@ -182,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 24c3a2d98..e50627df1 100644
--- a/packages/tests/schema-misc/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/BookCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -120,12 +121,20 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     setField(this, "title", cleanStringValue(title));
   }
 
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookOpts>): void {
-    setOpts(this as any as Book, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookOpts>): void {
-    setOpts(this as any as Book, opts as OptsOf<Book>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Book>, { partial: true });
   }
 
   get changes(): Changes<Book> {
@@ -139,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 9f8ca729d..f4525f6ae 100644
--- a/packages/tests/schema-misc/src/entities/codegen/DatabaseOwnerCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/DatabaseOwnerCodegen.ts
@@ -9,6 +9,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -33,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 {
@@ -106,12 +107,20 @@ export abstract class DatabaseOwnerCodegen extends BaseEntity<EntityManager, str
     setField(this, "name", cleanStringValue(name));
   }
 
+  getFieldValue<K extends keyof DatabaseOwnerFields>(key: K): DatabaseOwnerFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof DatabaseOwnerFields>(key: K, value: DatabaseOwnerFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<DatabaseOwnerOpts>): void {
-    setOpts(this as any as DatabaseOwner, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<DatabaseOwnerOpts>): void {
-    setOpts(this as any as DatabaseOwner, opts as OptsOf<DatabaseOwner>, { partial: true });
+    setOpts(this as any, opts as OptsOf<DatabaseOwner>, { partial: true });
   }
 
   get changes(): Changes<DatabaseOwner> {
@@ -123,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 7a9eabdaa..d2f5478cc 100644
--- a/packages/tests/schema-misc/src/entities/codegen/PaintingCodegen.ts
+++ b/packages/tests/schema-misc/src/entities/codegen/PaintingCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -138,12 +139,20 @@ export abstract class PaintingCodegen extends BaseEntity<EntityManager, string>
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof PaintingFields>(key: K): PaintingFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof PaintingFields>(key: K, value: PaintingFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<PaintingOpts>): void {
-    setOpts(this as any as Painting, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<PaintingOpts>): void {
-    setOpts(this as any as Painting, opts as OptsOf<Painting>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Painting>, { partial: true });
   }
 
   get changes(): Changes<Painting> {
@@ -157,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/joist-config.json b/packages/tests/untagged-ids/joist-config.json
index b5bc68e8a..0395fdce6 100644
--- a/packages/tests/untagged-ids/joist-config.json
+++ b/packages/tests/untagged-ids/joist-config.json
@@ -8,5 +8,5 @@
   },
   "entitiesDirectory": "./src/entities",
   "idType": "untagged-string",
-  "version": "1.155.2"
+  "version": "1.156.0"
 }
diff --git a/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts b/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts
index 472a38e1f..c96e9532d 100644
--- a/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/untagged-ids/src/entities/codegen/AuthorCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -152,12 +153,20 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorOpts>): void {
-    setOpts(this as any as Author, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorOpts>): void {
-    setOpts(this as any as Author, opts as OptsOf<Author>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Author>, { partial: true });
   }
 
   get changes(): Changes<Author> {
@@ -171,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);
   }
 
@@ -193,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 3003b9493..7fb0a2537 100644
--- a/packages/tests/untagged-ids/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/untagged-ids/src/entities/codegen/BookCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -42,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 {
@@ -144,12 +145,20 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookOpts>): void {
-    setOpts(this as any as Book, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookOpts>): void {
-    setOpts(this as any as Book, opts as OptsOf<Book>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Book>, { partial: true });
   }
 
   get changes(): Changes<Book> {
@@ -163,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);
   }
@@ -177,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 80e0485c6..e6f409838 100644
--- a/packages/tests/untagged-ids/src/entities/codegen/CommentCodegen.ts
+++ b/packages/tests/untagged-ids/src/entities/codegen/CommentCodegen.ts
@@ -12,6 +12,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -49,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 {
@@ -146,12 +147,20 @@ export abstract class CommentCodegen extends BaseEntity<EntityManager, string> i
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof CommentFields>(key: K): CommentFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof CommentFields>(key: K, value: CommentFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<CommentOpts>): void {
-    setOpts(this as any as Comment, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<CommentOpts>): void {
-    setOpts(this as any as Comment, opts as OptsOf<Comment>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Comment>, { partial: true });
   }
 
   get changes(): Changes<Comment> {
@@ -165,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/joist-config.json b/packages/tests/uuid-ids/joist-config.json
index 9eb698f21..b0ec85f44 100644
--- a/packages/tests/uuid-ids/joist-config.json
+++ b/packages/tests/uuid-ids/joist-config.json
@@ -3,5 +3,5 @@
   "contextType": "Context@src/context",
   "entities": { "Author": { "tag": "a" }, "Book": { "tag": "b" } },
   "entitiesDirectory": "./src/entities",
-  "version": "1.155.2"
+  "version": "1.156.0"
 }
diff --git a/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts b/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts
index 3b1743fce..8a3c4fa20 100644
--- a/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts
+++ b/packages/tests/uuid-ids/src/entities/codegen/AuthorCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -40,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 {
@@ -148,12 +149,20 @@ export abstract class AuthorCodegen extends BaseEntity<EntityManager, string> im
     return getField(this, "updatedAt");
   }
 
+  getFieldValue<K extends keyof AuthorFields>(key: K): AuthorFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof AuthorFields>(key: K, value: AuthorFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<AuthorOpts>): void {
-    setOpts(this as any as Author, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<AuthorOpts>): void {
-    setOpts(this as any as Author, opts as OptsOf<Author>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Author>, { partial: true });
   }
 
   get changes(): Changes<Author> {
@@ -167,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 af78f3fc8..883d29e73 100644
--- a/packages/tests/uuid-ids/src/entities/codegen/BookCodegen.ts
+++ b/packages/tests/uuid-ids/src/entities/codegen/BookCodegen.ts
@@ -11,6 +11,7 @@ import {
   newChangesProxy,
   newRequiredRule,
   setField,
+  setFieldValue,
   setOpts,
   toIdOf,
 } from "joist-orm";
@@ -34,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 {
@@ -174,12 +165,20 @@ export abstract class BookCodegen extends BaseEntity<EntityManager, string> impl
     return getField(this, "status") === BookStatus.Published;
   }
 
+  getFieldValue<K extends keyof BookFields>(key: K): BookFields[K]["value"] {
+    return getField(this as any, key);
+  }
+
+  setFieldValue<K extends keyof BookFields>(key: K, value: BookFields[K]["value"]): void {
+    setFieldValue(this, key, value);
+  }
+
   set(opts: Partial<BookOpts>): void {
-    setOpts(this as any as Book, opts);
+    setOpts(this as any, opts);
   }
 
   setPartial(opts: PartialOrNull<BookOpts>): void {
-    setOpts(this as any as Book, opts as OptsOf<Book>, { partial: true });
+    setOpts(this as any, opts as OptsOf<Book>, { partial: true });
   }
 
   get changes(): Changes<Book> {
@@ -193,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);
   }