@@ -0,0 +1,13 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/i18n': patch
+---
+
+fix(app-shell): Setup → Datasources names the objects that still use a datasource, in the console's language, before and after its delete
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+- **The confirm.** Opening a datasource's delete reads object metadata and lists every object whose `datasource` names it (label, with the name beside it when they differ). While any is listed, the confirm says the datasource cannot be deleted yet and that each object must be deleted or moved to another datasource first. With none, or when the read fails, the confirm is unchanged.
+- **The refusal.** A `400` from `DELETE /api/v1/datasources/:name` re-reads that list. When objects still name the datasource, the toast says, in the console's language, that it was not deleted, which objects still use it, and what to do next. Any other failure, and a `400` with no bound object, keep the server's message in the existing frame. No server text is matched.
+- **The widening.** Three new `studio` namespace rows in `@object-ui/i18n` (en and zh): `engine.datasource.deleteBoundBody`, `engine.datasource.deleteBoundRefused` and `engine.datasource.boundObjectSeparator`.
@@ -11,6 +11,11 @@
  *  - (b) CONTROL: Cancel sends no `DELETE`.
  *  - (c) a row with no label is named by its name.
  *  - every case: `window.confirm` is never called.
+ *
+ * The objects that still use the datasource (the second describe): the confirm
+ * lists the objects whose metadata names it, and a `400` refusal is reported in
+ * the console's language, naming those objects and what to do. Expectations are
+ * read from Studio's table, never retyped; no case matches the server's English.
  */
 
 import * as React from 'react';
@@ -36,8 +41,15 @@ vi.mock('sonner', () => ({
   toast: { success: vi.fn(), error: vi.fn(), warning: vi.fn(), info: vi.fn(), message: vi.fn() },
 }));
 
+import { toast } from 'sonner';
+import { t, tFormat } from '../i18n';
 import { DatasourceResourcePage } from './DatasourceResourcePage';
 
+// The zh rows read below live in the lazily fetched `studio` namespace; resident
+// before any case, so they read synchronously.
+import { loadStudioCatalogue } from '@object-ui/i18n/namespaces/studio';
+await loadStudioCatalogue('zh');
+
 const nativeConfirm = vi.fn(() => true);
 beforeEach(() => {
   nativeConfirm.mockClear();
@@ -104,3 +116,107 @@ describe('DatasourceResourcePage — the delete confirm is in-app and names the
     expect(within(dialog).getByRole('heading').textContent).toBe('Delete datasource "warehouse"?');
   });
 });
+
+const OBJECTS = [
+  { name: 'part', label: 'Part', datasource: 'parts_db' },
+  { name: 'supplier', label: '供应商', datasource: 'parts_db' },
+  { name: 'stock_level', datasource: 'parts_db' },
+  { name: 'account', label: 'Account', datasource: 'default' },
+];
+/** The server's own refusal text: what the page shows when it cannot name the objects. */
+const SERVER_REFUSAL = "Cannot remove datasource 'parts_db': 3 object(s) are still bound to it.";
+
+function renderBound(
+  language: string,
+  { objects = OBJECTS, deleteStatus = 400 }: { objects?: unknown[]; deleteStatus?: number } = {},
+) {
+  const deletes: string[] = [];
+  state.metadataClient = { list: async (type: string) => (type === 'object' ? objects : []) };
+  state.fetch = (async (url: string, init?: RequestInit) => {
+    const method = init?.method ?? 'GET';
+    if (url === '/api/v1/datasources' && method === 'GET') {
+      return ok({ datasources: [{ ...BASE, name: 'parts_db', label: 'Parts DB' }] });
+    }
+    if (method === 'DELETE') {
+      deletes.push(url);
+      return reply(deleteStatus, { success: false, error: { code: 'DATASOURCE_ADMIN_ERROR', message: SERVER_REFUSAL } });
+    }
+    return reply(404, { success: false, error: { message: `unexpected ${method} ${url}` } });
+  }) as typeof state.fetch;
+  render(
+    <I18nProvider config={{ defaultLanguage: language, detectBrowserLanguage: false }}>
+      <DatasourceResourcePage />
+    </I18nProvider>,
+  );
+  return deletes;
+}
+
+async function openConfirm(deleteTitle: string) {
+  fireEvent.click(await screen.findByTitle(deleteTitle));
+  return screen.findByRole('alertdialog');
+}
+
+describe('DatasourceResourcePage — the objects that still use a datasource are named before and after its delete', () => {
+  afterEach(() => {
+    state.metadataClient = {};
+    vi.mocked(toast.error).mockClear();
+  });
+
+  it('guard: the zh rows the cases read are real zh rows', () => {
+    for (const key of ['engine.datasource.deleteBoundBody', 'engine.datasource.deleteBoundRefused']) {
+      expect(t(key, 'zh-CN')).not.toBe(t(key, 'en-US'));
+      expect(t(key, 'zh-CN')).toMatch(/\p{Script=Han}/u);
+    }
+  });
+
+  it('the confirm lists the objects bound to this datasource, and no other datasource\'s', async () => {
+    renderBound('zh');
+    const dialog = await openConfirm(t('engine.datasource.delete', 'zh-CN'));
+    const list = await within(dialog).findByTestId('datasource-delete-bound');
+    expect(within(list).getAllByRole('listitem').map((li) => li.textContent)).toEqual([
+      'Part (part)',
+      '供应商 (supplier)',
+      'stock_level',
+    ]);
+    expect(dialog.textContent).toContain(tFormat('engine.datasource.deleteBoundBody', 'zh-CN', { name: 'parts_db' }));
+    expect(dialog.textContent).not.toContain(tFormat('engine.datasource.deleteBody', 'zh-CN', { name: 'parts_db' }));
+  });
+
+  it('a 400 refusal is reported in zh, naming the objects, never in the server\'s English', async () => {
+    const deletes = renderBound('zh');
+    const dialog = await openConfirm(t('engine.datasource.delete', 'zh-CN'));
+    await within(dialog).findByTestId('datasource-delete-bound');
+    fireEvent.click(within(dialog).getByTestId('datasource-delete-confirm'));
+    await waitFor(() => expect(toast.error).toHaveBeenCalledTimes(1));
+    expect(deletes).toEqual(['/api/v1/datasources/parts_db']);
+    expect(vi.mocked(toast.error).mock.calls[0][0]).toBe(
+      tFormat('engine.datasource.deleteBoundRefused', 'zh-CN', {
+        name: 'parts_db',
+        objects: ['Part (part)', '供应商 (supplier)', 'stock_level'].join(t('engine.datasource.boundObjectSeparator', 'zh-CN')),
+      }),
+    );
+  });
+
+  it('CONTROL: with no bound object the confirm keeps its plain body, and a 400 keeps the server\'s message', async () => {
+    renderBound('en', { objects: [{ name: 'account', datasource: 'default' }] });
+    const dialog = await openConfirm('Delete');
+    expect(dialog.textContent).toContain(tFormat('engine.datasource.deleteBody', 'en-US', { name: 'parts_db' }));
+    expect(within(dialog).queryByTestId('datasource-delete-bound')).toBeNull();
+    fireEvent.click(within(dialog).getByTestId('datasource-delete-confirm'));
+    await waitFor(() => expect(toast.error).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(toast.error).mock.calls[0][0]).toBe(
+      tFormat('engine.datasource.deleteFailed', 'en-US', { name: 'parts_db', error: SERVER_REFUSAL }),
+    );
+  });
+
+  it('CONTROL: a failure that is not a 400 keeps the server\'s message even while objects are bound', async () => {
+    renderBound('en', { deleteStatus: 503 });
+    const dialog = await openConfirm('Delete');
+    await within(dialog).findByTestId('datasource-delete-bound');
+    fireEvent.click(within(dialog).getByTestId('datasource-delete-confirm'));
+    await waitFor(() => expect(toast.error).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(toast.error).mock.calls[0][0]).toBe(
+      tFormat('engine.datasource.deleteFailed', 'en-US', { name: 'parts_db', error: SERVER_REFUSAL }),
+    );
+  });
+});
@@ -34,7 +34,9 @@
  *    Offered only on a federation source (`offersSync`, objectui#13318).
  *  - **Delete** a runtime datasource (`DELETE …/:name`; blocked by the backend
  *    while objects are still bound), confirmed in an in-app AlertDialog that
- *    names the datasource by its label and name (objectui#13333).
+ *    names the datasource by its label and name (objectui#13333). The confirm
+ *    lists the objects whose metadata names the datasource, and a refused
+ *    delete names them in the console's language, with what to do next.
  *
  * Code-defined (`origin: 'code'`) datasources are read-only: edit/delete are
  * hidden for them.
@@ -125,6 +127,15 @@ interface DatasourceRow {
   active?: boolean;
 }
 
+/** An object whose metadata names this datasource as its `datasource`. */
+interface BoundObject {
+  name: string;
+  label?: string;
+}
+
+/** A refused request: the envelope's message, with the HTTP status and the envelope's `code` beside it. */
+type DatasourceRequestError = Error & { status?: number; code?: string };
+
 /**
  * Status chip per verdict. `unvalidated` stays visually quiet — it means
  * "nothing is known", not "something is wrong" — while `error`/`blocked` carry
@@ -251,6 +262,11 @@ export function DatasourceResourcePage(_props: { type?: string }): React.ReactEl
   const [busy, setBusy] = React.useState<string | null>(null);
   // objectui#13333 — the row whose delete is being confirmed (in-app dialog).
   const [confirmDelete, setConfirmDelete] = React.useState<DatasourceRow | null>(null);
+  /**
+   * The objects bound to the datasource whose delete is being confirmed, keyed
+   * by its name so an answer for an earlier row is never drawn under a later one.
+   */
+  const [bound, setBound] = React.useState<{ datasource: string; objects: BoundObject[] } | null>(null);
 
   /**
    * Fetch + unwrap the declared response envelope.
@@ -283,7 +299,8 @@ export function DatasourceResourcePage(_props: { type?: string }): React.ReactEl
           (body && typeof body.error === 'string' ? body.error : undefined) ||
           (body && body.message) ||
           `HTTP ${res.status}`;
-        throw new Error(detail);
+        const code = body && typeof body.error === 'object' && typeof body.error?.code === 'string' ? body.error.code : undefined;
+        throw Object.assign(new Error(detail), { status: res.status, code }) as DatasourceRequestError;
       }
       return body && typeof body.success === 'boolean' && 'data' in body ? body.data : body;
     },
@@ -322,14 +339,47 @@ export function DatasourceResourcePage(_props: { type?: string }): React.ReactEl
     }
   };
 
+  /**
+   * The objects whose metadata names `datasource` as theirs: the same test the
+   * server's delete guard counts by (`object.datasource === name`).
+   */
+  const readBoundObjects = async (datasource: string): Promise<BoundObject[]> => {
+    const objects = await metaClient.list<{ name?: unknown; label?: unknown; datasource?: unknown }>('object');
+    return objects
+      .filter((o) => o?.datasource === datasource && typeof o.name === 'string')
+      .map((o) => ({ name: o.name as string, ...(typeof o.label === 'string' && o.label ? { label: o.label } : {}) }));
+  };
+
+  /** Each object by its label, with its name beside it when the two differ. */
+  const boundObjectText = (o: BoundObject) => (o.label && o.label !== o.name ? `${o.label} (${o.name})` : o.name);
+
+  const openDeleteConfirm = (row: DatasourceRow) => {
+    setConfirmDelete(row);
+    setBound(null);
+    // A failed read leaves the confirm as it was: the server still judges the delete.
+    readBoundObjects(row.name).then(
+      (objects) => setBound({ datasource: row.name, objects }),
+      () => undefined,
+    );
+  };
+
   const remove = async (name: string) => {
     setBusy(`del:${name}`);
     try {
       await api(`/api/v1/datasources/${encodeURIComponent(name)}`, { method: 'DELETE' });
       toast.success(tFormat('engine.datasource.deleted', locale, { name }));
       void load();
     } catch (err) {
-      toast.error(tFormat('engine.datasource.deleteFailed', locale, { name, error: (err as Error).message }));
+      // A 400 on a datasource that objects still name is the server's
+      // bound-object refusal: read the objects now and name them in the
+      // console's language. Any other failure keeps the server's own message.
+      const objects = (err as DatasourceRequestError).status === 400 ? await readBoundObjects(name).catch(() => []) : [];
+      if (objects.length) {
+        const list = objects.map(boundObjectText).join(t('engine.datasource.boundObjectSeparator', locale));
+        toast.error(tFormat('engine.datasource.deleteBoundRefused', locale, { name, objects: list }));
+      } else {
+        toast.error(tFormat('engine.datasource.deleteFailed', locale, { name, error: (err as Error).message }));
+      }
     } finally {
       setBusy(null);
     }
@@ -619,6 +669,8 @@ export function DatasourceResourcePage(_props: { type?: string }): React.ReactEl
     );
   };
 
+  const confirmBound = confirmDelete && bound?.datasource === confirmDelete.name ? bound.objects : [];
+
   return (
     <div className="mx-auto max-w-4xl px-6 py-8">
       <div className="mb-6 flex items-center justify-between">
@@ -686,7 +738,7 @@ export function DatasourceResourcePage(_props: { type?: string }): React.ReactEl
                     <Button variant="ghost" size="icon" className="h-8 w-8" title={t('engine.datasource.edit', locale)} disabled={busy === `edit:${ds.name}`} onClick={() => void openEdit(ds)}>
                       {busy === `edit:${ds.name}` ? <Loader2 className="h-4 w-4 animate-spin" /> : <Pencil className="h-4 w-4" />}
                     </Button>
-                    <Button variant="ghost" size="icon" className="h-8 w-8 text-destructive hover:text-destructive" title={t('engine.datasource.delete', locale)} disabled={busy === `del:${ds.name}`} onClick={() => setConfirmDelete(ds)}>
+                    <Button variant="ghost" size="icon" className="h-8 w-8 text-destructive hover:text-destructive" title={t('engine.datasource.delete', locale)} disabled={busy === `del:${ds.name}`} onClick={() => openDeleteConfirm(ds)}>
                       {busy === `del:${ds.name}` ? <Loader2 className="h-4 w-4 animate-spin" /> : <Trash2 className="h-4 w-4" />}
                     </Button>
                   </>
@@ -823,17 +875,25 @@ export function DatasourceResourcePage(_props: { type?: string }): React.ReactEl
         </DialogContent>
       </Dialog>
 
-      {/* Delete a datasource — names it by label and name (objectui#13333). */}
+      {/* Delete a datasource — names it by label and name (objectui#13333), and
+          lists the objects that still use it, which the server refuses the delete for. */}
       <AlertDialog open={confirmDelete !== null} onOpenChange={(o) => { if (!o) setConfirmDelete(null); }}>
         <AlertDialogContent data-testid="datasource-delete-dialog">
           <AlertDialogHeader>
             <AlertDialogTitle>
               {confirmDelete && tFormat('engine.datasource.deleteTitle', locale, { item: confirmDelete.label || confirmDelete.name })}
             </AlertDialogTitle>
             <AlertDialogDescription>
-              {confirmDelete && tFormat('engine.datasource.deleteBody', locale, { name: confirmDelete.name })}
+              {confirmDelete && (confirmBound.length
+                ? tFormat('engine.datasource.deleteBoundBody', locale, { name: confirmDelete.name })
+                : tFormat('engine.datasource.deleteBody', locale, { name: confirmDelete.name }))}
             </AlertDialogDescription>
           </AlertDialogHeader>
+          {confirmBound.length > 0 && (
+            <ul data-testid="datasource-delete-bound" className="max-h-48 list-disc space-y-0.5 overflow-y-auto pl-5 text-sm">
+              {confirmBound.map((o) => <li key={o.name}>{boundObjectText(o)}</li>)}
+            </ul>
+          )}
           <AlertDialogFooter>
             <AlertDialogCancel data-testid="datasource-delete-cancel">{t('engine.cancel', locale)}</AlertDialogCancel>
             <AlertDialogAction
 
@@ -1980,6 +1980,11 @@ const STUDIO_EN: Record<string, string> = {
   'engine.datasource.deleteTitle': 'Delete datasource "{item}"?',
   'engine.datasource.deleteBody': 'The connection {name} is removed. This cannot be undone.',
   'engine.datasource.delete': 'Delete',
+  // The objects bound to a datasource, read from object metadata (each object's
+  // `datasource`): the delete confirm lists them, and a refused delete names them.
+  'engine.datasource.deleteBoundBody': 'These objects still use {name}, so it cannot be deleted yet. Delete each object or move it to another datasource first:',
+  'engine.datasource.deleteBoundRefused': '{name} was not deleted: {objects} still use it. Delete these objects or move them to another datasource, then delete {name} again.',
+  'engine.datasource.boundObjectSeparator': ', ',
   // objectui#13460 — the datasource page's own copy. Author data (names, driver
   // labels and descriptions, server messages) and the driver config schema's enum
   // option values (objectui#13353) are not rows here.
 
@@ -1791,6 +1791,9 @@ const STUDIO_ZH: Record<string, string> = {
   'engine.datasource.deleteTitle': '删除数据源“{item}”？',
   'engine.datasource.deleteBody': '连接 {name} 将被移除。此操作不可撤销。',
   'engine.datasource.delete': '删除',
+  'engine.datasource.deleteBoundBody': '以下对象仍在使用 {name}，暂时无法删除。请先删除这些对象，或把它们改到其他数据源：',
+  'engine.datasource.deleteBoundRefused': '未删除 {name}：{objects} 仍在使用它。请先删除这些对象或把它们改到其他数据源，再删除 {name}。',
+  'engine.datasource.boundObjectSeparator': '、',
   'engine.datasource.title': '数据源',
   'engine.datasource.subtitle': '连接外部数据库，并将其中的表同步为对象。',
   'engine.datasource.refresh': '刷新',