@object-ui/fields 17.2.0 → 17.5.0

package/dist/widgets/AddressField.d.ts

@@ -1,17 +1,9 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-/**
- * Address data structure
- */
-export interface AddressValue {
-    street?: string;
-    city?: string;
-    state?: string;
-    zipCode?: string;
-    country?: string;
-}
+import { AddressValue } from './address-format';
+export type { AddressValue } from './address-format';
 /**
  * Address field widget - provides a structured address input
- * Supports street, city, state, zip code, and country
+ * Supports street, city, state, postal code, and country
  */
-export declare function AddressField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<AddressValue>): React.JSX.Element;
+export declare function AddressField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<AddressValue>): React.JSX.Element;

package/dist/widgets/AvatarField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * Avatar field widget - provides an avatar/profile picture uploader
  * Supports image URLs or file uploads
  */
-export declare function AvatarField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function AvatarField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/CharacterCount.d.ts

@@ -0,0 +1,56 @@
+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/dist/widgets/CheckboxesField.d.ts

@@ -12,4 +12,4 @@ import { FieldWidgetComponentProps } from './types';
  * first" hint while a dependency is empty, and selections no longer offered
  * (parent changed / predicate flipped) are pruned from the array.
  */
-export declare function CheckboxesField({ value, onChange, field, readonly, className, schema, dependentValues, dependsOn: dependsOnProp, emptyHint: _emptyHint, dataSource: _dataSource, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;
+export declare function CheckboxesField({ value, onChange, field, readonly, className, dependentValues, dependsOn: dependsOnProp, emptyHint, dataSource: _dataSource, error, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;

package/dist/widgets/CodeField.d.ts

@@ -5,4 +5,4 @@ import { FieldWidgetComponentProps } from './types';
  * Uses a simple textarea with monospace font
  * For advanced code editing, use the @object-ui/plugin-editor component
  */
-export declare function CodeField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function CodeField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/ColorField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * Color field widget - provides a color picker input
  * Supports hex color values (e.g., #ff0000)
  */
-export declare function ColorField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function ColorField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/CurrencyField.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-export declare function CurrencyField({ value, onChange, field, readonly, errorMessage, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function CurrencyField({ value, onChange, field, readonly, error, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/EmailField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * EmailField - Email address input with mailto link in readonly mode
  * Renders as a clickable mailto link when readonly, standard email input otherwise
  */
-export declare function EmailField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function EmailField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/FileField.d.ts

@@ -5,7 +5,7 @@ import { FieldWidgetComponentProps } from './types';
  * Supports single and multiple file uploads with configurable accepted file types.
  * L2: File size validation, per-file progress indicators, error messages.
  */
-export declare function FileField({ value, onChange, field, readonly, onUploadingChange, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function FileField({ value, onChange, field, readonly, onUploadingChange, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
 /**
  * FileCell — compact upload control for a line-item grid cell (objectui#2360).
  *

package/dist/widgets/FilterConditionField.d.ts

@@ -32,5 +32,5 @@ export declare function kvToCondition(field: string, v: any, idx: number): Build
  * @internal exported for tests
  */
 export declare function isMatchAllCriteria(parsed: any): boolean;
-export declare function FilterConditionField({ value, onChange, readonly, className, ...props }: FieldWidgetComponentProps<string | object>): React.JSX.Element;
+export declare function FilterConditionField({ value, onChange, readonly, className, error, ...props }: FieldWidgetComponentProps<string | object>): React.JSX.Element;
 export default FilterConditionField;

package/dist/widgets/FullscreenFieldEditor.d.ts

@@ -0,0 +1,45 @@
+import { default as React } from 'react';
+import { FullscreenEditorProps } from '@object-ui/components';
+/**
+ * The fullscreen-edit affordance shared by every long-text widget in this
+ * package (`field:textarea` → `TextAreaField`, `field:markdown` / `field:html`
+ * → `RichTextField`).
+ *
+ * ## This is now a thin wrapper (objectui#3398)
+ *
+ * The affordance, the dialog, the draft/commit state machine and the
+ * `readOnly` / `disabled` semantics all live in `FullscreenEditor`
+ * (`@object-ui/components`). They used to live here AND, separately, in the
+ * form renderer's built-in `textarea` branch — one form-level promise
+ * (`ObjectFormSchema.mobile.fullscreenLongText`, projected onto every long-text
+ * field as `mobile_fullscreen`) answered twice, on the two render paths.
+ *
+ * Two copies of a state machine drift, and these did: objectui#3400 measured a
+ * read-only field editable through the built-in branch's dialog, objectui#3402
+ * measured the same hole for `disabled` here, and #3393 (label in the dialog
+ * title) and #3272 (i18n) each landed on one side before the other. The
+ * maintainer's ruling of 2026-08-10 was one implementation hoisted to the
+ * dependency-legal side — and the measured import graph allows exactly that
+ * direction: this package depends on `@object-ui/components`, which declares no
+ * dependency on `@object-ui/fields` in `dependencies` or `peerDependencies`.
+ *
+ * ## Why the wrapper survives the merge rather than being deleted
+ *
+ * It carries the one thing that is genuinely about THIS package: `readOnly` is
+ * not part of the contract here. Both hosts early-return a read-only DISPLAY
+ * before they compute the affordance (`TextAreaField.tsx`, `RichTextField.tsx`),
+ * so a `readOnly` reaching this component would be a prop with no producer on
+ * this path — the shape this package keeps deleting (objectui#3232/#3233). The
+ * `Omit` below is that statement in the type system, and it is why the hoist did
+ * not simply re-export the primitive. A future host that renders an editor for
+ * read-only fields must widen this type AND pass the prop together; the
+ * primitive already answers it (no affordance at all).
+ *
+ * Everything else — `value` / `onCommit` / `label` / `testIdPrefix` /
+ * `disabled` / `children` / `footer` — passes straight through, so the hosts and
+ * their pins are unchanged. `testIdPrefix` still namespaces this package's ids
+ * (`textarea-`, `richtext-`), distinct from the built-in branch's
+ * `form-textarea-`, so a test can still say which render path it found.
+ */
+export type FullscreenFieldEditorProps = Omit<FullscreenEditorProps, 'readOnly'>;
+export declare function FullscreenFieldEditor(props: FullscreenFieldEditorProps): React.JSX.Element;

package/dist/widgets/GeolocationField.d.ts

@@ -12,4 +12,4 @@ export interface GeolocationValue {
  * Geolocation field widget - provides a location picker with coordinates
  * Supports manual entry and browser geolocation API
  */
-export declare function GeolocationField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<GeolocationValue>): React.JSX.Element;
+export declare function GeolocationField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<GeolocationValue>): React.JSX.Element;

package/dist/widgets/GridField.d.ts

@@ -11,7 +11,8 @@ import { FieldWidgetComponentProps } from './types';
  *
  * Column config (a subset of `GridColumnDefinition`):
  *   { field, label?, type?, options?, width?, required?, prefix?, step? }
- *   type ∈ 'text' | 'number' | 'currency' | 'date' | 'select' | 'lookup' | 'file'
+ *   type ∈ 'text' | 'number' | 'currency' | 'date' | 'datetime' | 'time'
+ *        | 'select' | 'lookup' | 'file'
  *
  * Field-level config (from `GridFieldMetadata`):
  *   columns, min_rows, max_rows, allow_add, allow_delete, total_field
@@ -19,7 +20,16 @@ import { FieldWidgetComponentProps } from './types';
 export interface GridColumn {
     field: string;
     label?: string;
-    type?: 'text' | 'number' | 'currency' | 'date' | 'select' | 'lookup' | 'file';
+    /**
+     * Cell control + read/write adapter for the column.
+     *
+     * `date` / `datetime` / `time` are three DISTINCT controls, not one
+     * (objectui#3569). Collapsing `datetime` onto the `date` control did not
+     * merely under-render it — `<input type="date">` hands back a bare
+     * `YYYY-MM-DD` on change, so touching the day of a `datetime` cell silently
+     * DELETED its time component from the record.
+     */
+    type?: 'text' | 'number' | 'currency' | 'date' | 'datetime' | 'time' | 'select' | 'lookup' | 'file';
     options?: Array<{
         label: string;
         value: string;

package/dist/widgets/ImageField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * ImageField - Image upload widget with preview thumbnails
  * Supports single and multiple image uploads with drag-and-drop and preview display
  */
-export declare function ImageField({ value, onChange, field, readonly, onUploadingChange, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function ImageField({ value, onChange, field, readonly, onUploadingChange, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/LocationField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * LocationField - Geographic coordinate input for latitude and longitude
  * Stores location as { latitude, longitude } object and displays as comma-separated pair
  */
-export declare function LocationField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function LocationField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/LookupField.d.ts

@@ -15,4 +15,4 @@ export interface LookupOption {
  * from the referenced object using `DataSource.find()`.
  * Falls back to static `options` when no DataSource is available.
  */
-export declare function LookupField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function LookupField({ value, onChange, field, readonly, error: fieldError, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/MultiSelectField.d.ts

@@ -14,4 +14,4 @@ import { FieldWidgetComponentProps } from './types';
  * parent first" hint while a dependency is empty, and selections no longer
  * offered (parent changed / predicate flipped) are dropped from the array.
  */
-export declare function MultiSelectField({ value, onChange, field, readonly, className, schema, dependentValues, dependsOn: dependsOnProp, emptyHint: _emptyHint, dataSource: _dataSource, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;
+export declare function MultiSelectField({ value, onChange, field, readonly, className, dependentValues, dependsOn: dependsOnProp, emptyHint, dataSource: _dataSource, error, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;

package/dist/widgets/ObjectField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * ObjectField - JSON object editor
  * Allows editing structured JSON data
  */
-export declare function ObjectField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function ObjectField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/ObjectRefField.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-export declare function ObjectRefField({ value, onChange, readonly, className, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function ObjectRefField({ value, onChange, readonly, className, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
 export default ObjectRefField;

package/dist/widgets/OptionsEmptyState.d.ts

@@ -0,0 +1,59 @@
+import { default as React } from 'react';
+import { HostGroupProps } from './toHostGroupProps';
+/**
+ * The "this option list cannot be filled" state shared by every fixed-option
+ * widget (`SelectField` single, `MultiSelectField`, `RadioField`,
+ * `CheckboxesField`) — objectui#3231.
+ *
+ * ## One producer, one consumer
+ *
+ * `emptyHint` is a declared prop on `FieldWidgetComponentProps`, computed by
+ * the form renderer (`form.tsx`, the `#2284` dependency gate) and forwarded to
+ * these widgets. **When the host supplies it, it wins**: the host resolves the
+ * controlling fields to their human LABELS ("Select Country first"), where a
+ * widget on its own only knows the raw metadata names ("Select country first").
+ * Absent a host hint — a standalone widget, the inline grid editor, an action
+ * param dialog — the widget falls back to its own copy.
+ *
+ * Each of the four widgets used to inline this box, destructure `emptyHint`
+ * into `_emptyHint` and throw it away, then render a hardcoded English literal.
+ * Four independent copies is precisely why they drifted together, so the box
+ * AND the copy live here only: adding a fifth option widget cannot re-introduce
+ * the gap without deliberately re-implementing it.
+ *
+ * ## Fallback copy is translated
+ *
+ * The fallback goes through `useFieldTranslation()` (`fields.options.*`,
+ * present in all ten locale packs) rather than an English string literal — the
+ * gate sentence is the SAME i18n key the form renderer uses, so the two can
+ * never say different things in the same locale.
+ */
+export interface OptionsEmptyStateProps {
+    /**
+     * Host-computed hint. Wins over the widget's own copy whenever it is a
+     * non-empty string — this is the whole point of the prop.
+     */
+    emptyHint?: string;
+    /** The list is waiting on a `dependsOn` controlling field (vs. unconfigured). */
+    gated: boolean;
+    /** Controlling field names, used by the fallback gate sentence. */
+    dependsOnFields: readonly string[];
+    /** Widget-specific stable locator, e.g. `select-empty-${fieldName}`. */
+    testId?: string;
+    /** Widget-specific sizing (the dropdown is a fixed `h-9`, lists grow). */
+    className?: string;
+    /**
+     * The host label's IDREF plumbing, when this box is the whole rendered surface
+     * of a group-labelled field (objectui#3990) — a `checkboxes` / `radio` /
+     * `multiselect` whose option list came back empty renders NOTHING but this
+     * box, so the visible label named zero elements until it landed here.
+     *
+     * A closed three-key type rather than an open props tail: only `id`,
+     * `aria-labelledby` and the `role` that makes them meaningful may reach this
+     * element, and reopening a spread is what objectui#3291 exists to prevent.
+     * Absent for the single `SelectField` — it is not group-labelled, its label
+     * still uses a plain `for`, and it must keep emitting no such attributes.
+     */
+    hostGroupProps?: HostGroupProps;
+}
+export declare function OptionsEmptyState({ emptyHint, gated, dependsOnFields, testId, className, hostGroupProps, }: OptionsEmptyStateProps): React.JSX.Element;

package/dist/widgets/PercentField.d.ts

@@ -5,4 +5,4 @@ import { FieldWidgetComponentProps } from './types';
  * Stores values as decimals (0-1) and displays as percentages (0-100%)
  * Includes a slider for interactive control.
  */
-export declare function PercentField({ value, onChange, field, readonly, errorMessage, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function PercentField({ value, onChange, field, readonly, error, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/PhoneField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * PhoneField - Telephone number input with tel link in readonly mode
  * Renders as a clickable tel link when readonly, standard phone input otherwise
  */
-export declare function PhoneField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function PhoneField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/QRCodeField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * QR Code field widget - generates QR codes from text
  * Uses a simple SVG-based QR code generator
  */
-export declare function QRCodeField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function QRCodeField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/RadioField.d.ts

@@ -12,4 +12,4 @@ import { FieldWidgetComponentProps } from './types';
  * first" hint while a dependency is empty, and a value no longer offered (parent
  * changed / predicate flipped) is cleared.
  */
-export declare function RadioField({ value, onChange, field, readonly, className, schema, dependentValues, dependsOn: dependsOnProp, emptyHint: _emptyHint, dataSource: _dataSource, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function RadioField({ value, onChange, field, readonly, className, dependentValues, dependsOn: dependsOnProp, emptyHint, dataSource: _dataSource, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/RatingField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * Rating field widget - provides a star rating input
  * Supports numeric values from 0 to max (default 5)
  */
-export declare function RatingField({ value, onChange, field, readonly, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function RatingField({ value, onChange, field, readonly, className, error, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/RecipientPickerField.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-export declare function RecipientPickerField({ value, onChange, readonly, className, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function RecipientPickerField({ value, onChange, readonly, className, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
 export default RecipientPickerField;

package/dist/widgets/RecordPickerDialog.d.ts

@@ -126,13 +126,39 @@ export interface RecordPickerDialogProps {
      */
     lookupFilters?: LookupFilterDef[];
     /**
-     * Hard filter constraints applied to every query, in QueryParams.$filter
-     * record form. Unlike `lookupFilters`, entries here never surface in the
-     * filter bar and cannot be overridden by user filter input — used for the
-     * dependent (cascading) lookup chain, where the parent field's value MUST
-     * scope the candidate set (#2215).
+     * Hard filter constraint applied to every query. Unlike `lookupFilters`,
+     * entries here never surface in the filter bar and cannot be overridden by
+     * user filter input.
+     *
+     * Two shapes, discriminated STRUCTURALLY (`Array.isArray`), because the two
+     * callers speak two legitimate vocabularies and neither should be bent into
+     * the other:
+     *
+     * - **`QueryParams.$filter` record form** (`{ account: 'a1' }`) — the
+     *   dependent (cascading) lookup chain, where the parent field's value MUST
+     *   scope the candidate set (#2215). Merged by KEY OVERWRITE, so a cascaded
+     *   value REPLACES a stale `lookupFilters` entry on the same field instead of
+     *   intersecting with it. That precedence is load-bearing: an `and` of both
+     *   would ask for `account = 'stale' AND account = 'a1'` and return nothing.
+     * - **A spec `ViewFilterRule[]`** (`[{ field, operator, value? }]`) — an
+     *   author's `record:related_list.add.picker.filter`, handed over VERBATIM
+     *   (#3831). Lowered by `mergeFilterNodes`, the repo's single filter sink, so
+     *   all 19 `VIEW_FILTER_OPERATORS` reach the wire — including the four
+     *   (`before`, `after`, `is_empty`, `is_not_empty`) the record form has no
+     *   `$op` for. No second operator vocabulary is introduced here: two already
+     *   exist (the spec's `AST_OPERATOR_MAP`, data-objectstack's
+     *   `FILTER_OPERATOR_ALIASES`) and #3948 is what a third costs.
+     *
+     * The discriminator is exact rather than heuristic — every AST node is an
+     * ARRAY and a rule is a plain OBJECT, the same predicate `toFilterNode` uses.
+     *
+     * Typed `unknown` rather than `Record< string, any >` on purpose: that type
+     * ACCEPTED a rule array (TypeScript lets an array satisfy a string index of
+     * `any`), the old object-spread merge then flattened it to
+     * `{"0": {...}, "1": {...}}`, and the query filtered on columns literally
+     * named `0`/`1` — type-check green, wrong query, no diagnostic anywhere.
      */
-    baseFilter?: Record<string, any>;
+    baseFilter?: unknown;
     /**
      * Cell renderer resolver function.
      * When provided, columns with a `type` property will be rendered using the
@@ -140,6 +166,22 @@ export interface RecordPickerDialogProps {
      * Typically pass `getCellRenderer` from @object-ui/fields.
      */
     cellRenderer?: CellRendererResolver;
+    /**
+     * The referenced object's schema `fields` map (field name → field
+     * definition). When provided, cell renderers receive the FULL field
+     * metadata — `options`, `currency`, `scale`, `precision`, `format`,
+     * `reference_to`, … — exactly like the list view enriches its columns from
+     * the object schema. Without it a `select` column falls back to
+     * title-casing the raw stored value instead of resolving the option label
+     * (#3333: `manufacturing` rendered as "Manufacturing" instead of the
+     * authored option label).
+     *
+     * The filter bar reads the same map: a `select` filter column with no
+     * authored `options` takes them from the schema field here, so the filter
+     * panel's dropdown offers exactly the options the table cells render
+     * (#3336 — it used to open empty, leaving the field unfilterable).
+     */
+    fieldsMeta?: Record<string, any>;
     /**
      * Filter bar column definitions.
      * When provided, shows an inline filter bar below the search input.
@@ -185,4 +227,4 @@ export interface RecordPickerDialogProps {
  * states, and single/multi-select.  Responsive: mobile-friendly width
  * via Tailwind breakpoints.
  */
-export declare function RecordPickerDialog({ open, onOpenChange, title, multiple, dataSource, objectName, columns: columnsProp, displayField, titleFormat, idField, pageSize, value, onSelect, onSelectRecords, lookupFilters, baseFilter, cellRenderer, filterColumns, renderFilterBar, renderGrid, }: RecordPickerDialogProps): React.JSX.Element;
+export declare function RecordPickerDialog({ open, onOpenChange, title, multiple, dataSource, objectName, columns: columnsProp, displayField, titleFormat, idField, pageSize, value, onSelect, onSelectRecords, lookupFilters, baseFilter, cellRenderer, fieldsMeta, filterColumns, renderFilterBar, renderGrid, }: RecordPickerDialogProps): React.JSX.Element;

package/dist/widgets/RichTextField.d.ts

@@ -4,5 +4,23 @@ import { FieldWidgetComponentProps } from './types';
  * Rich text field with markdown/HTML support
  * For now, this is a simple textarea. A full implementation would use
  * a rich text editor like TipTap, Lexical, or Slate.
+ *
+ * Reached by forms as `field:markdown` and `field:html`; both resolve here.
+ *
+ * ## Fullscreen editing (objectui#3301)
+ *
+ * `ObjectForm` stamps `mobile_fullscreen` onto the metadata of every long-text
+ * field — textarea AND rich-text — when `ObjectFormSchema.mobile
+ * .fullscreenLongText` is set, and `ObjectFormSchema.mobile`'s own JSDoc has
+ * always promised "textarea/rich-text get an expand button". This widget never
+ * read the flag, so for `field:markdown` / `field:html` that promise did
+ * nothing at all: the producer stamped, and no consumer existed.
+ *
+ * The flag is read off `field` and nowhere else — the single metadata carrier
+ * since objectui#3233 — matching `TextAreaField` read for read, so a
+ * misspelled flag stays inert in both widgets rather than being caught by a
+ * tolerant fallback in one of them. The affordance and dialog themselves come
+ * from the shared `FullscreenFieldEditor`, so one form-level setting keeps
+ * producing one behaviour across both widgets.
  */
-export declare function RichTextField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function RichTextField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/SelectField.d.ts

@@ -5,11 +5,31 @@ import { FieldWidgetComponentProps } from './types';
  *
  * A field declared `multiple: true` selects zero-or-more values (spec:
  * `multiple` is valid on `select`), so it renders the multi-value chip picker
- * — the same widget the `multiselect` type uses. Delegating here (rather than
- * only at a type-resolution layer) means every surface that renders the
- * `select` widget — the object form, the inline grid editor, and
- * `ActionParamDialog` — inherits multi-select identically, with no drift
- * between them. Single-value selects keep the cascading dropdown below.
+ * — the same widget the `multiselect` type uses. Single-value selects keep the
+ * cascading dropdown below.
+ *
+ * The FORM no longer arrives here with `multiple` (objectui#3986):
+ * `mapFieldTypeToFormType` now resolves a `select` + `multiple: true` field to
+ * `field:multiselect`, so the object-form path renders `MultiSelectField`
+ * directly under its own registry id — which is what carries the
+ * `labelling: 'group'` declaration the host label needs. Deciding the widget at
+ * the type-resolution layer is what keeps the declaration and the render from
+ * disagreeing; a delegation invisible to the resolver could not.
+ *
+ * The branch below stays because it is NOT dead — measured entrances that reach
+ * it with `multiple` set, none of which consult that resolver:
+ *
+ *  - **the inline grid editor** — `FieldEditWidget` looks `select` up in its own
+ *    `EDIT_WIDGETS` table, which SHORT-CIRCUITS before the alias map is
+ *    consulted, and forwards the whole metadata object as `field`;
+ *  - **`ActionParamDialog`** — `paramToField` resolves through
+ *    `resolveFormWidgetType`, which likewise returns `select` from
+ *    `fieldWidgetMap` before reaching the alias map, and carries
+ *    `multiple: param.multiple` on the field it builds;
+ *  - **hand-written SDUI** — a `{ type: 'field:select' }` node whose metadata
+ *    declares `multiple`, which addresses this widget by name.
+ *
+ * All three then inherit multi-select from here identically, with no drift.
  *
  * Both branches resolve per-option `visibleWhen` cascading / role-gating through
  * the shared {@link useCascadingOptions} hook (#2715), so single and multi stay

package/dist/widgets/TagsField.d.ts

@@ -5,4 +5,4 @@ import { FieldWidgetComponentProps } from './types';
  * comma) to add it; click a tag's × to remove it. The stored value is a
  * string[]. Used for the `tags` field type.
  */
-export declare function TagsField({ value, onChange, field, readonly, className, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;
+export declare function TagsField({ value, onChange, field, readonly, className, error, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;

package/dist/widgets/TextAreaField.d.ts

@@ -4,9 +4,48 @@ import { FieldWidgetComponentProps } from './types';
  * TextAreaField - Multi-line text input widget
  * Supports configurable row count and preserves whitespace in readonly mode.
  *
- * Mobile UX (round 3): when the host form passes `mobileFullscreen` (or the
- * field schema sets `mobile_fullscreen: true`), an "expand" affordance opens
- * a fullscreen edit dialog — much easier on phones than tapping a 4-row
- * textarea trapped between other fields.
+ * Mobile UX (round 3): when the FIELD METADATA carries `mobile_fullscreen:
+ * true`, an "expand" affordance opens a fullscreen edit dialog — much easier
+ * on phones than tapping a 4-row textarea trapped between other fields.
+ *
+ * That flag has exactly one producer: `ObjectForm` stamps it onto every
+ * long-text field when `ObjectFormSchema.mobile.fullscreenLongText` is set
+ * (`plugin-form/src/ObjectForm.tsx`). It reaches this widget on `field` — the
+ * single metadata carrier since objectui#3233. A `SchemaRenderer`-hosted node
+ * arrives there too: the registry adapter (`withFieldCarrier`) maps the SDUI
+ * `schema` node onto `field` before the widget sees it.
+ *
+ * The affordance, the dialog and the draft/commit semantics live in the shared
+ * `FullscreenFieldEditor` — the same producer stamps the same flag on
+ * rich-text fields, and `RichTextField` renders it from there too
+ * (objectui#3301). Only the EDITOR differs per widget; here it is a
+ * full-height `Textarea`.
+ *
+ * There is deliberately NO widget-prop override. A `mobileFullscreen`
+ * (camelCase) prop was read here and written by nobody in the repo, and the
+ * snake_case `mobile_fullscreen` prop cannot arrive either: the form renderer
+ * strips both `mobile_fullscreen` and `fullscreen` from the props it forwards
+ * to registered widgets (`stripRegisteredFieldProps` in
+ * `components/src/renderers/form/form.tsx`). Reading keys nobody produces
+ * documented a contract that never held and invited the next author to pass a
+ * silently-ignored prop, so the reads are gone (objectui#3232). If a host
+ * override is ever genuinely needed, declare ONE key on
+ * `FieldWidgetComponentProps`, stop stripping it, and have a host pass it.
+ *
+ * ## The character counter (objectui#3408, shared across surfaces in #3417)
+ *
+ * Both editing surfaces below — the inline `<Textarea>` and the fullscreen
+ * dialog's — render the SAME `CharacterCount`, which owns the three-node
+ * GOV.UK shape (decorative digits / accessible description / gated status
+ * region) and the debounce and threshold behind it. Until #3417 the fullscreen
+ * footer had its own hand-written copy that was digits and nothing else, which
+ * is what a second copy of a UI always costs: it drifts, and nothing reports
+ * the drift.
+ *
+ * This widget's remaining job is the part only it can do — mint the two
+ * description ids and name each one in the `aria-describedby` of the control
+ * it describes. The surfaces differ in exactly one behaviour, and it is
+ * declared rather than implied: `announceNearLimit`. Inline announces
+ * (unchanged since #3408); the fullscreen dialog does not.
  */
-export declare function TextAreaField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function TextAreaField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/UrlField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * UrlField - URL input with clickable link in readonly mode
  * Validates URLs to only render http/https links for security
  */
-export declare function UrlField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function UrlField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;