@cosmicdrift/kumiko-renderer 0.363.0 → 0.365.0

package/dist/app/form-schema.js

@@ -1,4 +1,4 @@
-import { evalFieldCondition, findUnavailableSelectOptions, NO_WIDGET_FIELD_TYPES, } from "@cosmicdrift/kumiko-framework/ui-types";
+import { evalFieldCondition, findUnavailableSelectOptions, isUnchangedValue, NO_WIDGET_FIELD_TYPES, } from "@cosmicdrift/kumiko-framework/ui-types";
 import { I18N_KEY_PARAM } from "@cosmicdrift/kumiko-headless";
 import * as z from "zod";
 import { layoutEditFields } from "./layout-fields.js";
@@ -34,8 +34,7 @@ function isRequiredValueMissing(spec, field, record, unchangedFrom) {
         return false;
     if (isPresent(record[spec.field]))
         return false;
-    return !(unchangedFrom !== undefined &&
-        JSON.stringify(record[spec.field]) === JSON.stringify(unchangedFrom[spec.field]));
+    return !(unchangedFrom !== undefined && isUnchangedValue(record[spec.field], unchangedFrom[spec.field]));
 }
 // Client-side presence validation for the auto-wired entityEdit path —
 // checks that every rendered required field HAS a value, not that the
@@ -79,17 +78,24 @@ export function buildFormSchema(entity, screen, verb, unchangedFrom) {
         // @cast-boundary form-values
         const record = values;
         const selectFieldsToCheck = {};
+        // The server validates the merged row, so a locked select still fails there; the
+        // client reports it on the condition field the user can actually change.
+        const lockedSelectFields = {};
         for (const spec of fields) {
             const field = entity.fields[spec.field];
             if (!field)
                 continue;
             // Hidden on create, read-only on update: the user cannot resolve a presence error.
-            if (excludedFromWrite.has(spec.field))
+            if (excludedFromWrite.has(spec.field)) {
+                lockedSelectFields[spec.field] = field;
                 continue;
+            }
             // Not operable by the user — a presence error would be unresolvable,
             // same reason as the NO_WIDGET_FIELD_TYPES check below.
-            if (spec.readOnly !== undefined && evalFieldCondition(spec.readOnly, record))
+            if (spec.readOnly !== undefined && evalFieldCondition(spec.readOnly, record)) {
+                lockedSelectFields[spec.field] = field;
                 continue;
+            }
             selectFieldsToCheck[spec.field] = field;
             if (!isRequiredValueMissing(spec, field, record, unchangedFrom))
                 continue;
@@ -103,11 +109,15 @@ export function buildFormSchema(entity, screen, verb, unchangedFrom) {
         }
         // Against `unchangedFrom` the helper still checks a stored value whose
         // discriminator changed — the server validates the merged row.
-        for (const issue of findUnavailableSelectOptions(selectFieldsToCheck, record, unchangedFrom)) {
+        for (const issue of findUnavailableSelectOptions({ ...lockedSelectFields, ...selectFieldsToCheck }, record, unchangedFrom)) {
+            const lockedDef = lockedSelectFields[issue.field];
+            const blamedField = lockedDef !== undefined && lockedDef.type === "select"
+                ? (lockedDef.conditionalOptions?.find((rule) => rule.options.includes(issue.value) && !evalFieldCondition(rule.when, record))?.when.field ?? issue.field)
+                : issue.field;
             ctx.addIssue({
                 code: "custom",
-                path: [issue.field],
-                message: `"${issue.field}" is not available for the current selection.`,
+                path: [blamedField],
+                message: `"${blamedField}" is not available for the current selection.`,
                 params: { [I18N_KEY_PARAM]: OPTION_NOT_AVAILABLE_I18N_KEY, allowed: issue.allowed },
             });
         }

package/dist/app/kumiko-screen.js

@@ -51,7 +51,7 @@ import { findEditScreenFor, navigateTargetAllows, screenAccessAllows } from "./s
 import { SecretMintBody } from "./secret-mint-body.js";
 import { SecretsEditBody } from "./secrets-edit-body.js";
 import { useEmbeddedScreen } from "./use-embedded-screen.js";
-import { evalVisibleWhen } from "./visible-when.js";
+import { evalVisibleWhenAfterShown } from "./visible-when.js";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error.js";
 export { qualifyScreenId };
 /** Mirrors qualifyScreenId for nav QNs (registry form `<feature>:nav:<short-id>`).
@@ -96,9 +96,13 @@ export function KumikoScreen({ schema, qn, translate, entityId, onRowClick, onCo
 function ScreenVisibilityGate({ featureName, visibleWhen, fallback, translate, children, }) {
     const { Banner, PageHeader } = usePrimitives();
     const pageHeaderSlotAvailable = usePageHeaderSlotAvailable();
-    const t = useTranslation();
     const result = useQuery(visibleWhen.query, {}, { live: true });
-    const verdict = evalVisibleWhen(visibleWhen, result);
+    const wasShown = useRef(false);
+    const verdict = evalVisibleWhenAfterShown(visibleWhen, result, wasShown.current);
+    useEffect(() => {
+        if (verdict === "visible")
+            wasShown.current = true;
+    }, [verdict]);
     if (verdict === "visible")
         return children;
     if (verdict === "loading") {
@@ -106,14 +110,19 @@ function ScreenVisibilityGate({ featureName, visibleWhen, fallback, translate, c
     }
     // The route still names the locked screen; its breadcrumb must not label what stands in for it.
     const hideLockedBreadcrumb = PageHeader !== undefined && pageHeaderSlotAvailable ? _jsx(PageHeader, { hideBreadcrumb: true }) : null;
-    return (_jsxs(_Fragment, { children: [hideLockedBreadcrumb, fallback !== undefined ? (_jsx(FallbackScreen, { featureName: featureName, fallback: fallback, translate: translate })) : (_jsx(Banner, { padded: true, variant: "info", testId: "kumiko-screen-unavailable", children: t("kumiko.screen.unavailable") }))] }));
+    return (_jsxs(_Fragment, { children: [hideLockedBreadcrumb, fallback !== undefined ? (_jsx(FallbackScreen, { featureName: featureName, fallback: fallback, translate: translate })) : (_jsx(ScreenUnavailableBanner, {}))] }));
+}
+function ScreenUnavailableBanner() {
+    const { Banner } = usePrimitives();
+    const t = useTranslation();
+    return (_jsx(Banner, { padded: true, variant: "info", testId: "kumiko-screen-unavailable", children: t("kumiko.screen.unavailable") }));
 }
 function FallbackScreen({ featureName, fallback, translate, }) {
     const target = useEmbeddedScreen(featureName, fallback);
-    const { Banner, Text } = usePrimitives();
-    if (target === undefined) {
-        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-not-found", children: ["Screen not found: ", _jsx(Text, { variant: "code", children: fallback })] }));
-    }
+    // Also undefined when the user lacks access to the fallback screen, which is
+    // not a framework error.
+    if (target === undefined)
+        return _jsx(ScreenUnavailableBanner, {});
     return _jsx(KumikoScreen, { schema: target.schema, qn: target.qn, translate: translate });
 }
 function renderScreenBody({ schema, screen, translate, entityId, onRowClick, onCopyLink, }) {
@@ -480,7 +489,11 @@ function isRepresentableAtScale(value, scale) {
     const tolerance = Math.abs(scaled) * 8 * Number.EPSILON + Number.EPSILON;
     return Math.abs(scaled - Math.round(scaled)) <= tolerance;
 }
-function isIsoInstant(value) {
+// Server schema (`z.iso.datetime()`) accepts only a `Z` suffix, while
+// Temporal.Instant.from also takes numeric offsets.
+function isUtcIsoInstant(value) {
+    if (!value.endsWith("Z"))
+        return false;
     try {
         Temporal.Instant.from(value);
         return true;
@@ -490,6 +503,21 @@ function isIsoInstant(value) {
     }
 }
 const EMBEDDED_LIST_PREFILL_ROW_LIMIT = 500;
+// The server schema (`z.string().date()`) rejects calendar-invalid days like 2020-02-31.
+function isValidIsoDate(value) {
+    if (!ISO_DATE_PATTERN.test(value))
+        return false;
+    try {
+        Temporal.PlainDate.from(value, { overflow: "reject" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isDecimalWithinSafeRange(value, scale) {
+    return scale === undefined || Math.abs(value) <= Number.MAX_SAFE_INTEGER / 10 ** scale;
+}
 function coerceEmbeddedCell(value, cell) {
     switch (cell.type) {
         case "number":
@@ -497,13 +525,15 @@ function coerceEmbeddedCell(value, cell) {
         case "decimal":
             return typeof value === "number" &&
                 Number.isFinite(value) &&
-                (cell.scale === undefined || isRepresentableAtScale(value, cell.scale))
+                (cell.scale === undefined ||
+                    (isRepresentableAtScale(value, cell.scale) &&
+                        isDecimalWithinSafeRange(value, cell.scale)))
                 ? value
                 : undefined;
         case "date":
-            return typeof value === "string" && ISO_DATE_PATTERN.test(value) ? value : undefined;
+            return typeof value === "string" && isValidIsoDate(value) ? value : undefined;
         case "timestamp":
-            return typeof value === "string" && isIsoInstant(value) ? value : undefined;
+            return typeof value === "string" && isUtcIsoInstant(value) ? value : undefined;
         case "money":
             // Row cells are signed minor units; the currency lives on the head, so a
             // top-level `{amount, currency}` in major units would land 100x off.
@@ -552,6 +582,8 @@ function coerceEmbeddedListRows(raw, fieldName, schema, maxItems) {
 }
 function coercePrefillString(raw, name, shape, fallback, defaultCurrency, moneyCurrencyOverrides) {
     if (shape.type === "number") {
+        if (raw.trim() === "")
+            return fallback;
         const parsed = Number(raw);
         return Number.isFinite(parsed) ? parsed : fallback;
     }
@@ -2198,8 +2230,12 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
             (screen.detailFor !== undefined
                 ? findEntityListScreen(schema, screen.detailFor)?.id
                 : undefined);
-        return (_jsx(RecordNotFoundState, { translate: effectiveTranslate, ...(backListScreen !== undefined && {
-                onBack: () => nav.navigate({ screenId: lastSegment(backListScreen) }),
+        return (_jsx(RecordNotFoundState, { translate: effectiveTranslate, ...((returnTarget !== undefined || backListScreen !== undefined) && {
+                onBack: () => navigateToReturnOr(nav, returnTarget, () => {
+                    if (backListScreen !== undefined) {
+                        nav.navigate({ screenId: lastSegment(backListScreen) });
+                    }
+                }),
             }) }));
     }
     // Grouped into the head Card alongside title/status/metrics (fw#2713):

package/dist/app/list-facets.js

@@ -217,16 +217,20 @@ export function clampDateRange(current, bound, value) {
 // starts at that day's first instant, "to the 14th" includes everything up to
 // its last. Going through the next day's start keeps both ends right across a
 // DST boundary, where the day is not 24h long.
-function dayBoundInstant(date, bound, timeZone) {
-    let plainDate;
+function parsePlainDate(date) {
     try {
-        plainDate = Temporal.PlainDate.from(date);
+        return Temporal.PlainDate.from(date);
     }
     catch {
-        // Half-typed or hand-crafted URL value — drop the bound rather than send
-        // something the handler's ISO-datetime schema would reject.
         return null;
     }
+}
+function dayBoundInstant(date, bound, timeZone) {
+    // Half-typed or hand-crafted URL value — drop the bound rather than send
+    // something the handler's ISO-datetime schema would reject.
+    const plainDate = parsePlainDate(date);
+    if (plainDate === null)
+        return null;
     const start = plainDate.toZonedDateTime(timeZone).toInstant();
     return bound === "from"
         ? start.toString()
@@ -242,7 +246,10 @@ function dayBoundInstant(date, bound, timeZone) {
 // A shared or hand-built URL can carry from > to; the handler's `from <= to`
 // refine would answer 422, so the bounds are put in order before conversion.
 function swapInvertedRange(range) {
-    const inverted = range.from !== "" && range.to !== "" && range.from > range.to;
+    // Comparing raw strings would swap a valid bound against garbage and flip the filter's meaning.
+    const from = parsePlainDate(range.from);
+    const to = parsePlainDate(range.to);
+    const inverted = from !== null && to !== null && Temporal.PlainDate.compare(from, to) > 0;
     return inverted ? { from: range.to, to: range.from } : range;
 }
 export function buildDateRangePayload(specs, urlFilters, timeZone) {

package/dist/app/nav.d.ts

@@ -18,7 +18,9 @@ export type ObjectTarget = {
 export type NavTarget = ScreenTarget | ObjectTarget;
 export type NavigateOptions = {
     /** Search params of the target route, set in the same history entry as
-     *  the path. Without them the target starts with an empty query. */
+     *  the path. Without them a different target starts with an empty query;
+     *  navigating to the current path keeps the current query (pass
+     *  `searchParams: {}` to clear it). */
     readonly searchParams?: Readonly<Record<string, string>>;
 };
 export type NavApi = {

package/dist/app/visible-when.d.ts

@@ -2,3 +2,4 @@ import type { DashboardPanelVisibility } from "@cosmicdrift/kumiko-framework/ui-
 import type { UseQueryResult } from "../hooks/use-query.js";
 export type VisibleWhenVerdict = "loading" | "visible" | "hidden" | "error";
 export declare function evalVisibleWhen(visibleWhen: DashboardPanelVisibility, result: UseQueryResult<Readonly<Record<string, unknown>>> | undefined): VisibleWhenVerdict;
+export declare function evalVisibleWhenAfterShown(visibleWhen: DashboardPanelVisibility, result: UseQueryResult<Readonly<Record<string, unknown>>> | undefined, wasShown: boolean): VisibleWhenVerdict;

package/dist/app/visible-when.js

@@ -9,3 +9,10 @@ export function evalVisibleWhen(visibleWhen, result) {
         return result.loading ? "loading" : "hidden";
     return result.data[visibleWhen.field] === visibleWhen.eq ? "visible" : "hidden";
 }
+// Once the content was shown, a failed refetch must not unmount it (and drop unsaved
+// form input) while the last good data still matches; the first evaluation stays fail-closed.
+export function evalVisibleWhenAfterShown(visibleWhen, result, wasShown) {
+    const verdict = evalVisibleWhen(visibleWhen, result);
+    const lastGoodDataMatches = result?.data?.[visibleWhen.field] === visibleWhen.eq;
+    return verdict === "error" && wasShown && lastGoodDataMatches ? "visible" : verdict;
+}

package/dist/components/availability-options-select.d.ts

@@ -1,6 +1,6 @@
 import type { EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
 import type { OptionsQueryPayload } from "@cosmicdrift/kumiko-types/fields";
-import type { ReactNode } from "react";
+import { type ReactNode } from "react";
 export type SelectOptionEntry = {
     readonly value: string;
     readonly label: string;
@@ -9,14 +9,14 @@ export type SelectOptionEntry = {
 };
 export declare function staticSelectOptions(field: EditFieldViewModel): readonly SelectOptionEntry[];
 export declare function mergeOptionAvailability(options: readonly SelectOptionEntry[], rows: readonly unknown[], current: string): readonly SelectOptionEntry[];
-export declare function filterUnavailableOptions(options: readonly SelectOptionEntry[], rows: readonly unknown[], currentValues: readonly string[]): readonly SelectOptionEntry[];
+export declare function filterUnavailableOptions(options: readonly SelectOptionEntry[], rows: readonly unknown[], heldValues: ReadonlySet<string>): readonly SelectOptionEntry[];
 type AvailabilityOptionsMultiSelectProps = {
     readonly field: EditFieldViewModel;
     readonly query: string;
-    readonly currentValues: readonly string[];
+    readonly initialValues: readonly string[];
     readonly children: (options: readonly SelectOptionEntry[]) => ReactNode;
 };
-export declare function AvailabilityOptionsMultiSelect({ field, query, currentValues, children, }: AvailabilityOptionsMultiSelectProps): ReactNode;
+export declare function AvailabilityOptionsMultiSelect({ field, query, initialValues, children, }: AvailabilityOptionsMultiSelectProps): ReactNode;
 type AvailabilityOptionsSelectProps = {
     readonly field: EditFieldViewModel;
     readonly query: string;

package/dist/components/availability-options-select.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from "react";
 import { useQuery } from "../hooks/use-query.js";
 import { usePrimitives } from "../primitives.js";
 import { resolveOptionsQueryPayload } from "./query-options-select.js";
@@ -36,21 +37,27 @@ export function mergeOptionAvailability(options, rows, current) {
         };
     });
 }
-// Combobox primitives cannot disable a single option, so unavailable ones are
-// dropped; an already selected value stays listed so it can still be removed.
-export function filterUnavailableOptions(options, rows, currentValues) {
+// Unavailable options are dropped unless the target already held them when the
+// form mounted; those stay listed but disabled, because the write path keeps
+// values the caller cannot grant and an unchecked one could never be re-checked.
+export function filterUnavailableOptions(options, rows, heldValues) {
     const unavailable = new Set();
     for (const row of rows) {
         if (isAvailabilityRow(row) && row.disabled === true)
             unavailable.add(row.value);
     }
-    return options.filter((option) => !unavailable.has(option.value) || currentValues.includes(option.value));
+    return options.flatMap((option) => {
+        if (!unavailable.has(option.value))
+            return [option];
+        return heldValues.has(option.value) ? [{ ...option, disabled: true }] : [];
+    });
 }
 // Until the result arrives, and when the query fails, every static option is
 // shown; the write path enforces the rule either way.
-export function AvailabilityOptionsMultiSelect({ field, query, currentValues, children, }) {
+export function AvailabilityOptionsMultiSelect({ field, query, initialValues, children, }) {
     const { data } = useQuery(query, {});
-    return children(filterUnavailableOptions(staticSelectOptions(field), data?.rows ?? [], currentValues));
+    const heldAtMount = useRef(new Set(initialValues));
+    return children(filterUnavailableOptions(staticSelectOptions(field), data?.rows ?? [], heldAtMount.current));
 }
 // Select with static options whose availability (SelectFieldDef.optionsAvailabilityQuery)
 // comes from a query, so it has to be a mounted component for useQuery. Until the

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

@@ -13,6 +13,8 @@ export function FileListField({ field, id, kind, onChange, hasError, }) {
     const { Input, Button, Grid, GridCell, Text } = usePrimitives();
     const t = useTranslation();
     const fileIds = readFileIds(field.value);
+    // The server accepts repeated ids, so the id alone is not a unique key.
+    const keys = fileIds.map((fileId, index) => `${fileId}#${fileIds.slice(0, index).filter((x) => x === fileId).length}`);
     const disabled = field.readOnly;
     const canAdd = !disabled && (field.maxCount === undefined || fileIds.length < field.maxCount);
     const inputProps = {
@@ -42,7 +44,7 @@ export function FileListField({ field, id, kind, onChange, hasError, }) {
                                 onChange(fileIds.filter((_, i) => i !== index));
                             else
                                 onChange(fileIds.map((existing, i) => (i === index ? next : existing)));
-                        } }), !disabled && (_jsxs(Grid, { columns: "auto", children: [index > 0 && (_jsx(Button, { variant: "ghost", size: "icon", icon: "chevron-up", ariaLabel: t("kumiko.field.file-list.move-up"), testId: `${id}-${index}-move-up`, onClick: () => move(index, index - 1) })), index < fileIds.length - 1 && (_jsx(Button, { variant: "ghost", size: "icon", icon: "chevron-down", ariaLabel: t("kumiko.field.file-list.move-down"), testId: `${id}-${index}-move-down`, onClick: () => move(index, index + 1) }))] }))] }, fileId))), canAdd && (_jsxs(GridCell, { children: [_jsx(Text, { variant: "muted", children: t("kumiko.field.file-list.add") }), _jsx(Input, { ...inputProps, id: `${id}-add`, value: null, onChange: (next) => {
+                        } }), !disabled && (_jsxs(Grid, { columns: "auto", children: [index > 0 && (_jsx(Button, { variant: "ghost", size: "icon", icon: "chevron-up", ariaLabel: t("kumiko.field.file-list.move-up"), testId: `${id}-${index}-move-up`, onClick: () => move(index, index - 1) })), index < fileIds.length - 1 && (_jsx(Button, { variant: "ghost", size: "icon", icon: "chevron-down", ariaLabel: t("kumiko.field.file-list.move-down"), testId: `${id}-${index}-move-down`, onClick: () => move(index, index + 1) }))] }))] }, keys[index]))), canAdd && (_jsxs(GridCell, { children: [_jsx(Text, { variant: "muted", children: t("kumiko.field.file-list.add") }), _jsx(Input, { ...inputProps, id: `${id}-add`, value: null, onChange: (next) => {
                             if (next !== null)
                                 onChange([...fileIds, next]);
                         } })] }, "add"))] }));

package/dist/components/multi-select-checkboxes.d.ts

@@ -3,6 +3,7 @@ import type { ReactNode } from "react";
 export type MultiSelectCheckboxOption = {
     readonly value: string;
     readonly label: string;
+    readonly disabled?: boolean;
 };
 export type MultiSelectCheckboxesProps = {
     readonly field: EditFieldViewModel;

package/dist/components/multi-select-checkboxes.js

@@ -14,8 +14,11 @@ export function MultiSelectCheckboxes({ field, id, options, value, onChange, })
     const allSelected = options.length > 0 && options.every((opt) => selected.has(opt.value));
     // Always emits in `field.options` order (MultiSelectFieldDef's documented
     // ordering guarantee), never in click/selection order.
+    // Disabled options are pinned: they keep their current state whatever is toggled.
     const emitOrdered = (next) => {
-        onChange(options.filter((opt) => next.has(opt.value)).map((opt) => opt.value));
+        onChange(options
+            .filter((opt) => (opt.disabled === true ? selected.has(opt.value) : next.has(opt.value)))
+            .map((opt) => opt.value));
     };
     const toggleOption = (optionValue, checked) => {
         const next = new Set(selected);
@@ -35,5 +38,5 @@ export function MultiSelectCheckboxes({ field, id, options, value, onChange, })
                     : t("kumiko.field.multiSelect.select-all") }), _jsx(Grid, { columns: field.columns ?? 2, testId: `${id}-checkboxes`, 
                 // Field's label targets `id`, which no checkbox carries here; point the
                 // group at Field's `${id}-label` element instead.
-                ariaLabelledBy: `${id}-label`, ...(field.maxRows !== undefined && { maxRows: field.maxRows }), children: options.map((opt) => (_jsx(GridCell, { children: _jsx(Field, { id: `${id}-${opt.value}`, label: opt.label, layout: "inline", children: _jsx(Input, { kind: "boolean", id: `${id}-${opt.value}`, name: `${id}-${opt.value}`, value: selected.has(opt.value), onChange: (checked) => toggleOption(opt.value, checked), disabled: disabled }) }) }, opt.value))) })] }));
+                ariaLabelledBy: `${id}-label`, ...(field.maxRows !== undefined && { maxRows: field.maxRows }), children: options.map((opt) => (_jsx(GridCell, { children: _jsx(Field, { id: `${id}-${opt.value}`, label: opt.label, layout: "inline", children: _jsx(Input, { kind: "boolean", id: `${id}-${opt.value}`, name: `${id}-${opt.value}`, value: selected.has(opt.value), onChange: (checked) => toggleOption(opt.value, checked), disabled: disabled || opt.disabled === true }) }) }, opt.value))) })] }));
 }

package/dist/components/render-field.js

@@ -352,9 +352,9 @@ function renderInput({ field, id, hasError, onChange, Input, appLocale, Banner,
             return (_jsx(Input, { kind: "tz", ...common, value: stringValue(field.value), onChange: (v) => onChange(v) }));
         case "multiSelect": {
             const arrayValue = stringArrayOf(field.value);
-            const renderMultiSelect = (options) => field.display === "checkboxes" ? (_jsx(MultiSelectCheckboxes, { field: field, id: id, options: options, value: arrayValue, onChange: (v) => onChange(v) })) : (_jsx(Input, { kind: "combobox", ...common, multiple: true, value: arrayValue, onChange: (v) => onChange(v), options: options }));
+            const renderMultiSelect = (options) => field.display === "checkboxes" ? (_jsx(MultiSelectCheckboxes, { field: field, id: id, options: options, value: arrayValue, onChange: (v) => onChange(v) })) : (_jsx(Input, { kind: "combobox", ...common, multiple: true, value: arrayValue, onChange: (v) => onChange(withPinnedValues(v, options, arrayValue)), options: options }));
             if (field.selectOptionsAvailabilityQuery !== undefined && field.readOnly !== true) {
-                return (_jsx(AvailabilityOptionsMultiSelect, { field: field, query: field.selectOptionsAvailabilityQuery.query, currentValues: arrayValue, children: renderMultiSelect }));
+                return (_jsx(AvailabilityOptionsMultiSelect, { field: field, query: field.selectOptionsAvailabilityQuery.query, initialValues: arrayValue, children: renderMultiSelect }));
             }
             return renderMultiSelect(staticSelectOptions(field));
         }
@@ -449,8 +449,11 @@ const ISO_CURRENCY_CODE = /^[A-Z]{3}$/;
 function resolveMoneyCurrency(value, fieldCurrency) {
     if (typeof value === "object" && value !== null && "currency" in value) {
         const { currency } = value;
-        if (typeof currency === "string" && ISO_CURRENCY_CODE.test(currency))
-            return currency;
+        if (typeof currency === "string") {
+            const normalized = currency.toUpperCase();
+            if (ISO_CURRENCY_CODE.test(normalized))
+                return normalized;
+        }
     }
     return fieldCurrency ?? "EUR";
 }
@@ -472,7 +475,17 @@ function resolveNumberUnit(unit, row) {
     return trimmed.length > 0 && trimmed.length <= MAX_SIBLING_UNIT_LENGTH ? trimmed : undefined;
 }
 function stringArrayOf(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
+// The combobox cannot disable a single option, so removals of disabled options
+// the form already holds are merged back.
+function withPinnedValues(next, options, current) {
+    const missingPinned = options
+        .filter((opt) => opt.disabled === true && current.includes(opt.value) && !next.includes(opt.value))
+        .map((opt) => opt.value);
+    return missingPinned.length === 0 ? next : [...next, ...missingPinned];
 }
 function stringPropertyOf(value, key) {
     const property = propertyOf(value, key);

package/dist/components/render-list.js

@@ -31,14 +31,20 @@ export function RenderList(props) {
     // mount and can flush after a keystroke landing in the same commit,
     // resetting localQ and swallowing the input.
     const [syncedSearchValue, setSyncedSearchValue] = useState(searchValue);
-    // The parent may echo our own debounced emit back late (router/URL round
-    // trip); adopting that stale echo would erase keys typed in between.
-    const lastEmittedRef = useRef(undefined);
+    // 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.
+    const pendingEmitsRef = useRef([]);
     if (searchValue !== syncedSearchValue) {
         setSyncedSearchValue(searchValue);
-        if (searchValue !== lastEmittedRef.current) {
+        const echoIndex = pendingEmitsRef.current.indexOf(searchValue ?? "");
+        if (echoIndex >= 0) {
+            pendingEmitsRef.current.splice(0, echoIndex + 1);
+        }
+        else {
             setLocalQ(searchValue ?? "");
-            lastEmittedRef.current = undefined;
+            pendingEmitsRef.current = [];
         }
     }
     useEffect(() => {
@@ -47,7 +53,7 @@ export function RenderList(props) {
         if (localQ === (searchValue ?? ""))
             return;
         const timer = setTimeout(() => {
-            lastEmittedRef.current = localQ;
+            pendingEmitsRef.current.push(localQ);
             onSearchChange(localQ);
         }, SEARCH_DEBOUNCE_MS);
         return () => clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.363.0",
+  "version": "0.365.0",
   "description": "Platform-agnostic React renderer for Kumiko screens. Contains the shared logic — primitives-contract, hooks, KumikoScreen, navigation & SSE abstractions — that any platform-specific renderer (web, native) composes. No DOM, no EventSource, no react-dom.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -15,9 +15,9 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.363.0",
-    "@cosmicdrift/kumiko-headless": "0.363.0",
-    "@cosmicdrift/kumiko-types": "0.363.0",
+    "@cosmicdrift/kumiko-framework": "0.365.0",
+    "@cosmicdrift/kumiko-headless": "0.365.0",
+    "@cosmicdrift/kumiko-types": "0.365.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
@@ -28,7 +28,7 @@
     "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
     "react-dom": "^19.2.6",
-    "@cosmicdrift/kumiko-locale-de": "0.363.0"
+    "@cosmicdrift/kumiko-locale-de": "0.365.0"
   },
   "repository": {
     "type": "git",

package/src/changes.json

@@ -1,4 +1,28 @@
 [
+  {
+    "version": "0.365.0",
+    "type": "fix",
+    "title": "List search keeps the newest typed text; file lists tolerate duplicate ids; date ranges and locked selects validate correctly",
+    "detail": "A late echo of an older debounced search emit no longer overwrites newer typing. Duplicate file ids no longer collide as React keys. An inverted date range is swapped only when both bounds parse. Select rules on writeExcluded or readOnly fields are now checked by the form schema."
+  },
+  {
+    "version": "0.364.0",
+    "type": "fix",
+    "title": "A failed refetch of a visibleWhen gate no longer unmounts a screen that is already showing",
+    "detail": "ScreenVisibilityGate used to fail closed on every error, so one failed live refetch (SSE reconnect, a short 5xx) removed the content and reset unsaved form input. Only the first evaluation fails closed now; after the content was shown, an error keeps it mounted as long as the last good data still matches the condition. The dashboard panel retry path is unchanged."
+  },
+  {
+    "version": "0.364.0",
+    "type": "fix",
+    "title": "A held multiSelect value that optionsAvailabilityQuery marks unavailable stays listed but cannot be removed",
+    "detail": "The keep-listed set is taken from the values present when the field mounted, not from the live value. In the checkbox grid the entry is rendered disabled and select-all/deselect-all leave it as is; in the combobox a removal is merged back into the value. Previously unchecking such a role hid it for good while the write path kept it, so the form reported a removal that never happened. A stored lower-case currency code such as usd is normalised to upper case instead of falling back to the field currency, and array values with a non-string element keep their string entries instead of being treated as empty."
+  },
+  {
+    "version": "0.364.0",
+    "type": "fix",
+    "title": "Screen fallback access, projectionDetail back navigation and stricter prefill",
+    "detail": "A visibleWhen fallback screen the user may not access now shows the standard unavailable notice instead of a \"Screen not found\" error. The not-found state of a projectionDetail honours returnTo for its back button. Embedded-list prefill rejects calendar-invalid dates, timestamps with numeric offsets and decimals beyond the safe range, and an empty number param keeps the field default instead of becoming 0."
+  },
   {
     "version": "0.363.0",
     "type": "improvement",