@object-ui/fields 17.3.0 → 17.6.0

package/dist/widgets/PercentField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * PercentField - Percentage input with configurable decimal precision
  * Stores values as decimals (0-1) and displays as percentages (0-100%)

package/dist/widgets/PhoneField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * PhoneField - Telephone number input with tel link in readonly mode
  * Renders as a clickable tel link when readonly, standard phone input otherwise

package/dist/widgets/QRCodeField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * QR Code field widget - generates QR codes from text
  * Uses a simple SVG-based QR code generator

package/dist/widgets/RadioField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * RadioField - choose exactly one value from a fixed option set, rendered as a
  * radio group. The stored value is the selected option value (string). Used for

package/dist/widgets/RatingField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * Rating field widget - provides a star rating input
  * Supports numeric values from 0 to max (default 5)

package/dist/widgets/RecipientPickerField.d.ts

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

package/dist/widgets/RecordPickerDialog.d.ts

@@ -1,13 +1,11 @@
 import { default as React } from 'react';
 import { DataSource, LookupColumnDef, LookupFilterDef } from '@object-ui/types';
+import { LookupCellRendererResolver } from './lookupColumnDisplay.js';
 /**
  * Cell renderer function signature — matches getCellRenderer from @object-ui/fields.
  * Accepts a field type and returns a React component that renders a formatted cell.
  */
-export type CellRendererResolver = (fieldType: string) => React.FC<{
-    value: any;
-    field: any;
-}>;
+export type CellRendererResolver = LookupCellRendererResolver;
 /**
  * Filter column definition used by the inline filter bar.
  * A subset of LookupColumnDef enriched with filter-specific metadata.
@@ -126,13 +124,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

package/dist/widgets/RichTextField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * Rich text field with markdown/HTML support
  * For now, this is a simple textarea. A full implementation would use
@@ -22,5 +22,41 @@ import { FieldWidgetComponentProps } from './types';
  * 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.
+ *
+ * ## Readonly display (objectui#5498)
+ *
+ * The readonly early return used to render `{value}` as a React TEXT CHILD,
+ * so a readonly field of any of the three types showed the user the markup
+ * SOURCE of their own content — a `markdown` field's asterisks and hashes, a
+ * `richtext` field's tags. The `prose` classes on that wrapper were the tell:
+ * they exist to style RENDERED rich content and there was none to style. Every
+ * other read surface — grid, kanban card, gallery, related list, dashboard
+ * record panel, record detail read mode — dispatches through `getCellRenderer`
+ * and renders the same stored bytes FORMATTED, so one field disagreed with
+ * itself depending on which surface it was read on, and this branch was the
+ * one disagreeing with the platform.
+ *
+ * It now renders through {@link richTextCellRenderer} — literally the same
+ * components `getCellRenderer` resolves, one table shared by both (see
+ * `./richTextDisplay.tsx`), so the html/richtext path carries that renderer's
+ * `sanitizeHtml` trust boundary rather than a second hand-rolled escape, and a
+ * future change to either pipeline moves both surfaces at once.
+ *
+ * ## Host plumbing (objectui#4810)
+ *
+ * The editable branch had no `toDomProps` at all, so everything
+ * `<FormControl>`'s Radix `Slot` hands down — the field's `id`, the
+ * `aria-describedby` naming its `<FormDescription>` and `<FormMessage>` —
+ * arrived as props and landed on no element. Measured on a real form: the
+ * visible label's `for` pointed at an id nothing carried (`for=DANGLING`) and
+ * the rendered description had zero consumers, for all three registry keys
+ * (`markdown` / `html` / `richtext`) since they are this one widget.
+ *
+ * The fix is objectui#3318's standing recipe — `toDomProps(props)` spread onto
+ * the REAL focusable control, which here is the `<Textarea>` inside
+ * `RichTextEditorSurface`, never the wrapper `<div>`s (a non-focusable wrapper
+ * carrying the id would satisfy `document.getElementById` and still leave the
+ * label inert). Only the inline surface receives it; see `domProps` there for
+ * why the dialog's copy must not.
  */
 export declare function RichTextField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/SelectField.d.ts

@@ -1,15 +1,35 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * SelectField - dropdown selection widget.
  *
  * 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/SignatureField.d.ts

@@ -1,7 +1,37 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * Signature field widget - provides a signature pad for capturing signatures
  * Outputs signature as a base64 PNG image
+ *
+ * ## Naming, and the half that is deliberately absent (objectui#3318)
+ *
+ * This widget forwarded nothing a host handed it — every branch below wrote its
+ * attributes by hand — so its visible label pointed `for` at an id no element
+ * in the row carried, and the rendered help text had zero consumers. Measured
+ * on `origin/main`, a real form, this field required and freshly failed:
+ *
+ * ```
+ * signature  labelFor=…-form-item -> DANGLING  descConsumers=0  ids=[]
+ * ```
+ *
+ * The name and the description arrive here, on the container, through
+ * {@link toHostGroupProps} — the objectui#3961 route for a widget whose surface
+ * no `<label for>` can reach (`<canvas>` is not a labelable element), and which
+ * therefore declares `labelling: 'group'` in `FIELD_WIDGET_LABELLING`.
+ * `'instead-of-the-inputs'` because this field renders no input of its own for
+ * the description to land on: the Clear button is auxiliary — it acts on the
+ * value, it is not the value's control — the same reading that put
+ * `geolocation`'s focusable "View on map" link on that side of the split.
+ *
+ * `aria-invalid` and `aria-required` are NOT here, and their absence is a
+ * verdict rather than an omission. The drawing surface has no keyboard path at
+ * all (measured: this row offers zero focusable elements while empty — the only
+ * candidate, Clear, is `disabled` until something has been drawn), so there is
+ * no element assistive technology would read a control state from. Marking the
+ * container instead would announce a state with no control behind it — the
+ * non-focusable-wrapper move objectui#3291 and #3318 both draw the line
+ * against. The type is recorded in that sweep's NOT_APPLICABLE ledger with a
+ * guard that turns red the day a real control appears here.
  */
-export declare function SignatureField({ value, onChange, readonly }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function SignatureField({ value, onChange, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/SliderField.d.ts

@@ -1,7 +1,42 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * Slider field widget - provides a range slider input
  * Supports numeric values with configurable min, max, and step
+ *
+ * ## Where the host's facts go, and why (objectui#3318)
+ *
+ * This widget used to read exactly two keys off its props (`disabled`,
+ * `className`) and forward nothing else, so everything `<FormControl>`'s Slot
+ * delivered was dropped on the floor. Measured on `origin/main`, a real form
+ * with a required slider that had just failed validation:
+ *
+ * ```
+ * ariaInvalidTrue=[]   labelFor=…-form-item -> DANGLING
+ * descConsumers=0      ids=[]   <- no element of the row carried an id at all
+ * ```
+ *
+ * Three channels, one cause. The DOM pass-through now goes to the THUMB — the
+ * `span[role="slider"]` a keyboard user lands on, which is where ARIA state
+ * belongs — through the `thumbProps` the primitive grew for this
+ * (`lib/slider-thumb.ts`; the shadcn `ui/slider.tsx` renders its thumb
+ * internally and exports only `Slider`, so it cannot be addressed from here
+ * the way objectui#3306 addressed `SelectTrigger`).
+ *
+ * The split of which keys stay on Root is `SelectField`'s, key for key:
+ *
+ * - `name`: Root owns the hidden input that takes part in form submission; on
+ *   a `span` it is not even DOM-legal, and is exactly the leak objectui#3291
+ *   sweeps for.
+ * - `disabled`: Root is the single authority (it disables the thumb and the
+ *   hidden input together); forwarding the raw prop to the thumb as well would
+ *   give the state a second, OR-merged author.
+ *
+ * The visible label reaches the thumb by IDREF, not by `for`: a
+ * `span[role="slider"]` is not one of HTML's labelable elements, so this widget
+ * is declared `labelling: 'group'` for the same reason `file` is — see
+ * `FIELD_WIDGET_LABELLING` in `../index` and objectui#3961. No extra
+ * `role="group"` wrapper: there is one control here, and `slider` is a role
+ * that carries a name perfectly well on its own.
  */
-export declare function SliderField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function SliderField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/SummaryField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * SummaryField - Read-only aggregation field
  * Values are aggregated from related records and cannot be edited

package/dist/widgets/TagsField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TagsField - free-form list of string tags. Type a value and press Enter (or
  * comma) to add it; click a tag's × to remove it. The stored value is a

package/dist/widgets/TextAreaField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TextAreaField - Multi-line text input widget
  * Supports configurable row count and preserves whitespace in readonly mode.
@@ -35,7 +35,11 @@ import { FieldWidgetComponentProps } from './types';
  * ## 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
+ * dialog's — render the SAME `CharacterCount`. It lives in
+ * `@object-ui/components` since objectui#3439, hoisted there so the form
+ * renderer's built-in `textarea` branch renders that very component too rather
+ * than growing a third copy; this widget's use of it is unchanged. It 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

package/dist/widgets/TextField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TextField - Standard single-line or multi-line text input
  * Automatically renders as a textarea when rows are configured in field metadata

package/dist/widgets/TimeField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TimeField - Time picker input widget
  * Uses native time input for hour and minute selection

package/dist/widgets/UrlField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * UrlField - URL input with clickable link in readonly mode
  * Validates URLs to only render http/https links for security

package/dist/widgets/UserField.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 export declare function UserField(props: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/VectorField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * VectorField - Vector/embedding data display
  * Shows vector embeddings in a read-only format

package/dist/widgets/_cell-renderer-bridge.d.ts

@@ -1,3 +1,3 @@
-import { CellRendererResolver } from './RecordPickerDialog';
+import { CellRendererResolver } from './RecordPickerDialog.js';
 export declare function setCellRendererResolver(resolver: CellRendererResolver): void;
 export declare function getCellRendererResolver(): CellRendererResolver | undefined;

package/dist/widgets/address-format.d.ts

@@ -0,0 +1,88 @@
+import { AddressValue } from '@objectstack/spec/data';
+/**
+ * Address data structure — `z.input` of `@objectstack/spec`'s
+ * `AddressValueSchema`, which is what the platform stores and what
+ * `/api/v1/data/**` serves back.
+ *
+ * The postal code is spelled `postalCode` (objectstack#5143). `AddressField`
+ * used to read and write `zipCode`, a key that appears nowhere in the spec, so
+ * the stored postal code never reached the input — and whatever the user then
+ * typed into that apparently-empty box was written under a key
+ * `AddressValueSchema` strips: lost outright on a new record, and on an
+ * existing one silently discarded while the stale stored value survived. (A
+ * postal code nobody touched did survive an unrelated edit, because the write
+ * spread the whole stored object through; the issue's account of that half is
+ * corrected in `AddressField.postalCode.test.tsx`.) One name, on both sides:
+ * the contract's.
+ *
+ * IMPORTED rather than declared since objectui#4167. rc.6 publishes
+ * `AddressValue` under this exact name, and the local copy — whose own comment
+ * already claimed to be "the part names of `AddressSchema`" — declared five of
+ * the seven parts. `countryCode` and `formatted` were missing, which is
+ * objectstack#4115's failure class precisely: a canonical CLAIM over a narrower
+ * shape, believed by the next reader. The claim is now the code.
+ *
+ * `AddressField` still renders five inputs and {@link formatAddress} still
+ * composes five parts, and that is a deliberate split rather than an omission:
+ * `formatted` is a derived one-line rendering of the parts (what this module
+ * computes) and `countryCode` is the ISO pair for `country`, neither of which a
+ * human types into a part box. Binding the type does not publish them as
+ * inputs — it stops the type from asserting the platform cannot store them, and
+ * it means a write from the widget no longer looks type-clean while dropping a
+ * key the contract carries: the `{ ...address }` spread in `handleFieldChange`
+ * preserves both, and now says so.
+ *
+ * The declaration moved here (objectui#4037) so the display cell renderer and
+ * the widget share one definition; the SOURCE of that definition is the spec.
+ */
+export type { AddressValue };
+/**
+ * The shape written by builds up to and including 17.0.0-rc.1, whose postal
+ * code landed under `zipCode` (objectstack#5143). Read-time compatibility ONLY,
+ * and deliberately not part of {@link AddressValue}: authoring code must not be
+ * able to spell `zipCode`, and nothing here ever writes it back — the first
+ * edit of any part normalizes the record onto `postalCode` (see
+ * `AddressField`'s `handleFieldChange`). This is not a producer alias to be
+ * honoured forever; it exists to carry data THIS widget mis-wrote, and can go
+ * once no such data remains.
+ */
+export type LegacyAddressValue = AddressValue & {
+    zipCode?: string;
+};
+/** Postal code of a stored address, preferring the canonical key. */
+export declare function readPostalCode(addr: AddressValue): string | undefined;
+/**
+ * Formats a stored address as a single line, in the part order the reader's
+ * locale writes addresses in.
+ *
+ * Two orders, and the second is exactly the first reversed:
+ *
+ *   - **small-to-large** (default; `en` and every Latin/Cyrillic/Arabic locale
+ *     this repo ships) — `Street, City, State ZIP, Country`. Unchanged from
+ *     what `AddressField`'s readonly branch has always produced, so English and
+ *     provider-less rendering are byte-identical to before.
+ *   - **large-to-small** ({@link LARGE_TO_SMALL_LANGUAGES}) — `Country, ZIP
+ *     State, City, Street`. A `zh` console rendering a Chinese address
+ *     largest-first is the whole point of objectui#4028: `中国, 310000 浙江,
+ *     杭州, 中策路 1 号` rather than the US-ordered line it produced before.
+ *
+ * Only the ORDER varies. The separator stays `', '` in both, because that is
+ * not what the issue reports and because these lines carry mixed-script data —
+ * a US address read on a `zh` console would look stranger under fullwidth
+ * punctuation than under the comma it already has.
+ *
+ * The state/postal-code pair keeps its one comma-delimited group in both
+ * orders, space-separated inside it ("CA 94102" / "310000 浙江"); either part
+ * alone occupies the group by itself. Missing parts are dropped rather than
+ * spaced over, so a street-only address is `"中策路 1 号"` and never `", , ,"`.
+ *
+ * Returns `''` when no part is usable — callers decide what an empty address
+ * looks like (an `EmptyValue` placeholder for the cell renderer), and a value
+ * carrying no recognized part at all is NOT silently blanked: see
+ * `AddressCellRenderer`, which falls back to JSON so unknown data stays visible.
+ *
+ * @param locale - BCP-47 tag from `useDisplayLocale()`. Omitted (tests, and any
+ *   caller with no React context) means the small-to-large default, which is
+ *   what this function did unconditionally before objectui#4028.
+ */
+export declare function formatAddress(addr: AddressValue, locale?: string): string;

package/dist/widgets/file-size-guard.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The client-side `maxSize` guard shared by the file and image widgets
+ * (objectui#4141).
+ *
+ * Why this is shared rather than mirrored per widget: the guard is the only
+ * thing standing between a declared `maxSize` and a real `presigned → PUT →
+ * complete` round trip, and `paramToField` copies `maxSize` onto the field
+ * config for **every** param type regardless of which widget ends up rendering
+ * it. So a widget that re-derives the check drifts silently — the image param
+ * shipped receiving the constraint and never reading it, while the file param
+ * rejected the identical pick, and nothing failed until QA drove the two side by
+ * side. One exported function makes the difference visible: a widget either
+ * calls it or conspicuously does not.
+ *
+ * Both widgets deliberately share the `fields.file.exceedsMaxSize` key too. The
+ * sentence names a file and a limit and says nothing file-widget-specific, it is
+ * already translated in all 11 built-in locales, and a parallel `fields.image.*`
+ * twin would be the same sentence maintained twice — drifting the moment one
+ * translator rewords one of them.
+ */
+/**
+ * Minimal shape of the i18next `t` this module needs, matching the established
+ * `TranslateFn` pattern in `app-shell/src/providers/writeWarningToast`.
+ */
+export type TranslateFn = (key: string, options?: Record<string, unknown>) => string;
+/**
+ * The rejection message for a pick that exceeds `maxSize`, or `null` when the
+ * pick is within the limit — so a caller reads it as `if (err) reject`.
+ *
+ * A falsy `maxSize` (undeclared, or an explicit `0`) means **unrestricted**,
+ * preserving the `if (maxSize && …)` semantics the file widget has always
+ * applied: an undeclared limit must never turn into a 0-byte one.
+ *
+ * Takes `name` and `size` separately instead of a `File` because the image
+ * widget's crop path validates a re-encoded `Blob`, which carries no name of its
+ * own — that name comes from the cropper's output.
+ */
+export declare function maxSizeError(t: TranslateFn, pick: {
+    name: string;
+    size: number;
+}, maxSize: number | undefined): string | null;

package/dist/widgets/lookupColumnDisplay.d.ts

@@ -0,0 +1,93 @@
+import { default as React } from 'react';
+import { LookupColumnDef } from '@object-ui/types';
+/**
+ * Cell renderer function signature — matches `getCellRenderer` from
+ * `@object-ui/fields`. Re-declared here (rather than imported from
+ * RecordPickerDialog) so this module sits BELOW both consumers in the import
+ * graph and neither surface can pull the other in.
+ */
+export type LookupCellRendererResolver = (fieldType: string) => React.FC<{
+    value: any;
+    field: any;
+}>;
+/**
+ * A select option as the object schema declares it — `{ value, label }` plus
+ * whatever the renderer also reads (`color`, …), which the i18n translation
+ * carries through untouched.
+ */
+export type SchemaOption = {
+    value: any;
+    label: string;
+    [key: string]: any;
+};
+/** Translate a schema field's options through the shared i18n option path. */
+export type OptionTranslator = (objectName: string, fieldName: string, options: SchemaOption[]) => SchemaOption[];
+/**
+ * Normalise a lookup_columns entry (string | LookupColumnDef) into a
+ * concrete LookupColumnDef object.
+ */
+export declare function normalizeColumn(col: string | LookupColumnDef): LookupColumnDef;
+/**
+ * Pretty-print a field name as a column header label.
+ * Converts snake_case / camelCase to Title Case.
+ */
+export declare function fieldToLabel(field: string): string;
+/**
+ * Resolve a field's select options from the referenced object's schema field
+ * definition (`fieldsMeta[field]`), translated through the shared i18n option
+ * path.
+ *
+ * This is the SINGLE source for every surface that needs option labels: the
+ * picker table cells (#3333), the picker's filter panel select inputs (#3336)
+ * and the inline dropdown's option preview (#5492) — so a picker column, the
+ * filter input for that same column and the dropdown row can never disagree
+ * about what an option is called.
+ *
+ * Returns `undefined` when the schema field declares no options: a select
+ * field with no authored options genuinely has nothing to offer, and
+ * synthesising entries from the loaded page's raw stored values would paper
+ * over the metadata gap with a list that changes per page.
+ */
+export declare function resolveSchemaOptions(meta: {
+    options?: unknown;
+} | undefined, objectName: string, fieldName: string, translateOptions: OptionTranslator): SchemaOption[] | undefined;
+/**
+ * Field descriptors handed to the type-aware cell renderers, enriched from the
+ * referenced object's schema (`fieldsMeta`) the same way the list view enriches
+ * its columns. This is what lets a `select` column resolve its option label
+ * (options + i18n) instead of title-casing the raw value (#3333), and what
+ * carries `reference` / `reference_to` through to the lookup cell renderer so
+ * an unresolved foreign-key id resolves to a name (#5492).
+ *
+ * Columns whose def carries no `type` inherit the schema field's type, so
+ * string-authored `lookup_columns` format identically to object-authored ones.
+ */
+export declare function buildLookupColumnDescriptors(columns: LookupColumnDef[], fieldsMeta: Record<string, any> | undefined, objectName: string, translateOptions: OptionTranslator): Record<string, any>;
+export interface LookupColumnRenderContext {
+    /** Field descriptors from {@link buildLookupColumnDescriptors}. */
+    descriptors: Record<string, any>;
+    /** Type-aware renderer resolver; when absent every cell degrades to text. */
+    cellRenderer?: LookupCellRendererResolver;
+    /** The referenced object's `titleFormat`, applied to the display column. */
+    titleFormat?: string | null;
+    /** The lookup's display field — the column the title template stands in for. */
+    displayField?: string;
+    /** Locale for the plain-text `$date` fallback. */
+    displayLocale?: string;
+}
+/**
+ * Render one column of one candidate record.
+ *
+ * Order:
+ *   1. `titleFormat` template, for the display column only — so users see a
+ *      human-readable name instead of a raw id when the display field
+ *      (commonly defaulted to `name`) does not exist on the record.
+ *   2. the type-aware cell renderer for the column's field descriptor.
+ *   3. a plain-text fallback for columns with no descriptor / no resolver.
+ *
+ * Step 3 never blanks a populated value: an object with no recognised shape
+ * keeps its JSON and a primitive keeps its `String()` form. That floor is
+ * deliberate — an unresolved reference showing its bare id is strictly better
+ * than a silently empty column (objectui#5492).
+ */
+export declare function renderLookupColumnValue(record: any, col: LookupColumnDef, ctx: LookupColumnRenderContext): React.ReactNode;

package/dist/widgets/nativeDateValue.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+/**
+ * Stored value → `<input type="date">` value (`YYYY-MM-DD`).
+ *
+ * A leading `YYYY-MM-DD` is passed through VERBATIM rather than re-parsed: a
+ * date-only string is parsed as UTC midnight by `new Date()`, so reading local
+ * calendar components back out of it shifts the day by one everywhere west of
+ * Greenwich. `2026-06-17` must stay June 17th in every zone.
+ */
+export declare function toDateInputValue(value: unknown): string;
+/**
+ * Stored value → `<input type="datetime-local">` value (`YYYY-MM-DDTHH:mm`),
+ * expressed in the viewer's local wall clock — the same instant the detail
+ * page shows, so opening the editor never appears to move the time.
+ *
+ * A value that is ALREADY a zone-less local datetime is truncated to minutes
+ * in place instead of being round-tripped through `Date`, which would
+ * reinterpret it and then re-render it, twice risking an off-by-a-zone shift.
+ */
+export declare function toDateTimeInputValue(value: unknown): string;
+/**
+ * `<input type="datetime-local">` value → stored value (ISO-8601, UTC).
+ *
+ * The control hands us a zone-less local wall clock; `new Date()` reads that
+ * form as local time, which is the inverse of what `toDateTimeInputValue`
+ * wrote — the pair is what keeps read and write on one basis.
+ *
+ * An unparseable string is returned untouched rather than blanked: dropping a
+ * value the user can see in the box would be a data loss dressed up as a fix.
+ */
+export declare function fromDateTimeInputValue(value: string): string;