@@ -7,6 +7,16 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### #214 — entity read-view codegen READ half (TypeScript reference)
+
+Completes the read side of the FR-024 §7 entity read-view (#213 shipped the write/schema half — the write table excludes derived `origin.*` fields and the replica view is emitted + migrate-converged). A **write-through entity** (a writable `table` source + a read-only replica `view` source + derived fields) now generates a hybrid read/write surface in TypeScript:
+
+- The entity file declares the `.existing()` replica **view** alongside the write table, plus a Zod read schema whose `z.infer` **is** the read type `<Entity>` — carrying the derived fields the write table omits (`z.infer`, not Drizzle `InferSelectModel`/`$inferSelect`, because a Drizzle view is not a Table and SQLite views don't expose `$inferSelect`; the read schema's nullability mirrors the view columns, exactly like a projection).
+- Generated **reads** (`find<Entity>ById` / `list<Plural>` / reverse finders) SELECT from the view; **writes** (`create` / `update` / `delete`) target the table; a create/update **re-reads** the row through the view by primary key (keyed on the full PK) so the returned `<Entity>` carries the derived fields (read-your-writes). Insert/Update stay derived-free (#213).
+- The scaffold-and-own reference generators (`meta init`) delegate the write-through variant to the engine composer (like the projection/TPH variants), so the default consumer path is not a silent no-op.
+
+Shared `renderExistingViewDecl` + `renderViewReadZodObject` helpers now back both projections and write-through entities (projection output byte-identical). Gated by a `tsc`-compile test of the real generated output on both dialects + a real-Postgres re-read round-trip. **TS-only** (ADR-0015 — schema/codegen is per-port); the other four ports' ORM/DTO generators are the tracked cross-port follow-up.
+
 ### #207 — projection row-scope `@filter` (a view-level WHERE)
 
 A projection (`object.projection`) can now declare a row-scope `@filter` — a portable `attr.filter` object (`eq`/`ne`/`gt`/`gte`/`lt`/`lte`/`like`/`in`/`isNull` with `and`/`or`, desugared to canonical `{ field: { op: value } }` at parse time) selecting which rows the derived view returns. It lowers to an outer SQL `WHERE`, the metadata-managed way to express soft-delete / status / type views instead of a hand-written unmanaged view (which is drift, invisible to `verify --db`). Placement mirrors `origin.aggregate @filter` exactly: a `filter`-subtype attr on `object.projection` (the predicate is a LOGICAL derivation, so it lives on the object, not on `source.rdb` — it survives non-RDB lowerings).
 
@@ -42,8 +42,11 @@ import {
   SHARED_ENUMS_BASENAME,
   // predicates + helpers:
   isProjection,
+  isWriteThrough,
   isAbstract,
   hasWritableRdbSource,
+  // engine composer — used for the delegated write-through variant:
+  renderEntityFile,
   // engine plumbing:
   formatTs,
   entityOutputPath,
@@ -79,8 +82,15 @@ function renderEntity(entity: MetaObject, ctx: RenderContext, opts?: RenderEntit
   if (!runtime || !hasWritableRdbSource(entity)) {
     return renderValueObjectFile(entity, ctx.apiPrefix, ctx);
   }
+  // #214 — a write-through entity read-view (writable table + a read-only replica view +
+  // derived origin.* fields) needs the hybrid file (table + `.existing()` view decl + a
+  // z.infer read type carrying the derived fields). Delegate to the engine composer rather
+  // than duplicate that branch here (mirrors the projection delegation above).
+  if (isWriteThrough(entity)) {
+    return renderEntityFile(entity, ctx, { allowlists });
+  }
 
-  // Write-through entity → the full Drizzle table file. Reorder/drop sections freely.
+  // Vanilla entity → the full Drizzle table file. Reorder/drop sections freely.
   const enumAliases = renderEnumTypeAliases(entity, ctx);
   const tphBlock = renderTphDiscriminatorUnion(entity, ctx.loadedRoot);
   const tphBase = tphBlock !== null && isTphDiscriminatorBase(entity, ctx.loadedRoot);
 
@@ -31,6 +31,7 @@ import {
   reverseFksFor,
   isTphDiscriminatorBase,
   isProjection,
+  isWriteThrough,
   isTphSubtype,
   renderQueriesFile, // engine composer — used for the delegated variants
   formatTs,
@@ -41,7 +42,9 @@ import {
 // --- composition (OWNED for the common case) ---
 function renderQueries(obj: MetaObject, ctx: RenderContext): string {
   // Advanced variants delegate to the engine (byte-identical). Own them by copying their source.
-  if (isTphDiscriminatorBase(obj, ctx.loadedRoot) || isProjection(obj)) {
+  // #214 — a write-through entity read-view (reads → replica view, writes → table) delegates
+  // too; owning it inline would duplicate the hybrid read/write routing.
+  if (isTphDiscriminatorBase(obj, ctx.loadedRoot) || isProjection(obj) || isWriteThrough(obj)) {
     return renderQueriesFile(obj, ctx);
   }
 
 
@@ -6,7 +6,7 @@
 //   !hasWritableRdbSource(entity)      → renderValueObjectFile (in-memory / transit shape: interface + Zod schema)
 //   vanilla / write-through entity     → Drizzle table path
 
-import { joinCode, type Code } from "ts-poet";
+import { code, imp, joinCode, type Code } from "ts-poet";
 import type { MetaObject } from "@metaobjectsdev/metadata";
 import type { RenderContext } from "../render-context.js";
 import { renderDrizzleSchema } from "./drizzle-schema.js";
@@ -17,8 +17,13 @@ import { renderFilterAllowlist, renderSortAllowlist } from "./filter-allowlist.j
 import { renderFilterType } from "./filter-type.js";
 import { renderTphDiscriminatorUnion, isTphDiscriminatorBase } from "./tph-discriminator.js";
 import { GENERATED_HEADER } from "../constants.js";
-import { isProjection } from "../projection/projection-detector.js";
+import { isProjection, isWriteThrough } from "../projection/projection-detector.js";
 import { renderProjectionDecl } from "./projection-decl.js";
+import { projectionViewName } from "../projection/extract-view-spec.js";
+import { renderExistingViewDecl, renderViewReadZodObject } from "./view-decl.js";
+import { renderDocsFor } from "./jsdoc.js";
+import { valueObjectModuleSpecifier } from "../import-path.js";
+import { stripPackage } from "@metaobjectsdev/metadata";
 import { hasWritableRdbSource } from "../source-detect.js";
 import { renderValueObjectFile } from "./value-object-file.js";
 import { isAbstract } from "../instance-artifacts.js";
@@ -108,9 +113,47 @@ export function renderEntityFile(
   // bare `<Base>` type — so the inferred Drizzle row type is emitted as
   // `<Base>Row` to avoid a duplicate `export type <Base>`.
   const tphBase = tphBlock !== null && isTphDiscriminatorBase(entity, ctx.loadedRoot);
+
+  // #214 — a write-through entity read-view (FR-024 §7): reads route to the replica
+  // VIEW, so the entity file additionally declares the `.existing()` view (carrying the
+  // derived fields the write table omits, #213) and a read schema `<Entity>Schema`
+  // whose `z.infer` IS the read type <Entity> (dialect-agnostic — a Drizzle view is not
+  // a Table, so InferSelectModel/`$inferSelect` don't uniformly apply; the Zod schema's
+  // nullability mirrors the view columns exactly like a projection). The write table +
+  // Insert/Update stay derived-free. `.existing()` is a runtime-target Drizzle binding,
+  // and this path only runs in a runtime target (contract-only/non-writable returned above).
+  // A TPH discriminator base owns `export type <Base>` via its discriminated-union block,
+  // so it must NOT also emit the view-schema read type (that would be a duplicate-identifier
+  // compile error). A base+write-through combo keeps the TPH polymorphic read path (reads
+  // the base table); routing its reads through a replica view is a documented non-goal.
+  const writeThrough = isWriteThrough(entity) && !tphBase;
+  const viewSections: Code[] = [];
+  if (writeThrough) {
+    const camel = entity.name.charAt(0).toLowerCase() + entity.name.slice(1);
+    const fields = entity.fields();
+    const voModule = (refBase: string): string =>
+      valueObjectModuleSpecifier(stripPackage(refBase), ctx.packageOf, entity.package, ctx.outputLayout, ctx.extStyle);
+    const viewOpts = {
+      dialect: ctx.dialect, columnNamingStrategy: ctx.columnNamingStrategy, timestampMode: ctx.timestampMode, voModule,
+    };
+    const z = imp("z@zod");
+    const docs = renderDocsFor(entity);
+    const docsPrefix = docs ? `${docs}\n` : "";
+    viewSections.push(
+      renderExistingViewDecl(fields, projectionViewName(entity, ctx.columnNamingStrategy), `${camel}View`, viewOpts),
+      code`
+export const ${entity.name}Schema = ${renderViewReadZodObject(fields, viewOpts)};
+`,
+      code`
+${docsPrefix}export type ${entity.name} = ${z}.infer<typeof ${entity.name}Schema>;
+`,
+    );
+  }
+
   const sections: Code[] = [
     renderDrizzleSchema(entity, ctx),
-    renderInferredTypes(entity, tphBase, ctx),
+    ...viewSections,
+    renderInferredTypes(entity, tphBase, ctx, writeThrough /* skipRow — read type is the view schema */),
     ...(enumAliases !== null ? [enumAliases] : []),
     renderZodValidators(entity, ctx),
     renderEntityConstants(entity, ctx.apiPrefix),
 
@@ -51,7 +51,12 @@ import type { RenderContext } from "../render-context.js";
  * to avoid a duplicate `export type <Base>`. Insert/Update keep their names
  * (no collision); they describe the physical TPH table row shape.
  */
-export function renderInferredTypes(entity: MetaObject, tphBase = false, ctx?: RenderContext): Code {
+export function renderInferredTypes(
+  entity: MetaObject,
+  tphBase = false,
+  ctx?: RenderContext,
+  skipRow = false,
+): Code {
   // The inferred Row/Insert types reference the Drizzle table var, so they must
   // resolve to the SAME (possibly overridden) collection name the schema emits.
   // ctx is optional for bare unit-test calls — those fall back to the default
@@ -64,6 +69,18 @@ export function renderInferredTypes(entity: MetaObject, tphBase = false, ctx?: R
   const docs = renderDocsFor(entity);
   const docsPrefix = docs ? `${docs}\n` : "";
   const rowName = tphBase ? `${entity.name}Row` : entity.name;
+  // #214 — a write-through entity read-view routes READS to the replica view, so the
+  // read row type <Entity> is emitted from the VIEW's read schema (z.infer, carrying
+  // the derived fields) by the entity-file composer, NOT here. `skipRow` suppresses
+  // the table-inferred Row so there is no duplicate `export type <Entity>` (selectSym
+  // then goes unreferenced and ts-poet drops its import). Insert/Update always stay
+  // inferred from the write TABLE (derived-free, #213).
+  if (skipRow) {
+    return code`
+export type ${entity.name}Insert = ${insertSym}<typeof ${varName}>;
+export type ${entity.name}Update = Partial<${entity.name}Insert>;
+`;
+  }
   return code`
 ${docsPrefix}export type ${rowName} = ${selectSym}<typeof ${varName}>;
 export type ${entity.name}Insert = ${insertSym}<typeof ${varName}>;
 
@@ -10,18 +10,17 @@
 import { code, imp, joinCode, type Code } from "ts-poet";
 import {
   MetaField, MetaObject, type MetaRoot,
-  FIELD_SUBTYPE_OBJECT, FIELD_ATTR_OBJECT_REF, stripPackage,
 } from "@metaobjectsdev/metadata";
 import { projectionViewName } from "../projection/extract-view-spec.js";
 import { columnNameFromField, toSnakeCase, pluralize } from "../naming.js";
 import { GENERATED_HEADER } from "../constants.js";
 import type { ColumnNamingStrategy } from "../metaobjects-config.js";
 import type { RenderContext } from "../render-context.js";
-import { mapColumnType } from "../column-mapper.js";
 import { valueObjectModuleSpecifier } from "../import-path.js";
 import { renderFilterAllowlist, renderSortAllowlist } from "./filter-allowlist.js";
 import { renderFilterType } from "./filter-type.js";
-import { inferViewKind, zodTypeFor, currencyMetaFor, labelFor } from "./field-meta.js";
+import { inferViewKind, currencyMetaFor, labelFor } from "./field-meta.js";
+import { renderExistingViewDecl, renderViewReadZodObject } from "./view-decl.js";
 
 // ---------------------------------------------------------------------------
 // Public interface
@@ -100,16 +99,7 @@ export function renderProjectionDecl(
     ctx
       ? valueObjectModuleSpecifier(refBase, ctx.packageOf, projection.package, ctx.outputLayout, ctx.extStyle)
       : `./${refBase}.js`;
-  const objectRefOf = (f: MetaField): string | undefined => {
-    if (f.subType !== FIELD_SUBTYPE_OBJECT) return undefined;
-    const ref = f.attr(FIELD_ATTR_OBJECT_REF);
-    return typeof ref === "string" && ref.length > 0 ? stripPackage(ref) : undefined;
-  };
 
-  const viewFn = dialect === "postgres" ? "pgView" : "sqliteView";
-  const viewModule =
-    dialect === "postgres" ? "drizzle-orm/pg-core" : "drizzle-orm/sqlite-core";
-  const viewSym = imp(`${viewFn}@${viewModule}`);
   const z = imp("z@zod");
 
   // Read-model generation needs only the view name — NOT the join/DDL
@@ -136,76 +126,6 @@ export function renderProjectionDecl(
   // inherited fields are not duplicated.
   for (const f of projection.ownFields()) allFields.push(f);
 
-  // A field.object passthrough carries the value-object's Zod schema (so the
-  // view's read schema + inferred type expose the VO shape, not z.unknown()).
-  const zodLines: Code[] = allFields.map((f) => {
-    // The read schema's nullability MUST mirror the view column's: a column that
-    // is not `.notNull()` infers `T | null` in Drizzle's SELECT type, so the Zod
-    // read type (and thus the generated query's return type) must be `.nullable()`
-    // too — otherwise `db.select().from(view)` yields `T | null` into a non-null
-    // `<Name>` field and the generated query fails to compile under strict TS.
-    const nullable =
-      mapColumnType(f, dialect, columnNamingStrategy, timestampMode)
-        .modifiers.includes(".notNull()")
-        ? ""
-        : ".nullable()";
-    const refBase = objectRefOf(f);
-    if (refBase) {
-      const schemaSym = imp(`${refBase}InsertSchema@${voModule(refBase)}`);
-      const base = f.resolvedIsArray()
-        ? code`${z}.array(${schemaSym})`
-        : code`${schemaSym}`;
-      return code`  ${f.name}: ${base}${nullable}`;
-    }
-    // #204 — array-wrap a scalar array passthrough so the read type is `T[]`
-    // (was scalar `T`, diverging from the Drizzle view column above + the Kotlin
-    // port). zodTypeFor returns the ELEMENT type; the array-ness rides here.
-    const inner = code`${z}.${zodTypeFor(f).replace(/^z\./, "")}`;
-    const zbase = f.resolvedIsArray() ? code`${z}.array(${inner})` : inner;
-    return code`  ${f.name}: ${zbase}${nullable}`;
-  });
-
-  // Typed view column map for the Drizzle `.existing()` declaration — keyed by
-  // projection field name, valued by the column builder for the (renamed)
-  // physical view column, so `db.select().from(<view>)` is typed. Honors
-  // `@dbColumnType` (e.g. a passthrough of a jsonb column). `.existing()` views
-  // carry type + physical name only — no PK/default/notNull modifiers.
-  const viewColumnLines: Code[] = allFields.map((f) => {
-    const spec = mapColumnType(f, dialect, columnNamingStrategy, timestampMode);
-    const colSym = imp(`${spec.fnName}@${spec.importModule}`);
-    const optsArg =
-      spec.fnOptions && Object.keys(spec.fnOptions).length > 0
-        ? `, ${JSON.stringify(spec.fnOptions)}`
-        : "";
-    // #204 — of the table modifiers, only `.array()` (postgres native array
-    // element typing) and `.notNull()` (shapes the SELECT type) carry to an
-    // existing view; `.primaryKey()`/`.default()`/`.references()`/`.unique()` are
-    // table-DDL concerns and invalid on a `.existing()` view declaration. Preserve
-    // the canonical order (`.array()` before `.notNull()`). Dropping `.array()`
-    // typed a `text[]` passthrough as scalar `string`, diverging from the Kotlin port.
-    const viewModifiers = spec.modifiers
-      .filter((m) => m === ".array()" || m === ".notNull()")
-      .join("");
-    // Narrow the column to its resolved element/value type — `.$type<…>()` —
-    // mirroring the entity column (drizzle-schema.ts) so the read row is typed
-    // (not `unknown`) and an array column reads as `T[]`, not `T`. #204: the
-    // scalar-array (`.$type<string[]>()`, SQLite's json-array path) and map kinds
-    // were dropped here — only objectRef was carried.
-    let dollarType: Code | string = "";
-    const dtr = spec.dollarTypeRef;
-    if (dtr?.kind === "scalar") {
-      dollarType = `.$type<${dtr.tsType}${dtr.array ? "[]" : ""}>()`;
-    } else if (dtr?.kind === "objectRef") {
-      const voTypeSym = imp(`${dtr.name}@${voModule(dtr.name)}`);
-      dollarType = dtr.array ? code`.$type<${voTypeSym}[]>()` : code`.$type<${voTypeSym}>()`;
-    } else if (dtr?.kind === "map") {
-      dollarType = "scalar" in dtr.value
-        ? `.$type<Record<string, ${dtr.value.scalar}>>()`
-        : code`.$type<Record<string, ${imp(`${dtr.value.objectRef}@${voModule(dtr.value.objectRef)}`)}>>()`;
-    }
-    return code`  ${f.name}: ${colSym}(${JSON.stringify(spec.dbName)}${optsArg})${dollarType}${viewModifiers}`;
-  });
-
   const constFieldLines: string[] = allFields.map((f) => {
     const dbCol = columnNameFromField(f.name, columnNamingStrategy);
     const view = inferViewKind(f);
@@ -224,19 +144,14 @@ export function renderProjectionDecl(
 
   const sections: Code[] = [
     ...(includeViewDecl
-      ? [code`
-// View declaration — Drizzle uses this for typed SELECT queries.
-// The SQL view is created/managed by migrate-ts; .existing() tells Drizzle
-// not to attempt DDL for this declaration.
-export const ${camelName}View = ${viewSym}(${JSON.stringify(viewName)}, {
-${joinCode(viewColumnLines, { on: ",\n" })}
-}).existing();
-`]
+      ? [renderExistingViewDecl(allFields, viewName, `${camelName}View`, {
+          dialect, columnNamingStrategy, timestampMode, voModule,
+        })]
       : []),
     code`
-export const ${projName}Schema = ${z}.object({
-${joinCode(zodLines, { on: ",\n" })}
-});
+export const ${projName}Schema = ${renderViewReadZodObject(allFields, {
+  dialect, columnNamingStrategy, timestampMode, voModule,
+})};
 `,
     code`
 export type ${projName} = ${z}.infer<typeof ${projName}Schema>;