@object-ui/fields 17.3.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, error, ...props }: FieldWidgetComponentProps<AddressValue>): React.JSX.Element;

package/dist/widgets/FullscreenFieldEditor.d.ts

@@ -1,155 +1,45 @@
 import { default as React } from 'react';
+import { FullscreenEditorProps } from '@object-ui/components';
 /**
- * The fullscreen-edit affordance shared by every long-text widget: the "expand"
- * button plus the full-height dialog it opens.
- *
- * ## Why this is shared rather than copied
- *
- * `ObjectFormSchema.mobile.fullscreenLongText` is ONE form-level promise, and
- * `ObjectForm` projects it onto EVERY long-text field as `mobile_fullscreen`
- * (`field:textarea` → `TextAreaField`, `field:markdown` / `field:html` →
- * `RichTextField`). A user who turns the setting on gets one behaviour, so the
- * behaviour has one implementation. objectui#3301 is what the other
- * arrangement costs: the flag reached `RichTextField` for as long as the
- * feature has existed and that widget simply never read it, so half the
- * documented promise ("textarea/rich-text get an expand button") silently did
- * nothing. A second hand-written copy of the state machine is the same failure
- * with an extra step — it drifts, and nothing reports the drift.
- *
- * What is genuinely per-widget is the EDITOR, so that is the only thing
- * injected: `children` renders it against the draft. Everything a user can
- * observe about the *interaction* — when the affordance appears, that the
- * dialog seeds from the committed value, that typing stays local until "Done",
- * that "Cancel" discards — lives here, once.
- *
- * ## Draft semantics (unchanged from the original `TextAreaField` behaviour)
- *
- * The dialog edits a LOCAL draft seeded from `value` at open time and commits
- * once, on "Done". It deliberately does not stream every keystroke to the host:
- * these widgets sit in a react-hook-form field, and per-keystroke `onChange`
- * during a modal edit would mark the form dirty (and fire validation) for an
- * edit the user may still cancel. "Cancel" therefore needs no undo — nothing
- * was written.
- *
- * ## `disabled` (objectui#3402)
- *
- * The dialog is a SECOND editing surface for the same value, so a field that is
- * not interactive has to be not interactive here too. It was not: hosts landed
- * `disabled` on their inline control only, this component never declared the
- * prop at all, and a disabled long-text field therefore sat correctly greyed out
- * next to a live expand button — click it, type anything, press "Done", and the
- * edit went into form state through `onCommit`. Measured on `origin/main`
- * before the fix: inline `disabled=true`, toggle `disabled=false`, dialog input
- * `disabled=false`, `onChange` called with "EDITED WHILE DISABLED".
- *
- * The gate is shaped like the built-in path's (`FullscreenTextarea` in
- * `components/src/renderers/form/form.tsx`, objectui#3400/PR #3401), because
- * one form-level setting must keep producing one behaviour on both paths:
- *
- *  - the toggle STAYS but is `disabled` — `disabled` means "not interactive,
- *    muted", not "shown plainly", which is `readonly`'s job (and `readonly`
- *    never reaches this component at all — see below);
- *  - `openFullscreen` refuses independently of the attribute, since a
- *    programmatic dispatch and a lost `pointer-events` rule both get past it;
- *  - the dialog locks on its OWN — `disabled` is not merely a static flag, it is
- *    also the form's `isSubmitting`, which flips to true while the dialog may
- *    already be open. At that moment the toggle is no longer the gate. So the
- *    editor is told (third `children` argument) and "Done" is disabled;
- *  - and `onCommit` is gated, because that is the single point where a value can
- *    leave this component for host state. Nothing native guards it: it is a
- *    click handler on a different control reading React state.
- *
- * "Cancel" and `Esc` stay live in every state — a dialog that goes disabled
- * mid-edit must still be closable, or a submit in flight traps the user in it.
- *
- * ## Why there is no `readonly` prop
- *
- * Both hosts early-return a read-only DISPLAY before they compute the affordance
- * (`TextAreaField.tsx`, `RichTextField.tsx`), so this component is never
- * rendered for a read-only field and a `readonly` prop here would be declared
- * with no producer — the shape this package keeps deleting (objectui#3232/#3233).
- * A future host that renders an editor for read-only fields must add the prop
- * AND the producer together; do not add it "for symmetry" beforehand.
- *
- * ## `testIdPrefix`
- *
- * Each host passes its own (`textarea`, `richtext`), yielding the same
- * convention with a per-widget namespace: `<prefix>-fullscreen-toggle` /
- * `-dialog` / `-save`. One form can contain both a textarea and a markdown
- * field, so a single shared id would make a test unable to say which widget it
- * had found. The editor's own test id belongs to `children` for the same
- * reason.
- *
- * ## Copy (objectui#3404)
- *
- * Every string here goes through `useFieldTranslation()` and consumes the
- * EXISTING `form.fullscreen.*` / `common.cancel` keys — the same ones the
- * built-in branch consumes since objectui#3272. Nothing was missing from the
- * ten locale packs; this path simply never read them, so a zh session opened a
- * dialog reading `Cancel` / `Done` while a long-text field rendered by the
- * built-in branch **in the same form** read 「取消 / 完成」.
- *
- * Sharing the keys rather than minting `fields.fullscreen.*` twins is the
- * point: one form-level setting (`mobile.fullscreenLongText`) projects onto
- * both render paths, so two copies of this copy could only drift.
- *
- * `useFieldTranslation` (not bare `useObjectTranslation`) because this widget
- * is rendered without an `I18nProvider` by standalone/embedded hosts and by
- * every bare-render test in this package. Measured before the change: with no
- * provider mounted `useObjectTranslation().t('common.cancel')` returns
- * `"common.cancel"` — the raw key — and the `{{label}}` interpolation collapses
- * entirely. The safe hook's English defaults are byte-identical to the literals
- * they replaced, so the provider-less rendering is unchanged.
- *
- * Focus management, `Esc`, the overlay and the close button are Radix's, via
- * the repo's `Dialog` (`@object-ui/components`) — deliberately not re-answered
- * here.
+ * 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 interface FullscreenFieldEditorProps {
-    /**
-     * The committed value. Seeds the draft each time the dialog opens — read at
-     * open time, not held, so a value that changes underneath while the dialog is
-     * closed is picked up on the next open.
-     */
-    value: string;
-    /** Called once with the draft when the user confirms. */
-    onCommit: (next: string) => void;
-    /** Field label — the dialog title and part of the toggle's accessible name. */
-    label?: string;
-    /** Namespace for this widget's fullscreen test ids. See above. */
-    testIdPrefix: string;
-    /**
-     * The host field is not interactive (objectui#3402). Disables the toggle, the
-     * "Done" button and the write-back, and is handed to `children` so the host's
-     * own editor renders disabled too. See the `disabled` section above for why
-     * each of those is a separate line rather than belt-and-braces.
-     *
-     * **Producer**: the widget's `disabled` prop, which the form renderer computes
-     * as `disabled || fieldDisabled || isSubmitting || optionGroupGated` and
-     * forwards to registered widgets (`stripRegisteredFieldProps` does not strip
-     * it).
-     */
-    disabled?: boolean;
-    /**
-     * The editor itself, rendered inside the dialog body against the draft. The
-     * host passes the SAME editor it renders inline, so "fullscreen" is a size
-     * change rather than a second, poorer editing surface.
-     *
-     * The third argument is this component's `disabled`, and the host is expected
-     * to put it on the control it renders: only the host knows which element its
-     * editor's disabled state belongs on. Ignoring it is not a write-back hole —
-     * `onCommit` is gated here regardless — but it does leave a control that looks
-     * editable while the field is not, so both in-repo hosts apply it and their
-     * tests pin it.
-     */
-    children: (draft: string, setDraft: (next: string) => void, disabled: boolean) => React.ReactNode;
-    /** Optional footer status for the draft (e.g. a character counter). */
-    footer?: (draft: string) => React.ReactNode;
-    /**
-     * Extra classes for the toggle button. It is absolutely positioned by
-     * default and expects a `relative` ancestor; a host whose layout has a
-     * better home for it can re-place it here.
-     */
-    toggleClassName?: string;
-}
-export declare function FullscreenFieldEditor({ value, onCommit, label, testIdPrefix, disabled, children, footer, toggleClassName, }: FullscreenFieldEditorProps): React.JSX.Element;
+export type FullscreenFieldEditorProps = Omit<FullscreenEditorProps, 'readOnly'>;
+export declare function FullscreenFieldEditor(props: FullscreenFieldEditorProps): 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/OptionsEmptyState.d.ts

@@ -1,4 +1,5 @@
 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`,
@@ -41,5 +42,18 @@ export interface OptionsEmptyStateProps {
     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, }: OptionsEmptyStateProps): React.JSX.Element;
+export declare function OptionsEmptyState({ emptyHint, gated, dependsOnFields, testId, className, hostGroupProps, }: OptionsEmptyStateProps): React.JSX.Element;

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

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/address-format.d.ts

@@ -0,0 +1,68 @@
+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: `Street, City, State ZIP, Country`.
+ *
+ * Ordering and separators are NOT invented here — they are the rule
+ * `AddressField` already applied in its readonly branch, and the sub-field set
+ * its inputs expose (street / city / state / postalCode / country). 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.
+ */
+export declare function formatAddress(addr: AddressValue): 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/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;

package/dist/widgets/toDomProps.d.ts

@@ -1,10 +1,4 @@
-/**
- * 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 { DomProps as CoreDomProps } from '@object-ui/core';
 /**
  * The RUNTIME EXECUTOR of the "DOM pass-through" section of
  * {@link FieldWidgetComponentProps} (objectui#3291).
@@ -59,13 +53,39 @@
  * open spread. If a field node should be able to author one, DECLARE it on
  * `FieldWidgetComponentProps` first and add it here — do not reopen the spread
  * (AGENTS.md #0.1: fix the contract, never widen the consumer).
+ *
+ * ## Where the mechanism lives now, and why the key list stayed here
+ *
+ * objectui#4425 phase 2 promoted this whitelist to the SDUI widget contract
+ * generally, so the MECHANISM — filter by a declared key list plus the `aria-*`
+ * / `data-*` open families — moved to `@object-ui/core`
+ * (`utils/dom-props.ts`, `pickDomProps`), where every plugin package can reach
+ * it without depending on `@object-ui/fields` (the objectui#4409
+ * dependency-direction method: `plugin-chatbot` declares `@object-ui/core` and
+ * does not declare this package).
+ *
+ * The KEY LIST did not move, because it is not the same list. Measured on
+ * objectui#4431:
+ *
+ *  - `name` and `disabled` are here and NOT in the SDUI set: both are legal
+ *    only on form controls, which is what every widget in this package renders
+ *    and what `FieldWidgetComponentProps` declares. `name` on the `<div>` an
+ *    SDUI container widget renders is a leak — one of the 14 attributes #4431
+ *    closed — and two widgets here already hand-strip it when they spread onto
+ *    something that is not a control (`ObjectRefField`'s trigger,
+ *    `FileField`'s dropzone).
+ *  - `role` is in the SDUI set and NOT here: `SchemaRenderer` resolves it for
+ *    every node from `@objectstack/spec`'s `AriaPropsSchema`, while this
+ *    contract deliberately does not declare it (see "Deliberately NOT
+ *    forwarded" above).
+ *
+ * So: one mechanism, two declarations, each bound by the assertions below to
+ * the contract it executes. Not two judges.
  */
 declare const DOM_PASS_THROUGH_KEYS: readonly ["id", "name", "autoFocus", "tabIndex", "onBlur", "onFocus", "onClick", "className", "disabled"];
 type DomPassThroughKey = (typeof DOM_PASS_THROUGH_KEYS)[number];
 /** The subset of `P` this helper forwards, with each key's declared type. */
-export type DomProps<P> = Pick<P, Extract<keyof P, DomPassThroughKey>> & {
-    [K in Extract<keyof P, `data-${string}` | `aria-${string}`>]: P[K];
-};
+export type DomProps<P> = CoreDomProps<P, DomPassThroughKey>;
 /**
  * Keep only what may legitimately become a DOM attribute, and drop everything
  * else — renderer plumbing, and any extra key an author put on the field