@object-ui/fields 17.5.0 → 17.7.0

package/dist/widgets/uploadingScope.d.ts

@@ -0,0 +1,142 @@
+import * as React from 'react';
+/**
+ * An ambient "is any upload still in flight?" scope for a whole form subtree.
+ *
+ * ## Why this exists beside `onUploadingChange`, and why it is not a second contract
+ *
+ * `onUploadingChange` (ADR-0059) is a PER-WIDGET prop: a host that renders one
+ * upload control and knows its name can pass a callback and keep the answer
+ * itself. That is `ActionParamDialog`, which holds a `Record<paramName, boolean>`
+ * because it lays out its own params one by one.
+ *
+ * A record form cannot do that. Its fields are rendered by the `form` node
+ * renderer from a `fields` array — the host hands over a list of field configs
+ * and never touches the widget — and its upload widgets may sit an arbitrary
+ * number of levels down (a section, a tab, a line-items subform). There is no
+ * place in that chain where the form host can attach a per-widget callback, so
+ * a record form was left with no notion of upload state at all and could submit
+ * mid-upload: the record was written WITHOUT the attachment and reported
+ * success (objectui#10166).
+ *
+ * The scope is the aggregation, not a second producer. `useUploadingSignal` is
+ * still the ONE place a widget's in-flight state is published; it drives the
+ * host prop and this scope from that same call, so the two can never disagree.
+ * A widget reports nothing extra and knows nothing about the scope, and a host
+ * that mounts no provider (every host on `main` today) is unaffected — the
+ * context read answers `null` and the reporting hook is inert.
+ *
+ * ## The one thing a mount-bound report cannot see (objectui#10180)
+ *
+ * A widget's in-flight state is React state, so it ends when the widget
+ * unmounts — and an upload does not. `FileField` does not abort its upload
+ * when it unmounts; the promise settles later and hands the value to the
+ * `onChange` it captured, which the form still accepts. So "the widget
+ * unmounted" is not "the upload ended". A wizard step the user leaves is the
+ * everyday case: leaving the step drops the widget's report, the wizard's final
+ * gate reads `false` while the upload is still running, and a Create pressed in
+ * that window writes the record WITHOUT the attachment and reports success.
+ *
+ * The in-repo upload widgets therefore also hold the scope for the lifetime of
+ * the upload ITSELF, through {@link useUploadingScopeHold}: taken when the
+ * upload starts, released when its promise settles, whether or not the widget
+ * is still mounted by then. While the widget is mounted the two entries start
+ * and stop together, so they cannot disagree; after it unmounts the hold is the
+ * only entry left, and it is the true one. The hold is internal to this package
+ * — it is not exported from the package entry.
+ */
+/**
+ * The write half of a scope. Kept separate from the boolean so a widget that
+ * only REPORTS does not re-render when some other widget's upload flips —
+ * reporters read this context, the host owns the boolean.
+ */
+interface UploadingScopeSink {
+    /**
+     * Record whether the widget registered under `id` is currently uploading.
+     * Reporting `false` for an unknown id is a no-op, which is what makes the
+     * unmount release below safe to call unconditionally.
+     */
+    report: (id: string, uploading: boolean) => void;
+}
+/** What {@link useUploadingScope} hands a host. */
+export interface UploadingScope {
+    /** True while at least one upload widget inside the scope is in flight. */
+    anyUploading: boolean;
+    /**
+     * Passed to {@link UploadingScopeProvider}. Opaque to the host: it is the
+     * channel the widgets report on, not state the host is meant to read.
+     */
+    sink: UploadingScopeSink;
+}
+/**
+ * Own an uploading scope. The host reads `anyUploading` to gate its own submit
+ * and to say WHY that control is disabled, and renders its form subtree inside
+ * {@link UploadingScopeProvider}.
+ *
+ * The host owns the state rather than reading it back out of the context on
+ * purpose: a provider cannot consume its own value, and splitting it would give
+ * "is anything uploading" two authors.
+ */
+export declare function useUploadingScope(): UploadingScope;
+/**
+ * Publish a host's {@link useUploadingScope} to every upload widget rendered
+ * below it. Nesting is legal and CHAINS: an inner scope gates its own Save on
+ * its own uploads AND reports itself to the scope above, so an outer Save whose
+ * write encompasses the inner content is never blind to it. See
+ * {@link useUploadingScope} for why the direction is not a preference.
+ */
+export declare function UploadingScopeProvider({ scope, children, }: {
+    scope: UploadingScope;
+    children: React.ReactNode;
+}): React.ReactElement;
+/**
+ * Report this widget's in-flight state to the enclosing scope, if there is one.
+ * Called by `useUploadingSignal` so every widget that already publishes to a
+ * host prop publishes here too, from the same state.
+ *
+ * ⚠️ The unmount release is load-bearing, not tidiness. A widget removed while
+ * its upload is in flight — a section collapsing, a tab switching, a subform
+ * row deleted — would otherwise leave its id in the set with nothing left to
+ * ever clear it, and the form's Save would stay disabled for the rest of the
+ * session. That failure mode is worse than the defect this scope fixes,
+ * because it has no user-visible cause at all.
+ *
+ * This report covers the widget's MOUNTED lifetime only. The upload's own
+ * lifetime, which can outlast the widget, is covered by
+ * {@link useUploadingScopeHold} — that is what keeps the release above from
+ * also releasing an upload that is still running (objectui#10180).
+ */
+export declare function useUploadingScopeReport(uploading: boolean): void;
+/**
+ * Hold the enclosing scope "uploading" for the lifetime of ONE upload
+ * (objectui#10180). The returned `hold()` is called when an upload starts and
+ * answers that upload's `release()`, to be called once its promise settles —
+ * in a `finally`, so a failed upload releases too.
+ *
+ * ## Why this is separate from the mount-bound report
+ *
+ * {@link useUploadingScopeReport} has to release on unmount (see there), and
+ * an upload keeps running after the widget that started it has unmounted —
+ * `FileField` does not abort it, and its settle still reaches the form's
+ * `onChange`. Leaving a wizard step mid-upload is exactly that: the step's
+ * widgets unmount, their reports are released, and without this hold the
+ * wizard's final gate read `false` while the file was still on its way, so a
+ * Create pressed in that window wrote the record without it.
+ *
+ * ## Why this cannot wedge the form
+ *
+ * The entry is released by the upload's own settle, not by a render, so it is
+ * cleared exactly when the upload ends, mounted widget or not. It can stay
+ * held only as long as the upload itself stays unsettled — the same bound a
+ * mounted widget's report already has — and while it is held the host shows
+ * the reason it gives for any upload in flight.
+ *
+ * The sink is captured when the upload STARTS: the scope the user picked the
+ * file under is the one whose save the file belongs to. A release that reaches
+ * a scope whose host has since unmounted is a no-op, and that host already
+ * released itself from any scope above it on the way out.
+ *
+ * Inert without a provider, like the report. Not exported from the package
+ * entry: it is how this package's own upload widgets report, not a contract.
+ */
+export declare function useUploadingScopeHold(): () => () => void;
+export {};

package/dist/widgets/useCascadingOptions.d.ts

@@ -9,8 +9,9 @@ import { CascadingOptions, OptionLike, DependsOnInput } from '@object-ui/core';
  * empty the list is *gated* — callers surface a "select the parent first" hint
  * rather than an unfiltered set, mirroring the dependent-lookup UX.
  *
- * This is the React wrapper that sources `record` (the live form values) and the
- * predicate scope from context; the actual resolution is the pure
+ * This is the React wrapper: `record` (the live form values) arrives on the
+ * `dependentValues` argument its HOST passes, the predicate scope comes from
+ * context, and the actual resolution is the pure
  * {@link resolveCascadingOptions} in `@object-ui/core`, shared with the form
  * renderer so gating/filtering can never drift between them (#2715).
  */

package/dist/widgets/useRecordQuery.d.ts

@@ -12,7 +12,9 @@ import { DataSource } from '@object-ui/types';
  *   (`{ data, total }`, tolerating a bare array),
  * - owns `records`/`loading`/`error`/`total` plus the `page`/`search`/`sort`
  *   controls, with a debounced search path,
- * - clears itself when `enabled` goes false (e.g. a dialog closing).
+ * - clears itself when it can no longer query — `enabled` false (e.g. a dialog
+ *   closing), or no data source or object name — superseding any read still in
+ *   flight, so that read's answer commits nothing (objectui#10712).
  *
  * The caller keeps ownership of *selection* state and of record→option mapping;
  * this hook only answers "what records match the current query". It is the
@@ -43,7 +45,7 @@ export interface UseRecordQueryOptions {
      */
     paginate?: boolean;
     /**
-     * `$filter` — already merged by the caller (base `lookup_filters`, dependent
+     * `$filter` — already merged by the caller (base `lookupFilters`, dependent
      * lookup chain, candidate hygiene like `banned != true`, …). Compared by
      * value, so a referentially-new-but-equal object each render will not loop.
      *

package/dist/widgets/useUploadingSignal.d.ts

@@ -5,5 +5,13 @@
  * submitted mid-upload (the value only becomes the fileId once the upload
  * settles). Fires with the latest callback and only when `uploading` actually
  * changes, so an inline arrow prop doesn't thrash the parent every render.
+ *
+ * It ALSO reports into the ambient `UploadingScope` when one is mounted above
+ * the widget (objectui#10166). The prop suits a host that renders one named
+ * control; a record form hands its fields to the `form` node renderer and never
+ * touches the widget, so it has no place to attach a callback — the scope is how
+ * that host learns an upload is in flight. Both sinks are driven from this one
+ * call so they cannot disagree, and a host that mounts no provider is
+ * unaffected: `useUploadingScopeReport` is inert without one.
  */
 export declare function useUploadingSignal(uploading: boolean, onUploadingChange?: (uploading: boolean) => void): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/fields",
-  "version": "17.5.0",
+  "version": "17.7.0",
   "description": "Field renderers and registry for Object UI",
   "license": "MIT",
   "type": "module",
@@ -18,25 +18,23 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@objectstack/spec": "^17.0.0-rc.6",
-    "clsx": "^2.1.1",
-    "lucide-react": "^1.29.0",
+    "@objectstack/spec": "^17.6.0",
+    "lucide-react": "^1.43.0",
     "react-markdown": "^10.1.0",
     "rehype-sanitize": "^6.0.0",
     "remark-gfm": "^4.0.1",
-    "tailwind-merge": "^3.6.0",
-    "@object-ui/components": "17.5.0",
-    "@object-ui/core": "17.5.0",
-    "@object-ui/i18n": "17.5.0",
-    "@object-ui/providers": "17.5.0",
-    "@object-ui/react": "17.5.0",
-    "@object-ui/types": "17.5.0"
+    "@object-ui/components": "17.7.0",
+    "@object-ui/core": "17.7.0",
+    "@object-ui/permissions": "17.7.0",
+    "@object-ui/i18n": "17.7.0",
+    "@object-ui/providers": "17.7.0",
+    "@object-ui/react": "17.7.0",
+    "@object-ui/types": "17.7.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
@@ -84,7 +82,7 @@
     "build": "tsc && vite build && node scripts/build-css.mjs",
     "clean": "rm -rf dist",
     "type-check": "tsc --noEmit && tsc -p tsconfig.test.json",
-    "test": "vitest run",
+    "test": "vitest run --root ../.. packages/fields/",
     "lint": "eslint ."
   }
 }

package/dist/widgets/CharacterCount.d.ts

@@ -1,56 +0,0 @@
-import { default as React } from 'react';
-export interface CharacterCountProps {
-    /**
-     * Length of the text this surface is counting. The inline surface passes the
-     * committed value's length; the fullscreen dialog passes the DRAFT's, which
-     * is the number that is true of what the user is looking at.
-     */
-    length: number;
-    /**
-     * The declared cap. Callers render this component only when the field
-     * declares one, so it is non-optional here — a counter with no cap to count
-     * against has nothing to say and must not be mounted at all (an unconditional
-     * live region in every long-text field is the objectui#3408 defect back
-     * again).
-     */
-    maxLength: number;
-    /**
-     * The description node's `id`, minted by the host from `useId()`.
-     *
-     * The host MUST also name it in the edited control's `aria-describedby` —
-     * this component renders the sentence, only the host knows which element is
-     * being described, and a description nothing references is a node no screen
-     * reader will ever reach. That association is asserted from the OUTSIDE (the
-     * tests resolve `aria-describedby` and concatenate the referenced nodes' text,
-     * exactly as an assistive technology does) rather than trusted here.
-     *
-     * Two surfaces of one widget therefore need two ids: the dialog's draft and
-     * the inline value diverge the moment the user types in the dialog, so one
-     * shared id would point both controls at whichever sentence rendered last.
-     */
-    descriptionId: string;
-    /**
-     * Render node 3, the threshold-gated debounced `aria-live` status region.
-     *
-     * Required on purpose — see the component doc above. `false` removes the
-     * region from the DOM entirely (not merely empties it), which is the only
-     * form of "no live region" a test can tell apart from "a live region that
-     * happens to be silent right now".
-     */
-    announceNearLimit: boolean;
-    /**
-     * Classes for the visible digits. Required because placement is entirely the
-     * surface's business — inline pins them to the textarea's bottom-right
-     * corner, the dialog lays them out as a footer item — and a default borrowed
-     * from either one would position the other wrongly while looking deliberate.
-     */
-    className: string;
-    /**
-     * `data-testid` for the visible digits, namespaced per surface
-     * (`textarea-character-count`, `textarea-fullscreen-character-count`) so a
-     * test that finds digits can say WHICH surface it found them on. Same
-     * convention, same reason, as `FullscreenFieldEditor`'s `testIdPrefix`.
-     */
-    testId: string;
-}
-export declare function CharacterCount({ length, maxLength, descriptionId, announceNearLimit, className, testId, }: CharacterCountProps): React.JSX.Element;

package/src/FieldEditWidget.test.ts

@@ -1,133 +0,0 @@
-/**
- * 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.
- */
-
-import { describe, it, expect } from 'vitest';
-import { FieldType } from '@objectstack/spec/data';
-import {
-  FORM_FIELD_TYPES,
-  INLINE_EXCLUDED_FIELD_TYPES,
-  hasFieldEditWidget,
-  isInlineExcludedFieldType,
-  mapFieldTypeToFormType,
-} from './index';
-
-/**
- * A field type the form can render — either a direct widget-map key, or a spec
- * spelling that resolves onto one through the alias table (`secret` →
- * `field:password`, `autonumber` → `field:auto_number`, …).
- *
- * `FORM_FIELD_TYPES` alone is `Object.keys(fieldWidgetMap)`, which does NOT
- * include the alias-only spellings — see the note at index.tsx's
- * `resolveFormWidgetType`. Using it as the definition of "a real type" made the
- * staleness check below reject `secret`, a genuine spec field type the form
- * renders, purely because it arrives via an alias.
- */
-function isRenderableFormType(t: string): boolean {
-  // `text` is the alias table's fallback, so a non-`field:text` result means an
-  // explicit entry exists. `text` itself is a direct widget key, so it is
-  // already covered by the first clause and no real type is missed here.
-  return FORM_FIELD_TYPES.includes(t) || mapFieldTypeToFormType(t) !== 'field:text';
-}
-
-/**
- * Drift-guard: the inline cell editor reuses the form's field widgets, but the
- * two lists were hand-maintained separately and drifted — `lookup` (and other
- * relational types) had a perfectly good form widget yet fell back to a plain
- * text box inline, because nobody wired it up. This pins the contract: every
- * type the FORM can render must have an explicit inline decision — an editor or
- * a documented exclusion — so a new form widget can never again silently become
- * an editable text box (or a missing one) in the grid.
- */
-describe('inline editor ↔ form widget parity', () => {
-  it('every form field type either has an inline editor or is explicitly excluded', () => {
-    const undecided = FORM_FIELD_TYPES.filter(
-      (t) => !hasFieldEditWidget(t) && !INLINE_EXCLUDED_FIELD_TYPES.has(t),
-    );
-    // If this fails: a form widget type has no inline decision. Either add it to
-    // EDIT_WIDGETS (inline-editable) or to INLINE_EXCLUDED_FIELD_TYPES (with a
-    // reason) in FieldEditWidget.tsx.
-    expect(undecided).toEqual([]);
-  });
-
-  it('the exclusion set lists only real form types (no stale entries)', () => {
-    const stale = [...INLINE_EXCLUDED_FIELD_TYPES].filter((t) => !isRenderableFormType(t));
-    expect(stale).toEqual([]);
-  });
-
-  it('credential types are never inline-editable', () => {
-    // The grid's fallback for a type with no inline editor is a PLAIN TEXT input.
-    // Both of these are masked on read, so that input would show the mask as the
-    // value and write it straight back; `secret` also round-trips through an
-    // encrypted store (ADR-0100), so the cell holds an opaque ref, not the value.
-    for (const t of ['password', 'secret']) {
-      expect(hasFieldEditWidget(t), `${t} must not have an inline editor`).toBe(false);
-      expect(INLINE_EXCLUDED_FIELD_TYPES.has(t), `${t} must be explicitly excluded`).toBe(true);
-    }
-  });
-
-  it('relational fields use the standard picker inline (regression: lookup was a text box)', () => {
-    for (const t of ['lookup', 'master_detail', 'user', 'owner']) {
-      expect(hasFieldEditWidget(t)).toBe(true);
-    }
-  });
-
-  it('computed / binary form types are NOT inline-editable (excluded)', () => {
-    for (const t of ['formula', 'summary', 'auto_number', 'file', 'image']) {
-      expect(hasFieldEditWidget(t)).toBe(false);
-      expect(INLINE_EXCLUDED_FIELD_TYPES.has(t)).toBe(true);
-    }
-  });
-
-  it('structured-value types edit inline with their form widget (color/address/location/code/…)', () => {
-    for (const t of ['color', 'address', 'location', 'geolocation', 'code', 'qrcode']) {
-      expect(hasFieldEditWidget(t)).toBe(true);
-      expect(INLINE_EXCLUDED_FIELD_TYPES.has(t)).toBe(false);
-    }
-  });
-});
-
-/**
- * #2942 — the guard above iterates FORM_FIELD_TYPES (the form widget-map
- * keys), so a SPEC field type that reaches the form only through the alias
- * table could sit in neither set and silently fall back to the grid's plain
- * text input: `json`, `composite`, `record`, `repeater`, `tree`, `video`,
- * `audio`, `autonumber` all did. This pins the contract at the spec boundary:
- * every `FieldType` member must resolve (alias-aware) to an inline editor or
- * a documented exclusion.
- */
-describe('inline editor ↔ SPEC FieldType parity (#2942)', () => {
-  const specTypes: string[] = Array.isArray((FieldType as { options?: readonly string[] }).options)
-    ? [...(FieldType as { options: readonly string[] }).options]
-    : [];
-
-  it('reads a non-empty enum from the spec', () => {
-    expect(specTypes, 'could not read FieldType.options from the spec').not.toEqual([]);
-  });
-
-  it('every spec field type resolves to an inline decision (editor or exclusion)', () => {
-    const undecided = specTypes.filter(
-      (t) => !hasFieldEditWidget(t) && !isInlineExcludedFieldType(t),
-    );
-    // If this fails: a spec field type would fall back to a plain text input
-    // inline. Give it a widget (EDIT_WIDGETS / the alias table) or a
-    // documented exclusion (INLINE_EXCLUDED_FIELD_TYPES).
-    expect(undecided).toEqual([]);
-  });
-
-  it('the structured/computed spec spellings are closed corruption paths', () => {
-    // Excluded (alias-aware): editing these through a text box corrupts the value.
-    for (const t of ['composite', 'record', 'repeater', 'video', 'audio', 'autonumber']) {
-      expect(isInlineExcludedFieldType(t), `${t} must be excluded from inline editing`).toBe(true);
-      expect(hasFieldEditWidget(t), `${t} must not resolve to an editor`).toBe(false);
-    }
-    // Editable through their form widgets: json → code editor, tree → lookup picker.
-    for (const t of ['json', 'tree']) {
-      expect(hasFieldEditWidget(t), `${t} must resolve to its form widget`).toBe(true);
-    }
-  });
-});

package/src/FieldEditWidget.tsx

@@ -1,207 +0,0 @@
-/**
- * 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.
- */
-
-import React from 'react';
-import type { FieldWidgetComponentProps } from './widgets/types';
-
-// The SAME dedicated widgets the form renders — reused for in-place editing
-// (e.g. the data grid's inline cell editor) so a select edits as a dropdown, a
-// boolean as a checkbox, a date as a date picker, etc. — never a bare text box.
-import { TextField } from './widgets/TextField';
-import { TextAreaField } from './widgets/TextAreaField';
-import { NumberField } from './widgets/NumberField';
-import { CurrencyField } from './widgets/CurrencyField';
-import { PercentField } from './widgets/PercentField';
-import { SliderField } from './widgets/SliderField';
-import { RatingField } from './widgets/RatingField';
-import { BooleanField } from './widgets/BooleanField';
-import { SelectField } from './widgets/SelectField';
-import { MultiSelectField } from './widgets/MultiSelectField';
-import { RadioField } from './widgets/RadioField';
-import { CheckboxesField } from './widgets/CheckboxesField';
-import { TagsField } from './widgets/TagsField';
-import { DateField } from './widgets/DateField';
-import { DateTimeField } from './widgets/DateTimeField';
-import { TimeField } from './widgets/TimeField';
-import { EmailField } from './widgets/EmailField';
-import { PhoneField } from './widgets/PhoneField';
-import { UrlField } from './widgets/UrlField';
-// Relational pickers — the SAME standard widgets the form uses. They read the
-// related-object dataSource from SchemaRendererContext (which the grid already
-// provides), so they drop straight into an inline cell.
-import { LookupField } from './widgets/LookupField';
-import { UserField } from './widgets/UserField';
-// Structured-value editors — lightweight (no map/code-editor deps), same
-// widgets the form uses. Drop into a cell like the rest.
-import { ColorField } from './widgets/ColorField';
-import { AddressField } from './widgets/AddressField';
-import { LocationField } from './widgets/LocationField';
-import { GeolocationField } from './widgets/GeolocationField';
-import { CodeField } from './widgets/CodeField';
-import { QRCodeField } from './widgets/QRCodeField';
-// The FORM's spec-alias table (`json` → `field:code`, `tree` → `field:lookup`,
-// …) — inline resolution reuses it so spec spellings get the form's decision.
-import { mapFieldTypeToFormType } from './field-type-alias';
-
-/**
- * Field types that edit in place with a dedicated widget. Keyed by the raw
- * field `type` (the widget map mirrors the form's `mapFieldTypeToFormType`).
- * Rich/heavy types (file, image, lookup, richtext, …) are intentionally absent
- * so callers fall back to their own simpler editor.
- */
-const EDIT_WIDGETS: Record<string, React.ComponentType<FieldWidgetComponentProps<any>>> = {
-  text: TextField,
-  textarea: TextAreaField,
-  number: NumberField,
-  currency: CurrencyField,
-  percent: PercentField,
-  slider: SliderField,
-  progress: SliderField,
-  rating: RatingField,
-  boolean: BooleanField,
-  toggle: BooleanField,
-  select: SelectField,
-  status: SelectField,
-  multiselect: MultiSelectField,
-  radio: RadioField,
-  checkboxes: CheckboxesField,
-  tags: TagsField,
-  date: DateField,
-  datetime: DateTimeField,
-  time: TimeField,
-  email: EmailField,
-  phone: PhoneField,
-  url: UrlField,
-  // Relational — the record/user pickers, same as the form (the form maps
-  // master_detail to the single-value LookupField too, see fieldWidgetMap).
-  lookup: LookupField,
-  master_detail: LookupField,
-  user: UserField,
-  owner: UserField,
-  // Structured-value editors — same widgets the form uses.
-  color: ColorField,
-  address: AddressField,
-  location: LocationField,
-  geolocation: GeolocationField,
-  code: CodeField,
-  qrcode: QRCodeField,
-};
-
-/**
- * Form field types that are deliberately NOT given an inline editor — every
- * other form widget type must be in {@link EDIT_WIDGETS}. This pairing is
- * enforced by a test against the form's widget map (`FORM_FIELD_TYPES`) so the
- * two can't silently drift again (which is how `lookup` was missed). To add a
- * type to inline editing, move it from here into EDIT_WIDGETS.
- */
-export const INLINE_EXCLUDED_FIELD_TYPES = new Set<string>([
-  // Computed / read-only — the grid keeps these non-editable (no value to author).
-  'formula', 'summary', 'auto_number',
-  // Binary / attachment — edited from the record form, shown read-only in the grid.
-  'file', 'image', 'avatar', 'signature',
-  // Heavy / full editors — better in the record form than a cell.
-  'markdown', 'html', 'richtext',
-  // Credentials — never inline-editable. Both are masked on read, so the cell has
-  // no real value to seed an editor with, and the grid's fallback is a PLAIN TEXT
-  // input: it would render the mask as if it were the value and write it straight
-  // back. `secret` additionally round-trips through an encrypted store (ADR-0100,
-  // data/field.zod.ts) — the cell holds an opaque ref, not the secret.
-  'password', 'secret',
-  // Containers / non-authorable — a sub-form / sub-grid / embedding vector
-  // doesn't belong in a single cell.
-  'object', 'grid', 'vector',
-  // Widget-hint-only pickers — authored in the record form (they depend on
-  // sibling fields / a loaded object catalog), not inline in a grid cell.
-  'object-ref', 'filter-condition', 'recipient-picker',
-]);
-
-/** Field types whose value is chosen in one discrete gesture (no free typing). */
-export const DISCRETE_EDIT_TYPES = new Set<string>([
-  'boolean', 'toggle', 'select', 'status', 'radio', 'rating',
-]);
-
-/**
- * Resolve a field type to its inline-editing key: the raw type when the
- * widget/exclusion tables name it directly, otherwise its form-alias target
- * (`mapFieldTypeToFormType`, `field:` prefix stripped).
- *
- * The tables are keyed by the FORM's spellings, but spec field types reach
- * this layer in the SPEC's spellings — `json`, `tree`, `composite`, `record`,
- * `repeater`, `video`, `audio`, `autonumber` are aliases in the form map and
- * were keys in NEITHER table here, so the grid silently fell back to a plain
- * text input for all of them: typing over structured JSON or a hierarchy ref
- * is a value-corruption path (#2942). Resolving through the same alias table
- * the form uses gives each spec type the form's own decision: `json` → the
- * code editor, `tree` → the lookup picker, and the container/computed/binary
- * families → their documented exclusions.
- */
-function resolveInlineEditType(type: string): string {
-  if (type in EDIT_WIDGETS || INLINE_EXCLUDED_FIELD_TYPES.has(type)) return type;
-  return mapFieldTypeToFormType(type).replace(/^field:/, '');
-}
-
-/** True when a field type has a dedicated in-place edit widget. */
-export function hasFieldEditWidget(type: string | undefined): boolean {
-  return !!type && resolveInlineEditType(type) in EDIT_WIDGETS;
-}
-
-/**
- * True when a field type is deliberately NOT inline-editable (alias-aware:
- * `composite` resolves to the excluded `object`, `video` to `file`, …).
- * Grid hosts must treat these as read-only cells — falling back to a plain
- * text editor is exactly the corruption path the exclusion exists to close.
- */
-export function isInlineExcludedFieldType(type: string | undefined): boolean {
-  return !!type && INLINE_EXCLUDED_FIELD_TYPES.has(resolveInlineEditType(type));
-}
-
-/**
- * Relational picker widgets (lookup / master_detail / user / owner) render best
- * in a grid cell as a single-line, borderless trigger — so the selected
- * record's NAME shows inside the trigger instead of a chip stacked above a
- * separate "Select…" button (which double-stacks and wastes the row height).
- * This mirrors how the line-item grid (`GridField`) renders its lookup cells.
- */
-const COMPACT_EDIT_TYPES = new Set<string>(['lookup', 'master_detail', 'user', 'owner']);
-
-/**
- * Render the dedicated edit widget for a field's type — the SAME control the
- * form uses — as a controlled `{ value, onChange, field }` input. Returns
- * `null` for types without a registered widget so the caller can fall back to
- * a plain editor.
- *
- * `autoFocus` is forwarded because an inline-edit host enters edit mode ON a
- * field and expects the caret to land there (objectui#4220 — the detail page's
- * delegation): each widget's own `toDomProps` whitelist already carries it onto
- * the real focusable control, so nothing here needs to know which element that
- * is. A host that passes nothing is unaffected.
- */
-export function FieldEditWidget({
-  field,
-  value,
-  onChange,
-  readonly,
-  autoFocus,
-}: FieldWidgetComponentProps<any>): React.ReactElement | null {
-  const resolved = field?.type ? resolveInlineEditType(field.type) : undefined;
-  const Widget = resolved ? EDIT_WIDGETS[resolved] : undefined;
-  if (!Widget) return null;
-  // `compact` is a declared widget prop (objectui#3221 closed this type), so
-  // the spread no longer needs an `any` escape hatch to get past it.
-  const compactProps = resolved && COMPACT_EDIT_TYPES.has(resolved) ? { compact: true } : {};
-  return (
-    <Widget
-      field={field}
-      value={value}
-      onChange={onChange}
-      readonly={readonly}
-      autoFocus={autoFocus}
-      {...compactProps}
-    />
-  );
-}