@cosmicdrift/kumiko-renderer 0.333.0 → 0.335.0

package/dist/app/kumiko-screen.js

@@ -1,14 +1,16 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { evalFieldCondition, isWriteFormEditSection, metricField, parseRefTarget, } from "@cosmicdrift/kumiko-framework/ui-types";
-import { computeRelatedListSectionViewModel, fieldLabelKey, fieldOptionLabelKey, isSafeHref, } from "@cosmicdrift/kumiko-headless";
+import { buildOptionLabels, computeRelatedListSectionViewModel, fieldLabelKey, fieldOptionLabelKey, isSafeHref, } from "@cosmicdrift/kumiko-headless";
 import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
 import { TENANT_CURRENCY_CONFIG_KEY } from "@cosmicdrift/kumiko-types/fields";
 import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { QueryOptionLabel, resolveOptionsQueryPayload, } from "../components/query-options-select.js";
 import { extractCreatedId, extractIdField } from "../components/reference-create-dialog.js";
 import { RenderEdit, resolveRecordTitle, } from "../components/render-edit.js";
 import { needsActionConfirm, RenderEditActionButton, RenderEditActionConfirmDialog, } from "../components/render-edit-action-button.js";
 import { RenderList } from "../components/render-list.js";
 import { useDispatcher, useOptionalDispatcher } from "../context/dispatcher-context.js";
+import { useIsEmbeddedScreen } from "../context/embedded-screen-context.js";
 import { useUserRoles } from "../context/user-roles-context.js";
 import { PAGE_SIZE_OPTIONS, useListUrlState } from "../hooks/use-list-url-state.js";
 import { useQuery } from "../hooks/use-query.js";
@@ -19,7 +21,7 @@ import { statusToneForOptionTone, statusToneForValue, usePrimitives, } from "../
 import { screenFillsHeight } from "../screen-fills-height.js";
 import { synthesizeActionFormEntity, synthesizeActionFormScreen } from "./action-form-shim.js";
 import { useAppFeatures } from "./app-features-context.js";
-import { synthesizeConfigEditEntity, synthesizeConfigEditScreen } from "./config-edit-shim.js";
+import { buildConfigEditSchema, synthesizeConfigEditEntity, synthesizeConfigEditScreen, } from "./config-edit-shim.js";
 import { useCustomScreenComponent } from "./custom-screens.js";
 import { useDashboardBody } from "./dashboard-body.js";
 import { EntityListExpandedRow } from "./entity-list-expanded-row.js";
@@ -32,9 +34,10 @@ import { synthesizeProjectionDetailEntity, synthesizeProjectionDetailScreen, } f
 import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim.js";
 import { lastSegment, toKebab } from "./qn.js";
 import { featureNameFromQualifiedScreenId, qualifyScreenId } from "./qualify-screen-id.js";
+import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
 import { ReferenceFacetBridges } from "./reference-facet-bridge.js";
 import { navigateToReturn, navigateToReturnOr, navigateWithReturnTo, ReturnHostProvider, useReturnHost, useReturnTarget, } from "./return-to.js";
-import { buildDefaultEditRowAction, buildProjectionRowActions, buildProjectionToolbarActions, buildRecordActions, evalRowExtractor, isWriteHandlerRowAction, navigateActionSearchParams, refetchAfterWrite, runProjectionRowNavigate, } from "./row-actions.js";
+import { buildDefaultEditRowAction, buildDrawerRowAction, buildProjectionRowActions, buildProjectionToolbarActions, buildRecordActions, evalRowExtractor, isWriteHandlerRowAction, navigateActionSearchParams, refetchAfterWrite, runProjectionRowNavigate, } from "./row-actions.js";
 import { findEditScreenFor, navigateTargetAllows, screenAccessAllows } from "./screen-access.js";
 import { SecretMintBody } from "./secret-mint-body.js";
 import { SecretsEditBody } from "./secrets-edit-body.js";
@@ -132,16 +135,19 @@ function entityWriteCommand(featureName, entity, verb) {
 // entityList-Screen für die Entity und navigiert dahin. Wird von
 // Create/Update/Delete genauso verwendet — alle drei haben "fertig
 // editiert, raus hier" als sinnvolles Default-Verhalten.
+function findEntityListScreen(schema, entityName) {
+    return schema.screens.find((s) => s.type === "entityList" && s.entity === entityName);
+}
 function useNavigateToListAfter(schema, entityName) {
     const nav = useNav();
     return useCallback(() => {
-        const list = schema.screens.find((s) => s.type === "entityList" && s.entity === entityName);
+        const list = findEntityListScreen(schema, entityName);
         if (!list)
             return;
         // schema.screens.id ist QN-form (registry-stamped); nav.navigate
         // erwartet Short-Form. Sonst landet die URL doppelt-qualifiziert.
         nav.navigate({ screenId: lastSegment(list.id) });
-    }, [nav, schema.screens, entityName]);
+    }, [nav, schema, entityName]);
 }
 // Default "+ Neu"-Navigation für die List-Toolbar: findet den ersten
 // entityEdit-Screen ohne entityId-Anhang und navigiert dorthin.
@@ -220,7 +226,7 @@ export function buildInitialValues(fields, defaultCurrency, moneyCurrencyOverrid
 // client-safe FieldDefinition subset, not the concrete MoneyFieldDef/
 // MoneyCurrencySource types, same idiom as the other field-shape narrowings
 // in this file (PrefillFieldShape etc.).
-function tenantCurrencyMoneyFieldNames(fields) {
+export function tenantCurrencyMoneyFieldNames(fields) {
     const names = [];
     for (const [name, def] of Object.entries(fields)) {
         const shape = def;
@@ -248,6 +254,7 @@ function resolveTenantCurrency(fieldNames, query, fallback) {
 // so a tenant-declared field whose config query errors or returns no value
 // lands here — same last resort as the entityEdit path's `?? "EUR"`.
 const ACTION_FORM_CURRENCY_FALLBACK = "EUR";
+const HEADER_CARD_DEFAULT_WIDTH = "4xl";
 // Shared by the update payload shape and the server-error path prefix so both can't drift.
 const UPDATE_CHANGES_KEY = "changes";
 // A money field naming a fixed ISO code (`currency: { kind: "literal", code }`,
@@ -271,7 +278,7 @@ export function literalCurrencyOverrides(fields) {
 // on a fast click submit, the wrong currency. Callers pass the tenant field
 // names themselves because an edit form only needs the fetch for fields the
 // record has no stored value for.
-function useMoneyCurrencyOverrides(fields, tenantFieldNames, fallback) {
+export function useMoneyCurrencyOverrides(fields, tenantFieldNames, fallback) {
     const query = useQuery("config:query:values", {}, { enabled: tenantFieldNames.length > 0 });
     const resolution = resolveTenantCurrency(tenantFieldNames, query, fallback);
     const resolvedTenantCurrency = resolution.status === "ready" ? resolution.currency : undefined;
@@ -478,7 +485,11 @@ export function mergeSearchParamsIntoInitial(fields, sources) {
             continue;
         if (shape.format === "password")
             continue;
-        if (drawerOverrides !== undefined && name in drawerOverrides) {
+        // An `undefined` override (row-extractor key whose row lacks the field)
+        // must not wipe the field default.
+        if (drawerOverrides !== undefined &&
+            Object.hasOwn(drawerOverrides, name) &&
+            drawerOverrides[name] !== undefined) {
             merged[name] = drawerOverrides[name];
             continue;
         }
@@ -659,7 +670,7 @@ function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onRelo
         }
         return out;
     }, [entity.fields, entityDefaultCurrency, moneyCurrencyOverrides, record]);
-    const formSchema = useMemo(() => buildFormSchema(entity, screen), [entity, screen]);
+    const formSchema = useMemo(() => buildFormSchema(entity, screen, initial), [entity, screen, initial]);
     // Extension-Werte (z.B. customFields-jsonb) an extension-sections geben,
     // damit sie beim Edit den Bestand zeigen statt write-only zu sein.
     const extensionInitialValues = useMemo(() => {
@@ -692,6 +703,24 @@ function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onRelo
     // pattern as ProjectionDetailBody.headerActions above (the edited record
     // stands in for the "row"), minus the cross-feature defaultEditAction
     // lookup that doesn't apply here (this screen already IS the edit form).
+    const handleRecordLeft = useCallback((action, resultData, deletedShownRecord) => {
+        // Never return onto the just-deleted record.
+        const target = deletedShownRecord && returnTarget?.entityId === entityId ? undefined : returnTarget;
+        if (action.redirect !== undefined) {
+            navigateAfterRedirect({
+                nav,
+                schema,
+                appFeatures,
+                returnTarget: target,
+                redirect: action.redirect,
+                resultData,
+                record,
+            });
+            return;
+        }
+        navigateToReturnOr(nav, target, navigateToList);
+        onDeleted?.();
+    }, [nav, schema, appFeatures, returnTarget, record, entityId, navigateToList, onDeleted]);
     const buildSectionActions = useCallback((actions) => buildRecordActions({
         actions,
         record,
@@ -701,33 +730,38 @@ function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onRelo
         dispatcher,
         openDrawer,
         onWriteSuccess: onReload,
+        onRecordLeft: handleRecordLeft,
         defaultScreenTargetEntityId: entityId,
-    }), [record, effectiveTranslate, nav, host, dispatcher, openDrawer, onReload, entityId]);
+        defaultWritePayloadId: entityId,
+    }), [
+        record,
+        effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        onReload,
+        handleRecordLeft,
+        entityId,
+    ]);
     const headerActions = useMemo(() => buildSectionActions(screen.actions ?? []), [buildSectionActions, screen.actions]);
     const handleSubmitted = useCallback((result) => {
         if (!result.isSuccess)
             return;
         const redirect = screen.redirect;
         if (redirect !== undefined) {
-            if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
-                navigateToReturn(nav, returnTarget);
-            }
-            else if (typeof redirect === "string") {
-                // String form unchanged: navigates without an entityId, same as
-                // before the object form existed. The object form resolves like
-                // actionForm's — the update handler's success payload usually
-                // reports only this record's own id (event-store-executor-write.ts),
-                // so a parent FK named by `idFrom` falls back to the already-loaded
-                // `record`.
-                nav.navigate({ screenId: lastSegment(redirect) });
-            }
-            else {
-                const { screenId, entityId: targetEntityId } = resolveRedirectTarget(redirect, result.data, schema, appFeatures, record);
-                nav.navigate({
-                    screenId,
-                    ...(targetEntityId !== undefined && { entityId: targetEntityId }),
-                });
-            }
+            // The update handler's success payload usually reports only this
+            // record's own id (event-store-executor-write.ts), so a parent FK
+            // named by `idFrom` falls back to the already-loaded `record`.
+            navigateAfterRedirect({
+                nav,
+                schema,
+                appFeatures,
+                returnTarget,
+                redirect,
+                resultData: result.data,
+                record: overlayUpdatedProjection(record, result.data),
+            });
         }
         else {
             navigateToReturnOr(nav, returnTarget, navigateToList);
@@ -967,6 +1001,7 @@ function EntityListScreen({ schema, screen, translate, onRowClick, }) {
     return (_jsx(EntityListBody, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }), ...(onRowClick !== undefined && { onRowClick }) }));
 }
 function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
+    const isEmbeddedScreen = useIsEmbeddedScreen();
     const featureName = schema.featureName;
     const onCreate = useNavigateToCreateFor(schema, screen.entity, screen.createScreen);
     const { Banner } = usePrimitives();
@@ -1232,26 +1267,7 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
                 };
             }
             if (action.kind === "drawer") {
-                const drawerAction = action;
-                const actionVisible = action.visible;
-                const actionIcon = resolveActionIcon(action.id, action.icon);
-                return {
-                    id: action.id,
-                    label: effectiveTranslate(action.label),
-                    ...(action.style !== undefined && { style: action.style }),
-                    ...(action.display !== undefined && { display: action.display }),
-                    confirmRequired: false,
-                    ...(actionIcon !== undefined && { icon: actionIcon }),
-                    onTrigger: (row) => {
-                        const initialValues = drawerAction.params !== undefined
-                            ? evalRowExtractor(drawerAction.params, row.values)
-                            : undefined;
-                        openDrawer(drawerAction, initialValues);
-                    },
-                    ...(actionVisible !== undefined && {
-                        isVisible: (row) => evalFieldCondition(actionVisible, row.values),
-                    }),
-                };
+                return buildDrawerRowAction(action, effectiveTranslate, openDrawer);
             }
             if (dispatcher === undefined)
                 return null;
@@ -1392,7 +1408,9 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
     // Bei Infinite-Mode: rows kommen aus accumulated (über mehrere
     // useQuery-Calls gesammelt), bei pages/false aus dem aktuellen Result.
     const renderRows = useInfinite ? accumulated : (rowsQuery.data?.rows ?? []);
-    return (_jsxs(_Fragment, { children: [_jsx(ReferenceFacetBridges, { specs: entityFacetSpecs, onOptions: handleEntityFacetOptions }), _jsx(FacetCountBridges, { queryType: queryType, queries: facetCountQueries, onCount: handleFacetCount }), _jsx(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: effectiveSort, onSortChange: urlState.setSort, screenPadding: true, ...(screenFillsHeight(screen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(toolbarActions !== undefined && toolbarActions.length > 0 && { toolbarActions }), ...(useInfinite && {
+    return (_jsxs(_Fragment, { children: [_jsx(ReferenceFacetBridges, { specs: entityFacetSpecs, onOptions: handleEntityFacetOptions }), _jsx(FacetCountBridges, { queryType: queryType, queries: facetCountQueries, onCount: handleFacetCount }), _jsx(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: effectiveSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
+                    ? { screenPadding: false, chromeless: true }
+                    : { screenPadding: true }), ...(screenFillsHeight(screen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(toolbarActions !== undefined && toolbarActions.length > 0 && { toolbarActions }), ...(useInfinite && {
                     onReachEnd: loadMore,
                     loadingMore: rowsQuery.loading,
                     hasMore,
@@ -1420,6 +1438,7 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
 // declared here. Pages-mode pagination only — infinite-scroll accumulation
 // isn't wired for projectionList.
 function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
+    const isEmbeddedScreen = useIsEmbeddedScreen();
     const { Banner, Text } = usePrimitives();
     const t = useTranslation();
     const nav = useNav();
@@ -1591,7 +1610,9 @@ function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
             onPageSizeChange: urlState.setPageSize,
         }
         : undefined;
-    return (_jsxs(_Fragment, { children: [_jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleProjectionFacetOptions }), _jsx(RenderList, { screen: listScreen, entity: entity, rows: rowsQuery.data?.rows ?? [], featureName: schema.featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: activeSort, onSortChange: urlState.setSort, screenPadding: true, ...(screenFillsHeight(listScreen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(toolbarActions !== undefined && { toolbarActions }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
+    return (_jsxs(_Fragment, { children: [_jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleProjectionFacetOptions }), _jsx(RenderList, { screen: listScreen, entity: entity, rows: rowsQuery.data?.rows ?? [], featureName: schema.featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: activeSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
+                    ? { screenPadding: false, chromeless: true }
+                    : { screenPadding: true }), ...(screenFillsHeight(listScreen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(toolbarActions !== undefined && { toolbarActions }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
                     filterFacets,
                     onFilterChange: urlState.setFilter,
                 }), ...(dateRangeFacets.length > 0 && {
@@ -1831,7 +1852,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
     // useQuery call re-runs too (it has no `live` subscription of its own).
     const [reloadNonce, setReloadNonce] = useState(0);
     const reloadDetail = useCallback(async () => {
-        await detailQuery.refetch();
+        await refetchAfterWrite(detailQuery.refetch);
         setReloadNonce((n) => n + 1);
     }, [detailQuery.refetch]);
     // Header actions render directly via RenderEditActionButton (fw#2713,
@@ -1850,7 +1871,49 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
     const userRoles = useUserRoles();
     const dispatcher = useOptionalDispatcher();
     const host = useReturnHost();
+    const returnTargetParam = useReturnTarget(screen.id);
+    // A singleton has no record route to come back to — same as entityEdit.
+    const returnTarget = screen.singleton === true ? undefined : returnTargetParam;
     const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
+    const handleRecordLeft = useCallback((action, resultData, deletedShownRecord) => {
+        const record = detailQuery.data ?? {};
+        // Never return onto the just-deleted record.
+        const target = deletedShownRecord && returnTarget?.entityId === effectiveEntityId
+            ? undefined
+            : returnTarget;
+        if (action.redirect !== undefined) {
+            navigateAfterRedirect({
+                nav,
+                schema,
+                appFeatures,
+                returnTarget: target,
+                redirect: action.redirect,
+                resultData,
+                record,
+            });
+            return;
+        }
+        navigateToReturnOr(nav, target, () => {
+            const listScreen = screen.listScreenId ??
+                (screen.detailFor !== undefined
+                    ? findEntityListScreen(schema, screen.detailFor)?.id
+                    : undefined);
+            if (listScreen !== undefined)
+                nav.navigate({ screenId: lastSegment(listScreen) });
+            else
+                void detailQuery.refetch();
+        });
+    }, [
+        detailQuery.data,
+        detailQuery.refetch,
+        nav,
+        schema,
+        appFeatures,
+        returnTarget,
+        effectiveEntityId,
+        screen.listScreenId,
+        screen.detailFor,
+    ]);
     const editScreen = useMemo(() => {
         const detailFor = screen.detailFor;
         if (detailFor === undefined)
@@ -1898,6 +1961,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         dispatcher,
         openDrawer,
         onWriteSuccess: detailQuery.refetch,
+        onRecordLeft: handleRecordLeft,
         sameEntityScreenId,
     }), [
         detailQuery.data,
@@ -1907,6 +1971,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         host,
         dispatcher,
         openDrawer,
+        handleRecordLeft,
         sameEntityScreenId,
     ]);
     const headerActions = useMemo(() => {
@@ -1920,6 +1985,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
             dispatcher,
             openDrawer,
             onWriteSuccess: detailQuery.refetch,
+            onRecordLeft: handleRecordLeft,
             sameEntityScreenId,
         });
         if (defaultEditAction === undefined || declaredHasEdit)
@@ -1935,8 +2001,25 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         detailQuery.data,
         detailQuery.refetch,
         openDrawer,
+        handleRecordLeft,
         sameEntityScreenId,
     ]);
+    const hasHeader = screen.header !== undefined;
+    const hasMetrics = screen.metrics !== undefined && screen.metrics.length > 0;
+    // ?? [] rather than threading `headerActions !== undefined` through every
+    // use below — an empty array is a safe no-op for .map/.length.
+    const headerActionsList = headerActions ?? [];
+    const hasHeaderActions = headerActionsList.length > 0;
+    const hasHeaderCard = hasHeader || hasMetrics || hasHeaderActions;
+    // A header card (metric band, status, actions) needs more room than the
+    // 640px form column; screens with only a record title keep the narrow one.
+    const widensScreenFormColumn = hasHeaderCard &&
+        !hasTabs &&
+        screenFillsHeight(screen) &&
+        detailScreen.layout.width === undefined;
+    const renderedDetailScreen = useMemo(() => widensScreenFormColumn
+        ? { ...detailScreen, layout: { ...detailScreen.layout, width: HEADER_CARD_DEFAULT_WIDTH } }
+        : detailScreen, [detailScreen, widensScreenFormColumn]);
     if (effectiveEntityId === undefined && screen.singleton !== true) {
         return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-detail-missing-id", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " (projectionDetail) needs a row id in the path \u2014 open it from a row action."] }));
     }
@@ -1950,18 +2033,11 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
     if (!record) {
         return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-record-missing", children: screen.singleton === true ? ("Record not found.") : (_jsxs(_Fragment, { children: ["Record ", _jsx(Text, { variant: "code", children: entityId }), " not found."] })) }));
     }
-    const hasHeader = screen.header !== undefined;
-    const hasMetrics = screen.metrics !== undefined && screen.metrics.length > 0;
-    // ?? [] rather than threading `headerActions !== undefined` through every
-    // use below — an empty array is a safe no-op for .map/.length.
-    const headerActionsList = headerActions ?? [];
-    const hasHeaderActions = headerActionsList.length > 0;
     // Grouped into the head Card alongside title/status/metrics (fw#2713):
     // these are actions on the record the head shows, not on whichever tab is
     // open, so they must stay in place across tab switches instead of
     // trailing the active tab's content in the card footer.
     const headerActionsContent = hasHeaderActions && (_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-actions", children: _jsx(HeaderActionsBar, { actions: headerActionsList, Button: Button, Dialog: Dialog, ActionOverflowMenu: ActionOverflowMenu, onError: setActionError }) }));
-    const hasHeaderCard = hasHeader || hasMetrics || hasHeaderActions;
     // Rendered as RenderEdit's headerRegion (not as JSX siblings before it) so
     // this shares the same page padding/width as the record's edit card below
     // it, instead of sitting flush against the screen edge (fw record-screen
@@ -2023,7 +2099,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
                         ...(count !== undefined && { count }),
                     };
                 }), activeId: activeSection.id ?? "", onSelect: (id) => nav.setSearchParams({ tab: id }) }))] }));
-    return (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { screen: detailScreen, entity: entity, featureName: schema.featureName, initial: record, entityId: effectiveEntityId, customSubmit: async () => ({ isSuccess: true, validationBlocked: false, data: undefined }), onReload: reloadDetail, onRelatedListDrawerAction: openDrawer, ...(translate !== undefined && { translate }), ...(hasTabs && { hideSectionTitles: true }), ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...((hasHeaderCard ||
+    return (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { screen: renderedDetailScreen, entity: entity, featureName: schema.featureName, initial: record, entityId: effectiveEntityId, customSubmit: async () => ({ isSuccess: true, validationBlocked: false, data: undefined }), onReload: reloadDetail, onRelatedListDrawerAction: openDrawer, ...(translate !== undefined && { translate }), ...(hasTabs && { hideSectionTitles: true }), ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...((hasHeaderCard ||
                     hasTabs ||
                     screen.slots?.header !== undefined ||
                     screen.recordTitleField !== undefined) && {
@@ -2037,18 +2113,24 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
 function redirectScreenTarget(redirect) {
     return typeof redirect === "string" ? redirect : redirect.screen;
 }
-// Checks this schema first, then every mounted feature — the target may live
-// in another (cross-feature) feature than the redirect's own screen.
+// A qualified redirect names its feature, so the search space is THAT feature
+// only — the current schema's own screens must not shadow it with a same
+// short-id screen of another type. An unqualified redirect searches this
+// schema first (own screen wins), then every mounted feature. A named feature
+// that isn't mounted (no provider / isolated test) falls back to this schema.
 function findRedirectTargetScreen(redirect, schema, appFeatures) {
     const redirectScreen = redirectScreenTarget(redirect);
     const targetId = lastSegment(redirectScreen);
     const targetFeatureName = featureNameFromQualifiedScreenId(redirectScreen);
-    return (schema.screens.find((s) => lastSegment(s.id) === targetId) ??
-        (targetFeatureName !== undefined
-            ? appFeatures
-                .find((f) => f.featureName === targetFeatureName)
-                ?.screens.find((s) => lastSegment(s.id) === targetId)
-            : appFeatures.flatMap((f) => f.screens).find((s) => lastSegment(s.id) === targetId)));
+    const targetFeature = targetFeatureName !== undefined
+        ? appFeatures.find((f) => f.featureName === targetFeatureName)
+        : undefined;
+    const searchSpace = targetFeature !== undefined
+        ? targetFeature.screens
+        : targetFeatureName === undefined
+            ? [...schema.screens, ...appFeatures.flatMap((f) => f.screens)]
+            : schema.screens;
+    return searchSpace.find((s) => lastSegment(s.id) === targetId);
 }
 // A redirect to a record screen ("show the result") is a deliberate forward
 // navigation and keeps precedence over returnTo.
@@ -2083,6 +2165,33 @@ function resolveRedirectTarget(redirect, submittedData, schema, appFeatures, fal
         (fallbackRecord !== undefined ? extractIdField(fallbackRecord, idField) : undefined);
     return { screenId: targetId, entityId };
 }
+// Success navigation for a configured redirect — shared by entityEdit's
+// save and writeHandler record actions. The string form navigates without an
+// entityId; the object form resolves like actionForm's, with `record` as the
+// fallback id source.
+function navigateAfterRedirect(options) {
+    const { nav, schema, appFeatures, returnTarget, redirect, resultData, record } = options;
+    if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
+        navigateToReturn(nav, returnTarget);
+        return;
+    }
+    if (typeof redirect === "string") {
+        nav.navigate({ screenId: lastSegment(redirect) });
+        return;
+    }
+    const { screenId, entityId } = resolveRedirectTarget(redirect, resultData, schema, appFeatures, record);
+    nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
+}
+// The update payload nests the saved projection under `data`; a changed
+// parent FK lives there, not in the pre-edit `record`.
+function overlayUpdatedProjection(record, resultData) {
+    if (typeof resultData !== "object" || resultData === null)
+        return record;
+    const projection = resultData.data;
+    if (typeof projection !== "object" || projection === null)
+        return record;
+    return { ...record, ...projection };
+}
 // Action-Form-Body — non-CRUD Write-Handler-driven Form. Re-uses
 // RenderEdit über synthetisierte EntityDefinition + EntityEditScreen-
 // Definition (siehe action-form-shim.ts für die Schulden-Doku). Die
@@ -2189,8 +2298,19 @@ function unwrapMoneyValue(value) {
     }
     return value;
 }
+const CONFIG_SCOPE_SOURCE = {
+    user: "user-row",
+    tenant: "tenant-row",
+    system: "system-row",
+};
+function isWriteOnlyTextField(fieldDef) {
+    return fieldDef?.type === "text" && fieldDef.writeOnly === true;
+}
+function hasStoredValue(stored) {
+    return stored !== undefined && stored !== null && stored !== "";
+}
 function ConfigEditBody({ schema, screen, translate, }) {
-    const { Banner, ConfigCascadeView } = usePrimitives();
+    const { ConfigCascadeView } = usePrimitives();
     const t = useTranslation();
     const effectiveTranslate = translate ?? t;
     const dispatcher = useDispatcher();
@@ -2201,6 +2321,7 @@ function ConfigEditBody({ schema, screen, translate, }) {
     const cascadeQuery = useQuery("config:query:cascade", {});
     const synthEntity = useMemo(() => synthesizeConfigEditEntity(screen.fields), [screen.fields]);
     const synthScreen = useMemo(() => synthesizeConfigEditScreen(screen), [screen]);
+    const boundsSchema = useMemo(() => buildConfigEditSchema(screen.fields), [screen.fields]);
     // Initial-Values: pro Field-Name den Wert aus `values[qualifiedKey]`
     // abholen. Fehlt der Key auf dem Server (= noch nie gesetzt), nutzen
     // wir den Field-Default (createTextField/createNumberField/...).
@@ -2220,6 +2341,15 @@ function ConfigEditBody({ schema, screen, translate, }) {
                 continue;
             }
             const stored = valuesQuery.data[qualified]?.value;
+            // The read carries a mask (or nothing); only whether a value exists is
+            // meaningful, so the field gets the writeOnly wire shape true / null.
+            // The read is the effective value: an inherited one is not "set" on this
+            // scope, and a reset here would remove nothing.
+            if (isWriteOnlyTextField(fieldDef)) {
+                const ownedByThisScope = valuesQuery.data[qualified]?.source === CONFIG_SCOPE_SOURCE[screen.scope];
+                out[shortName] = ownedByThisScope && hasStoredValue(stored) ? true : null;
+                continue;
+            }
             if (stored === undefined) {
                 out[shortName] = defaults[shortName];
                 continue;
@@ -2238,7 +2368,7 @@ function ConfigEditBody({ schema, screen, translate, }) {
             }
         }
         return out;
-    }, [valuesQuery.data, screen.fields, screen.configKeys]);
+    }, [valuesQuery.data, screen.fields, screen.configKeys, screen.scope]);
     // Cascade-Lookup: qualifiedKey → ConfigCascade für die
     // Cascade-Anzeige unter jedem Feld. Defensive `levels`-Shape-Check
     // damit fremde Query-Mocks (z.B. configEdit-Unit-Tests die nur
@@ -2271,7 +2401,36 @@ function ConfigEditBody({ schema, screen, translate, }) {
             const qualified = screen.configKeys[shortName];
             if (qualified === undefined)
                 continue;
-            const ftype = screen.fields[shortName]?.type;
+            const fieldDef = screen.fields[shortName];
+            const ftype = fieldDef?.type;
+            if (isWriteOnlyTextField(screen.fields[shortName])) {
+                // true (untouched/undone) and "" mean keep the stored secret; null removes it.
+                if (value === null) {
+                    commands.push({
+                        type: "config:write:reset",
+                        payload: { key: qualified, scope: screen.scope },
+                    });
+                }
+                else if (typeof value === "string" && value !== "") {
+                    commands.push({
+                        type: "config:write:set",
+                        payload: { key: qualified, value, scope: screen.scope },
+                    });
+                }
+                continue;
+            }
+            // A query-backed select is cleared to "" when its dependent value became
+            // invalid. config:write:set would store that as an empty override (the
+            // badge shows "Mandant" with no value); reset falls back to the inherited
+            // value. set can't do it: deleting the row is irreversible, reset is
+            // the high-risk handler.
+            if (ftype === "select" && fieldDef?.optionsQuery !== undefined && value === "") {
+                commands.push({
+                    type: "config:write:reset",
+                    payload: { key: qualified, scope: screen.scope },
+                });
+                continue;
+            }
             commands.push({
                 type: "config:write:set",
                 payload: {
@@ -2302,41 +2461,40 @@ function ConfigEditBody({ schema, screen, translate, }) {
         valuesQuery.refetch,
         cascadeQuery.refetch,
     ]);
-    // Cascade-Disclosure (#429): Trigger sitzt in der Label-Row, das Panel
-    // unter dem Input — zwei getrennte Render-Slots teilen sich den
-    // expanded-State, der daher hier (pro Feld) statt in der Komponente lebt.
-    const [expandedFields, setExpandedFields] = useState(new Set());
-    const toggleExpanded = useCallback((fieldName) => {
-        setExpandedFields((prev) => {
-            const next = new Set(prev);
-            if (next.has(fieldName))
-                next.delete(fieldName);
-            else
-                next.add(fieldName);
-            return next;
-        });
-    }, []);
-    if (valuesQuery.loading && valuesQuery.data === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
-    }
+    if (valuesQuery.loading && valuesQuery.data === null)
+        return _jsx(QueryLoadingBanner, {});
     if (valuesQuery.error) {
-        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(valuesQuery.error, effectiveTranslate) }));
+        return (_jsx(QueryErrorBanner, { error: valuesQuery.error, translate: effectiveTranslate, onRetry: valuesQuery.refetch }));
     }
-    if (initial === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
-    }
-    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, customSubmit: customSubmit, ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }), labelAppendix: (fieldName) => {
+    if (initial === null)
+        return _jsx(QueryLoadingBanner, {});
+    // Cascade values of a select show the option label the select itself shows,
+    // not the stored value (a UUID for optionsQuery selects).
+    const cascadeValueRenderer = (fieldName) => {
+        const fieldDef = screen.fields[fieldName];
+        if (fieldDef?.type !== "select")
+            return undefined;
+        if (fieldDef.optionsQuery !== undefined) {
+            const query = fieldDef.optionsQuery;
+            const payload = resolveOptionsQueryPayload(fieldDef.optionsQueryPayload ?? {}, initial);
+            return (value) => _jsx(QueryOptionLabel, { query: query, payload: payload, value: value });
+        }
+        if (fieldDef.options.length === 0)
+            return undefined;
+        return (value) => buildOptionLabels(effectiveTranslate, (option) => fieldOptionLabelKey(schema.featureName, synthScreen.entity, fieldName, option), [String(value)])[String(value)];
+    };
+    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, schema: boundsSchema, customSubmit: customSubmit, dirtyFooter: true, validateOnChange: true, ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }), fieldAppendixPlacement: "below-control", fieldAccent: (fieldName) => cascades[fieldName]?.levels.find((level) => level.isActive)?.source ===
+            CONFIG_SCOPE_SOURCE[screen.scope], markChangedFields: true, ...(screen.fieldDescriptions !== undefined && {
+            fieldDescription: (fieldName) => {
+                const key = screen.fieldDescriptions?.[fieldName];
+                return key === undefined ? undefined : effectiveTranslate(key);
+            },
+        }), fieldAppendix: (fieldName) => {
             const cascade = cascades[fieldName];
             if (cascade === undefined)
                 return undefined;
-            return (_jsx(ConfigCascadeView, { slot: "trigger", cascade: cascade, screenScope: screen.scope, expanded: expandedFields.has(fieldName), onToggle: () => toggleExpanded(fieldName) }));
-        }, fieldAppendix: (fieldName) => {
-            const cascade = cascades[fieldName];
-            // Panel nur rendern wenn aufgeklappt — sonst kein leerer Abstand
-            // unter dem Input.
-            if (cascade === undefined || !expandedFields.has(fieldName))
-                return undefined;
-            return (_jsx(ConfigCascadeView, { slot: "panel", cascade: cascade, screenScope: screen.scope, expanded: true, qualifiedKey: screen.configKeys[fieldName], onReset: async (key, scope) => {
+            const renderValue = cascadeValueRenderer(fieldName);
+            return (_jsx(ConfigCascadeView, { cascade: cascade, screenScope: screen.scope, qualifiedKey: screen.configKeys[fieldName], required: screen.requiredFields?.includes(fieldName) ?? false, ...(renderValue !== undefined && { renderValue }), onReset: async (key, scope) => {
                     await dispatcher.write("config:write:reset", { key, scope });
                     await Promise.allSettled([valuesQuery.refetch?.(), cascadeQuery.refetch?.()]);
                 } }));

package/dist/app/nav.d.ts

@@ -47,6 +47,11 @@ export type NavApi = {
 };
 export declare function parsePath(pathname: string, hasWorkspaces?: boolean): NavRoute | undefined;
 export declare function formatPath(target: ScreenTarget): string;
+export declare function findDetailForScreen(features: readonly FeatureSchema[], entity: string): {
+    readonly featureName: string;
+    readonly screenId: string;
+    readonly screen: FeatureSchema["screens"][number];
+} | undefined;
 /** Non-throwing existence check for findDetailForScreen — lets a caller pick
  *  a different default (fw#2164's row-click fallback) instead of resolving. */
 export declare function hasDetailScreen(features: readonly FeatureSchema[], entity: string): boolean;