@@ -0,0 +1,10 @@
+---
+'@object-ui/app-shell': patch
+---
+
+fix(studio): the field inspector's API name box refuses a name another field holds, and saves no trailing underscore
+
+Clause-②: no
+Metadata-protocol: none
+
+Typing another field's API name into the field inspector used to drop the last keystroke without a message and save the half-typed name (`status` saved as `statu`), and a trailing punctuation mark saved a trailing underscore (`Estimated Hours!` saved as `estimated_hours_`). The box now shows what the author typed, says the Add field popover's own refusal ("Another field is already named status. Type a different API name."), and keeps the name the field had before the edit. The name written is normalised the way the new-object dialog normalises an identifier, so a trailing underscore is never saved; an underscore can still be typed mid-word. Leaving the box shows the name the field carries.
@@ -0,0 +1,151 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * ObjectFieldInspector — the API name box refuses a name another field holds
+ * and normalises trailing punctuation (objectstack#27517).
+ *
+ * Measured on the release-candidate walkthrough: selecting all of an Estimated
+ * Hours field's API name and typing `status` (another field's name) left the
+ * box reading `statu` with no message, and `statu` was saved; typing
+ * `Estimated Hours!` saved `estimated_hours_`. The box now shows what the
+ * author typed, refuses a taken name in the Add field popover's own sentence,
+ * keeps the name the field had when the edit began, and writes the name the
+ * new-object dialog's rule derives.
+ *
+ * Every case types ONE CHARACTER AT A TIME through a host that feeds each
+ * patch back in and follows the rename with the selection, as the Studio host
+ * does: the dropped keystroke only exists in that loop.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+
+vi.mock('../useMetadata', () => ({
+  useMetadataClient: () => ({
+    list: vi.fn().mockResolvedValue([]),
+    listDrafts: vi.fn().mockResolvedValue([]),
+  }),
+}));
+
+vi.mock('../previews/useObjectFields', () => ({
+  useObjectFields: () => ({ fields: [], loading: false, error: null }),
+}));
+
+import { ObjectFieldInspector } from './ObjectFieldInspector';
+import { fieldNameTakenRefusal } from '../../studio-design/AddFieldPopover';
+
+afterEach(cleanup);
+
+type Fields = Record<string, Record<string, unknown>>;
+
+const WORK_ORDER: Fields = {
+  estimated_hours: { type: 'number', label: 'Estimated Hours' },
+  status: { type: 'select', label: 'Status', options: [{ value: 'new', label: 'New Request' }] },
+};
+
+/** The host's draft as last patched, read by the assertions. */
+let saved: Fields = {};
+
+function Host({ fields: initial, id }: { fields: Fields; id: string }) {
+  const [fields, setFields] = React.useState(initial);
+  const [selection, setSelection] = React.useState<any>({ kind: 'field', id });
+  return (
+    <ObjectFieldInspector
+      type="object"
+      name="work_order"
+      draft={{ name: 'work_order', fields }}
+      selection={selection}
+      onPatch={(patch: any) => {
+        saved = patch.fields;
+        setFields(patch.fields);
+      }}
+      onClearSelection={() => {}}
+      onSelectionChange={(next: any) => next && setSelection(next)}
+      readOnly={false}
+      locale={'en-US'}
+    />
+  );
+}
+
+function apiNameBox(): HTMLInputElement {
+  return screen.getByTestId('field-apiname-input') as HTMLInputElement;
+}
+
+/** Select all, then one `change` event per character — a person at a keyboard. */
+function typeOver(text: string): void {
+  fireEvent.focus(apiNameBox());
+  for (let i = 1; i <= text.length; i += 1) {
+    fireEvent.change(apiNameBox(), { target: { value: text.slice(0, i) } });
+  }
+}
+
+function renderWorkOrder(): void {
+  saved = WORK_ORDER;
+  render(<Host fields={WORK_ORDER} id="estimated_hours" />);
+}
+
+describe('ObjectFieldInspector — API name box refuses a taken name (#27517)', () => {
+  it('shows every keystroke and the Add field popover refusal, and keeps the previous name', () => {
+    renderWorkOrder();
+    typeOver('status');
+    // Pre-fix the box read `statu`: the refused keystroke was dropped silently.
+    expect(apiNameBox()).toHaveValue('status');
+    const refusal = screen.getByTestId('field-apiname-refusal');
+    // The same sentence the Add field popover says for the same name.
+    expect(refusal.textContent).toBe(fieldNameTakenRefusal('status', ['status'], 'en-US'));
+    expect(apiNameBox()).toHaveAttribute('aria-invalid', 'true');
+    expect(apiNameBox().getAttribute('aria-describedby')).toBe(refusal.id);
+    // Saves nothing: the field still carries the name it had before the edit,
+    // not the last free prefix (`statu`) of the refused one.
+    expect(Object.keys(saved).sort()).toEqual(['estimated_hours', 'status']);
+  });
+
+  it('takes the name once the author types past the refusal', () => {
+    renderWorkOrder();
+    typeOver('status_2');
+    expect(apiNameBox()).toHaveValue('status_2');
+    expect(screen.queryByTestId('field-apiname-refusal')).toBeNull();
+    expect(Object.keys(saved).sort()).toEqual(['status', 'status_2']);
+  });
+
+  it('shows the name the field carries once the author leaves a refused box', () => {
+    renderWorkOrder();
+    typeOver('status');
+    fireEvent.blur(apiNameBox());
+    expect(apiNameBox()).toHaveValue('estimated_hours');
+    expect(screen.queryByTestId('field-apiname-refusal')).toBeNull();
+  });
+
+  it('saves nothing for an emptied box', () => {
+    renderWorkOrder();
+    fireEvent.focus(apiNameBox());
+    fireEvent.change(apiNameBox(), { target: { value: '' } });
+    expect(apiNameBox()).toHaveValue('');
+    expect(Object.keys(saved).sort()).toEqual(['estimated_hours', 'status']);
+    fireEvent.blur(apiNameBox());
+    expect(apiNameBox()).toHaveValue('estimated_hours');
+  });
+});
+
+describe('ObjectFieldInspector — API name box normalises as the new-object dialog does (#27517)', () => {
+  it('saves `Estimated Hours!` as estimated_hours, without the trailing underscore', () => {
+    saved = {};
+    render(<Host fields={{ field_3: { type: 'number', label: '' } }} id="field_3" />);
+    typeOver('Estimated Hours!');
+    // While typing, the box keeps the `_` so the next letter can follow it.
+    expect(apiNameBox()).toHaveValue('estimated_hours_');
+    // Pre-fix this read `estimated_hours_`.
+    expect(Object.keys(saved)).toEqual(['estimated_hours']);
+    fireEvent.blur(apiNameBox());
+    expect(apiNameBox()).toHaveValue('estimated_hours');
+  });
+
+  it('still lets an underscore be typed mid-word', () => {
+    saved = {};
+    render(<Host fields={{ field_4: { type: 'text', label: '' } }} id="field_4" />);
+    typeOver('repair_ticket');
+    expect(apiNameBox()).toHaveValue('repair_ticket');
+    expect(Object.keys(saved)).toEqual(['repair_ticket']);
+  });
+});
@@ -98,6 +98,7 @@ import {
   readFields,
   writeFields,
   toFieldNameLoose,
+  toFieldNameOrEmpty,
   indexOfField,
   type FieldsView,
   type FieldEntry,
@@ -126,8 +127,99 @@ import { FilterConditionField } from './FilterConditionField.js';
 import type { FilterCondition } from './datasetFilterCondition.js';
 import { usePickerLoad, type LoadState } from '../loadState.js';
 import { isMainContentList } from '../../../utils/deriveRelatedLists.js';
+import { fieldNameTakenRefusal } from '../../studio-design/AddFieldPopover.js';
 
 
+/**
+ * The field inspector's API name box (objectstack#27517).
+ *
+ * The box still writes the field's name on every keystroke, but it shows what
+ * the author TYPED, not the name the field carries. Showing the stored name
+ * dropped keystrokes without a word: a keystroke whose name another field
+ * held was refused, the box snapped back to the previous keystroke (`status`
+ * read `statu`), and that half-typed name was the one saved. Now:
+ *
+ * - the text is normalised the way the new-object dialog normalises an
+ *   identifier: `toFieldNameLoose` while typing, so an `_` can still be typed
+ *   mid-word, and the strict rule (`toFieldNameOrEmpty`, `toFieldName` less
+ *   its placeholder) for the name written, so `Estimated Hours!` is saved as
+ *   `estimated_hours`, never `estimated_hours_`;
+ * - a name another field holds is refused in the Add field popover's own
+ *   sentence (`fieldNameTakenRefusal`), and the field keeps the name it had
+ *   when the author began typing, not the last free prefix of the refused one;
+ *   an emptied box writes no name either;
+ * - leaving the box shows the name the field carries.
+ */
+function FieldApiNameInput({
+  label,
+  value,
+  takenNames,
+  onRename,
+  disabled,
+  locale,
+}: {
+  label: string;
+  /** The name the field carries. */
+  value: string;
+  /** The names the object's OTHER fields carry. */
+  takenNames: readonly string[];
+  /** Called on every keystroke with the name the field is to carry: normalised, never a refused one. */
+  onRename: (name: string) => void;
+  disabled?: boolean;
+  locale: SupportedLocale;
+}) {
+  const id = React.useId();
+  const hintId = React.useId();
+  const [text, setText] = React.useState(value);
+  // What a refused or emptied box leaves the field named.
+  const [startName, setStartName] = React.useState(value);
+  // A name arriving from outside (another field selected, the Label deriving
+  // one) replaces the text; this box's own write echoing back does not.
+  const [seen, setSeen] = React.useState(value);
+  const [written, setWritten] = React.useState<string | null>(null);
+  if (value !== seen) {
+    setSeen(value);
+    setWritten(null);
+    if (value !== written) {
+      setText(value);
+      setStartName(value);
+    }
+  }
+
+  const refusal = fieldNameTakenRefusal(toFieldNameOrEmpty(text), takenNames, locale);
+  const change = (raw: string) => {
+    const typed = toFieldNameLoose(raw);
+    setText(typed);
+    const typedName = toFieldNameOrEmpty(typed);
+    const next = !typedName || fieldNameTakenRefusal(typedName, takenNames, locale) ? startName : typedName;
+    if (next !== value) setWritten(next);
+    onRename(next);
+  };
+
+  return (
+    <div className="space-y-1">
+      <Label htmlFor={id} className="text-xs text-muted-foreground">{label}</Label>
+      <Input
+        id={id}
+        value={text}
+        onChange={(e) => change(e.target.value)}
+        onFocus={() => setStartName(value)}
+        onBlur={() => setText(value)}
+        disabled={disabled}
+        aria-invalid={refusal ? true : undefined}
+        aria-describedby={refusal ? hintId : undefined}
+        data-testid="field-apiname-input"
+        className="h-8 text-sm font-mono"
+      />
+      {refusal && (
+        <p id={hintId} className="text-xs text-destructive" data-testid="field-apiname-refusal">
+          {refusal}
+        </p>
+      )}
+    </div>
+  );
+}
+
 /**
  * One row of the picklist option editor.
  *
@@ -879,18 +971,19 @@ export function ObjectFieldInspector({
     writeView({ shape: view.shape, entries: nextEntries });
   };
 
-  const setKey = (rawNext: string) => {
-    const nextName = toFieldNameLoose(rawNext);
-    const rejected =
-      !nextName ||
-      nextName === entry.name ||
-      // Disallow collision
-      view.entries.some((e, i) => i !== idx && e.name === nextName);
+  /** The names the object's other fields carry: what the API name box refuses. */
+  const takenNames = view.entries.filter((_, i) => i !== idx).map((e) => e.name);
+
+  // `nextName` comes from `FieldApiNameInput`, already normalised and checked
+  // against `takenNames` (objectstack#27517).
+  const setKey = (nextName: string) => {
+    const rejected = !nextName || nextName === entry.name || takenNames.includes(nextName);
     // Every keystroke in the API name box is the author claiming that value —
     // recorded even when the edit is REJECTED just above (cleared, unchanged,
-    // or colliding), because a rejected keystroke is still an authorial edit
-    // and the Label must not resume overwriting what they are typing. The
-    // stamp names whichever value the field is left carrying (objectui#7615).
+    // or refused by the box), because a rejected keystroke is still an
+    // authorial edit and the Label must not resume overwriting what they are
+    // typing. The stamp names whichever value the field is left carrying
+    // (objectui#7615).
     apiNameOwnerRef.current = {
       object: objectName,
       field: rejected ? entry.name : nextName,
@@ -1107,13 +1200,13 @@ export function ObjectFieldInspector({
             <ExternalFieldBadge binding={external} state={externalWriteState} locale={locale} />
           </div>
         )}
-        <InspectorTextField
+        <FieldApiNameInput
           label={tr('designer.field.apiName')}
           value={entry.name}
-          onCommit={setKey}
+          takenNames={takenNames}
+          onRename={setKey}
           disabled={ddlLocked}
-          mono
-          testId="field-apiname-input"
+          locale={locale}
         />
         <InspectorTextField
           label={tr('designer.field.label')}
 
@@ -38,9 +38,26 @@ import {
 } from '@object-ui/components';
 import type { FieldTypeId } from '../metadata-admin/previews/field-types.js';
 import { FieldTypePicker } from '../metadata-admin/inspectors/FieldTypePicker.js';
-import { t, tFormat, useMetadataLocale } from '../metadata-admin/i18n.js';
+import { t, tFormat, useMetadataLocale, type SupportedLocale } from '../metadata-admin/i18n.js';
 import { toFieldNameLoose } from '../metadata-admin/previews/object-fields-io.js';
 
+/**
+ * The refusal for an api name another field of the object already holds, or
+ * `null` when `name` is free. The one duplicate-name refusal Studio has: this
+ * popover and the field inspector's API name box both say it, so the author
+ * reads the same sentence whichever door they rename through
+ * (objectstack#27517).
+ */
+export function fieldNameTakenRefusal(
+  name: string,
+  takenNames: readonly string[],
+  locale: SupportedLocale,
+): string | null {
+  return name && takenNames.includes(name)
+    ? tFormat('engine.studio.data.addFieldApiNameTaken', locale, { name })
+    : null;
+}
+
 export interface AddFieldPopoverProps {
   /**
    * Create the field: the label as typed (trimmed), the chosen type, and the
@@ -98,7 +115,8 @@ export function AddFieldPopover({
   // The label alone cannot name the field: the author types the api name.
   const asksName = !!trimmed && (!derived || derivedTaken);
   const typed = apiName.replace(/_+$/, '');
-  const typedTaken = !!typed && takenNames.includes(typed);
+  const typedRefusal = fieldNameTakenRefusal(typed, takenNames, locale);
+  const typedTaken = !!typedRefusal;
   const canCreate = !!trimmed && (!asksName || (!!typed && !typedTaken));
   const submit = (e: React.FormEvent) => {
     e.preventDefault();
@@ -108,11 +126,11 @@ export function AddFieldPopover({
   };
   const nameHint = !asksName
     ? null
-    : typedTaken || (!typed && derivedTaken)
-      ? tFormat('engine.studio.data.addFieldApiNameTaken', locale, { name: typed || derived })
-      : !typed
-        ? t('engine.studio.data.addFieldApiNameNotDerived', locale)
-        : null;
+    : typed
+      ? typedRefusal
+      : derivedTaken
+        ? fieldNameTakenRefusal(derived, takenNames, locale)
+        : t('engine.studio.data.addFieldApiNameNotDerived', locale);
 
   return (
     <Popover open={open} onOpenChange={setOpen}>