diff --git a/.changeset/fields-fullscreen-editor-disabled.md b/.changeset/fields-fullscreen-editor-disabled.md
new file mode 100644
index 0000000000..77384b3188
--- /dev/null
+++ b/.changeset/fields-fullscreen-editor-disabled.md
@@ -0,0 +1,7 @@
+---
+'@object-ui/fields': patch
+---
+
+`TextAreaField` / `RichTextField` now honour `disabled` on their fullscreen editing path. `disabled` used to reach the inline control only: `showFullscreenButton` never consulted it, neither widget forwarded it to `FullscreenFieldEditor`, and that component did not declare the prop at all. A disabled long-text or rich-text field therefore sat correctly greyed out next to a live expand button whose dialog accepted any edit and wrote it straight back through `onCommit` — reproduced dynamically before the fix as toggle `disabled=false`, dialog input `disabled=false`, `onChange` called with "EDITED WHILE DISABLED". The state was easy to miss precisely because the visible control looked right.
+
+`FullscreenFieldEditor` now declares `disabled`: the expand button stays (disabled means "not interactive, muted", unlike `readonly`, which suppresses the affordance entirely via each widget's read-only early return) but is disabled and refuses to open, the dialog's editor is disabled through a new third `children` argument, and "Done" is both disabled and gated before `onCommit`. The dialog locks on its own rather than trusting the button, because the form renderer folds `isSubmitting` into `disabled` — so a submit starting while the dialog was already open used to leave the field editable for the duration of the submit. Cancel and Esc stay live in every state. This is the registered-widget half of the same defect #3400 / #3401 fixed on the built-in `form.tsx` path, so both render paths now give the same metadata the same behaviour (#3402).
diff --git a/packages/fields/src/widgets/FullscreenFieldEditor.tsx b/packages/fields/src/widgets/FullscreenFieldEditor.tsx
index c9cc35d954..70cc3d4fb8 100644
--- a/packages/fields/src/widgets/FullscreenFieldEditor.tsx
+++ b/packages/fields/src/widgets/FullscreenFieldEditor.tsx
@@ -50,6 +50,46 @@ import { Maximize2, Check, X } from 'lucide-react';
  * edit the user may still cancel. "Cancel" therefore needs no undo — nothing
  * was written.
  *
+ * ## `disabled` (objectui#3402)
+ *
+ * The dialog is a SECOND editing surface for the same value, so a field that is
+ * not interactive has to be not interactive here too. It was not: hosts landed
+ * `disabled` on their inline control only, this component never declared the
+ * prop at all, and a disabled long-text field therefore sat correctly greyed out
+ * next to a live expand button — click it, type anything, press "Done", and the
+ * edit went into form state through `onCommit`. Measured on `origin/main`
+ * before the fix: inline `disabled=true`, toggle `disabled=false`, dialog input
+ * `disabled=false`, `onChange` called with "EDITED WHILE DISABLED".
+ *
+ * The gate is shaped like the built-in path's (`FullscreenTextarea` in
+ * `components/src/renderers/form/form.tsx`, objectui#3400/PR #3401), because
+ * one form-level setting must keep producing one behaviour on both paths:
+ *
+ *  - the toggle STAYS but is `disabled` — `disabled` means "not interactive,
+ *    muted", not "shown plainly", which is `readonly`'s job (and `readonly`
+ *    never reaches this component at all — see below);
+ *  - `openFullscreen` refuses independently of the attribute, since a
+ *    programmatic dispatch and a lost `pointer-events` rule both get past it;
+ *  - the dialog locks on its OWN — `disabled` is not merely a static flag, it is
+ *    also the form's `isSubmitting`, which flips to true while the dialog may
+ *    already be open. At that moment the toggle is no longer the gate. So the
+ *    editor is told (third `children` argument) and "Done" is disabled;
+ *  - and `onCommit` is gated, because that is the single point where a value can
+ *    leave this component for host state. Nothing native guards it: it is a
+ *    click handler on a different control reading React state.
+ *
+ * "Cancel" and `Esc` stay live in every state — a dialog that goes disabled
+ * mid-edit must still be closable, or a submit in flight traps the user in it.
+ *
+ * ## Why there is no `readonly` prop
+ *
+ * Both hosts early-return a read-only DISPLAY before they compute the affordance
+ * (`TextAreaField.tsx`, `RichTextField.tsx`), so this component is never
+ * rendered for a read-only field and a `readonly` prop here would be declared
+ * with no producer — the shape this package keeps deleting (objectui#3232/#3233).
+ * A future host that renders an editor for read-only fields must add the prop
+ * AND the producer together; do not add it "for symmetry" beforehand.
+ *
  * ## `testIdPrefix`
  *
  * Each host passes its own (`textarea`, `richtext`), yielding the same
@@ -76,12 +116,35 @@ export interface FullscreenFieldEditorProps {
   label?: string;
   /** Namespace for this widget's fullscreen test ids. See above. */
   testIdPrefix: string;
+  /**
+   * The host field is not interactive (objectui#3402). Disables the toggle, the
+   * "Done" button and the write-back, and is handed to `children` so the host's
+   * own editor renders disabled too. See the `disabled` section above for why
+   * each of those is a separate line rather than belt-and-braces.
+   *
+   * **Producer**: the widget's `disabled` prop, which the form renderer computes
+   * as `disabled || fieldDisabled || isSubmitting || optionGroupGated` and
+   * forwards to registered widgets (`stripRegisteredFieldProps` does not strip
+   * it).
+   */
+  disabled?: boolean;
   /**
    * The editor itself, rendered inside the dialog body against the draft. The
    * host passes the SAME editor it renders inline, so "fullscreen" is a size
    * change rather than a second, poorer editing surface.
+   *
+   * The third argument is this component's `disabled`, and the host is expected
+   * to put it on the control it renders: only the host knows which element its
+   * editor's disabled state belongs on. Ignoring it is not a write-back hole —
+   * `onCommit` is gated here regardless — but it does leave a control that looks
+   * editable while the field is not, so both in-repo hosts apply it and their
+   * tests pin it.
    */
-  children: (draft: string, setDraft: (next: string) => void) => React.ReactNode;
+  children: (
+    draft: string,
+    setDraft: (next: string) => void,
+    disabled: boolean,
+  ) => React.ReactNode;
   /** Optional footer status for the draft (e.g. a character counter). */
   footer?: (draft: string) => React.ReactNode;
   /**
@@ -97,6 +160,7 @@ export function FullscreenFieldEditor({
   onCommit,
   label,
   testIdPrefix,
+  disabled = false,
   children,
   footer,
   toggleClassName,
@@ -105,12 +169,17 @@ export function FullscreenFieldEditor({
   const [draft, setDraft] = useState(value ?? '');
 
   const openFullscreen = () => {
+    if (disabled) return;
     setDraft(value ?? '');
     setOpen(true);
   };
   const cancelFullscreen = () => setOpen(false);
   const commitFullscreen = () => {
-    onCommit(draft);
+    // THE gate: the one point where a value leaves this component for host
+    // state. `disabled` can flip to true while this dialog is open (it carries
+    // the form's `isSubmitting`), so this is checked here and not only on the
+    // way in. Closing is unconditional — see "Cancel and Esc stay live" above.
+    if (!disabled) onCommit(draft);
     setOpen(false);
   };
 
@@ -119,8 +188,10 @@ export function FullscreenFieldEditor({
       <button
         type="button"
         onClick={openFullscreen}
+        disabled={disabled}
         className={cn(
           'absolute top-1.5 right-1.5 inline-flex items-center justify-center size-7 rounded-md bg-background/80 text-muted-foreground hover:text-foreground hover:bg-background border shadow-sm transition-colors',
+          'disabled:opacity-50 disabled:pointer-events-none',
           toggleClassName,
         )}
         aria-label={`Edit ${label ?? 'text'} fullscreen`}
@@ -137,7 +208,7 @@ export function FullscreenFieldEditor({
           <DialogHeader className="p-4 border-b">
             <DialogTitle className="text-base">{label ?? 'Edit text'}</DialogTitle>
           </DialogHeader>
-          <div className="flex-1 min-h-0 p-4">{children(draft, setDraft)}</div>
+          <div className="flex-1 min-h-0 p-4">{children(draft, setDraft, disabled)}</div>
           <DialogFooter className="p-3 border-t flex-row justify-between sm:justify-end gap-2">
             {footer?.(draft)}
             <div className="flex gap-2 ml-auto">
@@ -147,6 +218,7 @@ export function FullscreenFieldEditor({
               <Button
                 type="button"
                 onClick={commitFullscreen}
+                disabled={disabled}
                 data-testid={`${testIdPrefix}-fullscreen-save`}
               >
                 <Check className="size-4 mr-1" /> Done
diff --git a/packages/fields/src/widgets/RichTextField.tsx b/packages/fields/src/widgets/RichTextField.tsx
index 36fc8014e4..ed0c305b32 100644
--- a/packages/fields/src/widgets/RichTextField.tsx
+++ b/packages/fields/src/widgets/RichTextField.tsx
@@ -120,6 +120,12 @@ export function RichTextField({ value, onChange, field, readonly, error, ...prop
   // Same single read as `TextAreaField`: the field metadata is the only
   // carrier, and this widget is the second consumer the flag always had.
   const showFullscreenButton = Boolean(richField?.mobile_fullscreen);
+  // Resolved once and given to BOTH renderings of the editor (objectui#3402) —
+  // exactly like `formatLabel` / `hint` / `placeholder` below, and for the same
+  // reason. Landing it on the inline surface alone left a disabled rich-text
+  // field greyed out next to a live expand button whose dialog committed any
+  // edit through `onCommit`. `disabled` also carries the form's `isSubmitting`.
+  const disabled = Boolean(props.disabled);
 
   // Resolved once and handed to BOTH renderings of the editor, so the dialog
   // cannot drift into showing different copy than the inline surface.
@@ -137,7 +143,7 @@ export function RichTextField({ value, onChange, field, readonly, error, ...prop
       hint={hint}
       placeholder={placeholder}
       rows={rows}
-      disabled={readonly || props.disabled}
+      disabled={readonly || disabled}
       error={error}
       className={props.className}
       overlay={
@@ -147,14 +153,16 @@ export function RichTextField({ value, onChange, field, readonly, error, ...prop
             onCommit={onChange}
             label={richField?.label}
             testIdPrefix="richtext"
+            disabled={disabled}
           >
-            {(draft, setDraft) => (
+            {(draft, setDraft, editorDisabled) => (
               <RichTextEditorSurface
                 value={draft}
                 onChange={setDraft}
                 formatLabel={formatLabel}
                 hint={hint}
                 placeholder={placeholder}
+                disabled={editorDisabled}
                 autoFocus
                 fullHeight
                 textareaTestId="richtext-fullscreen-input"
diff --git a/packages/fields/src/widgets/TextAreaField.tsx b/packages/fields/src/widgets/TextAreaField.tsx
index a57e5dcc1c..9c6b85f258 100644
--- a/packages/fields/src/widgets/TextAreaField.tsx
+++ b/packages/fields/src/widgets/TextAreaField.tsx
@@ -57,6 +57,12 @@ export function TextAreaField({ value, onChange, field, readonly, error, ...prop
   const showFullscreenButton = Boolean(textareaField?.mobile_fullscreen);
 
   const domProps = toDomProps(props);
+  // Resolved once and given to BOTH editing surfaces (objectui#3402). It used
+  // to reach the inline `<Textarea>` alone, so a disabled field greyed out
+  // correctly while its expand button stayed live and the dialog wrote the edit
+  // straight back through `onCommit`. `disabled` also carries the form's
+  // `isSubmitting`, so that hole was open for the duration of every submit.
+  const disabled = Boolean(domProps.disabled);
 
   return (
     <div className="relative">
@@ -65,7 +71,7 @@ export function TextAreaField({ value, onChange, field, readonly, error, ...prop
         value={value || ''}
         onChange={(e) => onChange(e.target.value)}
         placeholder={textareaField?.placeholder}
-        disabled={readonly || domProps.disabled}
+        disabled={readonly || disabled}
         rows={rows}
         maxLength={maxLength}
         aria-invalid={!!error}
@@ -87,6 +93,7 @@ export function TextAreaField({ value, onChange, field, readonly, error, ...prop
           onCommit={onChange}
           label={textareaField?.label}
           testIdPrefix="textarea"
+          disabled={disabled}
           footer={(draft) =>
             maxLength ? (
               <span className="text-xs text-muted-foreground self-center">
@@ -95,11 +102,12 @@ export function TextAreaField({ value, onChange, field, readonly, error, ...prop
             ) : null
           }
         >
-          {(draft, setDraft) => (
+          {(draft, setDraft, editorDisabled) => (
             <Textarea
               autoFocus
               value={draft}
               onChange={(e) => setDraft(e.target.value)}
+              disabled={editorDisabled}
               maxLength={maxLength}
               placeholder={textareaField?.placeholder}
               className="h-full min-h-full resize-none text-base"
diff --git a/packages/fields/src/widgets/__tests__/RichTextField.fullscreenDisabled.test.tsx b/packages/fields/src/widgets/__tests__/RichTextField.fullscreenDisabled.test.tsx
new file mode 100644
index 0000000000..4d25f260de
--- /dev/null
+++ b/packages/fields/src/widgets/__tests__/RichTextField.fullscreenDisabled.test.tsx
@@ -0,0 +1,244 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * A DISABLED `RichTextField` cannot be edited through its fullscreen dialog —
+ * objectui#3402.
+ *
+ * The rich-text half of the same defect the sibling
+ * `TextAreaField.fullscreenDisabled.test.tsx` pins, and it is a genuinely
+ * separate code path rather than a copy of the assertions: this widget reaches
+ * the affordance through `RichTextEditorSurface`'s `overlay` slot, and the
+ * dialog renders the SAME surface again. `disabled` therefore has to be
+ * resolved once and given to both renderings, exactly like `formatLabel` /
+ * `hint` / `placeholder` already were — otherwise the two surfaces disagree
+ * about whether the field is editable, which is the drift #3301 built the
+ * shared surface to prevent.
+ *
+ * Measured on `origin/main` before the fix, by a dynamic probe (the issue
+ * carried static evidence only):
+ *
+ *     PROBE richtext: inline disabled = true , toggle disabled = false
+ *     PROBE richtext: dialog opened = true , dialog input disabled = false
+ *     PROBE richtext: onChange calls = [["# EDITED WHILE DISABLED"]]
+ *
+ * `readonly` was never part of this: the widget early-returns a read-only
+ * display before the affordance is computed. That path is untouched by the fix
+ * and pinned below as a non-regression.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+import { RichTextField } from '../RichTextField';
+import type { FieldMetadata } from '@object-ui/types';
+
+const fieldMeta = (extra: Record<string, unknown> = {}) =>
+  ({
+    name: 'notes',
+    label: 'Notes',
+    type: 'markdown',
+    mobile_fullscreen: true,
+    ...extra,
+  }) as unknown as FieldMetadata;
+
+const toggle = () =>
+  screen.queryByTestId('richtext-fullscreen-toggle') as HTMLButtonElement | null;
+const dialogInput = () =>
+  screen.queryByTestId('richtext-fullscreen-input') as HTMLTextAreaElement | null;
+const saveButton = () =>
+  screen.queryByTestId('richtext-fullscreen-save') as HTMLButtonElement | null;
+
+describe('RichTextField fullscreen — disabled keeps the affordance but makes it inert (objectui#3402)', () => {
+  it('keeps the expand button and disables it', () => {
+    render(
+      <RichTextField value="# hello" onChange={() => {}} field={fieldMeta()} disabled />,
+    );
+
+    expect(toggle()).not.toBeNull();
+    expect(toggle()!.disabled).toBe(true);
+  });
+
+  it('does not open the dialog when that button is clicked anyway', () => {
+    render(
+      <RichTextField value="# hello" onChange={() => {}} field={fieldMeta()} disabled />,
+    );
+
+    fireEvent.click(toggle()!);
+
+    expect(screen.queryByTestId('richtext-fullscreen-dialog')).not.toBeInTheDocument();
+    expect(dialogInput()).toBeNull();
+  });
+
+  it('still disables the inline editing surface', () => {
+    render(
+      <RichTextField value="# hello" onChange={() => {}} field={fieldMeta()} disabled />,
+    );
+
+    const inline = screen.getAllByRole('textbox')[0] as HTMLTextAreaElement;
+    expect(inline.disabled).toBe(true);
+  });
+
+  it('never commits a value while disabled', () => {
+    const onChange = vi.fn();
+    render(
+      <RichTextField value="# hello" onChange={onChange} field={fieldMeta()} disabled />,
+    );
+
+    fireEvent.click(toggle()!);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
+
+describe('RichTextField fullscreen — the dialog holds on its own when disabled arrives mid-edit (objectui#3402)', () => {
+  /**
+   * The `isSubmitting` shape at widget level: the form renderer has already
+   * OR-ed `isSubmitting` into the `disabled` this widget receives, so a submit
+   * starting under an open dialog looks exactly like this rerender.
+   */
+  function openThenDisable(onChange: () => void) {
+    const { rerender } = render(
+      <RichTextField value="# hello" onChange={onChange} field={fieldMeta()} />,
+    );
+    fireEvent.click(toggle()!);
+    expect(dialogInput()).not.toBeNull();
+
+    rerender(
+      <RichTextField value="# hello" onChange={onChange} field={fieldMeta()} disabled />,
+    );
+  }
+
+  it('locks the dialog controls', () => {
+    openThenDisable(vi.fn());
+
+    expect(dialogInput()).not.toBeNull();
+    expect(dialogInput()!.disabled).toBe(true);
+    expect(saveButton()!.disabled).toBe(true);
+  });
+
+  /** Split from the attribute assertions for the reason its textarea sibling
+   * spells out: as a tail on them it could only run when the native attribute
+   * was already doing the work. */
+  it('refuses the write-back even when "Done" is driven directly', () => {
+    const onChange = vi.fn();
+    openThenDisable(onChange);
+
+    fireEvent.change(dialogInput()!, { target: { value: '# EDITED WHILE SUBMITTING' } });
+    fireEvent.click(saveButton()!);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('still lets the user out of the dialog', () => {
+    const onChange = vi.fn();
+    const { rerender } = render(
+      <RichTextField value="# hello" onChange={onChange} field={fieldMeta()} />,
+    );
+
+    fireEvent.click(toggle()!);
+    rerender(
+      <RichTextField value="# hello" onChange={onChange} field={fieldMeta()} disabled />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: /cancel/i }));
+
+    expect(screen.queryByTestId('richtext-fullscreen-dialog')).not.toBeInTheDocument();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
+
+describe('RichTextField fullscreen — the states the fix must not have moved (objectui#3402)', () => {
+  it('still edits fullscreen and commits when the field is editable', () => {
+    const onChange = vi.fn();
+    render(<RichTextField value="# hello" onChange={onChange} field={fieldMeta()} />);
+
+    expect(toggle()!.disabled).toBe(false);
+    fireEvent.click(toggle()!);
+
+    const input = dialogInput()!;
+    expect(input.disabled).toBe(false);
+    expect(saveButton()!.disabled).toBe(false);
+
+    fireEvent.change(input, { target: { value: '# hello from fullscreen' } });
+    fireEvent.click(saveButton()!);
+
+    expect(onChange).toHaveBeenCalledWith('# hello from fullscreen');
+  });
+
+  it('keeps the dialog holding the REAL editor, disabled and not', () => {
+    // #3301's acceptance criterion, re-pinned under `disabled`: the dialog
+    // shows the same surface as the inline one (same format indicator), and now
+    // the same interactivity too — the very thing that had drifted.
+    const onChange = vi.fn();
+    const { rerender } = render(
+      <RichTextField
+        value=""
+        onChange={onChange}
+        field={fieldMeta({ format: 'html' })}
+      />,
+    );
+
+    fireEvent.click(toggle()!);
+    expect(screen.getAllByText('Format: html')).toHaveLength(2);
+
+    rerender(
+      <RichTextField
+        value=""
+        onChange={onChange}
+        field={fieldMeta({ format: 'html' })}
+        disabled
+      />,
+    );
+
+    // Both surfaces present, both inert.
+    expect(screen.getAllByText('Format: html')).toHaveLength(2);
+    // Queried off the document rather than by role: the dialog is modal, so
+    // Radix marks the background `aria-hidden` and a role query sees only the
+    // dialog's own control — which is precisely the textarea NOT at issue here.
+    // Both surfaces have to be disabled, so both are read directly.
+    const textareas = Array.from(
+      document.body.querySelectorAll('textarea'),
+    ) as HTMLTextAreaElement[];
+    expect(textareas).toHaveLength(2);
+    expect(textareas.every((el) => el.disabled)).toBe(true);
+  });
+
+  it('still renders no affordance at all in readonly mode', () => {
+    // The untouched early return — why readonly was never part of this defect.
+    render(
+      <RichTextField value="# hello" onChange={() => {}} readonly field={fieldMeta()} />,
+    );
+
+    expect(toggle()).toBeNull();
+    expect(screen.queryByRole('textbox')).not.toBeInTheDocument();
+    expect(screen.getByText('# hello')).toBeInTheDocument();
+  });
+
+  it('still renders no affordance when the metadata does not opt in, disabled or not', () => {
+    const { rerender } = render(
+      <RichTextField
+        value="# hello"
+        onChange={() => {}}
+        field={fieldMeta({ mobile_fullscreen: false })}
+      />,
+    );
+    expect(toggle()).toBeNull();
+
+    rerender(
+      <RichTextField
+        value="# hello"
+        onChange={() => {}}
+        field={fieldMeta({ mobile_fullscreen: false })}
+        disabled
+      />,
+    );
+    expect(toggle()).toBeNull();
+  });
+});
diff --git a/packages/fields/src/widgets/__tests__/TextAreaField.fullscreenDisabled.test.tsx b/packages/fields/src/widgets/__tests__/TextAreaField.fullscreenDisabled.test.tsx
new file mode 100644
index 0000000000..4736c50974
--- /dev/null
+++ b/packages/fields/src/widgets/__tests__/TextAreaField.fullscreenDisabled.test.tsx
@@ -0,0 +1,246 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * A DISABLED `TextAreaField` cannot be edited through its fullscreen dialog —
+ * objectui#3402.
+ *
+ * `disabled` used to land on the inline `<Textarea>` and nowhere else:
+ * `showFullscreenButton` did not consult it, the call site did not forward it,
+ * and `FullscreenFieldEditor` did not declare it. Measured on `origin/main`
+ * with a probe equivalent to the cases below (the issue itself carried only
+ * static evidence, so the premise was reproduced dynamically before any fix):
+ *
+ *     PROBE textarea: inline disabled = true
+ *     PROBE textarea: toggle present = true, toggle disabled = false
+ *     PROBE textarea: dialog opened = true
+ *     PROBE textarea: dialog input disabled = false
+ *     PROBE textarea: onChange calls = [["EDITED WHILE DISABLED"]]
+ *
+ * That last line is the defect: a disabled field's value changed. The state is
+ * nastier than the read-only one precisely because it LOOKS right — the inline
+ * control is greyed out, and the only way around it is the button sitting on
+ * top of it.
+ *
+ * This is the registered-path half of the same family #3400/PR #3401 fixed on
+ * the built-in `form.tsx` path, and the two are deliberately pinned to the same
+ * behaviours so one form-level setting keeps producing one behaviour:
+ *
+ *   - `readonly` → no affordance at all. Untouched here: this widget's
+ *     early-return renders a read-only display before the button is computed.
+ *     Pinned below as a NON-REGRESSION, because the fix must not have moved it.
+ *   - `disabled` → the button stays but is inert, and the dialog locks on its
+ *     own. `disabled` is not only a static flag: the form renderer computes it
+ *     as `disabled || fieldDisabled || isSubmitting || …`, so it can flip to
+ *     true while the dialog is already open, at which point the button is no
+ *     longer the gate.
+ *
+ * Reachability is not exotic. `ObjectForm` stamps `mobile_fullscreen: true`
+ * onto EVERY long-text field when `ObjectFormSchema.mobile.fullscreenLongText`
+ * is set, without consulting readonly/disabled, and `stripRegisteredFieldProps`
+ * does not strip `disabled` from what registered widgets receive.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+import { TextAreaField } from '../TextAreaField';
+import type { FieldMetadata } from '@object-ui/types';
+
+const fieldMeta = (extra: Record<string, unknown> = {}) =>
+  ({
+    name: 'description',
+    label: 'Description',
+    type: 'textarea',
+    mobile_fullscreen: true,
+    ...extra,
+  }) as unknown as FieldMetadata;
+
+const toggle = () =>
+  screen.queryByTestId('textarea-fullscreen-toggle') as HTMLButtonElement | null;
+const dialogInput = () =>
+  screen.queryByTestId('textarea-fullscreen-input') as HTMLTextAreaElement | null;
+const saveButton = () =>
+  screen.queryByTestId('textarea-fullscreen-save') as HTMLButtonElement | null;
+
+describe('TextAreaField fullscreen — disabled keeps the affordance but makes it inert (objectui#3402)', () => {
+  it('keeps the expand button and disables it', () => {
+    render(
+      <TextAreaField value="hello" onChange={() => {}} field={fieldMeta()} disabled />,
+    );
+
+    // The affordance stays: `disabled` means "not interactive, muted", which is
+    // a different state from `readonly`'s "shown plainly" (no button at all).
+    expect(toggle()).not.toBeNull();
+    expect(toggle()!.disabled).toBe(true);
+  });
+
+  it('does not open the dialog when that button is clicked anyway', () => {
+    // The attribute stops a real user. The handler's own `if (disabled) return`
+    // is pinned separately here because the attribute is not the only thing
+    // that can be lost — a `pointer-events` rule and the attribute both live in
+    // a className/props soup that refactors touch.
+    render(
+      <TextAreaField value="hello" onChange={() => {}} field={fieldMeta()} disabled />,
+    );
+
+    fireEvent.click(toggle()!);
+
+    expect(screen.queryByTestId('textarea-fullscreen-dialog')).not.toBeInTheDocument();
+    expect(dialogInput()).toBeNull();
+  });
+
+  it('still disables the inline control', () => {
+    // The one exit that always held. Kept so a fix that moved `disabled` onto
+    // the dialog and off the inline textarea would be caught.
+    render(
+      <TextAreaField value="hello" onChange={() => {}} field={fieldMeta()} disabled />,
+    );
+
+    const inline = screen.getAllByRole('textbox')[0] as HTMLTextAreaElement;
+    expect(inline.disabled).toBe(true);
+  });
+
+  it('never commits a value while disabled', () => {
+    const onChange = vi.fn();
+    render(
+      <TextAreaField value="hello" onChange={onChange} field={fieldMeta()} disabled />,
+    );
+
+    fireEvent.click(toggle()!);
+
+    // The measured defect, in one assertion: the probe above got
+    // `[["EDITED WHILE DISABLED"]]` here.
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
+
+describe('TextAreaField fullscreen — the dialog holds on its own when disabled arrives mid-edit (objectui#3402)', () => {
+  /**
+   * Open the dialog while editable, then flip `disabled` under it — the
+   * `isSubmitting` case. This widget never sees `isSubmitting`; it sees
+   * `disabled`, which the form renderer has already OR-ed it into, so the honest
+   * widget-level reproduction is the prop flipping true while the dialog is
+   * open, which is exactly what a submit does to it. (The form-level
+   * composition itself is pinned on the built-in path by #3400/PR #3401.)
+   */
+  function openThenDisable(onChange: () => void) {
+    const { rerender } = render(
+      <TextAreaField value="hello" onChange={onChange} field={fieldMeta()} />,
+    );
+    // Opened while the field is still editable — the legitimate state.
+    fireEvent.click(toggle()!);
+    expect(dialogInput()).not.toBeNull();
+
+    // Submit starts. The dialog is still on screen; the button is no longer
+    // the gate.
+    rerender(
+      <TextAreaField value="hello" onChange={onChange} field={fieldMeta()} disabled />,
+    );
+  }
+
+  it('locks the dialog controls', () => {
+    openThenDisable(vi.fn());
+
+    expect(dialogInput()).not.toBeNull();
+    expect(dialogInput()!.disabled).toBe(true);
+    expect(saveButton()!.disabled).toBe(true);
+  });
+
+  /**
+   * Deliberately a SEPARATE test from the attribute assertions above, not a tail
+   * on them. Sharing one test made this assertion unreachable whenever an
+   * attribute assertion failed — i.e. it could only ever run in the world where
+   * the native attribute was already doing the work, which is no pin at all.
+   * Split, it is `commitFullscreen`'s own `if (!disabled)` guard that answers
+   * when the attribute is gone. Verified by removing each in turn: drop the
+   * `disabled` attribute from "Done" and this test stays green (the guard
+   * refuses); drop the guard as well and it turns red with
+   * `onChange` called with "EDITED WHILE SUBMITTING".
+   */
+  it('refuses the write-back even when "Done" is driven directly', () => {
+    const onChange = vi.fn();
+    openThenDisable(onChange);
+
+    fireEvent.change(dialogInput()!, { target: { value: 'EDITED WHILE SUBMITTING' } });
+    fireEvent.click(saveButton()!);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('still lets the user out of the dialog', () => {
+    // Cancel and Esc must stay live in every state, or a submit in flight traps
+    // the user inside a modal they can no longer use.
+    const onChange = vi.fn();
+    const { rerender } = render(
+      <TextAreaField value="hello" onChange={onChange} field={fieldMeta()} />,
+    );
+
+    fireEvent.click(toggle()!);
+    rerender(
+      <TextAreaField value="hello" onChange={onChange} field={fieldMeta()} disabled />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: /cancel/i }));
+
+    expect(screen.queryByTestId('textarea-fullscreen-dialog')).not.toBeInTheDocument();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
+
+describe('TextAreaField fullscreen — the states the fix must not have moved (objectui#3402)', () => {
+  it('still edits fullscreen and commits when the field is editable', () => {
+    // The control case for every "does not" above: without it they would all
+    // pass just as well on a widget that renders no affordance at all.
+    const onChange = vi.fn();
+    render(<TextAreaField value="hello" onChange={onChange} field={fieldMeta()} />);
+
+    expect(toggle()!.disabled).toBe(false);
+    fireEvent.click(toggle()!);
+
+    const input = dialogInput()!;
+    expect(input.disabled).toBe(false);
+    expect(saveButton()!.disabled).toBe(false);
+
+    fireEvent.change(input, { target: { value: 'hello from fullscreen' } });
+    fireEvent.click(saveButton()!);
+
+    expect(onChange).toHaveBeenCalledWith('hello from fullscreen');
+  });
+
+  it('still renders no affordance at all in readonly mode', () => {
+    // The early return this change deliberately did NOT touch: `readonly`
+    // returns a read-only display before `showFullscreenButton` is computed,
+    // which is why readonly was never part of this defect.
+    render(
+      <TextAreaField value="hello" onChange={() => {}} readonly field={fieldMeta()} />,
+    );
+
+    expect(toggle()).toBeNull();
+    expect(screen.queryByRole('textbox')).not.toBeInTheDocument();
+    expect(screen.getByText('hello')).toBeInTheDocument();
+  });
+
+  it('still renders no affordance when the metadata does not opt in, disabled or not', () => {
+    const { rerender } = render(
+      <TextAreaField value="hello" onChange={() => {}} field={fieldMeta({ mobile_fullscreen: false })} />,
+    );
+    expect(toggle()).toBeNull();
+
+    rerender(
+      <TextAreaField
+        value="hello"
+        onChange={() => {}}
+        field={fieldMeta({ mobile_fullscreen: false })}
+        disabled
+      />,
+    );
+    expect(toggle()).toBeNull();
+  });
+});