@@ -41,6 +41,20 @@ edit (two registered `description` strings) and was ruled a hold, as 1.0.4's was
   This covered BOTH view hosts — an `object.projection` and a write-through entity's replica
   view render through the same function, and the read-view is the shape the authoring
   guidance recommends over a projection.
+- **A projection field that RENAMED the base field built a view over a column that does not
+  exist.** `{ field.string: { name: bookingRef, extends: "Shipment.reference" } }` emitted
+  `SELECT s.booking_ref` against a table whose column is `reference`: the view's output alias
+  and the column it selects were both derived from the projection's field, and the `extends`
+  target was never consulted. SQLite does not resolve a view body at `CREATE VIEW`, so
+  `meta migrate --apply` reported success and the view failed at the first `SELECT`;
+  Postgres rejected the migration outright. The source column now comes from the `extends`
+  target, and only when that target names the BASE entity — a bare `extends` onto a
+  package-level abstract is shape reuse, not a column binding, and a read-view HOST reads
+  its own table, where a dotted `extends` onto a sibling field is shape reuse too. Both
+  still resolve to the field's own name. Renaming a base column is one of the two things the
+  authoring guidance names as genuinely forcing a projection. **An adopter whose view had a
+  renamed passthrough will see a view-replace in the next `meta migrate` diff** — that is the
+  corrected SQL, and the view it replaces could not be queried.
 - **`meta eject` and `meta gen --list` print an install command you can paste.** The line
   was documented as paste-ready and was not, on the most common selection
   (`meta eject entity queries routes names barrel`):
 
@@ -570,6 +570,50 @@ function sourceColumnNameFor(
   return columnNameFromField(entityField.name, ctx.columnNamingStrategy);
 }
 
+/**
+ * The BASE table's column an extends-bound passthrough field SELECTS.
+ *
+ * A projection field may RENAME what it exposes
+ * (`{ field.string: { name: bookingRef, extends: "Shipment.reference" } }`). The view's
+ * OUTPUT alias is the projection field's own; the column it reads from the base table is
+ * the extends TARGET's. Deriving both from the projection field emits
+ * `SELECT s.booking_ref` against a table whose column is `reference` — SQL that SQLite
+ * accepts at CREATE VIEW and only fails at the first SELECT, and that Postgres rejects
+ * outright at migrate time.
+ *
+ * Caller contract: this is for a PLAIN projection only. A read-view HOST (`base ===
+ * projection`) reads its own table, so its passthrough source is always the field's own
+ * column and there is no rename to resolve — and a host field may legally `extends` a
+ * SIBLING field of the same entity for shape reuse, which this would otherwise read as a
+ * rename and silently serve the sibling's data under this field's name.
+ *
+ * Only a DOTTED extends naming the BASE entity redirects the source column:
+ *
+ *   - `extends: "Shipment.reference"` — binds a base column; the target's column wins.
+ *   - `extends: "Code24"` (bare, a package-level abstract) — SHAPE REUSE, not a binding.
+ *     `refNamedOwner` returns undefined, so the field's own name stays the source.
+ *   - `extends: "Other.foo"` — names an entity that is not the base. The caller emits this
+ *     column against `joinTree.baseAlias`, so borrowing another entity's column name would
+ *     be a second wrong answer; keep the field's own.
+ *
+ * The alias is not always the projection's spelling: `sourceColumnNameFor` reads `@column`
+ * with the RESOLVING accessor, so a renaming field whose base carries an explicit `@column`
+ * inherits it and both sides land on that physical name. The rename then holds on the TS /
+ * wire tier only. That is pre-existing and self-consistent — the Drizzle view decl binds
+ * the same column — but it is not a promise this function makes.
+ */
+function baseColumnNameFor(
+  field: MetaField,
+  base: MetaObject,
+  root: MetaRoot,
+  ctx: ExtractContext,
+): string {
+  const target = field.superData;
+  if (target === undefined) return sourceColumnNameFor(field, ctx);
+  if (refNamedOwner(field, root) !== base) return sourceColumnNameFor(field, ctx);
+  return sourceColumnNameFor(target, ctx);
+}
+
 /**
  * Physical column for a join FK/PK field — resolves @column + naming strategy the
  * same way passthrough columns do (EFFECTIVE fields, so inherited PKs resolve).
@@ -976,22 +1020,27 @@ function buildSelectSpec(
   // fields — the declared set IS the exposure (FR-024/ADR-0028). Either way, each
   // field's own origin decides passthrough-from-base vs derived-from-join. origin.*
   // NEVER inherits (ADR-0029), so the origin reads below are own (category 4).
-  const declaredFields: MetaField[] =
-    base === projection
-      ? base.fields()
-      : projection.ownChildren().filter((c): c is MetaField => c.type === TYPE_FIELD);
+  // A read-view HOST reads its OWN table (base === projection), so every passthrough
+  // sources from the field's own column; a plain projection reads the base's, which an
+  // extends-bound field may rename. The flag decides both the field set and the source.
+  const isReadViewHost = base === projection;
+  const declaredFields: MetaField[] = isReadViewHost
+    ? base.fields()
+    : projection.ownChildren().filter((c): c is MetaField => c.type === TYPE_FIELD);
   for (const field of declaredFields) {
     const origin = field.ownChildren().find((c) => c.type === TYPE_ORIGIN);
     const dbCol = sourceColumnNameFor(field, ctx);
 
     if (!origin) {
-      // Declared on projection but no origin — passthrough from base table.
+      // Declared on projection but no origin — passthrough from base table. The alias is
+      // this field's own column; the SOURCE is the extends target's, which differs
+      // whenever the projection renames the base field.
       columns.push({
         kind: "passthrough",
         fieldName: field.name,
         dbColAlias: dbCol,
         sourceAlias: joinTree.baseAlias,
-        sourceColumn: dbCol,
+        sourceColumn: isReadViewHost ? dbCol : baseColumnNameFor(field, base, root, ctx),
       });
       continue;
     }
 
@@ -0,0 +1,227 @@
+import { describe, test, expect } from "bun:test";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
+import { extractViewSpec } from "../../src/projection/extract-view-spec.js";
+import { emitViewDdl } from "../../src/projection/view-ddl-emit.js";
+
+/**
+ * A projection field may RENAME what it exposes:
+ *
+ *   { field.string: { name: bookingRef, extends: "Shipment.reference" } }
+ *
+ * The view's OUTPUT column is the projection field's (`booking_ref`); the column it
+ * SELECTS is the extends TARGET's (`reference`). Deriving both from the projection
+ * field emits `SELECT s.booking_ref` against a table whose column is `reference` —
+ * a view SQLite accepts at CREATE and fails at first SELECT, Postgres rejects outright.
+ *
+ * Renaming base columns is one of only two things the authoring guidance says
+ * genuinely forces a projection, so this is the construct's headline case.
+ */
+async function load(children: unknown[]) {
+  const json = JSON.stringify({ "metadata.root": { package: "test", children } });
+  const result = await new MetaDataLoader().load([new InMemoryStringSource(json)]);
+  if (result.errors.length > 0) {
+    throw new Error(`Loader errors:\n${result.errors.map((e) => e.message).join("\n")}`);
+  }
+  return result.root;
+}
+
+const shipment = {
+  "object.entity": {
+    name: "Shipment",
+    children: [
+      { "source.rdb": { "@table": "shipment" } },
+      { "field.int": { name: "id" } },
+      { "field.string": { name: "reference" } },
+      { "field.string": { name: "originCity" } },
+      { "identity.primary": { name: "pk", "@fields": "id" } },
+    ],
+  },
+};
+
+describe("extractViewSpec — extends-bound passthrough that RENAMES the base field", () => {
+  test("sourceColumn comes from the extends target, dbColAlias from the projection field", async () => {
+    const root = await load([
+      shipment,
+      {
+        "object.projection": {
+          name: "ShipmentSummary",
+          children: [
+            { "source.rdb": { "@kind": "view", "@view": "v_shipment_summary" } },
+            { "field.int": { name: "id", extends: "Shipment.id" } },
+            // THE RENAME: exposed as bookingRef, sourced from Shipment.reference.
+            { "field.string": { name: "bookingRef", extends: "Shipment.reference" } },
+            { "identity.primary": { name: "pk", extends: "Shipment.pk" } },
+          ],
+        },
+      },
+    ]);
+
+    const projection = root.objects().find((o) => o.name === "ShipmentSummary")!;
+    const spec = extractViewSpec(projection, root, { columnNamingStrategy: "snake_case" });
+
+    const booking = spec.selectSpec.columns.find((c) => c.fieldName === "bookingRef")!;
+    expect(booking.kind).toBe("passthrough");
+    if (booking.kind === "passthrough") {
+      // The view exposes it under the projection's own name…
+      expect(booking.dbColAlias).toBe("booking_ref");
+      // …but SELECTs the base entity's real column.
+      expect(booking.sourceColumn).toBe("reference");
+    }
+
+    // An un-renamed field is unaffected.
+    const id = spec.selectSpec.columns.find((c) => c.fieldName === "id")!;
+    if (id.kind === "passthrough") {
+      expect(id.dbColAlias).toBe("id");
+      expect(id.sourceColumn).toBe("id");
+    }
+  });
+
+  test("an explicit @column on the projection field names the VIEW column, not the base's", async () => {
+    const root = await load([
+      shipment,
+      {
+        "object.projection": {
+          name: "ShipmentSummary",
+          children: [
+            { "source.rdb": { "@kind": "view", "@view": "v_shipment_summary" } },
+            { "field.int": { name: "id", extends: "Shipment.id" } },
+            {
+              "field.string": {
+                name: "bookingRef",
+                extends: "Shipment.reference",
+                "@column": "booking_code",
+              },
+            },
+            { "identity.primary": { name: "pk", extends: "Shipment.pk" } },
+          ],
+        },
+      },
+    ]);
+
+    const projection = root.objects().find((o) => o.name === "ShipmentSummary")!;
+    const spec = extractViewSpec(projection, root, { columnNamingStrategy: "snake_case" });
+    const booking = spec.selectSpec.columns.find((c) => c.fieldName === "bookingRef")!;
+    if (booking.kind === "passthrough") {
+      expect(booking.dbColAlias).toBe("booking_code");
+      expect(booking.sourceColumn).toBe("reference");
+    }
+  });
+
+  test("a field-level extends onto an ABSTRACT (shape reuse) does not hijack the source column", async () => {
+    const root = await load([
+      // A package-level abstract field reused for its shape, NOT a base column.
+      { "field.string": { name: "Code24", abstract: true, "@maxLength": 24 } },
+      {
+        "object.entity": {
+          name: "Shipment",
+          children: [
+            { "source.rdb": { "@table": "shipment" } },
+            { "field.int": { name: "id" } },
+            { "field.string": { name: "reference" } },
+            { "identity.primary": { name: "pk", "@fields": "id" } },
+          ],
+        },
+      },
+      {
+        "object.projection": {
+          name: "ShipmentSummary",
+          children: [
+            { "source.rdb": { "@kind": "view", "@view": "v_shipment_summary" } },
+            { "field.int": { name: "id", extends: "Shipment.id" } },
+            // Extends an abstract for SHAPE — the base column is its own name.
+            { "field.string": { name: "reference", extends: "Code24" } },
+            { "identity.primary": { name: "pk", extends: "Shipment.pk" } },
+          ],
+        },
+      },
+    ]);
+
+    const projection = root.objects().find((o) => o.name === "ShipmentSummary")!;
+    const spec = extractViewSpec(projection, root, { columnNamingStrategy: "snake_case" });
+    const ref = spec.selectSpec.columns.find((c) => c.fieldName === "reference")!;
+    if (ref.kind === "passthrough") {
+      expect(ref.dbColAlias).toBe("reference");
+      // NOT "code24" — the abstract is shape, not a base column.
+      expect(ref.sourceColumn).toBe("reference");
+    }
+  });
+
+  test("end to end: the emitted CREATE VIEW selects the base column under the new alias", async () => {
+    const root = await load([
+      shipment,
+      {
+        "object.projection": {
+          name: "ShipmentSummary",
+          children: [
+            { "source.rdb": { "@kind": "view", "@view": "v_shipment_summary" } },
+            { "field.int": { name: "id", extends: "Shipment.id" } },
+            { "field.string": { name: "bookingRef", extends: "Shipment.reference" } },
+            { "field.string": { name: "originCity", extends: "Shipment.originCity" } },
+            { "identity.primary": { name: "pk", extends: "Shipment.pk" } },
+          ],
+        },
+      },
+    ]);
+
+    const projection = root.objects().find((o) => o.name === "ShipmentSummary")!;
+    const spec = extractViewSpec(projection, root, { columnNamingStrategy: "snake_case" });
+    const sql = emitViewDdl(spec, {
+      dialect: "sqlite",
+      baseTableName: "shipment",
+      joinTables: {},
+    });
+
+    // The rename is an ALIAS over the base column, not a second column name.
+    expect(sql).toContain("s.reference AS booking_ref");
+    // And never the pre-fix form, which named a column `shipment` does not have.
+    expect(sql).not.toContain("s.booking_ref");
+    expect(sql).toContain("s.origin_city AS origin_city");
+  });
+});
+
+describe("read-view HOST — the rename rule must NOT apply", () => {
+  /**
+   * A write-through entity's read-view reads its OWN table, so a passthrough always sources
+   * from the field's own column. A host field may legally `extends` a SIBLING field of the
+   * same entity for shape reuse — a dotted ref whose owner IS the base. Treating that as a
+   * rename makes the view serve the sibling's data under this field's name: valid SQL, no
+   * error, wrong rows.
+   */
+  test("a host field extending a SIBLING field still selects its own column", async () => {
+    const root = await load([
+      {
+        "object.entity": {
+          name: "Shipment",
+          children: [
+            { "source.rdb": { "@kind": "table", "@table": "shipment", "@role": "primary" } },
+            { "source.rdb": { "@kind": "view", "@view": "v_shipment", "@role": "replica" } },
+            { "field.int": { name: "id" } },
+            { "field.string": { name: "reference" } },
+            // Shape reuse off a sibling — NOT a rename of it.
+            { "field.string": { name: "altReference", extends: "Shipment.reference" } },
+            { "identity.primary": { name: "pk", "@fields": "id" } },
+          ],
+        },
+      },
+    ]);
+
+    const host = root.objects().find((o) => o.name === "Shipment")!;
+    const spec = extractViewSpec(host, root, { columnNamingStrategy: "snake_case" });
+
+    const alt = spec.selectSpec.columns.find((c) => c.fieldName === "altReference")!;
+    expect(alt.kind).toBe("passthrough");
+    if (alt.kind === "passthrough") {
+      expect(alt.dbColAlias).toBe("alt_reference");
+      // Its OWN column — not the sibling's, which is a real separate column on the table.
+      expect(alt.sourceColumn).toBe("alt_reference");
+    }
+
+    const sql = emitViewDdl(spec, {
+      dialect: "sqlite",
+      baseTableName: "shipment",
+      joinTables: {},
+    });
+    expect(sql).toContain("s.alt_reference AS alt_reference");
+    expect(sql).toContain("s.reference AS reference");
+  });
+});