@cosmicdrift/kumiko-renderer 0.363.0 → 0.364.0

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.363.0",
+  "version": "0.364.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.364.0",
+    "@cosmicdrift/kumiko-headless": "0.364.0",
+    "@cosmicdrift/kumiko-types": "0.364.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.364.0"
   },
   "repository": {
     "type": "git",

package/src/changes.json

@@ -1,4 +1,22 @@
 [
+  {
+    "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",