@@ -0,0 +1,14 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/i18n': patch
+---
+
+fix(studio): a new Rollup field is held until it is set up, and its child-field picker offers only the fields the spec accepts for the chosen function
+
+Clause-②: no
+Metadata-protocol: none
+
+- **Held, not autosaved.** Adding a field with Type = Rollup used to send the draft at once as `{ type: 'summary' }` with no `summaryOperations`, which the server saves as a roll-up that reads 0 everywhere. The Data pillar now holds a roll-up like a choice field before its options: it stays on screen and unsent, the held line names the field and the input it still needs (Child object, Aggregation, or Child field to aggregate when the function reads one), "Show me" reopens it, and Publish refuses while it is held. The judges are the spec's: the `field/summary-without-operations` completeness rule and `FieldSchema`. A roll-up the spec refuses for any other reason is sent, so its refusal shows as before.
+- **Child field picker.** "Child field to aggregate" lists only the child fields `isAggregateCompatibleWithFieldType` accepts for the chosen function (Sum no longer offers text, audit, lookup or master-detail fields), and before a function is picked, a field some value-reading function accepts. The filter rows still offer every child field.
+
+`@object-ui/i18n` gains `engine.studio.held.fieldNeedsInput` in the en and zh studio packs.
@@ -0,0 +1,107 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#27461 — the roll-up's "Child field to aggregate" picker offers
+ * only the child fields the spec accepts for the chosen function.
+ *
+ * The card: with Aggregation = Sum, the picker listed text fields, the audit
+ * columns, the owner lookup and the master-detail parent beside the one
+ * number. The spec already says which field types each aggregate accepts
+ * (`isAggregateCompatibleWithFieldType`, the table both the dataset compiler
+ * and the engine's aggregate door read), so the picker reads that rule: every
+ * expectation below is paired with the rule's own verdict on the same child
+ * fields, so the picker can be neither wider nor narrower than the spec.
+ */
+
+import * as React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, within } from '@testing-library/react';
+import { isAggregateCompatibleWithFieldType } from '@objectstack/spec/data';
+
+vi.mock('../useMetadata', () => ({
+  useMetadataClient: () => ({
+    list: vi.fn().mockResolvedValue([]),
+    listDrafts: vi.fn().mockResolvedValue([]),
+  }),
+}));
+
+/** The card's child object: a number beside text, audit, relationship, a rate, a flag and a formula. */
+const CHILD_FIELDS = [
+  { name: 'name', label: 'Name', type: 'text', hidden: false },
+  { name: 'memo', label: 'Memo', type: 'textarea', hidden: false },
+  { name: 'created_at', label: 'Created At', type: 'datetime', hidden: false },
+  { name: 'owner', label: 'Owner', type: 'lookup', hidden: false },
+  { name: 'parent', label: 'Parent', type: 'master_detail', hidden: false },
+  { name: 'amount', label: 'Amount', type: 'number', hidden: false },
+  { name: 'rate', label: 'Rate', type: 'percent', hidden: false },
+  { name: 'done', label: 'Done', type: 'boolean', hidden: false },
+  { name: 'margin', label: 'Margin', type: 'formula', hidden: false },
+];
+
+vi.mock('../previews/useObjectFields', () => ({
+  useObjectFields: (obj?: string) => ({ fields: obj ? CHILD_FIELDS : [], loading: false, error: null }),
+}));
+
+import { ObjectFieldInspector } from './ObjectFieldInspector';
+
+afterEach(cleanup);
+
+function renderRollup(summaryOperations: Record<string, unknown>) {
+  render(
+    <ObjectFieldInspector
+      type="object"
+      name="parent_obj"
+      draft={{ name: 'parent_obj', fields: { total: { type: 'summary', label: 'Total', summaryOperations } } }}
+      selection={{ kind: 'field', id: 'total' }}
+      onPatch={vi.fn()}
+      onClearSelection={vi.fn()}
+      onSelectionChange={vi.fn()}
+      readOnly={false}
+      locale={'en-US'}
+    />,
+  );
+}
+
+/** The API names the "Child field to aggregate" picker offers, opened. */
+async function offeredAggregands(): Promise<string[]> {
+  fireEvent.click(screen.getByLabelText('Child field to aggregate'));
+  const list = await screen.findByRole('listbox');
+  return within(list).getAllByRole('option').map((o) => o.getAttribute('data-value') ?? '');
+}
+
+/** The child fields the spec's rule accepts for `fn`. */
+const specAccepts = (fn: string) =>
+  CHILD_FIELDS.filter((f) => isAggregateCompatibleWithFieldType(fn, f.type)).map((f) => f.name);
+
+describe('roll-up child-field picker follows the spec\'s aggregate × field-type rule (objectstack#27461)', () => {
+  it('Sum: the card\'s text, audit and relationship fields are gone; the number is offered', async () => {
+    renderRollup({ object: 'child_obj', function: 'sum' });
+    const offered = await offeredAggregands();
+    expect(offered).toEqual(specAccepts('sum'));
+    expect(offered).toContain('amount');
+    for (const refused of ['name', 'memo', 'created_at', 'owner', 'parent', 'margin']) {
+      expect(offered).not.toContain(refused);
+    }
+  });
+
+  it('each value-reading function offers exactly what the rule accepts for it', async () => {
+    for (const fn of ['sum', 'avg', 'min', 'max']) {
+      renderRollup({ object: 'child_obj', function: fn });
+      expect(await offeredAggregands(), fn).toEqual(specAccepts(fn));
+      cleanup();
+    }
+    // The rule is what differs, not the picker: a rate averages but does not
+    // add, and a date has an earliest but no total.
+    expect(specAccepts('avg')).toContain('rate');
+    expect(specAccepts('sum')).not.toContain('rate');
+    expect(specAccepts('min')).toContain('created_at');
+  });
+
+  it('before a function is picked: a field some value-reading function accepts', async () => {
+    renderRollup({ object: 'child_obj' });
+    const union = CHILD_FIELDS.filter((f) =>
+      ['sum', 'avg', 'min', 'max'].some((fn) => isAggregateCompatibleWithFieldType(fn, f.type)),
+    ).map((f) => f.name);
+    expect(await offeredAggregands()).toEqual(union);
+  });
+});
@@ -50,6 +50,7 @@
 import * as React from 'react';
 import {
   FieldSchema,
+  isAggregateCompatibleWithFieldType,
   isBodyTableRelationship,
   MULTI_OPTION_TYPES,
   NUMERIC_VALUE_TYPES,
@@ -2562,6 +2563,20 @@ function SummaryConfigFields({
     () => childFields.filter((f) => !f.hidden).map((f) => ({ value: f.name, label: f.label, hint: f.type })),
     [childFields],
   );
+  // objectstack#27461 — the child field to aggregate is offered only where the
+  // spec accepts it for the chosen function: its aggregate × field-type rule
+  // (`isAggregateCompatibleWithFieldType`), never a list kept here. Before a
+  // function is picked, a field any value-reading function accepts. The
+  // filter rows below still offer every child field: a filter reads any.
+  const aggregandOptions: InspectorComboOption[] = React.useMemo(() => {
+    const accepts = (type: string) =>
+      fn
+        ? isAggregateCompatibleWithFieldType(fn, type)
+        : SUMMARY_FUNCTIONS.some((f) => summaryFunctionReadsField(f) && isAggregateCompatibleWithFieldType(f, type));
+    return childFields
+      .filter((f) => !f.hidden && accepts(f.type))
+      .map((f) => ({ value: f.name, label: f.label, hint: f.type }));
+  }, [childFields, fn]);
   // The FK back to this parent lives on a child relation field.
   const relationshipOptions: InspectorComboOption[] = React.useMemo(
     () =>
@@ -2618,7 +2633,7 @@ function SummaryConfigFields({
           label={tr('designer.field.summary.field')}
           value={typeof ops.field === 'string' ? ops.field : ''}
           onCommit={(v) => patchOps({ field: v || undefined })}
-          options={aggregateOptions}
+          options={aggregandOptions}
           loading={loading}
           placeholder={fieldPlaceholder}
           searchPlaceholder={tr('designer.field.lookup.searchFields')}
 
@@ -0,0 +1,171 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#27461 — on the Studio data page, a new Rollup field is held
+ * until it is set up, not autosaved unconfigured.
+ *
+ * The card's step 4: "Add field", Type = Rollup, and the draft PUT went out at
+ * once with `{ type: 'summary' }` and no `summaryOperations`, which the server
+ * saved (a roll-up that reads 0 everywhere). Now the pillar asks the spec's
+ * judges before sending (`objectHeldEdit`, pinned predicate by predicate in
+ * `metadataError.summaryHeld-27461.test.ts`): the edit stays dirty and unsent,
+ * the held line names the field and the input it still needs, with "Show me"
+ * once the field is closed, and the save goes as soon as the roll-up is one
+ * the spec accepts.
+ *
+ * The harness is `DataPillar.heldIncomplete-11786.test.tsx`'s: a real
+ * `MetadataClient` over a transport double.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { render, screen, fireEvent, cleanup, act, waitFor, within } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { MetadataClient } from '@object-ui/data-objectstack';
+
+const objectDef = {
+  name: 'showcase_task',
+  label: 'Task',
+  fields: [{ name: 'title', label: 'Title', type: 'text' }],
+};
+
+/** Every PUT the transport received, parsed. */
+const puts: Array<Record<string, unknown>> = [];
+
+const fetchImpl = vi.fn(async (_url: string, init?: RequestInit) => {
+  if (init?.method === 'PUT') {
+    puts.push(JSON.parse(String(init.body)) as Record<string, unknown>);
+    return new Response(JSON.stringify({ success: true }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  return new Response('null', { status: 404, headers: { 'content-type': 'application/json' } });
+});
+
+const client = new MetadataClient({ baseUrl: 'http://test.local', fetch: fetchImpl as unknown as typeof fetch });
+Object.assign(client, {
+  list: vi.fn(async () => [{ name: 'showcase_task', label: 'Task' }]),
+  listDrafts: vi.fn(async () => []),
+  layered: vi.fn(async () => ({ effective: objectDef, code: objectDef })),
+  getDraft: vi.fn(async () => null),
+});
+
+vi.mock('../metadata-admin/useMetadata', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('../metadata-admin/useMetadata')>();
+  return { ...mod, useMetadataClient: () => client, 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: () => dataSource };
+});
+
+import { DataPillar } from './StudioDesignSurface';
+import { addFieldFromFormToolbar } from './__tests__/dataPillarAddField';
+import { createEmptyDataSource } from './__tests__/emptyDataSource';
+import { registerBuiltinInspectors } from '../metadata-admin/inspectors';
+import { t, tFormat } from '../metadata-admin/i18n';
+
+const dataSource = createEmptyDataSource();
+registerBuiltinInspectors();
+
+afterEach(() => {
+  cleanup();
+  puts.length = 0;
+  fetchImpl.mockClear();
+});
+
+/** Past the autosave's 1.5 s debounce. */
+async function outlastDebounce(): Promise<void> {
+  await act(async () => {
+    await new Promise((r) => setTimeout(r, 2300));
+  });
+}
+
+/** The inspector control under a visible label. */
+function controlUnder(label: string): HTMLElement {
+  const lab = screen.getByText(label, { selector: 'label' });
+  return lab.parentElement!.querySelector('input, [role="combobox"]') as HTMLElement;
+}
+
+/** The fields of the last PUT body, by name. */
+function lastSentField(name: string): Record<string, unknown> | undefined {
+  const fields = puts[puts.length - 1]?.fields;
+  return Array.isArray(fields)
+    ? (fields as Array<Record<string, unknown>>).find((f) => f.name === name)
+    : (fields as Record<string, Record<string, unknown>> | undefined)?.[name];
+}
+
+/**
+ * Mount and add the card's field the card's way: Form tab, Add field, Label
+ * "Child Count", Type Rollup, Create. Returns its API name and label.
+ */
+async function addRollup(): Promise<{ name: string; label: string }> {
+  render(
+    <MemoryRouter initialEntries={['/studio/com.example.showcase/data']}>
+      <DataPillar packageId="com.example.showcase" />
+    </MemoryRouter>,
+  );
+  fireEvent.click(await screen.findByRole('button', { name: 'Form' }));
+  await addFieldFromFormToolbar(undefined, { label: 'Child Count', type: /^Rollup$/ });
+  await screen.findByText('Type', { selector: 'label' }, { timeout: 4000 });
+  const name = (controlUnder('API name') as HTMLInputElement).value;
+  const label = (controlUnder('Label') as HTMLInputElement).value;
+  expect(name, 'the new field has no API name: the harness is dead').not.toBe('');
+  expect(label).toBe('Child Count');
+  return { name, label };
+}
+
+const heldLine = (clause: string) => tFormat('engine.studio.held.line', 'en', { clause });
+
+describe('Studio data page — a Rollup is held until it is set up (objectstack#27461)', () => {
+  it('sends no save for the bare roll-up; names each missing input in turn; a count lets the save go', async () => {
+    const { name, label } = await addRollup();
+    await outlastDebounce();
+
+    expect(puts, 'an unconfigured roll-up is not sent').toEqual([]);
+    expect(screen.queryByTestId('studio-refusal')).toBeNull();
+    const message = () => within(screen.getByTestId('studio-held')).getByTestId('studio-held-message');
+    const needs = (inputKey: string) =>
+      heldLine(tFormat('engine.studio.held.fieldNeedsInput', 'en', { input: t(inputKey, 'en'), field: label }));
+    expect(message()).toHaveTextContent(needs('designer.field.summary.object'));
+
+    const child = controlUnder(t('designer.field.summary.object', 'en')) as HTMLInputElement;
+    fireEvent.change(child, { target: { value: 'showcase_task' } });
+    fireEvent.blur(child);
+    await outlastDebounce();
+    expect(puts, 'a child object alone is not a roll-up yet').toEqual([]);
+    expect(message()).toHaveTextContent(needs('designer.field.summary.function'));
+
+    fireEvent.keyDown(controlUnder(t('designer.field.summary.function', 'en')), { key: 'ArrowDown' });
+    fireEvent.click(
+      within(await screen.findByRole('listbox')).getByRole('option', { name: t('designer.field.summary.fn.count', 'en') }),
+    );
+    await waitFor(() => expect(puts.length).toBe(1), { timeout: 4000 });
+    expect(lastSentField(name)).toEqual(
+      expect.objectContaining({ type: 'summary', summaryOperations: { object: 'showcase_task', function: 'count' } }),
+    );
+    await waitFor(() => expect(screen.queryByTestId('studio-held')).toBeNull());
+    expect(screen.queryByTestId('studio-refusal')).toBeNull();
+  });
+
+  it('"Show me" on the line reopens the held roll-up once its inspector is closed', async () => {
+    // The first case proves the roll-up is never sent; this one needs only the line.
+    const { name } = await addRollup();
+
+    const railHeader = screen.getByText(t('engine.studio.data.fieldProps', 'en')).closest('header') as HTMLElement;
+    fireEvent.click(within(railHeader).getByRole('button', { name: t('engine.studio.close', 'en') }));
+    expect(screen.queryByText('API name', { selector: 'label' })).toBeNull();
+
+    fireEvent.click(within(screen.getByTestId('studio-held')).getByRole('button', { name: t('engine.studio.refusal.show', 'en') }));
+    expect(await screen.findByText('API name', { selector: 'label' })).toBeInTheDocument();
+    expect((controlUnder('API name') as HTMLInputElement).value).toBe(name);
+  });
+});