@@ -0,0 +1,11 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/i18n': patch
+---
+
+fix(studio): a report switched to Joined in Properties is held until its first block is added, instead of autosaving a report the draft door refuses
+
+Clause-②: no
+Metadata-protocol: none
+
+Setting Report type = Joined clears the report's dataset and measures, because a joined report selects per block. Until a block is added, the report has no `blocks`, and the spec refuses it ("a `joined` report needs `blocks`"). Studio used to autosave that body and get a 422, and every later edit carried the same body and was refused too, then lost on reload. Now the Interfaces pillar holds it unsent, as it already holds an unfinished Order item, block or chart. A neutral line reads "Not saved yet: a Joined report needs at least one block in “Blocks”", its "Show me" focuses the Blocks list, and Studio's leave guard and Publish see the held edit. Adding a block hands the hold to that block until its Name and Dataset are set, and the next autosave then sends every edit kept meanwhile. A joined report with no blocks that also keeps a key the spec refuses is still sent, so that refusal stays on screen.
@@ -0,0 +1,214 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#29022 — the Interfaces pillar holds a report switched to Joined
+ * in its Properties until its first block is added, instead of autosaving a
+ * body the draft door refuses.
+ *
+ * The card: Report type = Joined sent `type: 'joined'` with the dataset and
+ * measures cleared and no `blocks` (422 at `blocks`); a Description edit then
+ * sent the same body plus the edit (422 again), and a reload dropped both with
+ * no prompt. Now nothing is sent, a neutral line names the Blocks list with a
+ * "Show me", and the surface is told what is held (its leave guard and Publish
+ * read that).
+ *
+ * Mounted as `InterfacesPillar.reportHeld-27785.test.tsx` mounts it: a metadata
+ * client double that records every save, a stub canvas and the real
+ * `ReportDefaultInspector` with its type picker.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+
+const NAV = [{ id: 'nav_rep', type: 'report', label: 'Sales report', reportName: 'sales_report' }];
+
+const SUMMARY_REPORT = {
+  name: 'sales_report',
+  label: 'Sales report',
+  type: 'summary',
+  dataset: 'sales_ds',
+  rows: ['stage'],
+  values: ['revenue'],
+};
+
+const DATASETS = [
+  {
+    name: 'sales_ds',
+    label: 'Sales',
+    object: 'opportunity',
+    dimensions: [{ name: 'stage', label: 'Stage' }],
+    measures: [{ name: 'revenue', label: 'Revenue', aggregate: 'sum' }],
+  },
+];
+
+/** The report the pillar opens, as served: it parses with the spec. */
+let stored: Record<string, unknown> = SUMMARY_REPORT;
+
+const mockClient = {
+  withPreviewDrafts: vi.fn((): unknown => mockClient),
+  save: vi.fn(async (_type: string, _name: string, _body: Record<string, unknown>) => ({
+    success: true,
+    version: 'v1',
+    state: 'draft',
+  })),
+  list: vi.fn(async (type: string) => {
+    if (type === 'app') return [{ name: 'acme_app', label: 'Acme' }];
+    if (type === 'dataset') return DATASETS;
+    if (type === 'report') return [stored];
+    return [];
+  }),
+  listDrafts: vi.fn(async () => []),
+  layered: vi.fn(async (type: string) => {
+    if (type === 'app') return { effective: { name: 'acme_app', label: 'Acme', active: true, navigation: NAV } };
+    if (type === 'report') return { effective: JSON.parse(JSON.stringify(stored)) };
+    return { code: null, overlay: null, overlayScope: null, effective: null };
+  }),
+  getDraft: vi.fn(async () => null),
+  get: vi.fn(async (type: string, name: string) =>
+    type === 'dataset' ? DATASETS.find((d) => d.name === name) : undefined,
+  ),
+};
+
+vi.mock('../metadata-admin/useMetadata', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('../metadata-admin/useMetadata')>();
+  return { ...mod, useMetadataClient: () => mockClient, useMetadataTypes: () => ({ entries: [] }) };
+});
+
+vi.mock('./packages-io', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('./packages-io')>();
+  return { ...mod, fetchPackages: vi.fn(async () => []) };
+});
+
+vi.mock('@object-ui/react', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@object-ui/react')>();
+  return { ...mod, useAdapter: () => ({}) };
+});
+
+import { InterfacesPillar } from './StudioDesignSurface';
+import { registerMetadataPreview } from '../metadata-admin/preview-registry';
+import { registerMetadataDefaultInspector } from '../metadata-admin/default-inspector-registry';
+import { ReportDefaultInspector } from '../metadata-admin/inspectors/ReportDefaultInspector';
+import { t, tFormat } from '../metadata-admin/i18n';
+
+// A stub canvas: the leaf needs a registered preview to be draft-editable,
+// and the canvas's own drawing is not what this file pins.
+registerMetadataPreview('report', () => null);
+registerMetadataDefaultInspector('report', ReportDefaultInspector);
+
+beforeEach(() => {
+  stored = SUMMARY_REPORT;
+  for (const fn of Object.values(mockClient)) fn.mockClear();
+});
+afterEach(cleanup);
+
+const L = (key: string) => t(key, 'en');
+
+function mountPillar(onHeldEditChange?: (clause: string | null) => void) {
+  return render(
+    <MemoryRouter initialEntries={['/studio/com.acme.app/interfaces']}>
+      <InterfacesPillar packageId="com.acme.app" onHeldEditChange={onHeldEditChange} />
+    </MemoryRouter>,
+  );
+}
+
+function reportSaves(): Array<Record<string, unknown>> {
+  return mockClient.save.mock.calls.filter((c) => c[0] === 'report').map((c) => c[2]);
+}
+
+/** Past the autosave's 1.5 s debounce. */
+async function outlastDebounce(): Promise<void> {
+  await act(async () => {
+    await new Promise((r) => setTimeout(r, 2300));
+  });
+}
+
+/** The report's properties are open, with the list property labelled `list` drawn. */
+async function ready(list: string): Promise<HTMLElement> {
+  const inspector = await screen.findByTestId('if-inspector', undefined, { timeout: 8000 });
+  await within(inspector).findByText(list, { selector: 'label' }, { timeout: 8000 });
+  return inspector;
+}
+
+/** The form row of the list property labelled `label`: its label and its repeater. */
+function listRow(inspector: HTMLElement, label: string): HTMLElement {
+  const row = within(inspector).getByText(label, { selector: 'label' }).parentElement?.parentElement;
+  if (!row) throw new Error(`no form row for ${label}`);
+  return row;
+}
+
+/** The report's own Label input. */
+function editLabel(inspector: HTMLElement, value: string): void {
+  const input = within(inspector).getByLabelText(L('engine.inspector.report.label'));
+  fireEvent.change(input, { target: { value } });
+  fireEvent.blur(input);
+}
+
+/** Picks `option` in the inspector select labelled `label`. */
+async function pick(inspector: HTMLElement, label: string, option: string | RegExp): Promise<void> {
+  fireEvent.keyDown(within(inspector).getByRole('combobox', { name: label }), { key: 'ArrowDown' });
+  await waitFor(() => expect(screen.queryAllByRole('option').length).toBeGreaterThan(0));
+  fireEvent.click(screen.getByRole('option', { name: option }));
+}
+
+const heldLine = (clause: string) => tFormat('engine.studio.held.line', 'en', { clause });
+const joinedClause = tFormat('engine.studio.held.reportJoinedNeedsBlock', 'en', { list: 'Blocks' });
+
+describe('a report switched to Joined is held until its first block is added (objectstack#29022)', () => {
+  it('Report type = Joined, then a Label edit: nothing is sent, no red strip, the line names Blocks', async () => {
+    const report = vi.fn();
+    mountPillar(report);
+    const inspector = await ready('Order');
+    await pick(inspector, L('engine.inspector.report.type'), L('engine.inspector.report.type.joined'));
+    editLabel(inspector, 'Sales v2');
+    await outlastDebounce();
+
+    expect(reportSaves(), 'the joined report without blocks is not sent, nor the Label edit with it').toEqual([]);
+    expect(screen.queryByTestId('studio-refusal'), 'no red strip on the normal path').toBeNull();
+    expect(screen.getByTestId('studio-held-message')).toHaveTextContent(heldLine(joinedClause));
+    // The surface's half: its leave guard and Publish read the held clause.
+    expect(report).toHaveBeenLastCalledWith(joinedClause);
+  });
+
+  it('"Show me" focuses the Blocks list in the report properties', async () => {
+    mountPillar();
+    const inspector = await ready('Order');
+    await pick(inspector, L('engine.inspector.report.type'), L('engine.inspector.report.type.joined'));
+    await within(inspector).findByText('Blocks', { selector: 'label' });
+    const row = listRow(inspector, 'Blocks');
+    const show = await within(await screen.findByTestId('studio-held')).findByRole('button', {
+      name: L('engine.studio.refusal.show'),
+    });
+    (document.activeElement as HTMLElement | null)?.blur();
+    fireEvent.click(show);
+    await waitFor(() => expect(row.contains(document.activeElement)).toBe(true));
+  });
+
+  it('Blocks → Add item hands the hold to the new block, still unsent', async () => {
+    const report = vi.fn();
+    mountPillar(report);
+    const inspector = await ready('Order');
+    await pick(inspector, L('engine.inspector.report.type'), L('engine.inspector.report.type.joined'));
+    await within(inspector).findByText('Blocks', { selector: 'label' });
+    fireEvent.click(within(listRow(inspector, 'Blocks')).getByRole('button', { name: L('engine.form.addItem') }));
+    await outlastDebounce();
+
+    const clause = tFormat('engine.studio.held.listItemNeedsInput', 'en', { input: 'Name', n: 1, list: 'Blocks' });
+    expect(reportSaves()).toEqual([]);
+    expect(screen.queryByTestId('studio-refusal')).toBeNull();
+    expect(screen.getByTestId('studio-held-message')).toHaveTextContent(heldLine(clause));
+    expect(report).toHaveBeenLastCalledWith(clause);
+  });
+
+  // CONTROL: a type switch the door accepts saves at once.
+  it('Report type = Tabular saves at once, with no line', async () => {
+    mountPillar();
+    const inspector = await ready('Order');
+    await pick(inspector, L('engine.inspector.report.type'), L('engine.inspector.report.type.tabular'));
+    await waitFor(() => expect(reportSaves()).toHaveLength(1), { timeout: 4000 });
+    expect(reportSaves()[0].type).toBe('tabular');
+    expect(screen.queryByTestId('studio-held')).toBeNull();
+  });
+});
@@ -0,0 +1,114 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#29022 — a report switched to Joined before its first block is
+ * HELD by the Interfaces pillar's leaf autosave, not sent.
+ *
+ * The card: Properties → Report type = Joined sent `type: 'joined'` with the
+ * container's dataset and measures cleared (objectui#10746) and no `blocks`;
+ * the draft door answered 422 at `blocks` ("a `joined` report needs
+ * `blocks`"), and every later edit carried the same body and was refused too,
+ * then lost on reload. `reportHeldEdit` held list items and the chart
+ * (objectstack#27785) but not a joined report with no list at all.
+ *
+ * Every "held" case is paired with the spec's own `ReportSchema` verdict on the
+ * same body (it refuses it at `blocks` alone), and every "not held" control
+ * with a body that judge accepts, or refuses for something the author wrote.
+ * The pillar that acts on it is pinned in
+ * `InterfacesPillar.reportJoined-29022.test.tsx`.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { ReportSchema } from '@objectstack/spec/ui';
+import { reportHeldEdit } from './metadataError';
+import { tFormat } from '../metadata-admin/i18n';
+import { loadStudioCatalogue } from '@object-ui/i18n/namespaces/studio';
+
+// The studio zh catalogue loads on demand; the locale case below reads it.
+await loadStudioCatalogue('zh');
+
+/** The issue paths the spec's report parse refuses `report` at, as the door reports them. */
+function reportRefusals(report: Record<string, unknown>): string[] {
+  const result = ReportSchema.safeParse(report);
+  return result.success ? [] : result.error.issues.map((issue) => issue.path.join('.'));
+}
+
+/** A summary report as Save as draft wrote it in the card's step 1. */
+const SUMMARY = {
+  name: 'pipeline_report',
+  label: 'Pipeline',
+  type: 'summary',
+  dataset: 'sales_ds',
+  values: ['revenue'],
+  drilldown: true,
+};
+
+/**
+ * The body the type picker's switch leaves (`ReportDefaultInspector`'s
+ * `commitType`): `type: 'joined'`, the selection keys present and `undefined`.
+ */
+const SWITCHED = {
+  ...SUMMARY,
+  type: 'joined',
+  dataset: undefined,
+  values: undefined,
+};
+
+const joinedClause = (list: string, locale = 'en') =>
+  tFormat('engine.studio.held.reportJoinedNeedsBlock', locale, { list });
+
+describe('a report switched to Joined before its first block is held (objectstack#29022)', () => {
+  it('the switch itself: held, as the door refuses it at blocks, placed on the report properties', () => {
+    expect(reportRefusals(SWITCHED)).toEqual(['blocks']);
+    expect(reportHeldEdit(SWITCHED, 'en')).toEqual({
+      clause: joinedClause('Blocks'),
+      target: null,
+      input: 'Blocks',
+    });
+  });
+
+  it('a later edit (the card step 3 Description) stays held with it', () => {
+    const body = { ...SWITCHED, description: 'Won and lost, side by side' };
+    expect(reportRefusals(body)).toEqual(['blocks']);
+    expect(reportHeldEdit(body, 'en')?.clause).toBe(joinedClause('Blocks'));
+  });
+
+  it('every block removed again: held the same way', () => {
+    const body = { ...SWITCHED, blocks: [] };
+    expect(reportRefusals(body)).toEqual(['blocks']);
+    expect(reportHeldEdit(body, 'en')?.clause).toBe(joinedClause('Blocks'));
+  });
+
+  it('a first block added but not bound is held as a list item, by the 27785 rule', () => {
+    const body = { ...SWITCHED, blocks: [{ name: 'won' }] };
+    expect(reportRefusals(body)).toEqual(['blocks.0.dataset']);
+    expect(reportHeldEdit(body, 'en')?.clause).toBe(
+      tFormat('engine.studio.held.listItemNeedsInput', 'en', { input: 'Dataset', n: 1, list: 'Blocks' }),
+    );
+  });
+
+  it('names the list in the designer locale', () => {
+    const held = reportHeldEdit(SWITCHED, 'zh-CN');
+    expect(held?.clause).toBe(joinedClause(held?.input ?? '', 'zh-CN'));
+    expect(held?.clause).toMatch(/^联合报表/);
+  });
+
+  // CONTROL: the hold is never stricter than the contract.
+  it('a joined report with a bound block: not held, and the spec accepts it', () => {
+    const body = { ...SWITCHED, blocks: [{ name: 'won', dataset: 'sales_ds' }] };
+    expect(reportRefusals(body)).toEqual([]);
+    expect(reportHeldEdit(body, 'en')).toBeNull();
+  });
+
+  it('a summary report with no blocks: not held, and the spec accepts it', () => {
+    expect(reportRefusals(SUMMARY)).toEqual([]);
+    expect(reportHeldEdit(SUMMARY, 'en')).toBeNull();
+  });
+
+  // CONTROL: errors stay for finished work.
+  it('a joined report with no blocks that also keeps a container key it refuses is not held', () => {
+    const body = { ...SWITCHED, dataset: 'sales_ds' };
+    expect(reportRefusals(body)).toEqual(['blocks', 'dataset']);
+    expect(reportHeldEdit(body, 'en')).toBeNull();
+  });
+});
@@ -1260,16 +1260,46 @@ const REPORT_CHART_INPUT_KEYS: Readonly<Record<string, string>> = {
   yAxis: 'engine.inspector.report.chartY',
 };
 
+/**
+ * objectstack#29022 — a report switched to Joined before its first block,
+ * held. The type picker sends `type: 'joined'` and clears the container's
+ * selection (objectui#10746), so the body carries no `blocks`, and
+ * `ReportSchema` refuses it at `blocks` itself ("a `joined` report needs
+ * `blocks`"): no item of the list exists for {@link listItemHeldInput} to
+ * hold. Held while the list is missing or empty and that is the spec's only
+ * refusal; an added block is then judged as a list item. Named by the report
+ * form's label for the list, which "Show me" focuses.
+ */
+function joinedReportHeld(draft: SentBody, locale: string): StudioHeld<MetadataSelection | null> | null {
+  if (draft.type !== 'joined') return null;
+  const blocks = draft.blocks;
+  if (blocks !== undefined && !(Array.isArray(blocks) && blocks.length === 0)) return null;
+  const parsed = ReportSchema.safeParse(draft);
+  // Only when that is all it refuses: any other issue is finished but wrong work, whose refusal stays on screen.
+  if (parsed.success || !parsed.error.issues.every((issue) => issue.path.length === 1 && issue.path[0] === 'blocks')) {
+    return null;
+  }
+  const rows = (getReportForm()?.sections ?? []).flatMap((section) =>
+    'fields' in section && Array.isArray(section.fields) ? section.fields : [],
+  );
+  const list = formRowLabel(formRowOf(rows, 'blocks'), 'blocks', locale);
+  return { clause: tFormat('engine.studio.held.reportJoinedNeedsBlock', locale, { list }), target: null, input: list };
+}
+
 /**
  * The edit the Interfaces pillar holds for `draft`, the report its leaf
  * autosave would send, or `null`: the first item of one of its list properties
  * `ReportSchema` refuses only for inputs it leaves unset, named by the report
- * form's labels; else its chart, refused only for unset inputs, named by the
- * chart panel's own label. Both are placed on the report's properties.
+ * form's labels; else a joined report with no block yet
+ * ({@link joinedReportHeld}); else its chart, refused only for unset inputs,
+ * named by the chart panel's own label. All are placed on the report's
+ * properties.
  */
 export function reportHeldEdit(draft: SentBody, locale: string): StudioHeld<MetadataSelection | null> | null {
   const item = listItemHeldInput(draft, ReportSchema);
   if (item) return heldListItem(item, getReportForm(), locale);
+  const joined = joinedReportHeld(draft, locale);
+  if (joined) return joined;
   const key = objectHeldInput(draft, ReportSchema, 'chart');
   if (key === null) return null;
   const labelKey = REPORT_CHART_INPUT_KEYS[key];