@cosmicdrift/kumiko-renderer 0.387.0 → 0.388.0

package/dist/app/action-form-body.js

@@ -129,6 +129,7 @@ export function ActionFormBody({ schema, screen, translate, entityId, initialOve
         })
         : undefined, loadableFieldNames);
     const loadedValues = loadState?.status === "ready" ? loadState.values : undefined;
+    const refetchLoadedValues = loadState?.status === "ready" ? loadState.refetch : undefined;
     const initial = useMemo(() => {
         // With `load` the loaded record is the only source of values: a crafted link
         // or a row's params must not seed fields the record would otherwise own.
@@ -204,8 +205,14 @@ export function ActionFormBody({ schema, screen, translate, entityId, initialOve
             else if (hasSuccessLinks || screen.resetOnSuccess === true) {
                 publish(effectiveTranslate("kumiko.actionForm.success"));
             }
-            if (screen.resetOnSuccess === true)
-                setFormEpoch((epoch) => epoch + 1);
+            if (screen.resetOnSuccess === true) {
+                // A loaded record is stale after the write: reseed the form from the fresh one.
+                const remountForm = () => setFormEpoch((epoch) => epoch + 1);
+                if (refetchLoadedValues === undefined)
+                    remountForm();
+                else
+                    void refetchLoadedValues().finally(remountForm);
+            }
         }
         // Without a redirect the form stays put; returnTo only replaces an existing
         // navigation, and never one to a record screen (see redirectTargetsRecord).
@@ -227,6 +234,7 @@ export function ActionFormBody({ schema, screen, translate, entityId, initialOve
         dispatcher,
         locale,
         effectiveTranslate,
+        refetchLoadedValues,
     ]);
     // The success box disappears with the next edit; a submit clears it itself.
     const handleDirtyChange = useCallback((dirty) => {

package/dist/app/action-form-support.d.ts

@@ -21,6 +21,7 @@ export type ActionFormLoadState = {
 } | {
     readonly status: "ready";
     readonly values: Readonly<Record<string, unknown>>;
+    readonly refetch: () => Promise<void>;
 };
 /** A sensitive, writeOnly or password field never takes a value from a loaded
  *  record: the form must not echo a secret back into an input. */

package/dist/app/action-form-support.js

@@ -53,7 +53,7 @@ export function useActionFormLoad(load, recordId, fieldNames) {
         return { status: "loading" };
     if (query.data === null)
         return { status: "missing-record" };
-    return { status: "ready", values };
+    return { status: "ready", values, refetch: query.refetch };
 }
 /** Banner for every `load` state that is not "ready". */
 export function ActionFormLoadStatus({ state, screenId, translate, }) {

package/dist/app/config-edit-body.js

@@ -97,8 +97,12 @@ export function ConfigEditBody({ schema, screen, translate, }) {
     // Detail load: config:query:values returns ALL keys of the tenant.
     // We map them via screen.configKeys from short to qualified name onto our
     // form field values.
-    const valuesQuery = useQuery("config:query:values", {});
-    const cascadeQuery = useQuery("config:query:cascade", {});
+    const valuesQuery = useQuery("config:query:values", {
+        scope: screen.scope,
+    });
+    const cascadeQuery = useQuery("config:query:cascade", {
+        scope: screen.scope,
+    });
     const secretKeys = screen.secretKeys;
     const secretsQuery = useQuery("secrets:query:list", {}, { enabled: secretKeys !== undefined });
     const synthEntity = useMemo(() => synthesizeConfigEditEntity(screen.fields), [screen.fields]);

package/dist/app/entity-edit-prefill.d.ts

@@ -2,6 +2,17 @@ import type { FormValues } from "../headless/index.ts";
 export declare function versionOf(record: Readonly<Record<string, unknown>>): number;
 export declare function buildInitialValues(fields: Readonly<Record<string, unknown>>, defaultCurrency?: string, moneyCurrencyOverrides?: Readonly<Record<string, string>>): FormValues;
 export declare function tenantCurrencyMoneyFieldNames(fields: Readonly<Record<string, unknown>>): readonly string[];
+export type TenantCurrencyResolution = {
+    readonly status: "not-needed";
+} | {
+    readonly status: "loading";
+} | {
+    readonly status: "unresolved";
+} | {
+    readonly status: "ready";
+    readonly currency: string;
+};
+export declare function useTenantCurrency(needed: boolean, fallback: string | undefined): TenantCurrencyResolution;
 export declare function literalCurrencyOverrides(fields: Readonly<Record<string, unknown>>): Readonly<Record<string, string>>;
 export declare function useMoneyCurrencyOverrides(fields: Readonly<Record<string, unknown>>, tenantFieldNames: readonly string[], fallback: string | undefined): {
     readonly overrides: Readonly<Record<string, string>> | undefined;

package/dist/app/entity-edit-prefill.js

@@ -71,8 +71,8 @@ export function tenantCurrencyMoneyFieldNames(fields) {
 // back to "EUR" while the query is genuinely still in flight — a
 // screen with no tenant-declared money field, or a query that errored or
 // returned no value for the key, resolves immediately instead of blocking.
-function resolveTenantCurrency(fieldNames, query, fallback) {
-    if (fieldNames.length === 0)
+function resolveTenantCurrency(needed, query, fallback) {
+    if (!needed)
         return { status: "not-needed" };
     if (query.error) {
         return fallback === undefined
@@ -88,6 +88,12 @@ function resolveTenantCurrency(fieldNames, query, fallback) {
         ? { status: "unresolved" }
         : { status: "ready", currency: fallback };
 }
+// `needed = false` skips the config query entirely; an errored query or a missing value
+// resolves to `fallback` (or `unresolved` without one).
+export function useTenantCurrency(needed, fallback) {
+    const query = useQuery("config:query:values", { keys: [TENANT_CURRENCY_CONFIG_KEY] }, { enabled: needed });
+    return resolveTenantCurrency(needed, query, fallback);
+}
 // A money field naming a fixed ISO code (`currency: { kind: "literal", code }`)
 // resolves with no query at all. Read structurally, same idiom as
 // tenantCurrencyMoneyFieldNames above.
@@ -115,8 +121,7 @@ export function useMoneyCurrencyOverrides(fields, tenantFieldNames,
 // `undefined` = no safe last resort (entity-less forms): an unresolvable
 // tenant currency is reported via `unresolved` instead of guessing a code.
 fallback) {
-    const query = useQuery("config:query:values", { keys: [TENANT_CURRENCY_CONFIG_KEY] }, { enabled: tenantFieldNames.length > 0 });
-    const resolution = resolveTenantCurrency(tenantFieldNames, query, fallback);
+    const resolution = useTenantCurrency(tenantFieldNames.length > 0, fallback);
     const resolvedTenantCurrency = resolution.status === "ready" ? resolution.currency : undefined;
     const overrides = useMemo(() => {
         const out = { ...literalCurrencyOverrides(fields) };

package/dist/app/extension-sections.d.ts

@@ -43,10 +43,12 @@ export type ExtensionSectionProps = {
      *  `snapshot.errors` on the field instead of a collective message.
      *  Undefined outside entityEdit sections. */
     readonly validate?: () => boolean;
-    /** Marks the current host form values as saved after the section wrote
-     *  them itself, so a following navigation does not ask to discard.
+    /** Marks host form values as saved after the section wrote them itself, so
+     *  a following navigation does not ask to discard. Pass the field names the
+     *  section persisted: other host fields keep their unsaved state. Without
+     *  `fields`, every current host value counts as saved.
      *  Undefined outside entityEdit sections and the entityEdit footer slot. */
-    readonly markSaved?: () => void;
+    readonly markSaved?: (fields?: readonly string[]) => void;
     /** Whether the host form has unsaved changes. Only set in the entityEdit
      *  footer slot (`screen.slots.footer`); undefined in all other mounts. */
     readonly hasUnsavedChanges?: boolean;

package/dist/app/form-schema.js

@@ -29,7 +29,7 @@ function isRequiredValueMissing(spec, field, record, unchangedFrom) {
     // — they're fillable, so NO_WIDGET_FIELD_TYPES's "embedded"
     // entry must not exempt them. A statically-`required: true` field
     // with no bound widget is also caught at boot
-    // (validateNoWidgetRequiredField in boot-validator/screens.ts).
+    // (validateNoWidgetRequiredField in boot-validator/screens-forms.ts).
     if (NO_WIDGET_FIELD_TYPES.includes(field.type) && !isEmbeddedListField(field))
         return false;
     if (isPresent(record[spec.field]))

package/dist/app/header-actions-bar.js

@@ -18,7 +18,7 @@ export function HeaderActionsBar({ actions, Button, Dialog, ActionOverflowMenu,
     if (compact && PageHeader !== undefined) {
         const compactPrimary = compactHeaderPrimary(actions, preferredPrimaryId);
         const overflowActions = actions.filter((a) => a !== compactPrimary?.action);
-        return (_jsxs(_Fragment, { children: [compactPrimary !== undefined && (_jsx(RenderEditActionButton, { action: compactPrimary.action, Button: Button, Dialog: Dialog, iconOnly: compactPrimary.iconOnly, compactLabel: true, onError: onError }, compactPrimary.action.id)), overflowActions.length > 0 && (_jsx(PageHeader, { overflowItems: overflowActions.map(toMenuItem) })), pendingActionDialog] }));
+        return (_jsxs(_Fragment, { children: [compactPrimary !== undefined && (_jsx(RenderEditActionButton, { action: compactPrimary.action, Button: Button, Dialog: Dialog, iconOnly: compactPrimary.iconOnly, onError: onError }, compactPrimary.action.id)), overflowActions.length > 0 && (_jsx(PageHeader, { overflowItems: overflowActions.map(toMenuItem) })), pendingActionDialog] }));
     }
     const maxPlainButtons = collapseAfterPrimary ? 1 : 2;
     if (actions.length <= maxPlainButtons || ActionOverflowMenu === undefined) {

package/dist/components/edit-mounts.d.ts

@@ -10,7 +10,7 @@ export declare function ExtensionSectionMount({ section, entityName: hostEntityN
     readonly values?: Readonly<Record<string, unknown>>;
     readonly patch?: (partial: Readonly<Record<string, unknown>>) => void;
     readonly validate?: () => boolean;
-    readonly markSaved?: () => void;
+    readonly markSaved?: (fields?: readonly string[]) => void;
     readonly hideTitle?: boolean;
     /** section.actions, already resolved into buttons by the caller. */
     readonly actions?: ReactNode;
@@ -24,7 +24,7 @@ export declare function EditSlotMount({ slot, slotName, screenId, entityName, en
     readonly entityName: string;
     readonly entityId: string | null;
     readonly values: Readonly<Record<string, unknown>>;
-    readonly markSaved?: () => void;
+    readonly markSaved?: (fields?: readonly string[]) => void;
     readonly hasUnsavedChanges?: boolean;
     readonly wizardStep?: {
         readonly index: number;

package/dist/components/embedded-list-field.js

@@ -169,7 +169,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
             };
         }
         return {
-            field: entry.from.join("+"),
+            field: `${entry.from.join("+")}:${entry.label}`,
             label: t(entry.label),
             value: entry.from.reduce((sum, name) => sum + sumEmbeddedListColumn(rows, name), 0),
             money: entry.from.every((name) => cells.find((c) => c.field === name)?.type === "money"),

package/dist/components/related-list-section.js

@@ -22,8 +22,21 @@ import { usePrimitives, } from "../primitives.js";
 import { sortByAccessor } from "../sort-by-accessor.js";
 import { RenderEditActionButton } from "./render-edit-action-button.js";
 import { RenderList } from "./render-list.js";
+// Keyed on the type, not on key presence: most factories omit `sortable`
+// from the definition, so `"sortable" in field` would drop the column flag.
+const NON_SORTABLE_FIELD_TYPES = new Set([
+    "longText",
+    "multiSelect",
+    "embedded",
+    "jsonb",
+    "tz",
+    "file",
+    "image",
+    "files",
+    "images",
+]);
 function isSortableCapable(field) {
-    return "sortable" in field;
+    return !NON_SORTABLE_FIELD_TYPES.has(field.type);
 }
 const RELATED_LIST_PSEUDO_ENTITY = "__related-list__";
 // Minimal EntityDefinition from the section's own columns — same shape as

package/dist/components/render-edit-action-button.d.ts

@@ -10,15 +10,13 @@ export declare function RenderEditActionConfirmDialog({ action, open, onOpenChan
     readonly onConfirm: () => void | Promise<void>;
     readonly Dialog: ReturnType<typeof usePrimitives>["Dialog"];
 }): ReactNode;
-export declare function RenderEditActionButton({ action, iconOnly, hideIcon, compactLabel, Button, Dialog, onError, }: {
+export declare function RenderEditActionButton({ action, iconOnly, hideIcon, Button, Dialog, onError, }: {
     readonly action: RenderEditAction;
     /** Group-level collapse (see `shouldRenderActionsIconOnly`) — only takes
      *  effect when this action actually resolved an icon. */
     readonly iconOnly?: boolean;
     /** Record-header actions are text-only; the icon still shows when collapsed to icon-only. */
     readonly hideIcon?: boolean;
-    /** Short labelled button for a phone header, where a bare icon would hide what the action does. */
-    readonly compactLabel?: boolean;
     readonly Button: ReturnType<typeof usePrimitives>["Button"];
     readonly Dialog: ReturnType<typeof usePrimitives>["Dialog"];
     readonly onError: (notice: ErrorNotice | null) => void;

package/dist/components/render-edit-action-button.js

@@ -15,7 +15,7 @@ export function RenderEditActionConfirmDialog({ action, open, onOpenChange, onCo
 // render-list.tsx's ToolbarActionView (each RenderEditAction is
 // independently bound by the caller, there is no shared trigger pipeline
 // to hook into like the built-in onDelete/onSubmit paths have).
-export function RenderEditActionButton({ action, iconOnly = false, hideIcon = false, compactLabel = false, Button, Dialog, onError, }) {
+export function RenderEditActionButton({ action, iconOnly = false, hideIcon = false, Button, Dialog, onError, }) {
     const [busy, setBusy] = useState(false);
     const [confirmOpen, setConfirmOpen] = useState(false);
     const trigger = async () => {
@@ -33,7 +33,7 @@ export function RenderEditActionButton({ action, iconOnly = false, hideIcon = fa
     };
     const variant = action.style ?? "secondary";
     const showIconOnly = iconOnly && action.icon !== undefined;
-    return (_jsxs(_Fragment, { children: [_jsx(Button, { type: "button", variant: variant, loading: busy, ...(action.icon !== undefined && (!hideIcon || showIconOnly) && { icon: action.icon }), ...(compactLabel && !showIconOnly && { size: "sm" }), ...(showIconOnly && {
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { type: "button", variant: variant, loading: busy, ...(action.icon !== undefined && (!hideIcon || showIconOnly) && { icon: action.icon }), ...(showIconOnly && {
                     size: "icon",
                     ariaLabel: action.label,
                     title: action.label,

package/dist/components/render-edit.js

@@ -215,10 +215,13 @@ export function RenderEdit(props) {
     const scopeFieldNamesRef = useRef(scopeFieldNames);
     scopeFieldNamesRef.current = scopeFieldNames;
     const scopedValidate = useCallback(() => controller.validate(scopeFieldNamesRef.current), [controller]);
-    const markSaved = useCallback(() => {
-        controller.rebase();
-        extensionDirtyRef.current = false;
-        setExtensionDirty(false);
+    // The extension dirty flag aggregates every section; each section clears its
+    // own part, so a host-side markSaved must not reset it.
+    const markSaved = useCallback((fields) => {
+        if (fields === undefined)
+            controller.rebase();
+        else
+            controller.rebaseFields(fields);
     }, [controller]);
     // `saveDraft` (defined below) is a fresh closure every render, over that
     // render's `draftKey`/`draftId` — the ref lets the debounce timer below
@@ -1048,7 +1051,7 @@ export function RenderEdit(props) {
                             // Title-less sections would otherwise collide on key/testId, so use the index
                             // as a fallback.
                             const sectionKey = section.title ?? `section-${sectionIndex}`;
-                            const renderFieldGrid = (fields, columns, gridKey) => (_jsx(Grid, { columns: columns, ...(isSettingsList ? { list: true } : usesFieldFlow && { flow: true }), children: fields.map((field) => (_jsx(GridCellForField, { field: disabled ? { ...field, readOnly: true } : field, columns: columns, ...(!isSettingsList && usesFieldFlow && { flow: true }), ...(isSettingsList && {
+                            const renderFieldGrid = (fields, columns, gridKey, columnsDeclared) => (_jsx(Grid, { columns: usesFieldFlow && columnsDeclared !== true ? 1 : columns, ...(isSettingsList ? { list: true } : usesFieldFlow && { flow: true }), children: fields.map((field) => (_jsx(GridCellForField, { field: disabled ? { ...field, readOnly: true } : field, columns: columns, ...(!isSettingsList && usesFieldFlow && { flow: true }), ...(isSettingsList && {
                                         layout: "row",
                                         accent: fieldAccent?.(field.field) === true,
                                     }), issues: snapshot.errors[field.field], onChange: (v) => {
@@ -1075,7 +1078,7 @@ export function RenderEdit(props) {
                             // cannot stand in for the tabs-mode card here.
                             if (hideSectionTitles === true) {
                                 if (section.groups !== undefined) {
-                                    const groupsGrid = (_jsx(Grid, { columns: 1, children: section.groups.map((group, groupIndex) => (_jsx(Card, { slots: { title: group.title }, testId: `section-${sectionKey}-group-${groupIndex}`, children: renderFieldGrid(group.fields, group.columns, `${sectionKey}-group-${groupIndex}-grid`) }, group.title))) }, `${sectionKey}-groups`));
+                                    const groupsGrid = (_jsx(Grid, { columns: 1, children: section.groups.map((group, groupIndex) => (_jsx(Card, { slots: { title: group.title }, testId: `section-${sectionKey}-group-${groupIndex}`, children: renderFieldGrid(group.fields, group.columns, `${sectionKey}-group-${groupIndex}-grid`, group.columnsDeclared) }, group.title))) }, `${sectionKey}-groups`));
                                     // `actions` on a `groups` section has no group of its own to
                                     // sit in and would need an extra title-less Card around the
                                     // group cards (Card-in-Card) — the boot-validator rejects that
@@ -1092,7 +1095,7 @@ export function RenderEdit(props) {
                                             ...(section.description !== undefined && { subtitle: section.description }),
                                             ...(sectionActionsEl !== undefined && { headerActions: sectionActionsEl }),
                                         },
-                                    }), testId: `section-${sectionKey}`, children: renderFieldGrid(section.fields, section.columns, `${sectionKey}-grid`) }, sectionKey));
+                                    }), testId: `section-${sectionKey}`, children: renderFieldGrid(section.fields, section.columns, `${sectionKey}-grid`, section.columnsDeclared) }, sectionKey));
                                 return wrapWizardStep(sectionKey, cardEl);
                             }
                             // Suppress the section header when it would just repeat the form
@@ -1109,7 +1112,7 @@ export function RenderEdit(props) {
                             const sectionSubtitle = section.description ?? (headerFallback ? formSubtitle : undefined);
                             const sectionEl = (_jsxs(Section, { ...(sectionNavItems.some((item) => item.id === formSectionDomId(sectionIndex)) && {
                                     id: formSectionDomId(sectionIndex),
-                                }), ...(sectionTitle !== undefined && { title: sectionTitle }), ...(sectionSubtitle !== undefined && { subtitle: sectionSubtitle }), ...(section.icon !== undefined && { icon: section.icon }), ...(sectionActionsEl !== undefined && { actions: sectionActionsEl }), ...(isSettingsList && { layout: "settings-list" }), testId: `section-${sectionKey}`, children: [showsAllRequiredHint && insideDrawer && sectionIndex === 0 && allRequiredHint, renderFieldGrid(section.fields, section.columns, `${sectionKey}-grid`)] }, sectionKey));
+                                }), ...(sectionTitle !== undefined && { title: sectionTitle }), ...(sectionSubtitle !== undefined && { subtitle: sectionSubtitle }), ...(section.icon !== undefined && { icon: section.icon }), ...(sectionActionsEl !== undefined && { actions: sectionActionsEl }), ...(isSettingsList && { layout: "settings-list" }), testId: `section-${sectionKey}`, children: [showsAllRequiredHint && insideDrawer && sectionIndex === 0 && allRequiredHint, renderFieldGrid(section.fields, section.columns, `${sectionKey}-grid`, section.columnsDeclared)] }, sectionKey));
                             return wrapWizardStep(sectionKey, sectionEl);
                         }), formError !== null && (_jsxs(Banner, { variant: "error", testId: "render-edit-form-error", actions: formError.code === "version_conflict" && onReload !== undefined ? (_jsx(Button, { variant: "secondary", onClick: () => {
                                     onReload();

package/dist/components/render-field.js

@@ -16,7 +16,7 @@ import { fileIdsOf } from "../file-ids-of.js";
 import { applyFormatSpec, currencyDecimals, EMPTY_VALUE_PLACEHOLDER, } from "../headless/index.js";
 import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits.js";
 import { useQuery } from "../hooks/use-query.js";
-import { referenceOptionSource } from "../hooks/use-reference-lookup.js";
+import { isCompleteRowPage, referenceOptionSource } from "../hooks/use-reference-lookup.js";
 import { useLocale, useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
 import { AvailabilityOptionsMultiSelect, AvailabilityOptionsSelect, staticSelectOptions, } from "./availability-options-select.js";
@@ -354,7 +354,10 @@ function ReadOnlyReferenceValue({ field, featureName, }) {
         const row = rows.find((r) => String(r["id"] ?? "") === id);
         if (row === undefined) {
             const unknownKey = UNRESOLVED_REFERENCE_LABEL_KEYS[`${refFeature}:${refEntity}`];
-            const label = unknownKey !== undefined && !queryResult.loading && queryResult.error === null
+            const label = unknownKey !== undefined &&
+                !queryResult.loading &&
+                queryResult.error === null &&
+                isCompleteRowPage(queryResult.data)
                 ? t(unknownKey)
                 : id;
             return { id, label, link: undefined };

package/dist/components/render-list.js

@@ -12,7 +12,8 @@ import { shouldRenderActionsIconOnly, usePrimitives, } from "../primitives.js";
 import { ListEmptyStateBody } from "./list-empty-state.js";
 import { needsActionConfirm } from "./render-edit-action-button.js";
 const SEARCH_DEBOUNCE_MS = 300;
-// Icon-less actions are promoted too (with a "plus" fallback at the call site).
+// Icon-less actions are promoted too; on phones the call site falls back to a
+// "plus" icon, on desktop the label carries the action.
 function isHeaderPromotableToolbarAction(action) {
     return action.style === "primary" && !needsActionConfirm(action);
 }
@@ -37,24 +38,31 @@ export function RenderList(props) {
     // The parent may echo our own debounced emits back late (router/URL round
     // trip), possibly after a newer emit already went out; adopting such a stale
     // echo would erase keys typed in between. All unechoed emits are kept, and a
-    // matching echo drops itself and every older one.
+    // matching echo drops itself and every older one. The render phase only reads
+    // the list (a discarded or repeated render must find the echo again); the
+    // matched entries are dropped in an effect.
     const pendingEmitsRef = useRef([]);
     if (searchValue !== syncedSearchValue) {
         setSyncedSearchValue(searchValue);
-        const echoIndex = pendingEmitsRef.current.indexOf(searchValue ?? "");
-        if (echoIndex >= 0) {
-            pendingEmitsRef.current.splice(0, echoIndex + 1);
-        }
-        else {
+        if (!pendingEmitsRef.current.includes(searchValue ?? "")) {
             setLocalQ(searchValue ?? "");
             pendingEmitsRef.current = [];
         }
     }
+    useEffect(() => {
+        const echoIndex = pendingEmitsRef.current.indexOf(syncedSearchValue ?? "");
+        if (echoIndex >= 0)
+            pendingEmitsRef.current.splice(0, echoIndex + 1);
+    }, [syncedSearchValue]);
     useEffect(() => {
         if (onSearchChange === undefined)
             return;
         if (localQ === (searchValue ?? ""))
             return;
+        // A late echo of an older emit changes searchValue but must not re-send
+        // the value that is already in flight.
+        if (pendingEmitsRef.current.at(-1) === localQ)
+            return;
         const timer = setTimeout(() => {
             pendingEmitsRef.current.push(localQ);
             onSearchChange(localQ);
@@ -79,14 +87,15 @@ export function RenderList(props) {
         labelField: c.refLabelField ?? "id",
     })), [vm.columns, featureName]);
     const [referenceLookups, setReferenceLookups] = useState({});
-    const handleLookupMap = useCallback((field, map) => {
+    const handleLookupMap = useCallback((field, lookup) => {
         setReferenceLookups((prev) => {
-            // Skip the update when the map is identical. Otherwise the bridge
+            // Skip the update when the lookup is identical. Otherwise the bridge
             // would re-render and send the same map back until React entered
             // an infinite loop.
-            if (prev[field] === map)
+            const current = prev[field];
+            if (current?.map === lookup.map && current.complete === lookup.complete)
                 return prev;
-            return { ...prev, [field]: map };
+            return { ...prev, [field]: lookup };
         });
     }, []);
     const resolveReferenceLink = useReferenceLinkResolver();
@@ -100,15 +109,19 @@ export function RenderList(props) {
             // the default is used only when none is set.
             if (col.renderer !== undefined)
                 return col;
-            const map = referenceLookups[col.field];
+            const published = referenceLookups[col.field];
+            const map = published?.map;
             const unknownKey = UNRESOLVED_REFERENCE_LABEL_KEYS[`${col.refFeature ?? featureName}:${col.refEntity ?? ""}`];
             // No raw id for entities that opt in: a placeholder while the lookup
-            // loads, the "unknown" label once it found nothing.
+            // loads, the "unknown" label once the complete lookup found nothing. A
+            // capped lookup page cannot prove absence, so it keeps the raw id.
             const unresolvedLabel = (id) => unknownKey === undefined
                 ? id
-                : map === undefined
+                : published === undefined
                     ? EMPTY_VALUE_PLACEHOLDER
-                    : translate(unknownKey);
+                    : published.complete
+                        ? translate(unknownKey)
+                        : id;
             const labelField = col.refLabelField ?? "id";
             const refEntity = col.refEntity ?? "";
             // Only a row the user can see is linkable: resolved by the server
@@ -273,8 +286,8 @@ function ReferenceLookupBridge({ field, refEntity, labelField, featureName, onMa
     const resolved = !lookup.loading && !lookup.failed;
     useEffect(() => {
         if (resolved)
-            onMap(field, lookup.map);
-    }, [field, lookup.map, resolved, onMap]);
+            onMap(field, { map: lookup.map, complete: lookup.complete });
+    }, [field, lookup.map, lookup.complete, resolved, onMap]);
     return null;
 }
 // ToolbarActionView renders one button per toolbar action, with a confirm
@@ -305,7 +318,7 @@ function ToolbarActionView({ action, iconOnly = false, Button, Dialog, Banner, }
     const variant = action.style ?? "secondary";
     const needsConfirm = needsActionConfirm(action);
     const showIconOnly = iconOnly && action.icon !== undefined;
-    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: variant, loading: busy, ...(action.icon !== undefined && { icon: action.icon }), size: showIconOnly ? "icon" : "sm", ...(showIconOnly && { ariaLabel: action.label, title: action.label }), onClick: () => {
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: variant, loading: busy, ...(action.icon !== undefined && { icon: action.icon }), size: showIconOnly ? "icon" : "md", ...(showIconOnly && { ariaLabel: action.label, title: action.label }), onClick: () => {
                     if (needsConfirm) {
                         setConfirmOpen(true);
                     }

package/dist/flow-diagram/render.js

@@ -23,7 +23,15 @@ function cardSize(node) {
     return { width, height };
 }
 function assertEdgesReferenceKnownNodes(spec) {
-    const ids = new Set(spec.nodes.map((n) => n.id));
+    const ids = new Set();
+    for (const node of spec.nodes) {
+        if (ids.has(node.id))
+            throw new Error(`FlowSpec: duplicate node id "${node.id}"`);
+        ids.add(node.id);
+        if (node.icon !== undefined && node.icon !== "ai" && !Object.hasOwn(ICONS, node.icon)) {
+            throw new Error(`FlowSpec: node "${node.id}" has unknown icon "${node.icon}"`);
+        }
+    }
     for (const edge of spec.edges) {
         if (!ids.has(edge.from))
             throw new Error(`FlowSpec: edge references unknown node "${edge.from}"`);

package/dist/headless/form/form-controller.js

@@ -217,6 +217,13 @@ export function createFormController(options) {
             errors = Object.freeze({});
         invalidate();
     }
+    function runRebaseFields(fields) {
+        initial = {
+            ...initial,
+            ...Object.fromEntries(fields.map((field) => [field, values[field]])),
+        };
+        invalidate();
+    }
     // Stale-submit-safe rebase. Difference to runRebase: the baseline is
     // taken from the values that were actually SENT to the server, not
     // from `values` at the moment the server replied. If the user typed
@@ -296,6 +303,7 @@ export function createFormController(options) {
             invalidate();
         },
         rebase: runRebase,
+        rebaseFields: runRebaseFields,
         setCtx(nextCtx) {
             // Cast back to TCtx: setCtx's public signature takes unknown so
             // callers don't need to plumb generics. If conditions depend on ctx

package/dist/headless/form/types.d.ts

@@ -33,6 +33,7 @@ export type FormController<TValues extends FormValues> = {
     validate(scope?: readonly FormScopeKey<TValues>[]): boolean;
     reset(): void;
     rebase(): void;
+    rebaseFields(fields: readonly string[]): void;
     setCtx(ctx: unknown): void;
     submit<TData = unknown>(): Promise<SubmitResult<TData>>;
 };