@@ -0,0 +1,10 @@
+---
+'@object-ui/app-shell': patch
+---
+
+fix(app-shell): in Studio Interfaces, a draft-only object's nav entry opens the object's drafted default list view, not a non-existent "Default view"
+
+Clause-②: no
+Metadata-protocol: none
+
+An object that is still only a draft in the package is absent from the shell's published metadata, so a nav entry for it with no `viewName` used to open `<object>.default`, a view that does not exist. The view switcher listed that "Default view" beside the view the author had drafted as the default, and the first edit in the panel created a second default list view in the package. The entry's default list view is now resolved against the published views and the package's drafted list views together, so it opens the drafted default view, the switcher lists only the views that exist, and an edit writes to that view. Until the package's drafts have been read, a default view that no published view flags is not loaded or listed, so no edit can be made against the wrong view. A published object with no default list view still opens `<object>.default`, created by the first edit, as before.
@@ -31,7 +31,12 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { act, cleanup, render, screen } from '@testing-library/react';
 import { MetadataCtx, type MetadataContextValue } from '@object-ui/react';
 import { MetadataClient } from '@object-ui/data-objectstack';
-import { useObjectListViewDraft, type DraftOnlyObjects } from './ObjectListViewInspector';
+import {
+  newListViewItem,
+  useObjectListViewDraft,
+  type DraftOnlyObjects,
+  type ObjectListViewDraft,
+} from './ObjectListViewInspector';
 import type { Surface } from './navSurface';
 
 const PKG = 'com.default.studio-test';
@@ -40,8 +45,14 @@ const PUBLISHED = 'st_case';
 
 const server = {
   active: new Map<string, Record<string, unknown>>(),
+  /** objectstack#30177 — this package's pending view drafts, by `view/<name>`. */
+  drafts: new Map<string, Record<string, unknown>>(),
   requests: [] as Array<{ method: string; path: string; status: number }>,
+  /** objectstack#30177 — the PUTs, by `view/<name>`, with the body sent. */
+  writes: [] as Array<{ path: string; body: Record<string, unknown> }>,
   failLayers: new Set<string>(),
+  /** objectstack#30177 — while set, the draft-overlaid view list waits for it. */
+  holdViewList: null as Promise<void> | null,
 };
 
 const json = (status: number, body: unknown) =>
@@ -55,14 +66,26 @@ async function serve(input: RequestInfo | URL, init?: RequestInit): Promise<Resp
   const meta = url.pathname.match(/^\/api\/v1\/meta\/(.+)$/);
   if (meta) {
     const seg = meta[1].split('/').map(decodeURIComponent);
-    if (seg.length === 3 && seg[2] === 'layers' && server.failLayers.has(`${seg[0]}/${seg[1]}`)) {
+    if (method === 'PUT' && seg.length === 2) {
+      server.writes.push({ path: `${seg[0]}/${seg[1]}`, body: JSON.parse(String(init?.body ?? '{}')) });
+      body = { success: true, version: 'v2', state: 'draft' };
+    } else if (seg.length === 1 && seg[0] === '_drafts') {
+      body = [...server.drafts.keys()].map((key) => ({ type: key.split('/')[0], name: key.slice(key.indexOf('/') + 1), packageId: PKG }));
+    } else if (seg.length === 1 && url.searchParams.get('preview') === 'draft') {
+      if (server.holdViewList) await server.holdViewList;
+      body = [...server.drafts.entries()]
+        .filter(([key]) => key.startsWith(`${seg[0]}/`))
+        .map(([, row]) => ({ ...row, _draft: true, _packageId: PKG }));
+    } else if (seg.length === 2 && url.searchParams.get('state') === 'draft' && server.drafts.has(`${seg[0]}/${seg[1]}`)) {
+      body = { type: seg[0], name: seg[1], item: { ...server.drafts.get(`${seg[0]}/${seg[1]}`), _draft: true }, version: 'v1' };
+    } else if (seg.length === 3 && seg[2] === 'layers' && server.failLayers.has(`${seg[0]}/${seg[1]}`)) {
       [status, body] = [500, { error: { code: 'INTERNAL_ERROR', message: 'metadata store unavailable' } }];
     } else if (seg.length === 3 && seg[2] === 'layers') {
       const row = server.active.get(`${seg[0]}/${seg[1]}`);
       if (row) body = { code: null, overlay: row, overlayScope: 'env', effective: row };
       else [status, body] = [404, { error: { code: 'NOT_FOUND', message: 'absent' } }];
     } else if (seg.length === 2) {
-      // No view draft is pending in this suite.
+      // No draft of that view is pending.
       [status, body] = [404, { error: { code: 'NO_DRAFT', message: 'absent' } }];
     }
   }
@@ -131,8 +154,11 @@ const knownUnder = (publishNonce: number): DraftOnlyObjects => ({ publishNonce,
 
 beforeEach(() => {
   server.active.clear();
+  server.drafts.clear();
   server.requests = [];
+  server.writes = [];
   server.failLayers.clear();
+  server.holdViewList = null;
 });
 afterEach(cleanup);
 
@@ -169,3 +195,113 @@ describe('useObjectListViewDraft — a view of a draft-only object is not asked
     expect(seen.failure).toEqual({ during: 'load', error: expect.stringContaining('metadata store unavailable') });
   });
 });
+
+/**
+ * objectstack#30177 — a draft-only object's nav entry with no `viewName`
+ * opens the object's drafted default list view. The shell's merged metadata
+ * does not hold the object, so its views are known from this package's
+ * drafts alone: the entry is resolved against them, the view switcher lists
+ * no "Default view" beside them, and the first edit writes to the drafted
+ * view rather than creating a second default one.
+ */
+describe('useObjectListViewDraft — a draft-only object opens its drafted default view (objectstack#30177)', () => {
+  const DEAL = 'acmetrial_deal';
+  const ALL_DEALS = {
+    name: `${DEAL}.all`,
+    object: DEAL,
+    viewKind: 'list',
+    label: 'All deals',
+    isDefault: true,
+    config: { type: 'grid', data: { provider: 'object', object: DEAL }, columns: ['name'] },
+  };
+  const dealsKnown: DraftOnlyObjects = { publishNonce: 0, names: new Set([DEAL]) };
+
+  let latest: ObjectListViewDraft | null = null;
+  const report = (d: ObjectListViewDraft) => {
+    latest = d;
+  };
+  function HookProbe({ object, known }: { object: string; known: DraftOnlyObjects | null }) {
+    const leaf: Surface = { type: 'object', name: object, label: object };
+    const d = useObjectListViewDraft({ client, packageId: PKG, leaf, publishNonce: 0, draftOnlyObjects: known });
+    React.useLayoutEffect(() => report(d));
+    return null;
+  }
+
+  const settle = () =>
+    act(async () => {
+      for (let i = 0; i < 20; i++) await new Promise((r) => setTimeout(r, 0));
+    });
+
+  async function mount(object: string, known: DraftOnlyObjects | null) {
+    render(
+      <MetadataCtx.Provider value={METADATA}>
+        <HookProbe object={object} known={known} />
+      </MetadataCtx.Provider>,
+    );
+    await settle();
+    return () => latest!;
+  }
+
+  /** The panel's first edit, as the panel makes it: one column added to the view it shows. */
+  async function firstEdit(d: () => ObjectListViewDraft) {
+    const { target, row, seedColumns } = d();
+    const working = row ?? newListViewItem(target!, seedColumns);
+    const config = working.config as Record<string, unknown>;
+    await act(async () => {
+      d().edit({ ...working, config: { ...config, columns: [...(config.columns as unknown[]), 'stage'] } });
+    });
+    await act(async () => {
+      await d().save({ unmoved: () => true });
+    });
+    await settle();
+  }
+
+  it('the entry opens the drafted default view, the switcher lists no "Default view", and the first edit writes to that view', async () => {
+    server.drafts.set(`view/${ALL_DEALS.name}`, ALL_DEALS);
+    const d = await mount(DEAL, dealsKnown);
+
+    expect(d().target).toEqual({ objectName: DEAL, viewId: `${DEAL}.all`, isDefault: true });
+    expect(d().loadedFor).toBe(`listView:${DEAL}.all`);
+    expect(d().row).toMatchObject({ name: `${DEAL}.all`, isDefault: true });
+    expect(d().views.map((v) => v.target.viewId)).toEqual([`${DEAL}.all`]);
+
+    await firstEdit(d);
+    expect(server.writes.map((w) => w.path)).toEqual([`view/${DEAL}.all`]);
+    expect(server.writes.filter((w) => w.body.isDefault === true).map((w) => w.body.name)).toEqual([`${DEAL}.all`]);
+  });
+
+  it('until the package\'s view drafts answer, no view is loaded and none is listed', async () => {
+    server.drafts.set(`view/${ALL_DEALS.name}`, ALL_DEALS);
+    let release = () => {};
+    server.holdViewList = new Promise<void>((r) => {
+      release = r;
+    });
+    const d = await mount(DEAL, dealsKnown);
+
+    expect(d().loadedFor).toBe('');
+    expect(d().views).toEqual([]);
+    expect(server.requests.filter((r) => r.path.startsWith(`/api/v1/meta/view/${DEAL}.default`))).toEqual([]);
+
+    release();
+    await settle();
+    expect(d().target?.viewId).toBe(`${DEAL}.all`);
+    expect(d().loadedFor).toBe(`listView:${DEAL}.all`);
+  });
+
+  it('CONTROL: a published object\'s entry with no flagged view still opens `<object>.default`', async () => {
+    const d = await mount(PUBLISHED, dealsKnown);
+
+    expect(d().target).toEqual({ objectName: PUBLISHED, viewId: `${PUBLISHED}.default`, isDefault: true });
+    expect(d().views.map((v) => v.target.viewId)).toEqual([`${PUBLISHED}.default`]);
+  });
+
+  it('CONTROL: a draft-only object with no drafted view still opens `<object>.default`, created by the first edit', async () => {
+    const d = await mount(DEAL, dealsKnown);
+
+    expect(d().target).toEqual({ objectName: DEAL, viewId: `${DEAL}.default`, isDefault: true });
+    expect(d().loadedFor).toBe(`listView:${DEAL}.default`);
+    await firstEdit(d);
+    expect(server.writes.map((w) => w.path)).toEqual([`view/${DEAL}.default`]);
+    expect(server.writes[0]!.body).toMatchObject({ name: `${DEAL}.default`, isDefault: true });
+  });
+});
@@ -18,9 +18,13 @@
  *    (`resolveViewId`). A name that matches none is the view the entry opens
  *    once it exists, `<object>.<viewName>`;
  *  - any other entry → the object's default list view: the merged view
- *    flagged `isDefault`, else `<object>.default`, the identity the
- *    platform's own composer gives a container's default `list`
- *    (`expandViewContainer`).
+ *    flagged `isDefault`, else this package's drafted list view flagged so
+ *    (objectstack#30177: a draft-only object is absent from the merged
+ *    metadata, so its default is known from the drafts alone), else
+ *    `<object>.default`, the identity the platform's own composer gives a
+ *    container's default `list` (`expandViewContainer`). Until the drafts
+ *    are read, a default no merged view flags is not known yet: nothing is
+ *    loaded or listed for it, so no edit can create a second default view.
  *
  * ## What is written, and where
  *
@@ -161,7 +165,8 @@ function qualifiedViewId(objectName: string, key: string): string {
  * `landingViewName` is the view the entry lands on as the runtime reads the
  * entry (`navEntryListTarget(...).viewName`), not the raw `viewName`: an entry
  * that also slices (`filters`) lands on the data surface, and its view is then
- * the default one. `views` is the object's merged `listViews` map.
+ * the default one. `views` is the object's merged `listViews` map, with this
+ * package's drafted list views of it (objectstack#30177).
  */
 export function listViewTargetOf(
   objectName: string,
@@ -296,6 +301,19 @@ export function listViewChoicesOf(
   return choices;
 }
 
+/**
+ * objectstack#30177 — this package's drafted list views of `objectName` (the
+ * draft-overlaid list's `_draft` rows), by item name: the views a draft-only
+ * object has, which the shell's merged `listViews` never holds.
+ */
+function draftedListViewsOf(objectName: string, drafts: readonly Row[]): Record<string, Row> {
+  const views: Record<string, Row> = {};
+  for (const row of drafts) {
+    if (row.object === objectName && typeof row.name === 'string' && isListViewRow(row)) views[row.name] = row;
+  }
+  return views;
+}
+
 /** What `useDraftAutoSave` hands a save: whether the buffer is still what it sent. */
 interface DraftSendClaim {
   unmoved: () => boolean;
@@ -475,7 +493,6 @@ export function useObjectListViewDraft({
   }, [objectName, navId, filtersKey, entryViewName, currentUserId, currentOrgId]);
   const objectDef = objectName ? findByName(metadata.objects, objectName) : undefined;
   const publishedViews = listViewsOf(objectDef);
-  const entryTarget = objectName ? listViewTargetOf(objectName, landingViewName, publishedViews) : null;
   // objectstack#27836, objectstack#27896 — a view New view created or the
   // view switcher opened, stamped with the nav entry it was opened on, so it
   // expires by construction when another opens.
@@ -490,8 +507,6 @@ export function useObjectListViewDraft({
   React.useEffect(() => {
     if (link && leafOpen && !linkHolds) setLink(null);
   }, [link, leafOpen, linkHolds]);
-  const chosenViewId = (picked && picked.for === entryKey ? picked.viewId : null) ?? (linkHolds ? link.viewId : null);
-  const pickedViewId = chosenViewId && chosenViewId !== entryTarget?.viewId ? chosenViewId : null;
   // objectstack#27896 — this package's pending drafts of the object's views,
   // read with the drafts overlaid: the published world is the merged map
   // above. A failed or refused read (a caller the server serves no pending
@@ -518,7 +533,21 @@ export function useObjectListViewDraft({
       cancelled = true;
     };
   }, [client, packageId, objectName, publishNonce, viewsNonce]);
-  const draftViewRows = viewDrafts.for === viewDraftsKey ? viewDrafts.rows : [];
+  const viewDraftsRead = viewDrafts.for === viewDraftsKey;
+  const draftViewRows = viewDraftsRead ? viewDrafts.rows : [];
+  // objectstack#30177 — the entry's view among the merged views and this
+  // package's drafted list views (the module docblock's "Which view").
+  const entryTarget = objectName
+    ? listViewTargetOf(objectName, landingViewName, { ...publishedViews, ...draftedListViewsOf(objectName, draftViewRows) })
+    : null;
+  const entryUnsettled =
+    !!entryTarget?.isDefault &&
+    !viewDraftsRead &&
+    !Object.values(publishedViews).some((v) => isPlainObject(v) && v.isDefault === true);
+  const chosenViewId = (picked && picked.for === entryKey ? picked.viewId : null) ?? (linkHolds ? link.viewId : null);
+  const pickedViewId = chosenViewId && chosenViewId !== entryTarget?.viewId ? chosenViewId : null;
+  // The entry's default is not known yet: nothing is loaded or listed for it.
+  const holding = !pickedViewId && entryUnsettled;
   const pickedIsDefault =
     !!objectName &&
     !!pickedViewId &&
@@ -527,7 +556,8 @@ export function useObjectListViewDraft({
     );
   const target: ListViewTarget | null =
     objectName && pickedViewId ? { objectName, viewId: pickedViewId, isDefault: pickedIsDefault } : entryTarget;
-  const views = objectName ? listViewChoicesOf(objectName, publishedViews, draftViewRows, entryTarget, target) : [];
+  const views =
+    objectName && !holding ? listViewChoicesOf(objectName, publishedViews, draftViewRows, entryTarget, target) : [];
   const viewId = target?.viewId ?? '';
   const targetKey = viewId ? listViewBufferKey(viewId) : '';
   const seedColumns = React.useMemo(() => defaultListColumnsFromObject(objectDef, 5), [objectDef]);
@@ -571,7 +601,7 @@ export function useObjectListViewDraft({
 
   React.useEffect(() => {
     setFailure(null);
-    if (!viewId) {
+    if (!viewId || holding) {
       setBuffer({ for: '', row: null, dirty: false, hasDraft: false, draftChanges: null, published: undefined });
       return;
     }
@@ -667,7 +697,7 @@ export function useObjectListViewDraft({
     return () => {
       cancelled = true;
     };
-  }, [client, viewId, objectName, packageId, publishNonce, reloadNonce, recordRead, customizing]);
+  }, [client, viewId, holding, objectName, packageId, publishNonce, reloadNonce, recordRead, customizing]);
 
   const edit = React.useCallback((row: Row) => {
     setBuffer((b) => ({ ...b, row, dirty: true }));