@object-ui/fields 17.6.0 → 17.7.0

package/dist/widgets/personDisplay.d.ts

@@ -13,8 +13,22 @@
  */
 /** Resolve a possibly-dotted path (e.g. `primary_business_unit_id.name`) against a record. */
 export declare function resolvePath(record: any, path: string): any;
-/** Best display name for a person record, tolerating expanded / raw shapes. */
-export declare function getPersonName(record: any, nameField?: string): string;
+/**
+ * The fields a person's display name is read from, in order: the configured
+ * display field, then `name`, `username`, `label`. A caller that gates the name
+ * by field-level security filters THIS list and hands the rest to
+ * {@link getPersonName} (objectui#10535): a denied rung is skipped, so the name
+ * falls through to the next readable one — the row a stripping backend serves
+ * reads the same.
+ */
+export declare function getPersonNameFields(nameField?: string): string[];
+/**
+ * Best display name for a person record, tolerating expanded / raw shapes: the
+ * first field of the name ladder the record holds a value for. `nameField` is
+ * the configured display field, whose ladder is {@link getPersonNameFields}, or
+ * the ladder itself, already filtered to the fields the viewer may read.
+ */
+export declare function getPersonName(record: any, nameField?: string | readonly string[]): string;
 /**
  * Up-to-2-char initials for the avatar fallback.
  * - "John Doe" → "JD"; "John" → "JO"
@@ -23,8 +37,12 @@ export declare function getPersonName(record: any, nameField?: string): string;
 export declare function getPersonInitials(name: string): string;
 /** Secondary line: resolve each field path, drop empties, join with " · ". */
 export declare function getPersonSubtitle(record: any, fields?: string[]): string;
-/** Avatar image URL (defaults to `sys_user.image`); undefined when absent. */
-export declare function getPersonAvatarUrl(record: any, avatarField?: string): string | undefined;
+/**
+ * Avatar image URL (defaults to `sys_user.image`); undefined when absent, and
+ * when `avatarField` is `null` — no avatar field to read, e.g. one field-level
+ * security withholds (objectui#10433).
+ */
+export declare function getPersonAvatarUrl(record: any, avatarField?: string | null): string | undefined;
 /** Record id, tolerating `id` / `_id` / a custom id field. */
 export declare function getPersonId(record: any, idField?: string): any;
 /**

package/dist/widgets/richTextDisplay.d.ts

@@ -12,6 +12,10 @@ import { CellRendererProps } from '../index.js';
  * pipeline drops all of it; see {@link HtmlCellRenderer}, which is where that
  * type belongs. Loosening this pipeline to pass raw HTML through would have
  * "fixed" one type by moving every `markdown` cell's trust boundary.
+ *
+ * What the cell holds is decided by {@link richTextSource} (objectui#8580):
+ * `[]` is the No-value affordance, never a childless container, and an
+ * object is the text the string class prints for it, never `[object Object]`.
  */
 export declare function MarkdownCellRenderer({ value }: CellRendererProps): React.ReactElement;
 /**
@@ -27,6 +31,14 @@ export declare function MarkdownCellRenderer({ value }: CellRendererProps): Reac
  * emits — headings, paragraphs, emphasis, lists, links, quotes all survive, so
  * routing `richtext` here restores the content rather than trading a blank cell
  * for a mangled one.
+ *
+ * What the cell holds is decided by {@link richTextSource} (objectui#8580):
+ * `[]` is the No-value affordance, never a childless `prose` container, and
+ * an object is the text the string class prints for it. The populated branch
+ * stays on {@link sanitizeHtml}: a stored string comes back from
+ * `richTextSource` verbatim, so the bytes that reach the sanitiser are the
+ * bytes that always did — pinned byte-for-byte in
+ * `__tests__/cellRenderers.childlessContainer-8580.test.tsx`.
  */
 export declare function HtmlCellRenderer({ value }: CellRendererProps): React.ReactElement;
 /**
@@ -50,6 +62,30 @@ export declare const RICH_TEXT_CELL_RENDERERS: {
 };
 /** The rich-content field types, i.e. the keys of {@link RICH_TEXT_CELL_RENDERERS}. */
 export type RichTextFieldType = keyof typeof RICH_TEXT_CELL_RENDERERS;
+/**
+ * The same three types as a RUNTIME list, DERIVED from THE table rather than
+ * spelled a second time — the type-level {@link RichTextFieldType} cannot be
+ * enumerated at runtime, and a hand-written array beside it would be exactly
+ * the shape this export exists to retire.
+ *
+ * ## Why this export exists
+ *
+ * objectui#4831 asked, in its own body, whether the hand-written type lists
+ * that keep omitting the third of this widget's three registry keys should
+ * become "every type that resolves to the long-text widget". It was answered
+ * by adding one literal, and the omission recurred (objectui#4250,
+ * objectui#8438). This is that question answered in the other direction: a
+ * consumer that spreads this list cannot omit a key, because it never names
+ * one. Adding a fourth key to {@link RICH_TEXT_CELL_RENDERERS} extends every
+ * such consumer in the same commit that adds the key.
+ *
+ * ⚠️ It is NOT a general "long text" list and must not be used as one:
+ * `textarea` renders a `<Textarea>` too and is deliberately absent, because it
+ * is a different widget with its own registry key and its own metadata face.
+ * The invariant this list states is narrower and exact — *these are the keys
+ * `RichTextField` serves*.
+ */
+export declare const RICH_TEXT_FIELD_TYPES: readonly RichTextFieldType[];
 /**
  * The SYNTAX a rich-content type stores, derived from the renderer that type
  * resolves to rather than declared a second time.

package/dist/widgets/toDomProps.d.ts

@@ -83,7 +83,16 @@ import { DomProps as CoreDomProps } from '@object-ui/core';
  * 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 keys this helper forwards.
+ *
+ * Exported so the SIBLING executor — `toHostProps`, which carries the declared
+ * NON-DOM keys (`f08bcd9af`) — can subtract this set from the contract and
+ * assert that the two together cover every declared key exactly once. Without
+ * that subtraction there is no way to state "these keys are handled elsewhere"
+ * as a compile-time fact rather than as a comment.
+ */
+export 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> = CoreDomProps<P, DomPassThroughKey>;
 /**

package/dist/widgets/toHostGroupProps.d.ts

@@ -187,3 +187,56 @@ export declare function toHostGroupProps(props: {
     'aria-labelledby'?: string;
     'aria-describedby'?: string;
 }, surface: HostGroupSurface): HostGroupProps;
+/**
+ * The host keys a LABELABLE surface may consume — the `labelling: 'control'`
+ * counterpart of {@link HostGroupProps} (objectui#8803).
+ *
+ * ## Why a second, smaller bag instead of reusing the group one
+ *
+ * A widget declared `'control'` is told nothing by the host: its label emits a
+ * plain `for` and expects to reach a labelable element on its own. Every
+ * editable branch answers that by spreading `toDomProps` onto the control it
+ * renders. The branches that return EARLY answer it with nothing — and for the
+ * single `SelectField` that is the zero-option box, where the `…-form-item` id
+ * reached no element at all and the label's `for` DANGLED.
+ *
+ * What such a surface needs is therefore the exact complement of the group
+ * bag:
+ *
+ *  - `id` — yes. It is the id the `for` points at, and landing it is the whole
+ *    repair;
+ *  - `aria-describedby` — yes, for the objectui#4005 reason, unchanged by the
+ *    surface being labelable: the field renders no input in this state, so
+ *    this box is the only element the visible help text can be announced on;
+ *  - `aria-labelledby` — ⛔ NO. The `for` already names this element. Adding an
+ *    IDREF beside it is the second naming channel objectui#3978 removed;
+ *  - `role` — ⛔ NO. A labelable element's own semantics are what make the name
+ *    land; a synthetic role on top is the category error objectui#3991 named.
+ *
+ * `aria-invalid` / `aria-required` / `name` stay off for the reasons spelled
+ * out at length on {@link HostGroupProps}: control-channel state on a surface
+ * nobody can edit, and the DOM leak objectui#3291 sweeps for. A closed type,
+ * not an open props tail, for that same reason.
+ */
+export interface HostControlProps {
+    /** The host's control id — the id its label's `for` points at. */
+    id?: string;
+    /** IDREF of the host's visible help text. */
+    'aria-describedby'?: string;
+}
+/**
+ * Read the two whole-field keys a labelable replacement surface may carry. See
+ * {@link HostControlProps}.
+ *
+ * Routed through {@link toDomProps} for the same reason {@link toHostGroupProps}
+ * is: the keys keep ONE gate, and its compile-time assertions bind that
+ * whitelist to the props contract in both directions.
+ *
+ * Standalone rendering (the grid's inline cell editor, an action param dialog,
+ * a bare SDUI node) hands down neither key, so both values are `undefined`,
+ * React emits no attribute, and that markup stays byte-identical.
+ */
+export declare function toHostControlProps(props: {
+    id?: string;
+    'aria-describedby'?: string;
+}): HostControlProps;

package/dist/widgets/toHostProps.d.ts

@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+/**
+ * The RUNTIME EXECUTOR of the NON-DOM half of {@link FieldWidgetComponentProps}
+ * (`f08bcd9af`) — the sibling of `toDomProps`, and deliberately a SEPARATE
+ * function rather than more entries in that whitelist.
+ *
+ * ## The defect
+ *
+ * objectui#6909 / #7009 closed the DOM half at `FieldEditWidget`: the factory
+ * hands the widget `toDomProps(props)`, so `id` / `name` / `tabIndex` /
+ * `aria-*` / `data-*` and friends finally arrive. The contract also declares a
+ * "Host plumbing" block plus two controlled-input keys the factory neither owns
+ * nor routes to the DOM, and NOTHING carried those. A host could pass any of
+ * them with no type error and the widget never received it — this package's own
+ * first-class defect class, named in `toDomProps.ts`: "a key that type-checks,
+ * reads as supported, and silently never reaches the element" (objectui#3290's
+ * `aria-required`, objectui#3222's validation slot).
+ *
+ * Measured on `main` at `71d83a6b1`, the live victim was `error`:
+ * `InlineFieldInput` (`@object-ui/plugin-detail`, since PR #7109) already
+ * passes `error={error}` to `FieldEditWidget`, and the factory dropped it on
+ * the floor — so a control that had failed validation never reported
+ * `aria-invalid` and a screen-reader user was never told. The kanban
+ * `RequiredFieldsDialog` had the same hole from the other side: it computes the
+ * validation state, renders it in red text, and had no way to hand it over.
+ *
+ * ## Why NOT more keys in `DOM_PASS_THROUGH_KEYS`
+ *
+ * Because none of them is DOM-legal. That whitelist is deliberately closed and
+ * exists precisely to stop renderer plumbing reaching an element — its own
+ * header names `error`, `emptyHint`, `dataSource`, `dependentValues` and
+ * `dependsOn` as examples of what a blacklist would have failed to catch. Put
+ * them there and a `dataSource` adapter becomes `dataSource="[object Object]"`
+ * on an `<input>`. They travel as COMPONENT props, which is what they are.
+ *
+ * ## Declared = enforced, in both directions
+ *
+ * The three assertions below make the two executors PARTITION the contract:
+ * every declared key is DOM-handled, forwarded here, or named as one the
+ * factory itself owns. A key added to `FieldWidgetComponentProps` that is none
+ * of those is a compile error, so the next non-DOM key cannot repeat this bug.
+ *
+ * ## Precedence: this is a CONDUIT, and never a second authority
+ *
+ * Several of these keys have a context-based fallback inside the widget that
+ * reads them, so DELIVERING one can change behaviour where before it could not
+ * arrive at all. The rule is stated once, here, and this function implements it
+ * by doing nothing: it forwards what the host passed and resolves NOTHING.
+ * Each key's precedence stays where its single reader already implements and
+ * documents it —
+ *
+ *  - `dataSource`: **the explicit prop WINS** over `SchemaRendererContext`.
+ *    `LookupField` already resolves exactly that order and says so on the line
+ *    that does it: "explicit prop > field-level > wrapper field >
+ *    SchemaRendererContext > none". Hosts that pass nothing keep reading the
+ *    context, so the grid's inline editor is unaffected.
+ *  - `dependentValues`: the explicit prop is the ONLY channel that can carry a
+ *    record — the host supplies it, and there is NO context fallback. Both
+ *    readers (`useCascadingOptions`, and `LookupField`'s own resolver) used to
+ *    spell a `?? ctx.formValues ?? ctx.data` tail after it, but
+ *    `SchemaRendererContextType` declares exactly `dataSource` / `debug` /
+ *    `debugFlags` / `apiFetch` — neither member exists, so that tail was
+ *    unconditionally `{}` and no host could change it. It was retired under
+ *    ADR-0049 enforce-or-remove (objectui#7206). Unlike `dataSource` above,
+ *    DELIVERING this key cannot displace a context value, because there has
+ *    never been one to displace.
+ *  - `dependsOn`: the FIELD METADATA wins over the prop — the one documented
+ *    inversion, stated on the key's own doc comment and implemented as
+ *    `field?.dependsOn ?? dependsOnProp` in all four option widgets.
+ *  - `emptyHint`: the host's value wins when supplied (objectui#3231).
+ *  - `onCreateNew`: the prop wins over `field.onCreateNew`; `onSelectRecord`
+ *    has no metadata carrier at all, so the prop is its ONLY one.
+ *
+ * Resolving any of that HERE would give each key a second author — the
+ * `field || schema` shape objectui#3233 spent a release removing. One key, one
+ * resolver, in the widget that reads it.
+ */
+declare const HOST_PLUMBING_KEYS: readonly ["error", "onUploadingChange", "dataSource", "dependentValues", "dependsOn", "dependsOnLabels", "emptyHint", "onSelectRecord", "onCreateNew"];
+type HostPlumbingKey = (typeof HOST_PLUMBING_KEYS)[number];
+/** The subset of `P` this helper forwards, with each key's declared type. */
+export type HostProps<P> = Pick<P, Extract<keyof P, HostPlumbingKey>>;
+/**
+ * Keep only the declared NON-DOM keys — the host plumbing a widget interprets
+ * as component props — and drop everything else.
+ *
+ * The companion to `toDomProps`, and used the same way. A host that passes
+ * nothing gets an empty object, so the widget's prop set is unchanged:
+ *
+ * ```tsx
+ * <Widget {...toDomProps(props)} {...toHostProps(props)} field={field} … />
+ * ```
+ *
+ * Iterating the props (rather than the key list) mirrors `pickDomProps`, so a
+ * key the host did not mention stays ABSENT rather than arriving as
+ * `undefined` — which keeps the factory-boundary prop set readable as "what the
+ * host actually supplied".
+ */
+export declare function toHostProps<P extends object>(props: P): HostProps<P>;
+export {};

package/dist/widgets/types.d.ts

@@ -150,7 +150,7 @@ export type FieldWidgetComponentProps<T = any> = {
      */
     error?: string;
     /**
-     * Upload widgets (`file`/`image`) fire this when their in-progress state
+     * Upload widgets (`file`/`image`/`avatar`) fire this when their in-progress state
      * flips, so a host can block submit until a presigned upload settles. Other
      * widgets ignore it.
      */
@@ -173,7 +173,15 @@ export type FieldWidgetComponentProps<T = any> = {
     /**
      * Live sibling-field values driving cascading / role-gated options and
      * dependent lookups (ADR-0058, #2215/#2284). The form renderer passes the
-     * in-progress record; widgets fall back to `SchemaRendererContext`.
+     * in-progress record.
+     *
+     * ⚠️ This used to add "widgets fall back to `SchemaRendererContext`". They
+     * never could: they spelled such a fallback (`?? ctx.formValues ?? ctx.data`)
+     * while `SchemaRendererContextType` declares exactly `dataSource` / `debug` /
+     * `debugFlags` / `apiFetch`, so neither member could be supplied by any host
+     * and the fallback was unconditionally empty. Those reads were retired under
+     * ADR-0049 enforce-or-remove (objectui#7206) — this prop is the one channel
+     * that carries a record, and a widget reached without it gates.
      */
     dependentValues?: Record<string, unknown>;
     /**
@@ -187,7 +195,7 @@ export type FieldWidgetComponentProps<T = any> = {
      * sibling field in user-visible copy (the dependent-lookup gate hint).
      *
      * Only the form renderer knows a field's label — the widget sees its own
-     * metadata and a `depends_on` list of API names. Without this map the gate
+     * metadata and a `dependsOn` list of API names. Without this map the gate
      * sentence interpolated the raw API name into every locale, `en` included
      * ("Select crm_account first"), which is an internal identifier leaking into
      * the UI, not merely an untranslated word (objectstack#5407). This is the

package/dist/widgets/upload-error-message.d.ts

@@ -0,0 +1,6 @@
+import { TranslateFn } from '@object-ui/i18n';
+/**
+ * The translated error row for a pick named `name` whose upload ended in
+ * `err`, either kind.
+ */
+export declare function uploadErrorMessage(t: TranslateFn, name: string, err: unknown): string;

package/dist/widgets/uploadingScope.d.ts

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

package/dist/widgets/useCascadingOptions.d.ts

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

package/dist/widgets/useRecordQuery.d.ts

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

package/dist/widgets/useUploadingSignal.d.ts

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

package/package.json

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