diff --git a/.changeset/11601-ref-dataset-widget.md b/.changeset/11601-ref-dataset-widget.md
new file mode 100644
index 0000000000..94ad2ff040
--- /dev/null
+++ b/.changeset/11601-ref-dataset-widget.md
@@ -0,0 +1,25 @@
+---
+'@object-ui/app-shell': minor
+---
+
+A Studio form field that declares the `ref:dataset` widget now renders a dataset picker instead of the JSON editor fallback (objectui#11601).
+
+The metadata forms had no renderer for `ref:dataset`, so a field declaring it fell back to a raw
+JSON box with a "falling back to JSON" note. The new widget offers the analytics dataset catalog,
+showing each dataset's label beside its name and its description after it, and writes the dataset
+name. It works for a field in a form section and for a column of a repeater row, in both the grid
+and the card layouts. A stored dataset the catalog does not list stays visible and is marked
+"(not found)". While the catalog is loading the field shows the stored name, and if the catalog
+fails to load the field shows the load-failure notice beside a text box that stays editable. A
+form whose host does not supply a catalog shows a plain text input for the dataset name.
+
+The report inspector now supplies its dataset catalog to the report's form. A joined report's
+block row picks up the dataset picker once the spec's "Joined blocks" row declares `ref:dataset`
+(objectstack#21714). Until objectui is built against a spec that carries that declaration, a
+block's `dataset` is still entered as free text.
+
+The dataset option list that the report and dashboard-widget inspectors already show is unchanged.
+
+`SchemaForm`'s `widgetContext` prop gains one optional member, `datasets`, the catalog the new widget
+reads. It is additive: a host that passes no `datasets` renders exactly as before, except that a
+`ref:dataset` field now shows the text input instead of the JSON fallback.
diff --git a/packages/app-shell/src/views/metadata-admin/SchemaForm.controlWidgetGridNaming-9889.test.tsx b/packages/app-shell/src/views/metadata-admin/SchemaForm.controlWidgetGridNaming-9889.test.tsx
index d7fae5ff7f..99d2a98670 100644
--- a/packages/app-shell/src/views/metadata-admin/SchemaForm.controlWidgetGridNaming-9889.test.tsx
+++ b/packages/app-shell/src/views/metadata-admin/SchemaForm.controlWidgetGridNaming-9889.test.tsx
@@ -66,6 +66,7 @@ const ctx: WidgetContext = {
   objectNames: loaded(['account', 'contact']),
   objectFields: loaded([{ name: 'status', label: 'Status' }]),
   objectViews: loaded([{ name: 'account.all', label: 'All' }]),
+  datasets: loaded([{ name: 'sales_metrics', label: 'Sales metrics', dimensions: [], measures: [] }]),
 };
 
 /**
@@ -90,10 +91,11 @@ interface WidgetCase {
   faceName: string;
 }
 
-/** The eleven `labelling: 'control'` widgets. Checked against the registry below. */
+/** The `labelling: 'control'` widgets. Checked against the registry below. */
 const CONTROL_CASES: WidgetCase[] = [
   { widget: 'ref:object', control: (c) => c.querySelector('[role="combobox"]'), faceName: 'the object picker' },
   { widget: 'ref:component', control: (c) => c.querySelector('input'), faceName: 'the free-text component id box' },
+  { widget: 'ref:dataset', control: (c) => c.querySelector('[role="combobox"]'), faceName: 'the dataset picker' },
   { widget: 'object-selector', control: (c) => c.querySelector('[role="combobox"]'), faceName: 'the object picker' },
   { widget: 'field-selector', control: (c) => c.querySelector('input'), faceName: 'the "select an object first" box' },
   { widget: 'field-ref', control: (c) => c.querySelector('[role="combobox"]'), faceName: 'the object-field picker' },
diff --git a/packages/app-shell/src/views/metadata-admin/SchemaForm.refDatasetWidget-11601.test.tsx b/packages/app-shell/src/views/metadata-admin/SchemaForm.refDatasetWidget-11601.test.tsx
new file mode 100644
index 0000000000..8d00abae01
--- /dev/null
+++ b/packages/app-shell/src/views/metadata-admin/SchemaForm.refDatasetWidget-11601.test.tsx
@@ -0,0 +1,205 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectui#11601 — a spec-form field that declares `widget: 'ref:dataset'`
+ * renders the dataset picker, and writes the dataset NAME.
+ *
+ * ## The defect
+ *
+ * `ref:dataset` is a declared hint — the spec's `reportForm` puts it on the
+ * report's top-level `dataset` — but `WIDGETS` had no entry for it, so
+ * `resolveFieldFace` sent it down the announced raw-JSON face: a JSON
+ * `<textarea>` under "widget ref:dataset — falling back to JSON…". A joined
+ * report's block row is about to declare the same hint (objectstack#21714),
+ * and without a renderer that row would turn from free text into a JSON box.
+ *
+ * ## What this file pins
+ *
+ *  - with a dataset catalog on the host's `WidgetContext`, the picker renders
+ *    and writes the picked dataset's name — in a SECTION, and in a REPEATER row
+ *    under both layouts (grid cell and card row);
+ *  - the options are `datasetPickerOptions`' author text (objectui#11161): the
+ *    label beside the name, the description after ` — `;
+ *  - with NO catalog — every host that does not feed one — the field degrades
+ *    to a labelled text input that still writes the name, ⛔ never the raw-JSON
+ *    face.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { SchemaForm } from './SchemaForm';
+import type { WidgetContext } from './widgets';
+import { loaded } from './loadState';
+import { tFormat } from './i18n';
+import type { DatasetCatalogEntry } from './previews/useDatasetCatalog';
+
+afterEach(cleanup);
+
+const CATALOG: DatasetCatalogEntry[] = [
+  {
+    name: 'sales_metrics',
+    label: 'Sales metrics',
+    description: 'Won and open deals by stage',
+    dimensions: [],
+    measures: [],
+  },
+  { name: 'support_load', label: 'support_load', dimensions: [], measures: [] },
+];
+
+/** The ONE text a select item renders for each catalog entry (objectui#11161). */
+const SALES_OPTION = 'Sales metrics (sales_metrics) — Won and open deals by stage';
+const SUPPORT_OPTION = 'support_load';
+
+const WITH_CATALOG: WidgetContext = { conditionScope: 'none', datasets: loaded(CATALOG) };
+
+/** The announced fallback the defect rendered in place of a picker. */
+const RAW_JSON_NOTICE = tFormat('engine.form.fallbackJson', 'en-US', { widget: 'ref:dataset' });
+
+type Layout = 'grid' | 'card';
+
+function sectionForm() {
+  return {
+    type: 'simple',
+    sections: [{ label: 'S', fields: [{ field: 'dataset', label: 'Dataset', widget: 'ref:dataset' }] }],
+  } as never;
+}
+
+function sectionSchema() {
+  return { type: 'object', properties: { dataset: { type: 'string' } } } as never;
+}
+
+/** A `blocks` repeater whose row declares the hint — the shape objectstack#21714 gives the joined-blocks row. */
+function repeaterForm(layout: Layout) {
+  return {
+    type: 'simple',
+    sections: [
+      {
+        label: 'S',
+        fields: [
+          {
+            field: 'blocks',
+            type: 'repeater',
+            ...(layout === 'grid' ? { widget: 'grid' } : {}),
+            fields: [
+              { field: 'name', label: 'Name' },
+              { field: 'dataset', label: 'Dataset', widget: 'ref:dataset', required: true },
+            ],
+          },
+        ],
+      },
+    ],
+  } as never;
+}
+
+function repeaterSchema() {
+  return {
+    type: 'object',
+    properties: {
+      blocks: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: { name: { type: 'string' }, dataset: { type: 'string' } },
+          required: ['name'],
+        },
+      },
+    },
+  } as never;
+}
+
+function renderSection(ctx: WidgetContext | undefined, value: Record<string, unknown> = {}) {
+  const onChange = vi.fn<(next: Record<string, unknown>) => void>();
+  render(
+    <SchemaForm schema={sectionSchema()} form={sectionForm()} value={value} widgetContext={ctx} onChange={onChange} />,
+  );
+  return onChange;
+}
+
+function renderRepeater(layout: Layout, ctx: WidgetContext | undefined) {
+  const onChange = vi.fn<(next: Record<string, unknown>) => void>();
+  render(
+    <SchemaForm
+      schema={repeaterSchema()}
+      form={repeaterForm(layout)}
+      value={{ blocks: [{ name: 'won_deals' }] }}
+      widgetContext={ctx}
+      onChange={onChange}
+    />,
+  );
+  // The card layout keeps a row collapsed until it is opened.
+  if (layout === 'card') fireEvent.click(screen.getByText(/#1/));
+  return onChange;
+}
+
+/** Open the picker named `name`, pick `option`, and hand back what the form wrote. */
+async function pick(name: string, option: string) {
+  await userEvent.click(screen.getByRole('combobox', { name }));
+  await userEvent.click(await screen.findByRole('option', { name: option }));
+}
+
+/** The defect's face, read positively so a picker that renders nothing cannot pass. */
+function expectNoRawJsonFace() {
+  expect(screen.queryByText(RAW_JSON_NOTICE), 'the announced raw-JSON fallback is on screen').toBeNull();
+  expect(document.querySelector('textarea'), 'a JSON textarea renders in place of the field').toBeNull();
+}
+
+describe('`ref:dataset` with a catalog — the dataset picker (objectui#11601)', () => {
+  it('a SECTION field renders the picker and writes the dataset name', async () => {
+    const onChange = renderSection(WITH_CATALOG);
+    expectNoRawJsonFace();
+    await pick('Dataset', SALES_OPTION);
+    expect(onChange).toHaveBeenLastCalledWith({ dataset: 'sales_metrics' });
+  });
+
+  it('offers the catalog as the author text: label beside name, description after the dash; a label equal to the name reads once', async () => {
+    renderSection(WITH_CATALOG);
+    await userEvent.click(screen.getByRole('combobox', { name: 'Dataset' }));
+    const options = (await screen.findAllByRole('option')).map((o) => o.textContent);
+    expect(options).toEqual([SALES_OPTION, SUPPORT_OPTION]);
+  });
+
+  for (const layout of ['grid', 'card'] as const) {
+    it(`a REPEATER row (${layout} layout) renders the picker and writes the dataset name into that row`, async () => {
+      const onChange = renderRepeater(layout, WITH_CATALOG);
+      expectNoRawJsonFace();
+      await pick('Dataset', SALES_OPTION);
+      expect(onChange).toHaveBeenLastCalledWith({ blocks: [{ name: 'won_deals', dataset: 'sales_metrics' }] });
+    });
+  }
+
+  it('a stored dataset the catalog does not offer stays visible, flagged — never blanked', () => {
+    renderSection(WITH_CATALOG, { dataset: 'retired_metrics' });
+    expect(screen.getByRole('combobox', { name: 'Dataset' })).toHaveTextContent('retired_metrics (not found)');
+  });
+});
+
+describe('`ref:dataset` with NO catalog — a labelled text input, ⛔ not the raw-JSON face (objectui#11601)', () => {
+  it('a SECTION field degrades to a text input named by its label, and writes the typed name', () => {
+    const onChange = renderSection(undefined, { dataset: 'sales_metrics' });
+    expectNoRawJsonFace();
+    const input = screen.getByRole('textbox', { name: 'Dataset' });
+    expect(input.tagName).toBe('INPUT');
+    expect(input).toHaveValue('sales_metrics');
+    fireEvent.change(input, { target: { value: 'support_load' } });
+    expect(onChange).toHaveBeenLastCalledWith({ dataset: 'support_load' });
+  });
+
+  it('a host that hands a WidgetContext without `datasets` gets the same degrade', () => {
+    renderSection({ conditionScope: 'none' }, { dataset: 'sales_metrics' });
+    expectNoRawJsonFace();
+    expect(screen.getByRole('textbox', { name: 'Dataset' })).toHaveValue('sales_metrics');
+  });
+
+  for (const layout of ['grid', 'card'] as const) {
+    it(`a REPEATER row (${layout} layout) degrades to a named text input and writes into that row`, () => {
+      const onChange = renderRepeater(layout, undefined);
+      expectNoRawJsonFace();
+      const input = screen.getByRole('textbox', { name: 'Dataset' });
+      expect(input.tagName).toBe('INPUT');
+      fireEvent.change(input, { target: { value: 'sales_metrics' } });
+      expect(onChange).toHaveBeenLastCalledWith({ blocks: [{ name: 'won_deals', dataset: 'sales_metrics' }] });
+    });
+  }
+});
diff --git a/packages/app-shell/src/views/metadata-admin/SchemaForm.widgetLabelling.test.tsx b/packages/app-shell/src/views/metadata-admin/SchemaForm.widgetLabelling.test.tsx
index 8456084329..579e9c236a 100644
--- a/packages/app-shell/src/views/metadata-admin/SchemaForm.widgetLabelling.test.tsx
+++ b/packages/app-shell/src/views/metadata-admin/SchemaForm.widgetLabelling.test.tsx
@@ -133,6 +133,9 @@ const CASES: Case[] = [
   { key: 'ref:object', variant: 'no-objects', schema: { type: 'string', title: TITLE }, ctx: {}, value: 'x' },
   { key: 'ref:component', schema: { type: 'string', title: TITLE }, ctx: { componentIds: [{ id: 'c1' }] }, value: 'c1' },
   { key: 'ref:component', variant: 'no-components', schema: { type: 'string', title: TITLE }, ctx: {}, value: 'c1' },
+  { key: 'ref:dataset', schema: { type: 'string', title: TITLE }, ctx: { datasets: loaded([{ name: 'sales_metrics', label: 'Sales metrics', dimensions: [], measures: [] }]) }, value: 'sales_metrics' },
+  // No `ctx` at all: the hosts that feed no catalog get the labelled text input (objectui#11601).
+  { key: 'ref:dataset', variant: 'no-catalog', schema: { type: 'string', title: TITLE }, value: 'sales_metrics' },
   { key: 'filter-mode', schema: { type: 'object', title: TITLE }, ctx: { objectFields: loaded([{ name: 'status' }]) }, value: { element: 'dropdown' } },
   { key: 'object-selector', schema: { type: 'string', title: TITLE }, ctx: { objectNames: loaded(['account']) }, value: 'account' },
   { key: 'object-selector', variant: 'multiple', schema: { type: 'array', title: TITLE }, spec: { multiple: true }, ctx: { objectNames: loaded(['account', 'contact']) }, value: ['account'] },
diff --git a/packages/app-shell/src/views/metadata-admin/__tests__/SchemaForm.controlWidgetFailureArmNaming-9931.test.tsx b/packages/app-shell/src/views/metadata-admin/__tests__/SchemaForm.controlWidgetFailureArmNaming-9931.test.tsx
index b8d8ff0ced..83a8efb97b 100644
--- a/packages/app-shell/src/views/metadata-admin/__tests__/SchemaForm.controlWidgetFailureArmNaming-9931.test.tsx
+++ b/packages/app-shell/src/views/metadata-admin/__tests__/SchemaForm.controlWidgetFailureArmNaming-9931.test.tsx
@@ -38,7 +38,8 @@
  *
  * ## The two keys that are ⛔ NOT subjects — rejected on the record
  *
- * Six of the declared `'control'` widgets have a catalog-failure arm at all;
+ * When this card landed, six of the declared `'control'` widgets had a
+ * catalog-failure arm at all (the `banner` column below is the live reading);
  * two of them already kept a named control on it before this card, and this
  * file asserts they still do rather than treating them as defects:
  *
@@ -104,6 +105,7 @@ const FAILED_CTX: WidgetContext = {
   objectFields: failed('fields: HTTP 503'),
   objectViews: failed('views: HTTP 503'),
   objectActions: failed('actions: HTTP 503'),
+  datasets: failed('datasets: HTTP 503'),
 };
 
 const LOADED_CTX: WidgetContext = {
@@ -112,6 +114,7 @@ const LOADED_CTX: WidgetContext = {
   objectFields: loaded([{ name: 'status', label: 'Status' }]),
   objectViews: loaded([{ name: 'account.all', label: 'All' }]),
   objectActions: loaded([{ name: 'approve' }]),
+  datasets: loaded([{ name: 'sales_metrics', label: 'Sales metrics', dimensions: [], measures: [] }]),
 };
 
 interface ControlCase {
@@ -136,6 +139,7 @@ interface ControlCase {
 const CASES: ControlCase[] = [
   { key: 'ref:object', schema: { type: 'string' }, value: 'account', banner: 'ref-object-load-failed' },
   { key: 'ref:component', schema: { type: 'string' }, value: 'c1', banner: null },
+  { key: 'ref:dataset', schema: { type: 'string' }, value: 'sales_metrics', banner: 'ref-dataset-load-failed' },
   {
     key: 'object-selector',
     schema: { type: 'array' },
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.blockDatasetPicker-11601.test.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.blockDatasetPicker-11601.test.tsx
new file mode 100644
index 0000000000..2bfdb4594d
--- /dev/null
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.blockDatasetPicker-11601.test.tsx
@@ -0,0 +1,134 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectui#11601 — the report inspector hands its dataset catalog to the spec
+ * form, so a joined report's block row that DECLARES `widget: 'ref:dataset'`
+ * offers the dataset picker and binds the block to a dataset name.
+ *
+ * ## Why the form is a fixture here
+ *
+ * The row spec is objectstack's (`reportForm`, the "Joined blocks" repeater),
+ * and it is the one authority for which control a block's `dataset` gets: this
+ * inspector does not override the row. The bundled `@objectstack/spec` row is
+ * still `{ field: 'dataset', label: 'Dataset' }` — free text — until
+ * objectstack#21714 declares the hint and objectstack's `.objectui-sha` pin
+ * carries this change. So the fixture below is the bundled form with exactly
+ * that declaration added, which is what this inspector will be handed then.
+ *
+ * ## What it pins
+ *
+ *  - the block row renders the picker over the inspector's catalog — the
+ *    author's text, as the top-level picker reads it (objectui#11161);
+ *  - picking writes the dataset NAME into that block, and nothing else moves.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { ReportDefaultInspector } from './ReportDefaultInspector';
+import type { DatasetCatalogEntry } from '../previews/useDatasetCatalog';
+
+type FormNode = { field?: unknown; fields?: unknown[] };
+type FormShape = { sections?: Array<{ fields?: unknown[] }> };
+
+/** The bundled `reportForm`, with the joined-blocks row's `dataset` declared the way objectstack#21714 declares it. */
+function declareBlockDatasetPicker<T>(form: T): T {
+  if (!form) return form;
+  let declared = 0;
+  const declare = (row: unknown): unknown => {
+    const node = row as FormNode;
+    if (typeof row !== 'object' || row === null || node.field !== 'dataset') return row;
+    declared += 1;
+    return { ...node, widget: 'ref:dataset', required: true };
+  };
+  const shape = form as unknown as FormShape;
+  const sections = shape.sections?.map((section) => ({
+    ...section,
+    fields: section.fields?.map((field) => {
+      const node = field as FormNode;
+      if (typeof field !== 'object' || field === null || node.field !== 'blocks' || !Array.isArray(node.fields)) {
+        return field;
+      }
+      return { ...node, fields: node.fields.map(declare) };
+    }),
+  }));
+  // A fixture that silently stopped declaring anything would turn every pin
+  // below into a reading of the free-text row.
+  if (declared !== 1) throw new Error(`expected one joined-blocks dataset row, declared ${declared}`);
+  return { ...shape, sections } as unknown as T;
+}
+
+vi.mock('../report-schema.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../report-schema.js')>();
+  return { ...actual, getReportForm: () => declareBlockDatasetPicker(actual.getReportForm()) };
+});
+
+afterEach(cleanup);
+
+// Same module-scope fetch double as `ReportDefaultInspector.test.tsx`
+// (objectui#7439 / #6640): `useDatasetSemantics` fires a read no test awaits.
+vi.stubGlobal(
+  'fetch',
+  vi.fn(async () => new Response('null', { status: 404, headers: { 'content-type': 'application/json' } })),
+);
+
+const catalog: DatasetCatalogEntry[] = [
+  {
+    name: 'sales_metrics',
+    label: 'Sales metrics',
+    description: 'Won and open deals by stage',
+    dimensions: [{ name: 'stage', type: 'text' }],
+    measures: [{ name: 'total_amount', aggregate: 'sum' }],
+  },
+  { name: 'support_load', label: 'Support load', dimensions: [], measures: [] },
+];
+
+const draft = {
+  name: 'multi',
+  label: 'Multi',
+  type: 'joined',
+  blocks: [{ name: 'won_deals' }],
+};
+
+function renderJoined() {
+  const onPatch = vi.fn<(patch: Record<string, unknown>) => void>();
+  render(
+    <ReportDefaultInspector
+      type="report"
+      name="multi"
+      locale="en-US"
+      onSelectionChange={vi.fn()}
+      datasetCatalogOverride={catalog}
+      draft={draft}
+      onPatch={onPatch}
+      readOnly={false}
+    />,
+  );
+  // The joined-blocks repeater is the card layout: open the one row.
+  fireEvent.click(screen.getByText(/#1/));
+  return onPatch;
+}
+
+describe('ReportDefaultInspector — a declared `ref:dataset` block row is the dataset picker (objectui#11601)', () => {
+  it('offers the inspector catalog in the block row, as the author text', async () => {
+    renderJoined();
+    await userEvent.click(screen.getByRole('combobox', { name: 'Dataset' }));
+    const options = (await screen.findAllByRole('option')).map((o) => o.textContent);
+    expect(options).toEqual([
+      'Sales metrics (sales_metrics) — Won and open deals by stage',
+      'Support load (support_load)',
+    ]);
+  });
+
+  it('picking a dataset binds THAT block to the dataset name, and nothing else moves', async () => {
+    const onPatch = renderJoined();
+    await userEvent.click(screen.getByRole('combobox', { name: 'Dataset' }));
+    await userEvent.click(await screen.findByRole('option', { name: 'Support load (support_load)' }));
+    expect(onPatch).toHaveBeenCalledTimes(1);
+    expect(onPatch.mock.calls[0][0]).toStrictEqual({
+      ...draft,
+      blocks: [{ name: 'won_deals', dataset: 'support_load' }],
+    });
+  });
+});
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.tsx
index c016731ae5..8a6b57240b 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/ReportDefaultInspector.tsx
@@ -54,6 +54,9 @@ import {
 import { getReportForm, getReportSchema } from '../report-schema.js';
 import { mergeServerFields } from '../mergeServerFields.js';
 import { t } from '../i18n.js';
+import { mapLoaded } from '../loadState.js';
+import type { WidgetContext } from '../widgets.js';
+import { labelBesideName, datasetPickerOptions, datasetSelectOptions } from './dataset-picker-options.js';
 import { pickLocalized, setLocalized, clearLocalized } from '@object-ui/i18n';
 
 /**
@@ -174,12 +177,14 @@ function readNames(value: unknown): string[] {
  * `InspectorComboField` renders as a muted suffix; a text-only item appends it
  * after ` — ` (the objectui#11028 form). An option's VALUE is always the
  * machine name — the label never reaches what a binding stores.
+ *
+ * The dataset options themselves (`datasetPickerOptions`, `labelBesideName`)
+ * live in `./dataset-picker-options.ts` since objectui#11601, so the spec-form
+ * `ref:dataset` widget offers them too without importing this inspector.
+ * `datasetPickerOptions` stays exported from here for the inspectors that
+ * already import it from this module.
  */
-
-/** `LABEL (name)`, or the bare name when no label is declared or it repeats the name. */
-function labelBesideName(name: string, label: string | undefined): string {
-  return label && label !== name ? `${label} (${name})` : name;
-}
+export { datasetPickerOptions };
 
 /** A measure's aggregate hint, appended where the options have always shown it. */
 function withAggregate(text: string, aggregate: string | undefined): string {
@@ -206,17 +211,6 @@ export function datasetDimensionOptions(dimensions: DatasetDimensionInfo[]): Obj
   }));
 }
 
-/** The catalog as dataset-picker options: `LABEL (name)`, the description as `hint`. */
-export function datasetPickerOptions(
-  datasets: DatasetCatalogEntry[],
-): Array<{ value: string; label: string; hint?: string }> {
-  return datasets.map((d) => ({
-    value: d.name,
-    label: labelBesideName(d.name, d.label),
-    ...(d.description ? { hint: d.description } : {}),
-  }));
-}
-
 /**
  * A reorderable list of dataset member names (the report's `values` or
  * `rows`) with an add-popover fed by the bound dataset's catalog. Exported so
@@ -362,14 +356,32 @@ export function ReportDefaultInspector({
   // objectui#11161 — a select item renders text only, so a declared
   // description follows the label after ` — `.
   const datasetOptions = React.useMemo(
-    () =>
-      datasetPickerOptions(catalog.datasets).map((o) => ({
-        value: o.value,
-        label: o.hint ? `${o.label} — ${o.hint}` : o.label,
-      })),
+    () => datasetSelectOptions(catalog.datasets),
     [catalog.datasets],
   );
 
+  // objectui#11601 — the SAME catalog, handed to the spec form below, so a row
+  // that declares `widget: 'ref:dataset'` (a joined report's block row, once
+  // objectstack#21714 declares it) renders the dataset picker. The row spec is
+  // the one authority for which control a block's `dataset` gets; this host
+  // only supplies the catalog the widget reads. `rosterFrom` carries the
+  // hook's loading and error into the widget's `LoadState`, failure first.
+  //
+  // `conditionScope` is required on every `WidgetContext`: `none` is this
+  // surface's ruled verdict (`report` in `CONDITION_SCOPE_BY_METADATA_TYPE`),
+  // and the bundled `ReportSchema` carries no predicate-named key the
+  // condition detector would match, so it changes no field this form renders.
+  const widgetContext = React.useMemo<WidgetContext>(
+    () => ({
+      conditionScope: 'none',
+      datasets: mapLoaded(
+        rosterFrom({ loading: catalog.loading, error: catalog.error }),
+        () => catalog.datasets,
+      ),
+    }),
+    [catalog.datasets, catalog.loading, catalog.error],
+  );
+
   const measureOptions: ObjectFieldInfo[] = React.useMemo(
     () => datasetMeasureOptions(semantics.measures),
     [semantics.measures],
@@ -637,6 +649,7 @@ export function ReportDefaultInspector({
             value={draft}
             hiddenFields={['type', 'label', 'name', 'dataset', 'values', 'rows', 'columns', 'chart']}
             readOnly={readOnly}
+            widgetContext={widgetContext}
             onChange={(next) => onPatch(next)}
           />
         ) : (
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/dataset-picker-options.ts b/packages/app-shell/src/views/metadata-admin/inspectors/dataset-picker-options.ts
new file mode 100644
index 0000000000..6b49e82ed6
--- /dev/null
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/dataset-picker-options.ts
@@ -0,0 +1,46 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * The dataset catalog as picker options — the ONE place every dataset picker
+ * reads the author's text from (objectui#11161).
+ *
+ * Moved out of `ReportDefaultInspector.tsx` for objectui#11601, unchanged: the
+ * spec-form `ref:dataset` widget in `widgets.tsx` offers the same options, and
+ * importing them from the inspector would close a cycle (the inspector renders
+ * `SchemaForm`, which imports the widget registry). Pure functions, no React,
+ * so both the inspectors and the widget registry can import this module.
+ *
+ * An option's VALUE is always the dataset's machine name: the label and the
+ * description are display only, and never reach what a binding stores.
+ */
+
+import type { DatasetCatalogEntry } from '../previews/useDatasetCatalog.js';
+
+/** `LABEL (name)`, or the bare name when no label is declared or it repeats the name. */
+export function labelBesideName(name: string, label: string | undefined): string {
+  return label && label !== name ? `${label} (${name})` : name;
+}
+
+/** The catalog as dataset-picker options: `LABEL (name)`, the description as `hint`. */
+export function datasetPickerOptions(
+  datasets: DatasetCatalogEntry[],
+): Array<{ value: string; label: string; hint?: string }> {
+  return datasets.map((d) => ({
+    value: d.name,
+    label: labelBesideName(d.name, d.label),
+    ...(d.description ? { hint: d.description } : {}),
+  }));
+}
+
+/**
+ * The same options for a slot that renders TEXT ONLY — a select item: a
+ * declared description follows the label after ` — ` (the objectui#11028 form).
+ */
+export function datasetSelectOptions(
+  datasets: DatasetCatalogEntry[],
+): Array<{ value: string; label: string }> {
+  return datasetPickerOptions(datasets).map((o) => ({
+    value: o.value,
+    label: o.hint ? `${o.label} — ${o.hint}` : o.label,
+  }));
+}
diff --git a/packages/app-shell/src/views/metadata-admin/widgets.tsx b/packages/app-shell/src/views/metadata-admin/widgets.tsx
index 4cce2e379a..fbfd4a2d90 100644
--- a/packages/app-shell/src/views/metadata-admin/widgets.tsx
+++ b/packages/app-shell/src/views/metadata-admin/widgets.tsx
@@ -56,6 +56,8 @@ import type { ConditionScope } from './conditionScope.js';
 import { ConditionBuilder } from './inspectors/ConditionBuilder.js';
 import { expressionSource, writeExpressionSource } from './inspectors/expression-envelope.js';
 import { humanizeKey } from './inspectors/json-schema-to-fields.js';
+import { datasetSelectOptions } from './inspectors/dataset-picker-options.js';
+import type { DatasetCatalogEntry } from './previews/useDatasetCatalog.js';
 import {
   type LoadState,
   isLoading,
@@ -244,6 +246,20 @@ export interface WidgetContext {
    * free-text id the author can typo.
    */
   componentIds?: Array<{ id: string; type?: string; label?: string }>;
+  /**
+   * The analytics dataset catalog (objectui#11601). Drives the `ref:dataset`
+   * picker, so a spec-form field that declares that hint — a joined report's
+   * block `dataset` — is chosen from the real datasets, with the author's
+   * label and description beside each name, instead of a free-text name the
+   * author can typo. The value the picker writes is the dataset's name.
+   *
+   * The report inspector feeds the same `useDatasetCatalog` result its own
+   * top-level dataset picker reads. A host that never fetches the catalog
+   * omits this member; absence is {@link NOT_ASKED}, and the widget then
+   * renders a labelled text input, as it does for a completed load that found
+   * no datasets.
+   */
+  datasets?: LoadState<DatasetCatalogEntry[]>;
 }
 
 /* Stable empties for the arms that have no catalog to offer yet — `idle` and
@@ -254,6 +270,7 @@ const NO_OBJECT_NAMES: string[] = [];
 const NO_OBJECT_FIELDS: ObjectFieldOption[] = [];
 const NO_OBJECT_VIEWS: ObjectViewOption[] = [];
 const NO_OBJECT_ACTIONS: ObjectActionOption[] = [];
+const NO_DATASETS: DatasetCatalogEntry[] = [];
 
 export interface WidgetProps {
   /**
@@ -639,6 +656,87 @@ function RefComponentWidget({ id, ariaLabelledBy, required, value, onChange, rea
   );
 }
 
+/* -------------------------------------------------------------------------- */
+/* ref:dataset — pick an analytics dataset by name                            */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Single dataset picker for a field that declares `widget: 'ref:dataset'`
+ * (objectui#11601) — a report's `dataset`, and a joined report's block
+ * `dataset` once its row declares the hint. The datasets come from
+ * `context.datasets`; each option reads the author's label beside the name and
+ * the description after it (`datasetSelectOptions`, objectui#11161), and the
+ * value written is the dataset's NAME.
+ *
+ * The four arms of the catalog, as {@link RefObjectWidget} reads them:
+ *
+ *  - FAILED — the shared failure notice beside a freeform box that stays
+ *    enabled, so a failed catalog does not also block authoring (objectui#5170);
+ *  - LOADING — the stored name in a disabled box;
+ *  - `idle` (no host feeds a catalog) or a completed load with no datasets — a
+ *    labelled text input that writes the typed name. ⛔ Never the raw-JSON
+ *    face an unregistered hint falls back to;
+ *  - LOADED — the picker. A stored name the catalog does not offer is kept as
+ *    its own option, flagged `(not found)`, so it neither blanks the trigger
+ *    nor reads like an offered dataset (objectui#8488).
+ */
+function RefDatasetWidget({ id, ariaLabelledBy, required, value, onChange, readOnly, context }: WidgetProps) {
+  const locale = useMetadataLocale();
+  const datasetsState = context?.datasets ?? NOT_ASKED;
+  const current = value == null ? '' : String(value);
+  const freeform = (
+    <Input
+      {...controlNaming({ id, ariaLabelledBy, required })}
+      value={current}
+      disabled={readOnly}
+      onChange={(e) => onChange(e.target.value || undefined)}
+    />
+  );
+  if (datasetsState.status === 'error') {
+    return (
+      <div className="space-y-1.5">
+        <PickerLoadFailure message={datasetsState.message} testId="ref-dataset-load-failed" />
+        {freeform}
+      </div>
+    );
+  }
+  if (isLoading(datasetsState)) {
+    return (
+      <Input
+        {...controlNaming({ id, ariaLabelledBy, required })}
+        value={current}
+        disabled
+        placeholder={t('engine.form.loadingOptions', locale)}
+      />
+    );
+  }
+  const options = datasetSelectOptions(offeredOptions(datasetsState, NO_DATASETS));
+  if (options.length === 0) return freeform;
+  const offered = !current || options.some((o) => o.value === current);
+  return (
+    <Select value={current} onValueChange={(next) => onChange(next || undefined)} disabled={readOnly}>
+      <SelectTrigger {...controlNaming({ id, ariaLabelledBy, required })}>
+        <SelectValue placeholder={t('engine.form.selectEllipsis', locale)} />
+      </SelectTrigger>
+      <SelectContent>
+        {!offered && (
+          <SelectItem value={current}>
+            {tFormat('engine.form.flaggedValue', locale, {
+              value: current,
+              flag: t('engine.form.notFound', locale),
+            })}
+          </SelectItem>
+        )}
+        {options.map((o) => (
+          <SelectItem key={o.value} value={o.value}>
+            {o.label}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
 /* -------------------------------------------------------------------------- */
 /* object-selector — multi-select object picker                               */
 /* -------------------------------------------------------------------------- */
@@ -2934,6 +3032,7 @@ function DynamicConfigWidget({ value, onChange, readOnly, fieldSpec, formData, c
 export const WIDGETS = {
   'ref:object': RefObjectWidget,
   'ref:component': RefComponentWidget,
+  'ref:dataset': RefDatasetWidget,
   'filter-mode': FilterModeWidget,
   'object-selector': ObjectSelectorWidget,
   'field-selector': FieldSelectorWidget,
@@ -3042,6 +3141,7 @@ export type WidgetLabelling = Exclude<NonNullable<ComponentMeta['labelling']>, '
 export const WIDGET_LABELLING: Record<RegisteredWidgetKey, WidgetLabelling> = {
   'ref:object': 'control',
   'ref:component': 'control',
+  'ref:dataset': 'control',
   'filter-mode': 'group',
   'object-selector': 'control',
   'field-selector': 'control',