@@ -0,0 +1,15 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/console': patch
+'@object-ui/i18n': patch
+---
+
+feat(app-shell): Studio authors what the record page reads about related lists, highlight fields, and new record pages
+
+Clause-②: no
+Metadata-protocol: none
+
+- **Field inspector, lookup and master-detail fields.** A "Related list on the parent record" section with a three-state control (Show / Don't show / Primary (in body)) writes `relatedList`: Don't show writes `false`, Primary writes `'primary'`, and Show leaves the key absent, the spec's own "true or absent = shown". Below it, `relatedListFilter` is edited with the same filter builder the dataset designer and the list toolbar use, instead of being absent from the inspector. A stored filter the builder cannot hold (nested, OR) is kept as stored and named.
+- **Related-list block inspector.** The `record:related_list` block exposes `columns` (the child object's fields), `sort` (field and order rows), `filter` (the list toolbar's filter builder), `limit`, `showViewAll` (shown on when unset, the spec default) and `add`, beside the object, relationship field and title. A stored value in the other arm of a union, such as a string `sort` or `columns` given as saved-view column objects, is shown as JSON rather than as an empty or garbled list. The limit hint now reads 5, the renderer's own default.
+- **Object settings.** `highlightFields` is an ordered list: drag a row or use the move buttons to reorder, add fields up to six, and see the highlight strip preview in the picked order. Removing the last field removes the key.
+- **New record pages.** A record page created in the metadata editor now starts `kind: 'slotted'` with no slots, which is the synthesized default page, and it keeps following the object. The create form's kind follows the page type until the author picks one. Choosing `full` at create still copies the synthesized regions. In the page designer, a slotted record page says it is the default page and offers "Convert to full page", which copies the regions it renders, switches the kind to `full` and drops `slots`. An empty slotted page now opens on the slot editor instead of a blank regions canvas.
@@ -1,6 +1,6 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 // `createSeed` reaches the page synthesizer through a dynamic
 // `await import('@object-ui/plugin-detail')` (anchors.ts), so the cold transform
 // of that whole package graph is billed to whichever test first awaits the hook
@@ -17,11 +17,21 @@ import { describe, it, expect } from 'vitest';
 import '@object-ui/plugin-detail';
 import { registerBuiltinAnchors } from './anchors';
 import { resolveResourceConfig } from './registry';
+import { applyTransform } from './createDerive';
+import { buildCreateModeBody } from './createBody';
+import { validateMetadataDraft } from './clientValidation';
+import { getMetadataCreateSeed } from '@objectstack/spec/kernel';
+import { PageSchema, ComponentPropsMap } from '@objectstack/spec/ui';
 
 /**
- * #1541 — the `page` resource's `createSeed` hook seeds a record page's regions
- * from the bound object's synthesized default detail page, so authoring starts
- * from the auto-generated layout instead of a blank canvas.
+ * The `page` resource's create-time seeding.
+ *
+ * A record page is created `kind: 'slotted'` with no slots — the synthesized
+ * default page, which keeps following the object until the author overrides a
+ * slot. The synthesized regions are copied (#1541's seed) only when the author
+ * explicitly creates a `full` record page; the create form's `kind` follows the
+ * page type (`page-kind` derive), so `full` on a record page is the author's
+ * own pick.
  */
 registerBuiltinAnchors();
 
@@ -36,6 +46,34 @@ const objectDef = {
   },
 };
 
+/**
+ * Every block in `tree` judged by the spec's own props row for its type
+ * (`ComponentPropsMap`) — the per-block check the save door runs, which the
+ * page-level parse never reaches (`properties` is an open record there).
+ * Returns the refusals and how many `record:details` blocks were judged, so a
+ * walk that judged nothing cannot pass as clean.
+ */
+function blockPropsVerdict(tree: unknown): { refused: string[]; detailsJudged: number } {
+  const map = ComponentPropsMap as Record<string, { safeParse: (v: unknown) => { success: boolean; error?: { issues: Array<{ path: PropertyKey[]; message: string }> } } }>;
+  const refused: string[] = [];
+  let detailsJudged = 0;
+  const walk = (node: unknown) => {
+    if (Array.isArray(node)) { node.forEach(walk); return; }
+    if (!node || typeof node !== 'object') return;
+    const n = node as Record<string, unknown>;
+    if (typeof n.type === 'string' && map[n.type] && n.properties && typeof n.properties === 'object') {
+      const res = map[n.type].safeParse(n.properties);
+      if (n.type === 'record:details') detailsJudged++;
+      if (!res.success) {
+        for (const i of res.error!.issues) refused.push(`${n.type} ${i.path.join('.')}: ${i.message}`);
+      }
+    }
+    Object.values(n).forEach(walk);
+  };
+  walk(tree);
+  return { refused, detailsJudged };
+}
+
 function clientReturning(def: any) {
   return { get: async (_type: string, _name: string) => def };
 }
@@ -47,25 +85,69 @@ describe('page createSeed (record-page region seeding)', () => {
     expect(typeof cfg.createSeed).toBe('function');
   });
 
-  it('seeds regions from the bound object default for a record page', async () => {
-    const seeded = await cfg.createSeed!({ type: 'record', object: 'showcase_invoice' }, { client: clientReturning(objectDef) });
+  it('creates a record page slotted with no slots and no copied regions', async () => {
+    const get = vi.fn(async () => objectDef);
+    for (const kind of ['slotted', undefined]) {
+      const seeded = await cfg.createSeed!({ type: 'record', object: 'showcase_invoice', kind }, { client: { get } });
+      expect(seeded).toEqual({ kind: 'slotted' });
+    }
+    // The object is never read: nothing is synthesized to be copied.
+    expect(get).not.toHaveBeenCalled();
+  });
+
+  it('saves a new record page as kind slotted with empty slots, a body the spec accepts', async () => {
+    // The save path of `ResourceEditPage` in create mode: the spec create seed
+    // under the author's draft (whose `kind` the `page-kind` derive set), then
+    // the async seed on top.
+    const draft = { label: 'Invoice page', name: 'invoice_page', type: 'record', object: 'showcase_invoice', kind: 'slotted' };
+    const specSeed = getMetadataCreateSeed('page') as Record<string, unknown>;
+    expect(specSeed.kind).toBe('full'); // the seed alone would make a full page
+    const body = {
+      ...buildCreateModeBody(cfg, draft, specSeed),
+      ...(await cfg.createSeed!(draft, { client: clientReturning(objectDef) })),
+    } as Record<string, unknown>;
+    expect(body.kind).toBe('slotted');
+    expect(body.slots).toBeUndefined();
+    expect(body.regions).toEqual([]);
+    const parsed = PageSchema.safeParse(body);
+    expect(parsed.success, JSON.stringify(parsed.error?.issues)).toBe(true);
+  });
+
+  it('copies the synthesized regions when the author explicitly creates a full record page', async () => {
+    const seeded = await cfg.createSeed!({ type: 'record', object: 'showcase_invoice', kind: 'full' }, { client: clientReturning(objectDef) });
     expect(Array.isArray((seeded as any).regions)).toBe(true);
     expect((seeded as any).regions.length).toBeGreaterThan(0);
+    expect((seeded as any).kind).toBeUndefined();
+    // The copied regions are authored metadata the console's own page check accepts.
+    const body = { name: 'invoice_full', label: 'Invoice', type: 'record', object: 'showcase_invoice', kind: 'full', ...(seeded as object) };
+    const verdict = await validateMetadataDraft('page', body, undefined, { mode: 'edit' });
+    expect(verdict.issues, JSON.stringify(verdict.issues.slice(0, 3))).toEqual([]);
+    const blocks = blockPropsVerdict((seeded as any).regions);
+    expect(blocks.detailsJudged).toBeGreaterThan(0);
+    expect(blocks.refused).toEqual([]);
+  });
+
+  it('derives the create form kind from the page type (record → slotted, else full)', () => {
+    expect(cfg.createDerive).toContainEqual({ from: 'type', to: 'kind', transform: 'page-kind', untilUserEdits: true });
+    expect(applyTransform('page-kind', 'record')).toBe('slotted');
+    for (const type of ['list', 'app', 'home', 'utility', undefined]) {
+      expect(applyTransform('page-kind', type)).toBe('full');
+    }
   });
 
   it('returns {} for a non-record page (no object binding to synth from)', async () => {
     const seeded = await cfg.createSeed!({ type: 'app', object: 'showcase_invoice' }, { client: clientReturning(objectDef) });
     expect(seeded).toEqual({});
   });
 
-  it('returns {} when no object is chosen', async () => {
-    const seeded = await cfg.createSeed!({ type: 'record' }, { client: clientReturning(objectDef) });
+  it('returns {} for an explicit full record page when no object is chosen', async () => {
+    const seeded = await cfg.createSeed!({ type: 'record', kind: 'full' }, { client: clientReturning(objectDef) });
     expect(seeded).toEqual({});
   });
 
   it('is best-effort — swallows a client/synth failure and returns {}', async () => {
     const failing = { get: async () => { throw new Error('boom'); } };
-    const seeded = await cfg.createSeed!({ type: 'record', object: 'showcase_invoice' }, { client: failing });
+    const seeded = await cfg.createSeed!({ type: 'record', object: 'showcase_invoice', kind: 'full' }, { client: failing });
     expect(seeded).toEqual({});
   });
 });
@@ -152,6 +152,10 @@ export function registerBuiltinAnchors(): void {
     createFields: ['label', 'name', 'object', 'type', 'kind'],
     createDerive: [
       { from: 'label', to: 'name', transform: 'slugify', untilUserEdits: true },
+      // The kind follows the page type until the author picks one: a record
+      // page starts `slotted` with no slot overridden (= the synthesized
+      // default page), every other type `full` (`pageKindForType`).
+      { from: 'type', to: 'kind', transform: 'page-kind', untilUserEdits: true },
     ],
     createSchema: {
       type: 'object',
@@ -185,22 +189,34 @@ export function registerBuiltinAnchors(): void {
           title: 'Kind',
           enum: ['full', 'slotted'],
           default: 'full',
-          description: 'full = the whole page; slotted = override only named slots of the default.',
+          description: 'A record page starts slotted: no slot is overridden, so it shows the default record page and keeps up with the object. Choose full to own the whole layout, starting from a copy of the default.',
         },
       },
     },
     createDefaults: { type: 'list', kind: 'full', regions: [] },
-    // Seed a record page's regions from the bound object's synthesized default
-    // detail page, so authoring starts from the auto-generated layout (the same
-    // one the runtime renders by default) instead of a blank canvas.
+    // A record page is created `slotted` with no slots — the synthesized
+    // default page, which keeps following the object (its fields, sections and
+    // related lists) until the author overrides a slot. Its regions are copied
+    // only when the author explicitly asks for a `full` page: choosing `full`
+    // in this form (the `page-kind` derive above makes `slotted` the record
+    // default, so `full` here is the author's own pick), or the page
+    // designer's "Convert to full page" action (`PagePreview`). Seeding every
+    // record page with the synthesized regions forked it from the default on
+    // the day it was created.
     createSeed: async (draft, { client }) => {
       // List/interface page: pre-bind the chosen object as the data source so
       // the new page renders immediately (the author then curates columns,
       // filters, visualizations in the editor).
       if (draft?.type === 'list') {
         return draft?.object ? { interfaceConfig: { source: String(draft.object) } } : {};
       }
-      if (draft?.type !== 'record' || !draft?.object) return {};
+      if (draft?.type !== 'record') return {};
+      // Not an explicit `full`: the empty slotted page. The body's `kind` is
+      // stated here rather than left to the draft, so a record page reaching
+      // this hook without a kind (the spec create seed says `full`) still
+      // starts as the default page.
+      if (draft.kind !== 'full') return { kind: 'slotted' };
+      if (!draft?.object) return {};
       try {
         const objectDef = await client.get('object', String(draft.object));
         if (!objectDef || typeof objectDef !== 'object') return {};
 
@@ -74,6 +74,22 @@ export function firstToken(input: string): string {
   return m ? m[0] : '';
 }
 
+/**
+ * The `kind` a new page of this `type` starts as.
+ *
+ * A record page starts `slotted` with no slot overridden: what it renders is
+ * exactly the synthesized default page, so it stays in step with the object
+ * (new fields, related lists, sections) until the author overrides a slot.
+ * Seeding a `full` page with a copy of the synthesized regions forked every
+ * authored record page from the default on the day it was created. Owning
+ * the whole layout is an explicit act — choosing `full` here, or the
+ * page designer's "Convert to full page" action. Every other page type is a
+ * `full` page: `slotted` is a record-page mode only.
+ */
+export function pageKindForType(type: unknown): 'slotted' | 'full' {
+  return type === 'record' ? 'slotted' : 'full';
+}
+
 export function applyTransform(
   transform: CreateDeriveRule['transform'],
   value: unknown,
@@ -88,6 +104,8 @@ export function applyTransform(
       return titlecase(str);
     case 'first-token':
       return firstToken(str);
+    case 'page-kind':
+      return pageKindForType(value);
     default:
       return str;
   }