diff --git a/‎.changeset/11581-one-view-builder.md‎
Lines changed: 21 additions & 0 deletions b/‎.changeset/11581-one-view-builder.md‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎packages/app-shell/src/views/CreateViewDialog.tsx‎
Lines changed: 22 additions & 5 deletions b/‎packages/app-shell/src/views/CreateViewDialog.tsx‎
Lines changed: 22 additions & 5 deletions
diff --git a/‎packages/app-shell/src/views/CreateViewDialog.viewTypeParse-11581.test.tsx‎
Lines changed: 349 additions & 0 deletions b/‎packages/app-shell/src/views/CreateViewDialog.viewTypeParse-11581.test.tsx‎
Lines changed: 349 additions & 0 deletions
diff --git a/‎packages/app-shell/src/views/ObjectDataPage.tsx‎
Lines changed: 13 additions & 10 deletions b/‎packages/app-shell/src/views/ObjectDataPage.tsx‎
Lines changed: 13 additions & 10 deletions
diff --git a/‎packages/app-shell/src/views/ObjectView.createKanbanView-11581.test.tsx‎
Lines changed: 170 additions & 0 deletions b/‎packages/app-shell/src/views/ObjectView.createKanbanView-11581.test.tsx‎
Lines changed: 170 additions & 0 deletions
diff --git a/‎packages/app-shell/src/views/ObjectView.tsx‎
Lines changed: 27 additions & 27 deletions b/‎packages/app-shell/src/views/ObjectView.tsx‎
Lines changed: 27 additions & 27 deletions
@@ -0,0 +1,21 @@
+---
+'@object-ui/app-shell': patch
+---
+
+"Save as view" now saves a Kanban view the platform accepts, and both Create View doors save the same view from the same dialog choices (objectui#11581).
+
+The Create View dialog persists a new view through two doors: "Save as view" on the object data
+page, and Create View on the object page (the view tab bar's add button, and the view-config
+panel's create mode). The two assembled the saved view separately, and only the object page's
+door copied the view's columns into the type blocks that carry a field list of their own. So:
+
+- a Kanban saved through "Save as view" had no `kanban.columns`, which `@objectstack/spec`
+  requires ("Fields to show on cards"), and the platform's view write door refused it;
+- a Gallery saved through "Save as view" had no `gallery.visibleFields`, so its cards showed
+  nothing under the title, while the same choices on the object page showed the view's columns.
+
+Both doors now build the view through one builder. Each door still supplies its own columns (the
+data page's current columns, or the object's default business columns), and "Save as view" still
+folds the page's URL conditions into the view's `filter`. The builder writes those columns into
+`kanban.columns`, and into `gallery.visibleFields` when the gallery declares none. A view created
+on the object page is saved exactly as before.
@@ -150,6 +150,21 @@ function buildViewTypeMeta(t: (k: string) => string): ViewTypeMeta[] {
     .map(([type, row]) => ({ type, ...row }));
 }
 
+/**
+ * The view types this dialog offers, in grid order: the same rows the picker
+ * renders, read from {@link buildViewTypeMeta} with an identity translator.
+ *
+ * Pure, so a test can enumerate it at collection time without rendering.
+ * `CreateViewDialog.viewTypeParse-11581.test.tsx` drives its per-type parse
+ * pin from this list, so a type added to the picker without a parse row there
+ * turns that pin red (objectui#11581).
+ *
+ * Exported for that pin, not from the package index. @internal
+ */
+export function offeredViewTypes(): ListViewVisualization[] {
+  return buildViewTypeMeta((k) => k).map((m) => m.type);
+}
+
 /** Suggest a non-colliding default name like "Grid 1", "Grid 2", … */
 function suggestName(typeLabel: string, existing: Set<string>): string {
   for (let i = 1; i < 1000; i++) {
@@ -168,11 +183,13 @@ function suggestName(typeLabel: string, existing: Set<string>): string {
 // endDateField, gallery.coverField, map.latitudeField + longitudeField,
 // chart.chartType + dataset + values (+ dimensions), tree.parentField). The
 // blocks are meant to be the spec ListView blocks of those names. What
-// re-derives that is a parse against `ListViewSchema`, and only `chart` has
-// one: `CreateViewDialog.chartBinding-11576.test.tsx` (the "Save as view"
-// door) and `ObjectView.createChartView-11576.test.tsx` (the add-view door).
-// No test drives the other types' payloads through this dialog against the
-// spec (stated per AGENTS.md #9, not implied).
+// re-derives that is a parse against `ListViewSchema`:
+// `CreateViewDialog.viewTypeParse-11581.test.tsx` submits this dialog once per
+// type `offeredViewTypes()` lists and parses the body BOTH persisting doors
+// build from that payload ("Save as view" and the add-view door, which share
+// one builder, `buildNewViewSpec`). `chart` is also pinned on its own, through
+// each door's page: `CreateViewDialog.chartBinding-11576.test.tsx` and
+// `ObjectView.createChartView-11576.test.tsx`.
 //
 // `chart` was the one block that had drifted: it wrote `xAxisField` /
 // `yAxisFields`, the pre-ADR-0021 inline axes the spec's strict
 
@@ -65,6 +65,7 @@ import { PageHeader } from '../layout/PageHeader.js';
 import { getIcon } from '../utils/getIcon.js';
 import { useMetadataClient } from './metadata-admin/useMetadata.js';
 import { createRuntimeMetadata, viewEnvelope } from './runtime-metadata-persistence.js';
+import { buildNewViewSpec } from './newViewSpec.js';
 import { CreateViewDialog } from './CreateViewDialog.js';
 import {
   usePreviewDrafts,
@@ -168,22 +169,24 @@ function foldUrlFilterTriplesToSpecRules(triples: FilterTriple[]): ViewFilterRul
  * subConfig }`); `fallbackColumns` is this page's auto-derived, field-security
  * trimmed column list, used only when the dialog carried none.
  *
- * Exported for `ObjectDataPage.saveAsViewFilterFold.test.ts`. @internal
+ * This door resolves only its own inputs (those columns, and the URL
+ * conditions folded to spec rules); the spec itself, with every type-specific
+ * rule, is built by `buildNewViewSpec`, the one builder this door shares with
+ * the add-view door (objectui#11581). An all-dropped fold writes no `filter`
+ * key at all, byte-identical to a save with no drill conditions active.
+ *
+ * Exported for `ObjectDataPage.saveAsViewFilterFold.test.ts` and
+ * `CreateViewDialog.viewTypeParse-11581.test.tsx`. @internal
  */
 export function buildSaveAsViewSpec(
   config: Record<string, any>,
   fallbackColumns: string[],
   urlFilters: FilterTriple[],
 ): Record<string, any> {
-  const filterRules = foldUrlFilterTriplesToSpecRules(urlFilters);
-  return {
-    ...config,
-    columns:
-      Array.isArray(config.columns) && config.columns.length > 0 ? config.columns : fallbackColumns,
-    // An all-dropped fold writes no `filter` key at all, byte-identical to a
-    // save with no drill conditions active.
-    ...(filterRules.length ? { filter: filterRules } : {}),
-  };
+  return buildNewViewSpec(config, {
+    fallbackColumns,
+    filter: foldUrlFilterTriplesToSpecRules(urlFilters),
+  });
 }
 
 export function ObjectDataPage({ dataSource, objects }: any) {
 
@@ -0,0 +1,170 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectui#11581, the add-view door through its page: `ObjectView`'s
+ * `handleViewCreate`, reached from the view tab bar's add button, persists the
+ * spec the one builder (`buildNewViewSpec`, via `buildAddViewSpec`) builds,
+ * with the columns mirrored into the kanban block the spec requires them in.
+ *
+ * The per-type enumeration over both doors' builders, and "Save as view"
+ * through its page, are in `CreateViewDialog.viewTypeParse-11581.test.tsx`.
+ * This file proves the add-view door's callback goes through that builder: the
+ * real `ObjectView` and the real dialog run, and only the metadata client is a
+ * stub, so the body asserted is the one `createRuntimeMetadata` hands
+ * `metadataClient.save`.
+ *
+ * Direction, written before the run: GREEN on the tree before the builder too
+ * (this door always mirrored `kanban.columns`); RED when the kanban mirror is
+ * removed from `buildNewViewSpec`.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, cleanup, act, screen, fireEvent, waitFor } from '@testing-library/react';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import { ListViewSchema, ViewItemSchema } from '@objectstack/spec/ui';
+
+vi.mock('@object-ui/permissions', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@object-ui/permissions')>();
+  // Stable identities: `ListView` names `perms` in its fetch dependencies.
+  const perms = {
+    check: () => ({ allowed: true }),
+    checkField: () => true,
+    getFieldPermissions: () => [],
+    getRowFilter: () => undefined,
+    getObjectApiOperations: () => undefined,
+    roles: [],
+    isLoaded: false,
+    hasCapabilities: () => true,
+    can: () => true,
+    cannot: () => false,
+  };
+  const fieldPerms = { canRead: () => true, canWrite: () => true, permissions: [] };
+  return { ...actual, usePermissions: () => perms, useFieldPermissions: () => fieldPerms };
+});
+
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({ user: { id: 'u1', name: 'Ada' }, activeOrganization: null }),
+  // The add-view button and the dialog are admin-only.
+  useWorkspaceAdminStatus: () => ({ isAdmin: true, isResolved: true }),
+  createAuthenticatedFetch: () => vi.fn(),
+}));
+
+vi.mock('@object-ui/collaboration', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useRealtimeSubscription: () => ({ lastMessage: null }),
+  useConflictResolution: () => ({ hasConflicts: false, resolveAllConflicts: () => {} }),
+}));
+
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), {
+    success: vi.fn(), error: vi.fn(), info: vi.fn(),
+    warning: vi.fn(), loading: vi.fn(), dismiss: vi.fn(),
+  }),
+}));
+
+vi.mock('./MetadataInspector', () => ({
+  MetadataPanel: () => null,
+  useMetadataInspector: () => ({ showDebug: false, toggle: () => {} }),
+}));
+vi.mock('./RecordDetailView', () => ({ RecordDetailView: () => null }));
+
+// The metadata seam's client: `createRuntimeMetadata` writes through `save`;
+// the open dialog lists an empty dataset catalog through `list` / `get`.
+const metadataClient = {
+  save: vi.fn(async () => ({})),
+  get: vi.fn(async () => null),
+  list: vi.fn(async () => []),
+};
+vi.mock('./metadata-admin/useMetadata', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useMetadataClient: () => metadataClient,
+}));
+
+import { ObjectView, defaultListColumnsFromObject } from './ObjectView';
+import { ExpressionProvider } from '../providers/ExpressionProvider';
+
+const OBJECT_NAME = 'crm_deal';
+const DEAL = {
+  name: OBJECT_NAME,
+  label: 'Deal',
+  fields: {
+    name: { type: 'text', label: 'Name' },
+    stage: { type: 'select', label: 'Stage', options: [{ value: 'open', label: 'Open' }] },
+    amount: { type: 'number', label: 'Amount' },
+  },
+  listViews: { [`${OBJECT_NAME}.all`]: { name: `${OBJECT_NAME}.all`, label: 'All', type: 'grid', columns: ['name'] } },
+};
+
+function makeDataSource() {
+  return {
+    find: vi.fn(async () => ({ data: [], total: 0 })),
+    findOne: vi.fn(async () => null),
+    create: vi.fn(async () => ({})),
+    update: vi.fn(async () => ({})),
+    delete: vi.fn(async () => ({})),
+    getObjectSchema: vi.fn(async () => ({ name: OBJECT_NAME, fields: {} })),
+  } as any;
+}
+
+const settle = () => act(() => new Promise<void>((resolve) => setTimeout(resolve, 300)));
+const select = (key: string) => screen.getByTestId(`create-view-required-${key}`) as HTMLSelectElement;
+
+beforeEach(() => {
+  cleanup();
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async () =>
+      new Response(JSON.stringify({ data: [] }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    ),
+  );
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.clearAllMocks();
+});
+
+describe('ObjectView.handleViewCreate persists a kanban through the one builder (objectui#11581)', () => {
+  it('the saved config passes the spec ListViewSchema, the envelope the ViewItem gate, with the columns mirrored into kanban.columns', async () => {
+    render(
+      <ExpressionProvider user={{ id: 'u1', name: 'Ada', profile: 'admin' }}>
+        <MemoryRouter initialEntries={[`/apps/demo/${OBJECT_NAME}`]}>
+          <Routes>
+            <Route
+              path="/apps/:appName/:objectName/*"
+              element={<ObjectView dataSource={makeDataSource()} objects={[DEAL]} onEdit={() => {}} />}
+            />
+          </Routes>
+        </MemoryRouter>
+      </ExpressionProvider>,
+    );
+    await settle();
+    fireEvent.click(screen.getByTestId('view-tab-add'));
+    const card = (await screen.findByTestId('create-view-type-kanban')) as HTMLButtonElement;
+    await waitFor(() => expect(card.disabled).toBe(false));
+    fireEvent.click(card);
+    // `stage` is the object's one select field, so the dialog picks it.
+    await waitFor(() => expect(select('groupByField').value).toBe('stage'));
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('create-view-submit'));
+    });
+    await waitFor(() => expect(metadataClient.save).toHaveBeenCalledTimes(1));
+    const [type, , body, opts] = metadataClient.save.mock.calls[0] as unknown as [string, string, any, any];
+    expect(type).toBe('view');
+    expect(opts).toEqual({ mode: 'draft' });
+    // The spec's verdict first: it is the claim this pin exists for.
+    const listView = ListViewSchema.safeParse(body.config);
+    expect(listView.success, JSON.stringify(listView.error?.issues)).toBe(true);
+    const item = ViewItemSchema.safeParse(body);
+    expect(item.success, JSON.stringify(item.error?.issues)).toBe(true);
+    const columns = defaultListColumnsFromObject(DEAL, 5);
+    expect(columns.length).toBeGreaterThan(0);
+    expect(body.config.columns).toEqual(columns);
+    expect(body.config.kanban).toEqual({ groupByField: 'stage', columns });
+  });
+});
@@ -49,6 +49,7 @@ import { MetadataPanel, useMetadataInspector } from './MetadataInspector.js';
 import { ViewConfigPanel } from './ViewConfigPanel.js';
 import { useMetadataClient } from './metadata-admin/useMetadata.js';
 import { persistRuntimeMetadata, createRuntimeMetadata, viewEnvelope, type ViewEnvelope } from './runtime-metadata-persistence.js';
+import { buildNewViewSpec } from './newViewSpec.js';
 import { ListViewSchema as SpecListViewSchema, normalizeFilterOperator, VIEW_CONSOLE_ROUND_TRIP_KEYS } from '@objectstack/spec/ui';
 import { CreateViewDialog } from './CreateViewDialog.js';
 import {
@@ -648,6 +649,25 @@ export function defaultListColumnsFromObject(
     return [];
 }
 
+/**
+ * Assemble the list-view `spec` the add-view door (`handleViewCreate`: the
+ * Create View dialog from the view tab bar, and the view-config panel's create
+ * mode) hands to `viewEnvelope`.
+ *
+ * This door resolves only its own fallback columns: the object's default
+ * business columns (`defaultListColumnsFromObject` keeps the framework-injected
+ * `owner_id` / audit columns out of the lead, #2702 / #2777, so a new view
+ * never opens on a raw id). The spec itself, with every type-specific rule
+ * (the columns mirrored into `kanban.columns` and `gallery.visibleFields`), is
+ * built by `buildNewViewSpec`, the one builder this door shares with "Save as
+ * view" (objectui#11581).
+ *
+ * Exported for `CreateViewDialog.viewTypeParse-11581.test.tsx`. @internal
+ */
+export function buildAddViewSpec(config: Record<string, any>, objectDef: any): Record<string, any> {
+    return buildNewViewSpec(config, { fallbackColumns: defaultListColumnsFromObject(objectDef, 5) });
+}
+
 /**
  * Read the persisted per-view overrides (density, column widths, sort, hidden
  * columns, inlineEdit …) for `ids`, preferring the adapter's one-request batch
@@ -1523,39 +1543,19 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
         try {
             let createdId: string | undefined;
             if (metadataClient) {
-                // Prefill sensible defaults so the saved view renders rows
-                // immediately even if the user didn't pick columns yet.
-                const objectDef = objects?.find?.((o: any) => o.name === objectName);
-                // Prefill business columns only — the shared helper keeps the
-                // framework-injected `owner_id` / audit columns out of the lead
-                // (#2702, #2777), so a newly created view never opens on a raw id.
-                const defaultColumns = defaultListColumnsFromObject(objectDef, 5);
-                const incomingColumns = Array.isArray(config.columns) && config.columns.length > 0
-                    ? config.columns
-                    : defaultColumns;
                 // ADR-0005 overlay path — write the full spec under a unique
                 // `name` via the metadata customization API instead of into
                 // the physical `sys_view` table (whose columns no longer
                 // accommodate the spec shape: arrays, nested objects, etc.).
-                const spec: Record<string, any> = { ...config, columns: incomingColumns };
-                // Per @objectstack/spec, certain view types nest their card/field
-                // list inside their type-specific subconfig (e.g. kanban.columns,
-                // gallery.visibleFields). The CreateViewDialog only collects
-                // required *picker* fields; we mirror the resolved column list
-                // into the subconfig here so the spec validator accepts the row.
-                if (config.type === 'kanban') {
-                    spec.kanban = { ...(spec.kanban || {}), columns: incomingColumns };
-                } else if (config.type === 'gallery') {
-                    const existing = spec.gallery || {};
-                    if (!Array.isArray(existing.visibleFields) || existing.visibleFields.length === 0) {
-                        spec.gallery = { ...existing, visibleFields: incomingColumns };
-                    }
-                }
+                // The spec comes from the builder "Save as view" also uses
+                // (`buildAddViewSpec` → `buildNewViewSpec`, objectui#11581):
+                // this door supplies only its default business columns.
+                const objectDef = objects?.find?.((o: any) => o.name === objectName);
+                const spec = buildAddViewSpec(config, objectDef);
                 // ADR-0034: a new view is created as an invisible per-item
                 // draft via the metadata seam; an explicit Publish promotes it.
-                // UI-layer concerns (default columns, kanban/gallery massaging
-                // above, and the auto-activation below) stay here; the canonical
-                // ViewItem envelope + qualified-name identity live in the seam.
+                // The auto-activation below stays here; the canonical ViewItem
+                // envelope + qualified-name identity live in the seam.
                 //
                 // #2767 P1: the qualified name `<object>.<key>` is used as BOTH
                 // the URL segment and `body.name`, so the sys_metadata row key,