diff --git a/.changeset/inspector-combo-field-label-3997.md b/.changeset/inspector-combo-field-label-3997.md
new file mode 100644
index 000000000..a50a70cdc
--- /dev/null
+++ b/.changeset/inspector-combo-field-label-3997.md
@@ -0,0 +1,19 @@
+---
+'@object-ui/app-shell': patch
+---
+
+Name the `InspectorComboField` trigger: the visible label now owns it, and an anonymous combo no longer compiles (objectui#3997).
+
+This is the fourth inspector field atom with the shape PR #3996 fixed for the three in `_shared.tsx` — a `Label` rendered as a plain sibling of the control, with no `htmlFor`, no `id` and no `aria-label`. It lives in its own module, so it stayed broken after the other three were closed. The label and the `button[role=combobox]` were adjacent only visually: assistive tech announced an anonymous combobox with the field name floating above it as unowned text, `getByLabelText` could not reach it, and clicking the visible label did nothing. It renders at eighteen call sites across the object-field, dataset, dashboard-widget, app-nav and view-variant inspectors (lookup display/description fields, `lookupFilters` rows, summary aggregates, dataset dimensions and measures, nav targets), so it is on screen the moment any of those panels opens.
+
+The labelled branch closes the pair the same way the other atoms do: `React.useId()` mints the id inside the atom, `Label` gets the `htmlFor`, and the id lands on the trigger `Button` that `PopoverTrigger asChild` renders. Never on `Popover` — Radix's `Popover.Root` is a context provider that renders no DOM element, so an id handed to it is dropped silently and the `for` dangles, which is the objectui#3976 / #3994 mistake this repo has now paid for twice.
+
+`label` was optional, and the un-labelled branch was the same defect one notch worse: a combobox with no name at all. Five of the eighteen call sites had authored exactly that. Rather than adding a lenient fallback (synthesising a name from the placeholder would have produced "Select…" as the announced name), naming became a type-level requirement of exactly one of three channels:
+
+- `label` — the atom renders the visible label and owns the association. Unchanged for the thirteen call sites that already passed one.
+- `ariaLabel` — for repeated rows where no visible label exists and one would break the grid: an app-nav URL filter's `field = value` pair, a dataset's list of joined relationships, the dependent-lookup "add a field" picker.
+- `id` — for when an external `Label htmlFor` already owns the naming. `DashboardWidgetInspector` wraps its controls in a `Field` that renders `Label htmlFor={id}` and hands the same id to the control; every other field honoured it (`Input id`, `SelectTrigger id`) but the dataset combo could not, because the atom accepted no id. That `for` pointed at an id nothing carried — a dangling IDREF, worse than an unnamed control, because tooling reports an association that resolves to nothing.
+
+Zero channels and two channels are now both unauthorable: zero is anonymous, and two is the double-announcement failure objectui#3961/#3978 exists to avoid. Neither has a runtime symptom the component could detect and report — an unnamed combobox renders, lays out and commits values perfectly, and is wrong only for the users who cannot see it — so the check is compile-time or nothing. It is pinned in `InspectorComboField.naming.types.test.tsx`, listed in `tsconfig.typetests.json` so a compiler actually reads it.
+
+One new pair of strings (`engine.inspector.widget.filterBindingField`, en-US + zh-CN) names the per-filter binding combo in the dashboard widget inspector, which sits under a heading that captions its whole row rather than the combo alone.
diff --git a/packages/app-shell/src/views/metadata-admin/i18n.ts b/packages/app-shell/src/views/metadata-admin/i18n.ts
index b5d638426..00ed90875 100644
--- a/packages/app-shell/src/views/metadata-admin/i18n.ts
+++ b/packages/app-shell/src/views/metadata-admin/i18n.ts
@@ -328,6 +328,7 @@ const ENGINE_STRINGS_EN: Record<string, string> = {
     'Map each dashboard-level filter to one of this widget’s own fields, or untick Apply to opt the widget out. Empty = the filter’s own field.',
   'engine.inspector.widget.filterBindingApply': 'Apply',
   'engine.inspector.widget.filterBindingDefault': 'Default ({field})',
+  'engine.inspector.widget.filterBindingField': 'Bound field for {filter}',
   'engine.inspector.widget.filterBindingReset': 'Reset',
   // Flow node inspector
   'engine.inspector.flowNode.kind': 'Node',
@@ -2074,6 +2075,7 @@ const ENGINE_STRINGS_ZH: Record<string, string> = {
     '把每个仪表盘级过滤器映射到本组件自己的字段；取消勾选「应用」可让本组件不受该过滤器影响。留空表示使用过滤器自身的字段。',
   'engine.inspector.widget.filterBindingApply': '应用',
   'engine.inspector.widget.filterBindingDefault': '默认（{field}）',
+  'engine.inspector.widget.filterBindingField': '{filter} 绑定的字段',
   'engine.inspector.widget.filterBindingReset': '恢复默认',
   // Flow node inspector
   'engine.inspector.flowNode.kind': '节点',
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/AppNavInspector.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/AppNavInspector.tsx
index 11f69af61..d0eaf80af 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/AppNavInspector.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/AppNavInspector.tsx
@@ -235,6 +235,10 @@ function FiltersEditor({
         <div key={`${field}-${i}`} className="flex items-center gap-1">
           <div className="min-w-0 flex-1">
             <InspectorComboField
+              // No visible per-row label — the `field = value` shape is read
+              // from the row itself — so the trigger carries its own name
+              // instead of being an anonymous combobox (objectui#3997).
+              ariaLabel={t('engine.inspector.appNav.filtersField', locale)}
               value={field}
               onCommit={(v) => update(i, v, value)}
               options={fieldOptions}
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.test.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.test.tsx
index bbbe26437..5e9e52bb3 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.test.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.test.tsx
@@ -95,6 +95,34 @@ describe('DashboardWidgetInspector — dataset binding', () => {
     expect(screen.getByText('维度')).toBeInTheDocument();
   });
 
+  it('the Dataset label resolves to the combo trigger, not to nothing (#3997)', () => {
+    // This panel labels its controls through a `Field` wrapper that renders
+    // `<Label htmlFor={id}>` and expects the wrapped control to carry the same
+    // id. Every other field honoured it (`Input id`, `SelectTrigger id`); the
+    // dataset combo could not, because `InspectorComboField` took no id — so
+    // `htmlFor="widget-dataset"` pointed at an id nothing carried and the
+    // picker was an anonymous combobox. This is the call-site half of the fix:
+    // the atom's own pins live in `_shared.labels.test.tsx`.
+    renderWidget({ dataset: 'sales_pipeline' });
+
+    const label = screen.getByText('Dataset');
+    const forId = label.getAttribute('for');
+    expect(forId).toBeTruthy();
+
+    const trigger = screen.getByLabelText('Dataset');
+    expect(trigger).toBe(document.getElementById(forId!));
+    expect(trigger.tagName).toBe('BUTTON');
+    expect(trigger).toHaveAttribute('role', 'combobox');
+    expect(trigger).toHaveAccessibleName('Dataset');
+    // Exactly one element answers that id — the trigger, not a wrapper.
+    expect(document.querySelectorAll(`[id="${forId}"]`)).toHaveLength(1);
+
+    // Scoped to this `Field` deliberately: a panel-wide "no dangling for" sweep
+    // would also catch `widget-color`, whose `ColorVariantPicker` accepts no id
+    // either. That is a different component and out of this issue's scope — it
+    // is filed separately rather than fixed here or asserted broken here.
+  });
+
   it('disables every picker when readOnly', () => {
     renderWidget({ dataset: 'sales_pipeline', object: 'crm_opportunity' }, { readOnly: true });
     const combos = screen.getAllByRole('combobox');
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.tsx
index c5262f762..d2eceb689 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/DashboardWidgetInspector.tsx
@@ -259,6 +259,12 @@ export function DashboardWidgetInspector({
         </div>
         <Field id="widget-dataset" label={t('engine.inspector.widget.dataset', locale)}>
           <InspectorComboField
+            // `Field` above renders `<Label htmlFor="widget-dataset">`; the id
+            // has to reach the trigger or that `for` dangles (objectui#3997).
+            // Every other `Field` in this file already hands its id to the
+            // control it wraps (`Input id`, `SelectTrigger id`) — this one could
+            // not, because the combo took no id at all.
+            id="widget-dataset"
             value={datasetName}
             onCommit={(v) => patchWidget({ dataset: v || undefined } as Partial<DashboardWidgetSchema>)}
             options={datasetComboOptions}
@@ -346,6 +352,15 @@ export function DashboardWidgetInspector({
                   <div className="flex items-center gap-1">
                     <div className="min-w-0 flex-1">
                       <InspectorComboField
+                        // The filter's name above is a heading for the whole row
+                        // (it also captions the Apply checkbox) and disappears
+                        // from the association when the row is opted out, so the
+                        // trigger carries its own name rather than borrowing it
+                        // (objectui#3997). Includes the filter name because a
+                        // dashboard has several of these rows.
+                        ariaLabel={tFormat('engine.inspector.widget.filterBindingField', locale, {
+                          filter: def.label || def.name,
+                        })}
                         value={override}
                         onCommit={(v) => setBinding(v ? v : undefined)}
                         options={fieldComboOptions}
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/DatasetDefaultInspector.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/DatasetDefaultInspector.tsx
index dea37a25b..be9ac9076 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/DatasetDefaultInspector.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/DatasetDefaultInspector.tsx
@@ -412,6 +412,10 @@ export function DatasetDefaultInspector({ draft, onPatch, readOnly, name }: Meta
           include.map((rel, i) => (
             <div key={i} className="flex items-center gap-1.5">
               <InspectorComboField
+                // One row per join under the "Included relationships" heading;
+                // no per-row visible label, so the trigger is named directly
+                // rather than left anonymous (objectui#3997).
+                ariaLabel="Included relationship"
                 value={rel}
                 onCommit={(v) => onPatch({ include: include.map((r, idx) => (idx === i ? v : r)) })}
                 options={relationshipComboOptions}
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.naming.types.test.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.naming.types.test.tsx
new file mode 100644
index 000000000..8ca29a83c
--- /dev/null
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.naming.types.test.tsx
@@ -0,0 +1,117 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * `InspectorComboField`'s naming contract is enforced by the TYPE, so it is
+ * pinned at compile time (objectui#3997).
+ *
+ * The atom accepts exactly one of `label` / `ariaLabel` / `id` — never zero,
+ * never two. Zero is an anonymous `button[role=combobox]`: assistive tech reads
+ * "combobox" with no idea which field it edits. Two is the double-announcement
+ * failure objectui#3961/#3978 exists to avoid. Both were authorable before this
+ * change, and five of the eleven live call sites had in fact authored zero.
+ *
+ * The reason this is a TYPE and not a runtime guard is that neither mistake has
+ * a runtime symptom the component could detect and report: an unnamed combobox
+ * renders, lays out and commits values perfectly. It is only wrong for the users
+ * who cannot see it. So the check has to happen at authoring time or not at all.
+ *
+ * ## Why this file exists separately, and why it is listed
+ *
+ * The assertions below are its entire point, so it is listed in
+ * `packages/app-shell/tsconfig.typetests.json`. That listing is the difference
+ * between a pin and a decoration: the package's build tsconfig excludes
+ * `**\/*.test.tsx`, and vitest erases types before running, so a
+ * `@ts-expect-error` written in an ordinary `*.test.tsx` file in this directory
+ * is read by NO compiler — it neither fails when the error disappears nor when
+ * the error was never there. This was drafted that way first, and the mutation
+ * run said so: making naming optional again produced a completely green
+ * `tsc --noEmit`. That is objectui#3009's failure verbatim (assertions that
+ * never ran, under a header calling them the real enforcement), and
+ * `tsconfig.typetests.json`'s own header warns about it — so the type-level
+ * cases moved here, out of `_shared.labels.test.tsx`, where they are compiled.
+ *
+ * The runtime `expect` at the bottom is deliberately thin: the DOM consequences
+ * (which element carries the id, what the accessible name resolves to, that the
+ * id never lands on the Radix `Popover` root) are pinned in
+ * `_shared.labels.test.tsx`, which renders. This file only has to be a file
+ * vitest can run without complaining that it holds no tests.
+ */
+
+import * as React from 'react';
+import { describe, it, expect } from 'vitest';
+import { InspectorComboField, type InspectorComboFieldProps } from './InspectorComboField';
+
+type Assert<T extends true> = T;
+type Extends<A, B> = [A] extends [B] ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
+  ? true
+  : false;
+
+const OPTIONS = [{ value: 'profile', label: 'Profile' }];
+const noop = (_v: string) => {};
+
+/** Everything the combo needs EXCEPT a name. */
+type Base = {
+  value: string;
+  onCommit: (v: string) => void;
+  options: Array<{ value: string; label: string }>;
+};
+
+describe('InspectorComboField — naming is required, and singular (#3997)', () => {
+  it('is pinned at compile time', () => {
+    // Guard against the probe lying: were the props `any`, every assignability
+    // assertion below would pass while proving nothing.
+    type _PropsNotAny = Assert<Equal<IsAny<InspectorComboFieldProps>, false>>;
+
+    // ── the three legal spellings ────────────────────────────────────────────
+    // The atom renders the visible label and owns the `htmlFor` ⇄ `id` pair.
+    type _LabelIsANaming = Assert<Extends<Base & { label: string }, InspectorComboFieldProps>>;
+    // No visible label exists (repeated rows); the trigger names itself.
+    type _AriaLabelIsANaming = Assert<Extends<Base & { ariaLabel: string }, InspectorComboFieldProps>>;
+    // An external `<Label htmlFor={id}>` owns the naming; the id must reach the
+    // trigger or that `for` dangles.
+    type _IdIsANaming = Assert<Extends<Base & { id: string }, InspectorComboFieldProps>>;
+
+    // ── zero naming channels is not authorable ───────────────────────────────
+    // The regression this file exists for. Five call sites shipped this shape.
+    type _AnonymousRejected = Assert<Equal<Extends<Base, InspectorComboFieldProps>, false>>;
+
+    // ── two naming channels is not authorable either ─────────────────────────
+    type _LabelPlusAriaRejected = Assert<
+      Equal<Extends<Base & { label: string; ariaLabel: string }, InspectorComboFieldProps>, false>
+    >;
+    type _LabelPlusIdRejected = Assert<
+      Equal<Extends<Base & { label: string; id: string }, InspectorComboFieldProps>, false>
+    >;
+    type _AriaPlusIdRejected = Assert<
+      Equal<Extends<Base & { ariaLabel: string; id: string }, InspectorComboFieldProps>, false>
+    >;
+
+    // ── the same two rejections as a caller actually writes them ─────────────
+    // Assignability above is the contract; JSX is the authoring surface, and
+    // excess-property checking makes them differ often enough to pin both.
+    const anonymous = (
+      // @ts-expect-error objectui#3997 — a combo with no name must not compile.
+      <InspectorComboField value="" options={OPTIONS} onCommit={noop} />
+    );
+    const doublyNamed = (
+      // @ts-expect-error objectui#3997 — `label` and `ariaLabel` are exclusive.
+      <InspectorComboField label="Group" ariaLabel="Group" value="" options={OPTIONS} onCommit={noop} />
+    );
+
+    expect([anonymous, doublyNamed].every(React.isValidElement)).toBe(true);
+  });
+
+  it('accepts each legal spelling as a real element', () => {
+    // Keeps the three positive cases honest: an over-tight union that rejected a
+    // shape a call site needs would fail here rather than only in CI's build.
+    const labelled = <InspectorComboField label="Group" value="" options={OPTIONS} onCommit={noop} />;
+    const ariaLabelled = <InspectorComboField ariaLabel="Group" value="" options={OPTIONS} onCommit={noop} />;
+    const externallyLabelled = (
+      <InspectorComboField id="widget-dataset" value="" options={OPTIONS} onCommit={noop} />
+    );
+
+    expect([labelled, ariaLabelled, externallyLabelled].every(React.isValidElement)).toBe(true);
+  });
+});
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.tsx
index 4e5025024..897e19305 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/InspectorComboField.tsx
@@ -12,6 +12,23 @@
  * catalog, a computed path, or a server-only field is never a dead end).
  *
  * Self-filters (`shouldFilter={false}`) for predictable label+value matching.
+ *
+ * ## Naming (objectui#3997)
+ *
+ * The trigger is a `button[role=combobox]` rendered by `PopoverTrigger asChild`,
+ * so it is a labelable element — but visual adjacency to a `<Label>` is NOT an
+ * association. Before this fix the labelled branch rendered the `<Label>` as a
+ * bare sibling (no `htmlFor`, no id, no `aria-label`), so assistive tech read an
+ * anonymous "combobox" with the field name floating above it as unowned text,
+ * `getByLabelText` could not reach it, and clicking the visible label did
+ * nothing — the same defect PR #3996 closed for the three `_shared.tsx` atoms.
+ * The un-labelled branch was one notch worse: the combobox was wholly anonymous.
+ *
+ * Naming is therefore a TYPE-LEVEL requirement (see {@link InspectorComboFieldNaming}):
+ * exactly one of `label` / `ariaLabel` / `id` must be given, so an anonymous
+ * combo cannot be authored — it fails `tsc`, not a review. One channel only,
+ * never two: a control carrying both an associated `<Label>` and an `aria-label`
+ * is the double-announcement failure objectui#3961/#3978 exists to avoid.
  */
 
 import * as React from 'react';
@@ -40,8 +57,40 @@ export interface InspectorComboOption {
   group?: string;
 }
 
-export interface InspectorComboFieldProps {
-  label?: string;
+/**
+ * Where this combo's accessible name comes from — exactly one of three, never
+ * zero and never two. Pick the variant that matches where the name already lives:
+ *
+ * • `label`     — this atom renders the visible `<Label>` and owns the pair
+ *                 (`htmlFor` ⇄ a `React.useId()`-minted trigger id). The default
+ *                 choice, and the only one that needs no caller bookkeeping.
+ * • `ariaLabel` — there is no visible label to associate: repeated rows whose
+ *                 column is obvious from context (an object filter's `field =
+ *                 value` pair, a dataset's list of joined relationships) and
+ *                 "add another" pickers sitting under a group heading. The
+ *                 trigger carries the name itself.
+ * • `id`        — an EXTERNAL `<Label htmlFor={…}>` already owns the naming (the
+ *                 `Field` wrapper in `DashboardWidgetInspector` is the live
+ *                 case). The caller's id lands on the trigger so that `for`
+ *                 RESOLVES; without this prop the caller's `for` pointed at an
+ *                 id nothing carried, which is a dangling IDREF — strictly worse
+ *                 than no label, because the tooling reports an association that
+ *                 does not exist.
+ *
+ * `label` mints its id internally rather than accepting one because these combos
+ * render in loops over array items (`lookupFilters[i]`, `dimensions[i]`), where a
+ * caller-supplied id is exactly what collides: two rows sharing a label would
+ * share an id and both labels would silently resolve to the FIRST trigger.
+ * `useId()` cannot be authored into a collision. The `id` variant re-opens that
+ * door by necessity — the caller must already own the id to have written the
+ * `for` — so reach for it only when an external label is genuinely in charge.
+ */
+export type InspectorComboFieldNaming =
+  | { label: string; ariaLabel?: never; id?: never }
+  | { label?: never; ariaLabel: string; id?: never }
+  | { label?: never; ariaLabel?: never; id: string };
+
+export type InspectorComboFieldProps = InspectorComboFieldNaming & {
   value: string;
   onCommit: (v: string) => void;
   options: InspectorComboOption[];
@@ -56,7 +105,7 @@ export interface InspectorComboFieldProps {
   mono?: boolean;
   /** Override the trigger label for the currently-selected custom value. */
   className?: string;
-}
+};
 
 function matches(option: InspectorComboOption, q: string): boolean {
   if (!q) return true;
@@ -70,6 +119,8 @@ function matches(option: InspectorComboOption, q: string): boolean {
 
 export function InspectorComboField({
   label,
+  ariaLabel,
+  id,
   value,
   onCommit,
   options,
@@ -85,6 +136,20 @@ export function InspectorComboField({
   const [open, setOpen] = React.useState(false);
   const [search, setSearch] = React.useState('');
 
+  // The id goes on the trigger `Button`, never on `Popover`: Radix's
+  // `Popover.Root` is a context provider that renders no DOM element of its own,
+  // so an id (or any aria-*) handed to it is silently DROPPED and the label's
+  // `for` resolves to nothing — the failure objectui#3976 (PR #3992) and #3994
+  // (PR #3996) each paid for once. `PopoverTrigger asChild` merges its props
+  // onto the `Button` below, which renders the real `button[role=combobox]`.
+  //
+  // It is minted only when something points AT it: the `<Label>` this atom
+  // renders (`autoId`), or the caller's external label (`id`). In the
+  // `ariaLabel` variant nothing references an id, so none is emitted — an
+  // unreferenced id would be noise, and the naming channel stays exactly one.
+  const autoId = React.useId();
+  const triggerId = label ? autoId : id;
+
   const selected = options.find((o) => o.value === value);
   const triggerText = selected ? selected.label : value || (loading ? 'Loading…' : placeholder);
 
@@ -126,6 +191,8 @@ export function InspectorComboField({
           type="button"
           variant="outline"
           role="combobox"
+          id={triggerId}
+          aria-label={ariaLabel}
           aria-expanded={open}
           disabled={disabled}
           className={cn('h-8 w-full justify-between px-2 text-sm font-normal', className)}
@@ -173,10 +240,12 @@ export function InspectorComboField({
     </Popover>
   );
 
+  // No visible label to render: the name is already on the trigger (`ariaLabel`)
+  // or owned by an external `<Label htmlFor={id}>` that now resolves to it.
   if (!label) return field;
   return (
     <div className="space-y-1">
-      <Label className="text-xs text-muted-foreground">{label}</Label>
+      <Label htmlFor={autoId} className="text-xs text-muted-foreground">{label}</Label>
       {field}
     </div>
   );
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/ObjectFieldInspector.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/ObjectFieldInspector.tsx
index a66cceb3b..6a555700f 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/ObjectFieldInspector.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/ObjectFieldInspector.tsx
@@ -1147,6 +1147,10 @@ function LookupConfigFields({
         )}
         {!readOnly && hostOptions.length > 0 && (
           <InspectorComboField
+            // The `Depends on` label above heads the whole group (chips + this
+            // "add another" picker), so the picker names itself rather than
+            // hijacking the group heading (objectui#3997).
+            ariaLabel={tr('designer.field.lookup.addDependsOn')}
             value=""
             onCommit={(v) => addDependsOn(v)}
             options={hostOptions.filter((o) => !dependsOn.includes(o.value))}
diff --git a/packages/app-shell/src/views/metadata-admin/inspectors/_shared.labels.test.tsx b/packages/app-shell/src/views/metadata-admin/inspectors/_shared.labels.test.tsx
index 2f3796fcc..6170b6f85 100644
--- a/packages/app-shell/src/views/metadata-admin/inspectors/_shared.labels.test.tsx
+++ b/packages/app-shell/src/views/metadata-admin/inspectors/_shared.labels.test.tsx
@@ -1,7 +1,7 @@
 // Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
 
 /**
- * objectui#3994 — the three shared inspector atoms that render a `<Label>` as a
+ * objectui#3994 / #3997 — the inspector field atoms that render a `<Label>` as a
  * SIBLING of their control must close the association (`htmlFor` ⇄ `id`).
  *
  * Before this fix `InspectorTextField` / `InspectorNumberField` /
@@ -21,6 +21,24 @@
  * placeholder *because* `getByLabelText` could not reach them; that locator is
  * tightened in the same change.
  *
+ * ## The fourth atom (objectui#3997)
+ *
+ * `InspectorComboField` lives in its own module but is the same shape — a
+ * `<Label>` sibling over a `button[role=combobox]` — and PR #3996 did not touch
+ * it, so it kept the defect after the three `_shared.tsx` atoms were fixed. It
+ * joins the component-agnostic `describe.each` below unchanged, which is the
+ * point of having written those rows against a roster rather than per component.
+ *
+ * Its `label` is optional, and the un-labelled branch was the defect one notch
+ * worse: a wholly ANONYMOUS combobox (no `for`, no `aria-label`). That is now
+ * unauthorable rather than merely fixed at the five call sites — naming is a
+ * type-level requirement of exactly one of `label` / `ariaLabel` / `id`, pinned
+ * by the `@ts-expect-error` case at the bottom of this file. The `id` variant
+ * exists because one real call site (`DashboardWidgetInspector`'s `Field`
+ * wrapper) already rendered `<Label htmlFor="widget-dataset">` over a combo that
+ * accepted no id — a dangling IDREF, which is worse than an unnamed control
+ * because tooling reports an association that resolves to nothing.
+ *
  * ## Why the id is minted inside the atom
  *
  * `React.useId()`, not a caller-supplied prop. These atoms are rendered in
@@ -41,6 +59,10 @@
  *     select rows go red while text/number stay green, because Radix's
  *     `Select.Root` renders no DOM element and silently DROPS the id (the
  *     objectui#3976 / PR #3992 mechanism, one directory over).
+ *  3. (#3997) Move the combo's `id` off the trigger `Button` and onto `Popover`
+ *     → the combo rows go red for the same reason as (2): `Popover.Root` is a
+ *     context provider that renders no DOM element, so the id is dropped and the
+ *     `for` dangles. The other three atoms stay green.
  *
  * Measured outcomes are in the PR body.
  */
@@ -48,12 +70,14 @@
 import * as React from 'react';
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+import { Label } from '@object-ui/components';
 import {
   InspectorTextField,
   InspectorNumberField,
   InspectorSelectField,
   InspectorCheckboxField,
 } from './_shared';
+import { InspectorComboField } from './InspectorComboField';
 
 afterEach(cleanup);
 
@@ -121,6 +145,22 @@ const ATOMS: AtomCase[] = [
       />
     ),
   },
+  {
+    // objectui#3997 — the fourth atom, from its own module. Same shape, so the
+    // rows below apply verbatim; the trigger is the `Button` that
+    // `PopoverTrigger asChild` renders as `button[role=combobox]`.
+    atom: 'InspectorComboField',
+    role: 'combobox',
+    tag: 'BUTTON',
+    render: (label, onCommit) => (
+      <InspectorComboField
+        label={label}
+        value=""
+        options={OPTIONS}
+        onCommit={onCommit as (v: string) => void}
+      />
+    ),
+  },
 ];
 
 describe.each(ATOMS)('$atom — the visible label names the control (#3994)', ({ role, tag, render: renderAtom }) => {
@@ -262,6 +302,43 @@ describe('the labelled element is the live control, not a decoy (#3994)', () =>
     expect(trigger.textContent).toContain('Profile');
   });
 
+  it('InspectorComboField — the id lands on the trigger, not on the Radix Popover root', () => {
+    // Same mechanism as the select one line up: `Popover.Root` is a context
+    // provider with no DOM element of its own (objectui#3997). The trigger is
+    // the real control — it is the element that displays the selected option's
+    // label, takes focus, and toggles the list.
+    render(
+      <InspectorComboField label="Group" value="profile" options={OPTIONS} onCommit={vi.fn()} />,
+    );
+
+    const trigger = screen.getByLabelText('Group');
+    expect(trigger.tagName).toBe('BUTTON');
+    expect(trigger).toHaveAttribute('role', 'combobox');
+    expect(trigger).toHaveAttribute('aria-expanded', 'false');
+    expect(trigger.textContent).toContain('Profile');
+    // Nothing else in the tree carries the id — in particular no wrapper div
+    // stood in for the dropped Root.
+    expect(idOwners(trigger.getAttribute('id')!)).toBe(1);
+  });
+
+  it('InspectorComboField — a custom value keeps the trigger named', () => {
+    // The escape hatch (`allowCustom`) renders the raw value as the trigger
+    // text; naming must not depend on the value matching a catalog option.
+    render(
+      <InspectorComboField
+        label="Group"
+        value="account.owner.name"
+        options={OPTIONS}
+        onCommit={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByRole('combobox', { name: 'Group' }).textContent).toContain(
+      'account.owner.name',
+    );
+    expect(labelTargets().filter((l) => !l.resolves)).toEqual([]);
+  });
+
   it('InspectorSelectField — a disabled field is still named', () => {
     // `disabled` stays on the Root (single authority over trigger + items +
     // the hidden native mirror); naming must not travel with it.
@@ -280,6 +357,83 @@ describe('the labelled element is the live control, not a decoy (#3994)', () =>
   });
 });
 
+/* ────────── the un-labelled combo branch still names its trigger ─────────── */
+
+describe('InspectorComboField — a combo without a visible label is still named (#3997)', () => {
+  it('names the trigger from `ariaLabel` when no label is rendered', () => {
+    // The repeated-row shape: an object filter's `field = value` pair, a
+    // dataset's list of joins, an "add another" picker under a group heading.
+    // Pre-fix these rendered a wholly anonymous combobox.
+    render(
+      <InspectorComboField
+        ariaLabel="Included relationship"
+        value="account_id"
+        options={OPTIONS}
+        onCommit={vi.fn()}
+      />,
+    );
+
+    const trigger = screen.getByRole('combobox', { name: 'Included relationship' });
+    expect(trigger).toHaveAccessibleName('Included relationship');
+    expect(trigger.tagName).toBe('BUTTON');
+    // No visible label was rendered, so there is nothing to associate — and in
+    // particular no `for` pointing at nothing.
+    expect(document.querySelectorAll('label')).toHaveLength(0);
+    expect(labelTargets()).toEqual([]);
+    // `aria-label` is then the ONLY channel: no second `aria-labelledby`.
+    expect(trigger).not.toHaveAttribute('aria-labelledby');
+  });
+
+  it('resolves an EXTERNAL label to the trigger when the caller owns the id', () => {
+    // `DashboardWidgetInspector`'s `Field` wrapper verbatim: the caller renders
+    // `<Label htmlFor={id}>` and hands the same id to the control it wraps.
+    // Pre-fix the combo accepted no id, so that `for` dangled.
+    render(
+      <div className="space-y-1.5">
+        <Label htmlFor="widget-dataset">Dataset</Label>
+        <InspectorComboField
+          id="widget-dataset"
+          value="sales_pipeline"
+          options={OPTIONS}
+          onCommit={vi.fn()}
+        />
+      </div>,
+    );
+
+    const trigger = screen.getByLabelText('Dataset');
+    expect(trigger.tagName).toBe('BUTTON');
+    expect(trigger).toHaveAttribute('role', 'combobox');
+    expect(trigger).toHaveAccessibleName('Dataset');
+    // The caller's `for` now RESOLVES, and to exactly one element.
+    expect(labelTargets()).toEqual([{ text: 'Dataset', forId: 'widget-dataset', resolves: true }]);
+    expect(idOwners('widget-dataset')).toBe(1);
+    // The external label is the only channel — the atom did not also stamp an
+    // `aria-label` "just in case", which would double-announce.
+    expect(trigger).not.toHaveAttribute('aria-label');
+  });
+
+  it('does not render a visible label for either un-labelled variant', () => {
+    // Guards against "fixing" the anonymous branch by inventing a visible label
+    // out of the aria name or the placeholder: these call sites are laid out in
+    // rows where a rendered label would break the grid.
+    const { container } = render(
+      <InspectorComboField ariaLabel="Field" value="" options={OPTIONS} onCommit={vi.fn()} />,
+    );
+
+    expect(container.querySelector('label')).toBeNull();
+    expect(screen.queryByText('Field')).not.toBeInTheDocument();
+  });
+
+  // The type-level half of this contract — that a combo with NO name, or with
+  // two names, does not compile — is pinned in
+  // `InspectorComboField.naming.types.test.tsx`, not here. A `@ts-expect-error`
+  // in this file would be read by no compiler: the package's build tsconfig
+  // excludes `**/*.test.tsx` and vitest erases types, so it would neither fail
+  // when the error disappeared nor when it was never there (objectui#3009). That
+  // sibling file is listed in `tsconfig.typetests.json`, which is what makes its
+  // directives load-bearing.
+});
+
 /* ───────────────────────── the counter-example holds ─────────────────────── */
 
 describe('InspectorCheckboxField — the wrapping-label form still names its box', () => {
diff --git a/packages/app-shell/tsconfig.typetests.json b/packages/app-shell/tsconfig.typetests.json
index 4c81472f7..d4087f4ff 100644
--- a/packages/app-shell/tsconfig.typetests.json
+++ b/packages/app-shell/tsconfig.typetests.json
@@ -68,9 +68,20 @@
   // in which the hand-written shape was too NARROW — excess-property checking
   // rejected the canonical `{ dialect, source }` literal outright. No test that
   // vitest runs can observe that, so unlisted it would be commentary.
+  // `views/metadata-admin/inspectors/InspectorComboField.naming.types.test.tsx`
+  // earns its place through objectui#3997: the combo's naming contract (exactly
+  // one of `label` / `ariaLabel` / `id`) is enforced only by its props union, and
+  // neither violation has a runtime symptom the component could report — an
+  // unnamed combobox renders and commits perfectly, it is just anonymous to
+  // assistive tech. So the whole check is compile-time, and unlisted it would be
+  // decoration: the first draft put the `@ts-expect-error` cases in
+  // `_shared.labels.test.tsx`, and making naming optional again type-checked
+  // completely green. It is also the first `.tsx` entry here — JSX compiles
+  // because the root tsconfig sets `"jsx": "react-jsx"`.
   "include": [
     "src/__tests__/spec-symbol-parity.test.ts",
     "src/utils/resolveActionParams.test.ts",
+    "src/views/metadata-admin/inspectors/InspectorComboField.naming.types.test.tsx",
     "src/views/metadata-admin/previews/flow-designer-edge.types.test.ts",
     "src/views/metadata-admin/previews/simulator/__tests__/flow-sim-edge.types.test.ts"
   ]