@@ -0,0 +1,111 @@
+---
+name: Bug report
+about: Report a defect
+title: "Projection origin.aggregate columns dropped from generated view DDL (inverse-FK @via + aggregate filter)"
+labels: bug
+---
+
+**Affected port(s):** TypeScript (codegen-ts view-SQL builder)
+**Package + version:** `@metaobjectsdev/codegen-ts` 0.12.5 (`projection/extract-view-spec.ts`), surfaced via `@metaobjectsdev/migrate-ts` 0.12.0 + `@metaobjectsdev/cli` 0.12.5, dialect postgres.
+
+**What happened**
+
+A `object.projection` with an `origin.aggregate` column over a **one-to-many (inverse-FK)** relationship has that column **silently dropped** from the generated `CREATE VIEW` DDL. The column IS present in the generated TS contract (Zod + types), so the contract and the actual DB view disagree — querying the view fails (the column doesn't exist) while the types claim it does.
+
+Two distinct gaps, both in `codegen-ts` `extract-view-spec.ts` → `view-ddl-emit.ts`:
+
+1. **Inverse-FK `@via` not resolved into the join tree.** When `origin.aggregate @via` points at a `relationship.composition` whose FK lives on the *target* side (the 1→many inverse — parent has many children, child holds the FK), the join-tree builder doesn't add the child table, so `findAliasInTree(joinTree, entityName)` returns `undefined` and the aggregate branch hits `continue` — the column is dropped entirely. (`extract-view-spec.ts`, the `else if (origin.subType === ORIGIN_SUBTYPE_AGGREGATE)` block.) This drops *every* aggregate over an inverse relationship, including a plain `count`.
+
+2. **Aggregate `filter` not rendered.** `origin.aggregate` accepts a `filter` (an `attr.filter` desugar — e.g. `filter: { status: { eq: active } }`) and the loader accepts it without error, but `view-ddl-emit.ts` emits `AGG(src) AS alias` with **no `FILTER (WHERE …)`** clause. So even when the join resolves, a filtered aggregate (`max(version) where status='active'`) computes over *all* rows, returning the wrong value. (`meta types origin.aggregate` also doesn't list `filter` as an attr, though the loader honors it.)
+
+**What you expected**
+
+The generated view SQL should include the aggregate column with the join and the filter, e.g.:
+
+```sql
+CREATE VIEW v_behavior_definition AS
+SELECT
+  b.id, b.name, ...,
+  COUNT(DISTINCT v.id)                              AS version_count,
+  MAX(v.version) FILTER (WHERE v.status = 'active') AS active_version
+FROM behavior_definitions b
+LEFT JOIN behavior_versions v ON v.behavior_id = b.id
+GROUP BY b.id, b.name, ...;
+```
+
+**Reproduction**
+
+Minimal metadata: a parent entity, a child entity holding the FK back to the parent, an inverse `relationship.composition` on the parent, and a projection that aggregates over it.
+
+```yaml
+- object.entity:
+    name: BehaviorDefinition
+    children:
+    - source.rdb: { table: behavior_definitions }
+    - field.string: { name: name }
+    # inverse of behavior_versions.behavior_id (FK is on the child):
+    - relationship.composition: { name: versions, objectRef: BehaviorVersion, cardinality: many }
+    extends: AuditedEntity
+- object.entity:
+    name: BehaviorVersion
+    children:
+    - source.rdb: { table: behavior_versions }
+    - field.uuid:   { name: behaviorId, column: behavior_id }
+    - field.int:    { name: version }
+    - field.string: { name: status }
+    - identity.reference: { name: fk_b, fields: [behaviorId], references: BehaviorDefinition }
+- object.projection:
+    name: BehaviorDefinitionView
+    children:
+    - source.rdb: { kind: view, view: v_behavior_definition }
+    - field.uuid:   { name: id, extends: BehaviorDefinition.id }
+    - field.string: { name: name, children: [ origin.passthrough: { from: BehaviorDefinition.name } ] }
+    - field.int:    { name: version_count,
+                      children: [ origin.aggregate: { agg: count, of: BehaviorVersion.id, via: BehaviorDefinition.versions } ] }
+    - field.int:    { name: active_version,
+                      children: [ origin.aggregate: { agg: max, of: BehaviorVersion.version,
+                                                      via: BehaviorDefinition.versions,
+                                                      filter: { status: { eq: active } } } ] }
+    - identity.primary: { extends: BehaviorDefinition.pk }
+```
+
+Steps: `meta gen` (the TS contract gets `version_count` + `active_version` — correct), then `meta migrate --dialect postgres` → the generated `CREATE VIEW` has **only the passthrough columns**; both aggregate columns are absent (no `LEFT JOIN`, no `GROUP BY`).
+
+**Root-cause pointers**
+- `codegen-ts/src/projection/extract-view-spec.ts`: the aggregate branch `continue`s when `findAliasInTree` can't find the target — the join-tree builder needs to resolve an inverse (target-side-FK, cardinality `many`) composition into a `LEFT JOIN child ON child.fk = parent.pk`.
+- `codegen-ts/src/projection/view-ddl-emit.ts`: the aggregate emitter needs a postgres `FILTER (WHERE …)` (or per-dialect equivalent) when the `origin.aggregate` carries a `filter`.
+- A conformance fixture exercising an inverse-FK aggregate + a filtered aggregate would pin both.
+
+**Environment**
+Linux, Node 24, pnpm 10. Found while migrating a downstream consumer's admin UI to a generated projection view; worked around by hand-authoring the view SQL body.
+
+---
+
+## Resolution (2026-06-28)
+
+**Gap 1 (inverse-FK join) was already fixed on `main`** — the `ProgramSummary` test
+(`extract-view-spec.test.ts`) covers an aggregate `count` over an inverse-FK `weeks`
+relationship and passes. The reporter hit it only on the published 0.12.0 the CLI
+pins; latest `main` resolves the inverse join. No code change needed.
+
+**Gap 2 (aggregate filter) is fixed here** (codegen-ts only — no cross-port metamodel
+change, see scoping note):
+- `projection/view-spec.ts` — new `ViewFilterClause` type; `aggregate` SelectColumn
+  gains an optional `filter`.
+- `projection/extract-view-spec.ts` — reads the aggregate's `@filter` attr, **desugars**
+  it (scalar→eq, array→in, null→isNull, and/or recurse), and resolves each field to
+  `<sourceAlias>.<column>` on the aggregated entity.
+- `projection/view-ddl-emit.ts` — renders postgres `AGG(src) FILTER (WHERE …)` /
+  `COUNT(DISTINCT src) FILTER (WHERE …)`, and the portable `AGG(CASE WHEN … THEN src END)`
+  form for sqlite (no aggregate FILTER pre-3.30).
+- Tests: `build-projection-views.test.ts` — postgres FILTER, scalar-shorthand desugar,
+  and sqlite CASE WHEN. Full codegen-ts suite green (863).
+
+**Scoping note:** the `@filter` attr is read codegen-locally (a const in
+extract-view-spec) rather than declared in the `origin.aggregate` metamodel
+(`spec/metamodel/origin.json`). Declaring it there is the "proper" home but ripples to
+all five ports' registry-conformance + the embedded/manifest/docs drift gates — a
+separate cross-port change. The loader already stores the undeclared attr; codegen
+desugars it, so the feature works today without the metamodel churn. Follow-up: declare
+`@filter` on `origin.aggregate` across all ports when convenient (then codegen can drop
+its local desugar and rely on the framework's).
@@ -26,9 +26,67 @@ import {
 } from "../naming.js";
 import type { ColumnNamingStrategy } from "../metaobjects-config.js";
 import type {
-  JoinNode, JoinTree, SelectColumn, SelectSpec, ViewSpec,
+  JoinNode, JoinTree, SelectColumn, SelectSpec, ViewSpec, ViewFilterClause,
 } from "./view-spec.js";
 
+/** The optional scoping-filter attr on origin.aggregate (`@filter`). Not part of the
+ *  metamodel registry vocabulary (kept here, codegen-local, to avoid a cross-port
+ *  metamodel change); the loader stores it as a plain attr and codegen desugars it. */
+const ORIGIN_AGGREGATE_ATTR_FILTER = "filter";
+/** Compose keys in the attr.filter shape. */
+const FILTER_AND = "and";
+const FILTER_OR = "or";
+
+/**
+ * Desugar a single field clause to the canonical `{ op: value }` form (scalar→eq,
+ * array→in, null→isNull, object→as-is). Mirrors metadata's attr.filter desugar so an
+ * aggregate `@filter` works whether or not it was pre-desugared by the loader.
+ */
+function desugarClause(raw: unknown): Record<string, unknown> {
+  if (raw === null) return { isNull: true };
+  if (Array.isArray(raw)) return { in: raw };
+  if (typeof raw === "object") return raw as Record<string, unknown>;
+  return { eq: raw };
+}
+
+/**
+ * Resolve an aggregate `@filter` (`{ field: value | { op: value }, and?, or? }`) into
+ * a {@link ViewFilterClause} with column refs resolved to `alias.column` on the
+ * aggregated entity. Multiple fields at one level compose with AND. Unknown fields are
+ * skipped (defensive — the loader validates field existence elsewhere).
+ */
+function resolveAggregateFilter(
+  filter: unknown,
+  entity: MetaObject,
+  alias: string,
+  ctx: ExtractContext,
+): ViewFilterClause | undefined {
+  if (typeof filter !== "object" || filter === null || Array.isArray(filter)) return undefined;
+  const clauses: ViewFilterClause[] = [];
+  for (const [key, val] of Object.entries(filter as Record<string, unknown>)) {
+    if (key === FILTER_AND || key === FILTER_OR) {
+      const subs = (Array.isArray(val) ? val : [])
+        .map((s) => resolveAggregateFilter(s, entity, alias, ctx))
+        .filter((c): c is ViewFilterClause => c !== undefined);
+      if (subs.length > 0) clauses.push({ kind: key === FILTER_AND ? "and" : "or", clauses: subs });
+      continue;
+    }
+    const field = entity.fields().find((f) => f.name === key);
+    if (!field) continue;
+    const opObj = desugarClause(val);
+    const op = Object.keys(opObj)[0];
+    if (!op) continue;
+    clauses.push({
+      kind: "cmp",
+      ref: `${alias}.${sourceColumnNameFor(field, ctx)}`,
+      op,
+      value: opObj[op],
+    });
+  }
+  if (clauses.length === 0) return undefined;
+  return clauses.length === 1 ? clauses[0]! : { kind: "and", clauses };
+}
+
 // ---------------------------------------------------------------------------
 // Public context type
 // ---------------------------------------------------------------------------
@@ -382,13 +440,20 @@ function buildSelectSpec(
       if (!targetEntity || sourceAlias === undefined) continue;
       const targetField = targetEntity.fields().find((f) => f.name === fieldName);
       if (!targetField) continue;
+      // Optional scoping filter — resolved against the aggregated entity (the @of
+      // entity, reached at `sourceAlias`), e.g. max(version) over only active rows.
+      const filterAttr = origin.ownAttr(ORIGIN_AGGREGATE_ATTR_FILTER);
+      const filter = filterAttr !== undefined
+        ? resolveAggregateFilter(filterAttr, targetEntity, sourceAlias, ctx)
+        : undefined;
       columns.push({
         kind: "aggregate",
         fieldName: field.name,
         dbColAlias: dbCol,
         agg,
         sourceAlias,
         sourceColumn: sourceColumnNameFor(targetField, ctx),
+        ...(filter !== undefined ? { filter } : {}),
       });
     }
   }
 
@@ -1,4 +1,4 @@
-import type { JoinNode, ViewSpec } from "./view-spec.js";
+import type { JoinNode, ViewSpec, ViewFilterClause } from "./view-spec.js";
 
 // Quote an identifier only when it isn't a plain lowercase snake identifier —
 // exactly postgres's own rule. This keeps snake_case output unquoted (the common
@@ -32,17 +32,56 @@ export interface EmitOptions {
   readonly bodyOnly?: boolean;
 }
 
-function renderColumn(c: import("./view-spec.js").SelectColumn): string {
+/** SQL literal for a filter value, dialect-aware for booleans. */
+function sqlLiteral(value: unknown, dialect: EmitOptions["dialect"]): string {
+  if (value === null || value === undefined) return "NULL";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") {
+    return dialect === "sqlite" ? (value ? "1" : "0") : (value ? "TRUE" : "FALSE");
+  }
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+const FILTER_OP_SQL: Readonly<Record<string, string>> = {
+  eq: "=", ne: "<>", gt: ">", gte: ">=", lt: "<", lte: "<=", like: "LIKE",
+};
+
+/** Render a resolved {@link ViewFilterClause} to a SQL boolean expression. */
+function renderFilterCond(clause: ViewFilterClause, dialect: EmitOptions["dialect"]): string {
+  if (clause.kind === "and" || clause.kind === "or") {
+    const joined = clause.clauses.map((c) => renderFilterCond(c, dialect)).join(clause.kind === "and" ? " AND " : " OR ");
+    return `(${joined})`;
+  }
+  const ref = quoteRef(clause.ref);
+  if (clause.op === "isNull") return clause.value === false ? `${ref} IS NOT NULL` : `${ref} IS NULL`;
+  if (clause.op === "in") {
+    const vals = (Array.isArray(clause.value) ? clause.value : [clause.value]).map((v) => sqlLiteral(v, dialect));
+    return `${ref} IN (${vals.join(", ")})`;
+  }
+  const op = FILTER_OP_SQL[clause.op];
+  if (!op) throw new Error(`view-ddl-emit: unsupported aggregate filter operator "${clause.op}".`);
+  return `${ref} ${op} ${sqlLiteral(clause.value, dialect)}`;
+}
+
+function renderColumn(c: import("./view-spec.js").SelectColumn, dialect: EmitOptions["dialect"]): string {
   const src = `${c.sourceAlias}.${quoteIfNeeded(c.sourceColumn)}`;
   const alias = quoteIfNeeded(c.dbColAlias);
   if (c.kind === "passthrough") {
     return `${src} AS ${alias}`;
   }
   // aggregate — use DISTINCT for count() over joined PKs to avoid join inflation.
+  // A scoping @filter renders as postgres `FILTER (WHERE …)`; sqlite (no aggregate
+  // FILTER pre-3.30) uses the portable `CASE WHEN … END` argument form.
+  const cond = c.filter ? renderFilterCond(c.filter, dialect) : undefined;
   if (c.agg === "count") {
+    if (cond && dialect === "sqlite") return `COUNT(DISTINCT CASE WHEN ${cond} THEN ${src} END) AS ${alias}`;
+    if (cond) return `COUNT(DISTINCT ${src}) FILTER (WHERE ${cond}) AS ${alias}`;
     return `COUNT(DISTINCT ${src}) AS ${alias}`;
   }
-  return `${c.agg.toUpperCase()}(${src}) AS ${alias}`;
+  const fn = c.agg.toUpperCase();
+  if (cond && dialect === "sqlite") return `${fn}(CASE WHEN ${cond} THEN ${src} END) AS ${alias}`;
+  if (cond) return `${fn}(${src}) FILTER (WHERE ${cond}) AS ${alias}`;
+  return `${fn}(${src}) AS ${alias}`;
 }
 
 function renderJoin(
@@ -76,7 +115,7 @@ function renderJoin(
 
 export function emitViewDdl(spec: ViewSpec, options: EmitOptions): string {
   const cols = spec.selectSpec.columns
-    .map((c) => "    " + renderColumn(c))
+    .map((c) => "    " + renderColumn(c, options.dialect))
     .join(",\n");
   const fromClause = `  FROM ${quoteIfNeeded(options.baseTableName)} ${spec.joinTree.baseAlias}`;
   const joinsClause = spec.joinTree.joins
 
@@ -30,6 +30,16 @@ export interface JoinTree {
   readonly joins: readonly JoinNode[];
 }
 
+/**
+ * A resolved filter clause scoping an aggregate to a subset of related rows. Column
+ * refs are already resolved to `alias.column` (naming-strategy applied), so the
+ * emitter is a pure renderer. Mirrors the canonical attr.filter shape.
+ */
+export type ViewFilterClause =
+  | { readonly kind: "cmp"; readonly ref: string; readonly op: string; readonly value: unknown }
+  | { readonly kind: "and"; readonly clauses: readonly ViewFilterClause[] }
+  | { readonly kind: "or"; readonly clauses: readonly ViewFilterClause[] };
+
 /** One column of the SELECT list. */
 export type SelectColumn =
   | {
@@ -46,6 +56,8 @@ export type SelectColumn =
       readonly agg: AggregateFunction;
       readonly sourceAlias: string;
       readonly sourceColumn: string;
+      /** Optional scoping filter (origin.aggregate @filter) → SQL aggregate FILTER (WHERE …). */
+      readonly filter?: ViewFilterClause;
     };
 
 export interface SelectSpec {
 
@@ -75,3 +75,75 @@ describe("buildProjectionViews — package-qualified @from + inherited source fi
     expect(v.sql).toContain("FROM programs");
   });
 });
+
+describe("buildProjectionViews — scoped aggregate (origin.aggregate @filter)", () => {
+  // Program 1→many Week (FK on Week). A projection counts all weeks and takes the
+  // max ordinal over only the 'active' weeks — the filtered-scalar pattern that a
+  // plain aggregate can't express.
+  const model = (filter: unknown) => [
+    {
+      "object.entity": {
+        name: "Program",
+        children: [
+          { "source.rdb": { "@table": "programs" } },
+          { "field.int": { name: "id" } },
+          { "field.string": { name: "title" } },
+          { "identity.primary": { name: "id", "@fields": "id" } },
+          { "relationship.association": { name: "weeks", "@objectRef": "Week", "@cardinality": "many" } },
+        ],
+      },
+    },
+    {
+      "object.entity": {
+        name: "Week",
+        children: [
+          { "source.rdb": { "@table": "weeks" } },
+          { "field.int": { name: "id" } },
+          { "field.int": { name: "programId" } },
+          { "field.int": { name: "ordinal" } },
+          { "field.string": { name: "status" } },
+          { "identity.primary": { name: "id", "@fields": "id" } },
+          { "identity.reference": { name: "ref_program", "@fields": "programId", "@references": "Program" } },
+        ],
+      },
+    },
+    {
+      "object.projection": {
+        name: "ProgramSummary",
+        children: [
+          { "source.rdb": { "@kind": "view", "@table": "v_program_summary" } },
+          { "field.int": { name: "id", extends: "Program.id" } },
+          { "field.int": { name: "weekCount", children: [{ "origin.aggregate": { "@agg": "count", "@of": "Week.id", "@via": "Program.weeks" } }] } },
+          {
+            "field.int": {
+              name: "activeMax",
+              children: [{ "origin.aggregate": { "@agg": "max", "@of": "Week.ordinal", "@via": "Program.weeks", "@filter": filter } }],
+            },
+          },
+          { "identity.primary": { name: "id", extends: "Program.id" } },
+        ],
+      },
+    },
+  ];
+
+  test("postgres: filtered max renders FILTER (WHERE …); plain count unaffected", async () => {
+    const root = await load(model({ status: { eq: "active" } }));
+    const [v] = buildProjectionViews(root, { dialect: "postgres", columnNamingStrategy: "snake_case" });
+    expect(v!.sql).toContain("COUNT(DISTINCT");          // plain count still emits
+    expect(v!.sql).toMatch(/MAX\([a-z0-9]+\.ordinal\) FILTER \(WHERE [a-z0-9]+\.status = 'active'\) AS active_max/);
+    expect(v!.sql).toContain("LEFT OUTER JOIN weeks");   // inverse-FK join present
+  });
+
+  test("scalar filter desugars to eq (status: 'active')", async () => {
+    const root = await load(model({ status: "active" }));
+    const [v] = buildProjectionViews(root, { dialect: "postgres", columnNamingStrategy: "snake_case" });
+    expect(v!.sql).toMatch(/FILTER \(WHERE [a-z0-9]+\.status = 'active'\)/);
+  });
+
+  test("sqlite: filtered max renders the portable CASE WHEN form", async () => {
+    const root = await load(model({ status: { eq: "active" } }));
+    const [v] = buildProjectionViews(root, { dialect: "sqlite", columnNamingStrategy: "snake_case" });
+    expect(v!.sql).toMatch(/MAX\(CASE WHEN [a-z0-9]+\.status = 'active' THEN [a-z0-9]+\.ordinal END\) AS active_max/);
+    expect(v!.sql).not.toContain("FILTER (WHERE");
+  });
+});