@cosmicdrift/kumiko-renderer 0.378.0 → 0.379.0

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

@@ -14,8 +14,7 @@
 // RenderActionForm-Komponente, die `fields` direkt als Input nimmt.
 // Der Boot-Validator kennt actionForm bereits eigenständig (kein
 // entity-Lookup), also ist der Server-Pfad davon nicht betroffen.
-import { isFieldsEditSection, normalizeEditField, sectionFieldSpecs, } from "@cosmicdrift/kumiko-framework/ui-types";
-const ACTION_FORM_PSEUDO_ENTITY = "__action-form__";
+import { ACTION_FORM_PSEUDO_ENTITY, isFieldsEditSection, normalizeEditField, sectionFieldSpecs, } from "@cosmicdrift/kumiko-framework/ui-types";
 /** Baut eine minimale EntityDefinition aus den Inline-Fields eines
  *  ActionForm- oder SecretMint-Screens. RenderEdit + computeEditViewModel
  *  iterieren über entity.fields zur Render-Zeit; alle weiteren

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

@@ -40,11 +40,12 @@ function pickDeclaredFields(record, fieldNames) {
 /** Loads the initial values of an actionForm declaring `load`; undefined for a
  *  form without `load`. */
 export function useActionFormLoad(load, recordId, fieldNames) {
-    const query = useQuery(load?.query ?? "", { [load?.idParam ?? DEFAULT_LOAD_ID_PARAM]: recordId }, { enabled: load !== undefined && recordId !== undefined });
+    const isSingleton = load?.singleton === true;
+    const query = useQuery(load?.query ?? "", isSingleton ? {} : { [load?.idParam ?? DEFAULT_LOAD_ID_PARAM]: recordId }, { enabled: load !== undefined && (isSingleton || recordId !== undefined) });
     const values = useMemo(() => pickDeclaredFields(query.data, fieldNames), [query.data, fieldNames]);
     if (load === undefined)
         return undefined;
-    if (recordId === undefined)
+    if (!isSingleton && recordId === undefined)
         return { status: "missing-id" };
     if (query.error !== null)
         return { status: "error", error: query.error };
@@ -90,7 +91,18 @@ export function resolveSuccessFacts(facts, data, translate, locale) {
     });
     return resolved;
 }
+// Lines can repeat (two files with one name), so the position is the only stable key.
+function positionedLines(lines) {
+    return lines.map((line, position) => ({ position: String(position), line }));
+}
 export function ActionFormSuccessBanner({ success, }) {
-    const { Banner, Link, Text } = usePrimitives();
-    return (_jsxs(Banner, { variant: "info", testId: "action-form-success", children: [success.text, success.facts.map((fact) => (_jsxs(Text, { testId: `action-form-success-fact-${fact.key}`, children: [fact.label, ": ", fact.lines.join(", ")] }, fact.key))), success.links.map((link) => (_jsx(Link, { href: link.href, onPress: link.onPress, className: "ml-2 underline", testId: `action-form-success-link-${link.key}`, children: link.label }, link.key)))] }));
+    const { Banner, Grid, Link, Text } = usePrimitives();
+    // Text renders inline, so the message and each fact sit in a one-column grid to get their own lines.
+    return (_jsxs(Banner, { variant: "info", testId: "action-form-success", children: [_jsxs(Grid, { columns: 1, children: [_jsx(Text, { testId: "action-form-success-text", children: success.text }), success.facts.map((fact) => {
+                        const factTestId = `action-form-success-fact-${fact.key}`;
+                        if (fact.lines.length === 1) {
+                            return (_jsxs(Text, { testId: factTestId, children: [fact.label, ": ", fact.lines[0]] }, fact.key));
+                        }
+                        return (_jsxs(Grid, { columns: 1, testId: factTestId, children: [_jsxs(Text, { children: [fact.label, ":"] }), positionedLines(fact.lines).map(({ position, line }) => (_jsx(Text, { testId: `${factTestId}-line-${position}`, children: line }, position)))] }, fact.key));
+                    })] }), success.links.map((link) => (_jsx(Link, { href: link.href, onPress: link.onPress, className: "ml-2 underline", testId: `action-form-success-link-${link.key}`, children: link.label }, link.key)))] }));
 }

package/dist/app/kumiko-screen.js

@@ -21,6 +21,7 @@ import { useQuery } from "../hooks/use-query.js";
 import { referenceLookupSource } from "../hooks/use-reference-lookup.js";
 import { useLocale, useOptionalTimeZone, useTranslation } from "../i18n.js";
 import { InsideDrawerProvider, useInsideDrawer } from "../inside-drawer.js";
+import { requestLeave } from "../leave-guard.js";
 import { PageHeaderSlotAvailableProvider, usePageHeaderCompact, usePageHeaderSlotAvailable, } from "../page-header-slot.js";
 import { statusToneForOptionTone, statusToneForValue, usePrimitives, } from "../primitives.js";
 import { screenFillsHeight } from "../screen-fills-height.js";
@@ -37,7 +38,7 @@ import { FacetCountBridges } from "./facet-count-bridge.js";
 import { buildFormSchema } from "./form-schema.js";
 import { HeaderActionsBar } from "./header-actions-bar.js";
 import { hiddenRequiredFieldsFilled, layoutEditFields, layoutFieldNames } from "./layout-fields.js";
-import { isListNarrowed, useListEmptyContent } from "./list-empty-content.js";
+import { isDefaultFilterActive, isListNarrowed, useListEmptyContent, } from "./list-empty-content.js";
 import { buildDateRangePayload, buildEntityFilterFacets, buildFacetCountRequests, buildFilterFacets, buildFilterPayload, clampDateRange, mergeReferenceFacetOptions, normalizeDefaultFilters, readDateRange, resolveDateRangeFacets, resolveProjectionFacetSpecs, } from "./list-facets.js";
 import { useInitialValuesHandoff, useNav } from "./nav.js";
 import { synthesizeProjectionDetailEntity, synthesizeProjectionDetailScreen, } from "./projection-detail-shim.js";
@@ -94,7 +95,6 @@ export function KumikoScreen({ schema, qn, translate, entityId, onRowClick, onCo
     return _jsx(ReturnHostProvider, { value: ownHost, children: body });
 }
 function ScreenVisibilityGate({ featureName, visibleWhen, fallback, translate, children, }) {
-    const { Banner } = usePrimitives();
     const result = useQuery(visibleWhen.query, {}, { live: true });
     const wasShown = useRef(false);
     const verdict = evalVisibleWhenAfterShown(visibleWhen, result, wasShown.current);
@@ -105,7 +105,7 @@ function ScreenVisibilityGate({ featureName, visibleWhen, fallback, translate, c
     if (verdict === "visible")
         return children;
     if (verdict === "loading") {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
     if (fallback !== undefined) {
         return _jsx(FallbackScreen, { featureName: featureName, fallback: fallback, translate: translate });
@@ -724,7 +724,6 @@ function EntityEditScreen({ schema, screen, translate, entityId, onCopyLink, })
     return (_jsx(EntityEditCreateOrDisabled, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }) }));
 }
 function EntityEditCreateBody({ schema, screen, entity, translate, onSaved, }) {
-    const { Banner } = usePrimitives();
     const nav = useNav();
     const handoffValues = useInitialValuesHandoff(screen.id);
     const appFeatures = useAppFeatures();
@@ -800,7 +799,7 @@ function EntityEditCreateBody({ schema, screen, entity, translate, onSaved, }) {
     // Never seed a tenant-declared money field with entityDefaultCurrency while
     // its real tenant currency is still in flight (fw#2933) — wait instead.
     if (currencyLoading) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
     // Deliberately no `actions` prop here: `screen.actions` targets an
     // EXISTING record (publish/archive/duplicate and friends), which the
@@ -813,7 +812,6 @@ function EntityEditCreateBody({ schema, screen, entity, translate, onSaved, }) {
 // `<feature>:write:<entity>:update` on submit. `buildPayload` shapes the
 // snapshot into Kumiko's update-event envelope `{ id, version, changes }`.
 function EntityEditUpdateBody({ schema, screen, entity, entityId, translate, onCopyLink, autoReloadOnSave, onDeleted, }) {
-    const { Banner } = usePrimitives();
     const t = useTranslation();
     const effectiveTranslate = translate ?? t;
     const detailQn = `${toKebab(schema.featureName)}:query:${toKebab(screen.entity)}:detail`;
@@ -823,11 +821,13 @@ function EntityEditUpdateBody({ schema, screen, entity, entityId, translate, onC
     const returnTargetParam = useReturnTarget(screen.id);
     const returnTarget = screen.singleton === true ? undefined : returnTargetParam;
     if (detailQuery.loading && detailQuery.data === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
-    if (detailQuery.error) {
-        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(detailQuery.error, effectiveTranslate) }));
+    if (detailQuery.error && detailQuery.data === null) {
+        return (_jsx(QueryErrorBanner, { error: detailQuery.error, translate: effectiveTranslate, onRetry: detailQuery.refetch }));
     }
+    // A failed refetch keeps the last good data on screen.
+    const refetchErrorBanner = detailQuery.error ? (_jsx(QueryErrorBanner, { error: detailQuery.error, translate: effectiveTranslate, onRetry: detailQuery.refetch })) : null;
     const record = detailQuery.data;
     if (!record) {
         const onBack = returnTarget !== undefined || findEntityListScreen(schema, screen.entity) !== undefined
@@ -842,10 +842,9 @@ function EntityEditUpdateBody({ schema, screen, entity, entityId, translate, onC
     // weiter die stale version stampen und der Konflikt-Recovery wäre
     // kaputt.
     const recordKey = versionOf(record);
-    return (_jsx(EntityEditUpdateForm, { schema: schema, screen: screen, entity: entity, entityId: entityId, record: record, onReload: detailQuery.refetch, ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }), ...(autoReloadOnSave === true && { onSaved: () => void detailQuery.refetch() }), ...(onDeleted !== undefined && { onDeleted }) }, `${entityId}:${recordKey}`));
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(EntityEditUpdateForm, { schema: schema, screen: screen, entity: entity, entityId: entityId, record: record, onReload: detailQuery.refetch, ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }), ...(autoReloadOnSave === true && { onSaved: () => void detailQuery.refetch() }), ...(onDeleted !== undefined && { onDeleted }) }, `${entityId}:${recordKey}`)] }));
 }
 function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onReload, translate, onCopyLink, onSaved, onDeleted, }) {
-    const { Banner } = usePrimitives();
     // Seed the form with the server values for the entity's declared
     // fields; anything else (id, tenant_id, created_at…) stays out of
     // the form and lives in the closure. The record's `version` is
@@ -1019,7 +1018,7 @@ function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onRelo
     // stored (non-empty) value is unaffected — it never reaches this branch's
     // fallback because `initial` above already prefers `record[name]`.
     if (currencyLoading) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
     // Evaluated against the stored record only, so typing in a form can never
     // flip the screen between editable and view.
@@ -1045,23 +1044,24 @@ function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onRelo
 // existing record via list(limit:1) before deciding create vs update —
 // otherwise every visit without an id would create another record.
 function EntityEditSingletonBody({ schema, screen, entity, translate, onCopyLink, }) {
-    const { Banner } = usePrimitives();
     const t = useTranslation();
     const effectiveTranslate = translate ?? t;
     const listQn = entityQueryCommand(schema.featureName, screen.entity, "list");
     const listQuery = useQuery(listQn, { limit: 1 });
     if (listQuery.loading && listQuery.data === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
-    if (listQuery.error) {
-        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(listQuery.error, effectiveTranslate) }));
+    if (listQuery.error && listQuery.data === null) {
+        return (_jsx(QueryErrorBanner, { error: listQuery.error, translate: effectiveTranslate, onRetry: listQuery.refetch }));
     }
+    // A failed refetch keeps the last good data on screen.
+    const refetchErrorBanner = listQuery.error ? (_jsx(QueryErrorBanner, { error: listQuery.error, translate: effectiveTranslate, onRetry: listQuery.refetch })) : null;
     const rawExistingId = listQuery.data?.rows[0]?.["id"];
     const existingId = typeof rawExistingId === "string" ? rawExistingId : undefined;
     if (existingId !== undefined) {
-        return (_jsx(EntityEditUpdateBody, { schema: schema, screen: screen, entity: entity, entityId: existingId, ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }), autoReloadOnSave: true, onDeleted: () => void listQuery.refetch() }));
+        return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(EntityEditUpdateBody, { schema: schema, screen: screen, entity: entity, entityId: existingId, ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }), autoReloadOnSave: true, onDeleted: () => void listQuery.refetch() })] }));
     }
-    return (_jsx(EntityEditCreateOrDisabled, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }), onSaved: () => void listQuery.refetch() }));
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(EntityEditCreateOrDisabled, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }), onSaved: () => void listQuery.refetch() })] }));
 }
 // Shared no-entityId tail for both the plain create path and the
 // singleton path's empty-table fallback: `allowCreate: false` blocks
@@ -1248,7 +1248,6 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
     const featureName = schema.featureName;
     const resolvedCreate = useNavigateToCreateFor(schema, screen.entity, screen.createScreen, screen.createUnavailable);
     const onCreate = screen.allowCreate === false ? undefined : resolvedCreate;
-    const { Banner } = usePrimitives();
     const queryType = entityQueryCommand(featureName, screen.entity, "list");
     const nav = useNav();
     const host = useReturnHost();
@@ -1572,6 +1571,7 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         refetch: refreshRowsAfterWrite,
         openDrawer,
         host,
+        access: { appFeatures, userRoles },
     }), [
         screen.toolbarActions,
         effectiveTranslate,
@@ -1580,6 +1580,8 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         dispatcher,
         refreshRowsAfterWrite,
         openDrawer,
+        appFeatures,
+        userRoles,
     ]);
     const emptyContent = useListEmptyContent(screen.emptyState, effectiveTranslate, {
         nav,
@@ -1619,11 +1621,13 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         invalidateExpansions,
     ]);
     if (rowsQuery.loading && rowsQuery.data === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
-    if (rowsQuery.error) {
-        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(rowsQuery.error, effectiveTranslate) }));
+    if (rowsQuery.error && rowsQuery.data === null) {
+        return (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch }));
     }
+    // A failed refetch keeps the last good data on screen.
+    const refetchErrorBanner = rowsQuery.error ? (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch })) : null;
     // RenderList's onRowClick is a 1-arg callback; KumikoScreen's
     // 2-arg shape (row, entityName) is the public surface — thread the
     // screen's entity through here so callers don't have to re-derive
@@ -1666,7 +1670,7 @@ 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, refreshNonce: facetCountRefreshNonce }), _jsx(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, narrowed: isListNarrowed(urlState.q, urlState.filters, defaultFilters), ...(screen.description !== undefined && {
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ReferenceFacetBridges, { specs: entityFacetSpecs, onOptions: handleEntityFacetOptions }), _jsx(FacetCountBridges, { queryType: queryType, queries: facetCountQueries, onCount: handleFacetCount, refreshNonce: facetCountRefreshNonce }), _jsx(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, narrowed: isListNarrowed(urlState.q, urlState.filters, defaultFilters), defaultFilterActive: isDefaultFilterActive(urlState.q, urlState.filters, defaultFilters), ...(screen.description !== undefined && {
                     description: effectiveTranslate(screen.description),
                 }), ...(emptyContent !== undefined && { emptyContent }), searchValue: urlState.q, onSearchChange: urlState.setQ, sort: effectiveSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
                     ? { screenPadding: false, chromeless: true }
@@ -1838,6 +1842,7 @@ function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
         refetch: rowsQuery.refetch,
         openDrawer,
         host,
+        access: { appFeatures, userRoles },
     }), [
         screen.toolbarActions,
         effectiveTranslate,
@@ -1846,6 +1851,8 @@ function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
         dispatcher,
         rowsQuery.refetch,
         openDrawer,
+        appFeatures,
+        userRoles,
     ]);
     const emptyContent = useListEmptyContent(screen.emptyState, effectiveTranslate, {
         nav,
@@ -1855,11 +1862,13 @@ function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
         onWriteSuccess: rowsQuery.refetch,
     });
     if (rowsQuery.loading && rowsQuery.data === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
-    if (rowsQuery.error) {
-        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(rowsQuery.error, effectiveTranslate) }));
+    if (rowsQuery.error && rowsQuery.data === null) {
+        return (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch }));
     }
+    // A failed refetch keeps the last good data on screen.
+    const refetchErrorBanner = rowsQuery.error ? (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch })) : null;
     // rowsQuery.data is typed as PagedRows but the query handler is free to
     // return anything at runtime (fw#2216: a bare array silently rendered an
     // empty table instead of surfacing the mismatch); a system-boundary cast
@@ -1890,7 +1899,7 @@ 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, narrowed: isListNarrowed(activeSearch, urlState.filters), ...(screen.description !== undefined && {
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleProjectionFacetOptions }), _jsx(RenderList, { screen: listScreen, entity: entity, rows: rowsQuery.data?.rows ?? [], featureName: schema.featureName, searchable: searchable, narrowed: isListNarrowed(activeSearch, urlState.filters), ...(screen.description !== undefined && {
                     description: effectiveTranslate(screen.description),
                 }), ...(emptyContent !== undefined && { emptyContent }), searchValue: urlState.q, onSearchChange: urlState.setQ, sort: activeSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
                     ? { screenPadding: false, chromeless: true }
@@ -2181,13 +2190,13 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         host,
         dispatcher,
         openDrawer,
-        onWriteSuccess: detailQuery.refetch,
+        onWriteSuccess: reloadDetail,
         onRecordLeft: handleRecordLeft,
         sameEntityScreenId,
         clientActions,
     }), [
         detailQuery.data,
-        detailQuery.refetch,
+        reloadDetail,
         effectiveTranslate,
         nav,
         host,
@@ -2207,7 +2216,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
             host,
             dispatcher,
             openDrawer,
-            onWriteSuccess: detailQuery.refetch,
+            onWriteSuccess: reloadDetail,
             onRecordLeft: handleRecordLeft,
             sameEntityScreenId,
             clientActions,
@@ -2224,7 +2233,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         dispatcher,
         clientActions,
         detailQuery.data,
-        detailQuery.refetch,
+        reloadDetail,
         openDrawer,
         handleRecordLeft,
         sameEntityScreenId,
@@ -2249,11 +2258,13 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         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."] }));
     }
     if (detailQuery.loading && detailQuery.data === null) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
-    if (detailQuery.error) {
-        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(detailQuery.error, effectiveTranslate) }));
+    if (detailQuery.error && detailQuery.data === null) {
+        return (_jsx(QueryErrorBanner, { error: detailQuery.error, translate: effectiveTranslate, onRetry: detailQuery.refetch }));
     }
+    // A failed refetch keeps the last good record on screen.
+    const refetchErrorBanner = detailQuery.error ? (_jsx(QueryErrorBanner, { error: detailQuery.error, translate: effectiveTranslate, onRetry: detailQuery.refetch })) : null;
     const record = detailQuery.data;
     if (!record) {
         const backListScreen = screen.listScreenId ??
@@ -2337,8 +2348,8 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
                         label: effectiveTranslate(section.title ?? section.id ?? ""),
                         ...(count !== undefined && { count }),
                     };
-                }), activeId: activeSection.id ?? "", onSelect: (id) => nav.setSearchParams({ tab: id }) }))] }));
-    return (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { refreshToken: reloadNonce, 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 ||
+                }), activeId: activeSection.id ?? "", onSelect: (id) => requestLeave(() => nav.setSearchParams({ tab: id })) }))] }));
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(RenderEdit, { refreshToken: reloadNonce, 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) && {
@@ -2644,7 +2655,7 @@ function ActionFormBody({ schema, screen, translate, entityId, initialOverrides,
     // Rendering the form before a tenant-declared currency lands would show the
     // fallback and, on a fast click, submit it (fw#2933) — hold instead.
     if (currencyLoading) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
     if (currencyUnresolved) {
         return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-currency-unresolved", children: "The tenant currency could not be loaded, so this form cannot be submitted." }));
@@ -2652,7 +2663,7 @@ function ActionFormBody({ schema, screen, translate, entityId, initialOverrides,
     if (loadState !== undefined && loadState.status !== "ready") {
         return (_jsx(ActionFormLoadStatus, { state: loadState, screenId: screen.id, translate: effectiveTranslate }));
     }
-    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: derivedInitial, ...(screen.derive !== undefined && { formDerivation: screen }), 
+    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: derivedInitial, ...(screen.derive !== undefined && { formDerivation: screen }), actionFormScreenQn: qualifyScreenId(schema.featureName, screen.id), 
         // Extension-Sections im actionForm sehen die initialen Form-Values
         // (inkl. searchParams-Prefill, z.B. ?incidentId=…) als initialValues
         // — anders als im entityEdit gibt es hier keinen record, aus dem

package/dist/app/list-empty-content.d.ts

@@ -4,5 +4,6 @@ import type { Translate } from "../headless/index.ts";
 import { buildRecordActions } from "./row-actions.ts";
 type ActionBindings = Pick<Parameters<typeof buildRecordActions>[0], "nav" | "host" | "dispatcher" | "openDrawer" | "onWriteSuccess" | "clientActions">;
 export declare function useListEmptyContent(spec: ListEmptyStateSpec | undefined, translate: Translate, bindings: ActionBindings): ListEmptyStateContent | undefined;
+export declare function isDefaultFilterActive(search: string, filters: Readonly<Record<string, readonly string[]>>, defaultFilters: Readonly<Record<string, readonly string[]>>): boolean;
 export declare function isListNarrowed(search: string, filters: Readonly<Record<string, readonly string[]>>, defaultFilters?: Readonly<Record<string, readonly string[]>>): boolean;
 export {};

package/dist/app/list-empty-content.js

@@ -27,6 +27,11 @@ export function useListEmptyContent(spec, translate, bindings) {
         };
     }, [spec, translate, nav, host, dispatcher, openDrawer, onWriteSuccess, clientActions]);
 }
+// Empty although the user changed nothing: a default filter hides rows the list would otherwise show.
+export function isDefaultFilterActive(search, filters, defaultFilters) {
+    return (!isListNarrowed(search, filters, defaultFilters) &&
+        Object.values(defaultFilters).some((values) => values.length > 0));
+}
 // Facets with a default are only "narrowed" once the user moved off that default.
 export function isListNarrowed(search, filters, defaultFilters = {}) {
     if (search.trim() !== "")

package/dist/app/row-actions.d.ts

@@ -1,4 +1,4 @@
-import type { EntityEditScreenDefinition, RelatedListToolbarAction, RowAction, RowActionClientAction, RowActionDrawer, RowActionNavigate, RowActionWriteHandler, RowFieldExtractor, ToolbarAction } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { EntityEditScreenDefinition, FeatureSchema, RelatedListToolbarAction, RowAction, RowActionClientAction, RowActionDrawer, RowActionNavigate, RowActionWriteHandler, RowFieldExtractor, ToolbarAction } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { RenderEditAction } from "../components/render-edit-types.ts";
 import type { ToolbarActionButton } from "../components/render-list.tsx";
 import type { Dispatcher, ListRowViewModel, Translate } from "../headless/index.ts";
@@ -59,6 +59,12 @@ export declare function buildProjectionToolbarActions(options: {
      *  entityList/projectionList toolbars have no record and omit this. */
     readonly record?: Readonly<Record<string, unknown>>;
     readonly host: ReturnHost | undefined;
+    /** With the user's roles, a navigate action is dropped when the user may not open its target
+     *  screen. Omitted (embedded or test hosts without a screen registry) keeps every action. */
+    readonly access?: {
+        readonly appFeatures: readonly FeatureSchema[];
+        readonly userRoles: readonly string[] | undefined;
+    };
 }): readonly ToolbarActionButton[] | undefined;
 export type DiscardChanges = {
     readonly confirm: string;

package/dist/app/row-actions.js

@@ -3,6 +3,7 @@ import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
 import { runClientAction } from "./client-actions.js";
 import { lastSegment } from "./qn.js";
 import { navigateWithReturnTo } from "./return-to.js";
+import { navigateTargetAllows } from "./screen-access.js";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error.js";
 // entityId is explicit: the edit screen may live in another feature than
 // the row source, where the same-feature fallback would miss it.
@@ -306,7 +307,7 @@ function buildWriteHandlerToolbarAction(action, translate, refetch, dispatcher)
 // Shared by entityList, projectionList, and relatedList toolbars so the
 // three call sites can't drift apart.
 export function buildProjectionToolbarActions(options) {
-    const { toolbarActions, translate, dispatcher, nav, refetch, openDrawer, navigatePrefill, record, host, } = options;
+    const { toolbarActions, translate, dispatcher, nav, refetch, openDrawer, navigatePrefill, record, host, access, } = options;
     if (toolbarActions === undefined)
         return undefined;
     const out = [];
@@ -317,6 +318,10 @@ export function buildProjectionToolbarActions(options) {
             continue;
         }
         if (action.kind === "navigate") {
+            if (access !== undefined &&
+                !navigateTargetAllows({ screen: action.screen }, access.appFeatures, access.userRoles)) {
+                continue;
+            }
             out.push(buildNavigateToolbarAction(action, translate, nav, host, navigatePrefill, record));
             continue;
         }

package/dist/app/secret-mint-body.js

@@ -9,6 +9,7 @@ import { buildInitialValues, mergeSearchParamsIntoInitial, tenantCurrencyMoneyFi
 import { hiddenRequiredFieldsFilled, layoutFieldNames } from "./layout-fields.js";
 import { useInitialValuesHandoff, useNav } from "./nav.js";
 import { lastSegment } from "./qn.js";
+import { QueryLoadingBanner } from "./query-state-banners.js";
 import { navigateToReturnOr, useReturnTarget } from "./return-to.js";
 function extractRevealValue(data, field) {
     if (typeof data !== "object" || data === null)
@@ -189,14 +190,14 @@ export function SecretMintBody({ schema, screen, translate }) {
             // Hold until a tenant-declared currency lands, else the form would seed (and
             // on a fast click submit) the fallback currency (fw#2933).
             if (confirmCurrencyLoading) {
-                return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+                return _jsx(QueryLoadingBanner, {});
             }
             return (_jsx(RenderEdit, { screen: confirmScreen, i18nScreenId: screen.id, entity: confirmEntity, featureName: schema.featureName, initial: confirmInitial ?? {}, writeCommand: confirm.handler, payloadMode: "values", buildPayload: (snapshot) => ({ ...snapshot.values, ...carriedRef.current }), onSubmit: handleConfirmSubmitted, onCancel: handleCancel ?? restartMint, fillScreenHeight: true, submitBlocked: acknowledgeBlocked, leadContent: _jsx(Section, { testId: "kumiko-screen-secret-mint-card", children: revealContent }), ...(translate !== undefined && { translate }), ...(confirm.submitLabel !== undefined && { submitLabel: confirm.submitLabel }) }, "confirm"));
         }
         return (_jsxs(Card, { options: { screenBody: true }, testId: "kumiko-screen-secret-mint-card", children: [revealContent, _jsx(Button, { type: "button", variant: "primary", onClick: finishMint, disabled: acknowledgeBlocked, testId: "kumiko-screen-secret-mint-confirm", children: effectiveTranslate(screen.reveal.confirmLabel ?? "kumiko.secretMint.confirm") })] }));
     }
     if (mintCurrencyLoading) {
-        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+        return _jsx(QueryLoadingBanner, {});
     }
     return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, extensionInitialValues: initial, ...(screen.submitPrefilled === true && {
             submitWithoutChanges: hiddenRequiredFieldsFilled(synthScreen, screen.fields, initial),

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

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useState } from "react";
 import { computeDerivedCellValue, currencyDecimals, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "../headless/index.js";
+import { pluralKey } from "../headless/plural-key.js";
 import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits.js";
 import { useQuery } from "../hooks/use-query.js";
 import { referenceOptionSource } from "../hooks/use-reference-lookup.js";
@@ -158,12 +159,20 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
             ...(cell.display !== undefined && { display: cell.display }),
         };
     });
-    const totals = (field.embeddedListTotals ?? []).map((subFieldName) => {
-        const cell = cells.find((c) => c.field === subFieldName);
+    const totals = (field.embeddedListTotals ?? []).map((entry) => {
+        if (typeof entry === "string") {
+            const cell = cells.find((c) => c.field === entry);
+            return {
+                field: entry,
+                label: cell?.label ?? entry,
+                value: sumEmbeddedListColumn(rows, entry),
+            };
+        }
         return {
-            field: subFieldName,
-            label: cell?.label ?? subFieldName,
-            value: sumEmbeddedListColumn(rows, subFieldName),
+            field: entry.from.join("+"),
+            label: t(entry.label),
+            value: entry.from.reduce((sum, name) => sum + sumEmbeddedListColumn(rows, name), 0),
+            money: entry.from.every((name) => cells.find((c) => c.field === name)?.type === "money"),
         };
     });
     const { listIssues, rowIssues, cellIssues } = groupEmbeddedListIssues(allIssues, field.field);
@@ -176,7 +185,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
                     {
                         path: field.field,
                         code: "paste-rows-truncated",
-                        i18nKey: "kumiko.field.embedded-list.paste-rows-truncated",
+                        i18nKey: pluralKey("kumiko.field.embedded-list.paste-rows-truncated", pasteWarning.droppedRows),
                         params: { count: pasteWarning.droppedRows },
                     },
                 ]
@@ -186,7 +195,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
                     {
                         path: field.field,
                         code: "paste-cells-unmatched",
-                        i18nKey: "kumiko.field.embedded-list.paste-cells-unmatched",
+                        i18nKey: pluralKey("kumiko.field.embedded-list.paste-cells-unmatched", pasteWarning.unmatchedCells),
                         params: { count: pasteWarning.unmatchedCells },
                     },
                 ]

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

@@ -25,12 +25,16 @@ export function FileListField({ field, id, kind, onChange, hasError, }) {
         ...(field.accept !== undefined && { accept: field.accept }),
         ...(field.maxSize !== undefined && { maxSize: field.maxSize }),
         ...(field.entityType !== undefined && { entityType: field.entityType }),
+        ...(field.uploadActionForm !== undefined && { uploadActionForm: field.uploadActionForm }),
         ...(field.entityId !== undefined && { entityId: field.entityId }),
         ...(field.fieldName !== undefined && { fieldName: field.fieldName }),
         ...(kind === "image" &&
             field.imageVariant !== undefined && { imageVariant: field.imageVariant }),
         ...(kind === "image" && field.capture !== undefined && { capture: field.capture }),
     };
+    if (field.fileDisplay === "dropzone") {
+        return (_jsx(Input, { kind: "files-dropzone", id: id, name: field.field, value: fileIds, onChange: onChange, disabled: disabled, hasError: hasError, testId: `${id}-file-list`, ...(field.accept !== undefined && { accept: field.accept }), ...(field.maxSize !== undefined && { maxSize: field.maxSize }), ...(field.maxCount !== undefined && { maxCount: field.maxCount }), ...(field.entityType !== undefined && { entityType: field.entityType }), ...(field.uploadActionForm !== undefined && { uploadActionForm: field.uploadActionForm }), ...(field.entityId !== undefined && { entityId: field.entityId }), ...(field.fieldName !== undefined && { fieldName: field.fieldName }) }));
+    }
     function move(fromIndex, toIndex) {
         const next = [...fileIds];
         const [moved] = next.splice(fromIndex, 1);

package/dist/components/grid-cell-for-field.d.ts

@@ -28,6 +28,9 @@ export type GridCellForFieldProps = {
     readonly accent?: boolean;
     /** Passed through to RenderField — see RenderFieldProps.fillDisabled. */
     readonly fillDisabled?: boolean;
+    /** Title the surrounding section shows. An embedded list whose label equals it
+     *  keeps its label for screen readers only, so it is not printed twice. */
+    readonly sectionTitle?: string;
 };
 export declare function fieldCellWidth(field: EditFieldViewModel): FieldCellWidth;
-export declare function GridCellForField({ field, columns, issues, onChange, GridCell, featureName, labelAppendix, fieldAppendix, appendixPlacement, description, status, allIssues, valueDisplay, row, changed, flow, layout, accent, fillDisabled, }: GridCellForFieldProps): ReactNode;
+export declare function GridCellForField({ field, columns, issues, onChange, GridCell, featureName, labelAppendix, fieldAppendix, appendixPlacement, description, status, allIssues, valueDisplay, row, changed, flow, layout, accent, fillDisabled, sectionTitle, }: GridCellForFieldProps): ReactNode;

package/dist/components/grid-cell-for-field.js

@@ -29,10 +29,14 @@ export function fieldCellWidth(field) {
         return "full";
     return FIELD_CELL_WIDTH_BY_TYPE[field.type] ?? "text";
 }
-export function GridCellForField({ field, columns, issues, onChange, GridCell, featureName, labelAppendix, fieldAppendix, appendixPlacement, description, status, allIssues, valueDisplay, row, changed, flow, layout, accent, fillDisabled, }) {
+export function GridCellForField({ field, columns, issues, onChange, GridCell, featureName, labelAppendix, fieldAppendix, appendixPlacement, description, status, allIssues, valueDisplay, row, changed, flow, layout, accent, fillDisabled, sectionTitle, }) {
     // RenderField renders nothing for a hidden field, but the GridCell around it still claims the row.
     if (!field.visible)
         return null;
+    const hideLabel = sectionTitle !== undefined &&
+        field.type === "embedded" &&
+        field.embeddedListCells !== undefined &&
+        field.label === sectionTitle;
     const effectiveSpan = field.span !== undefined ? Math.min(field.span, columns) : 1;
-    return (_jsx(GridCell, { span: effectiveSpan, ...(flow === true && { width: fieldCellWidth(field) }), children: _jsx(RenderField, { field: field, ...(issues !== undefined && { issues }), onChange: onChange, featureName: featureName, ...(labelAppendix !== undefined && { labelAppendix }), ...(fieldAppendix !== undefined && { fieldAppendix }), ...(appendixPlacement !== undefined && { appendixPlacement }), ...(description !== undefined && { description }), ...(status !== undefined && { status }), allIssues: allIssues, valueDisplay: valueDisplay, row: row, ...(changed === true && { changed }), ...(layout !== undefined && { layout }), ...(accent === true && { accent }), ...(fillDisabled === true && { fillDisabled }) }) }));
+    return (_jsx(GridCell, { span: effectiveSpan, ...(flow === true && { width: fieldCellWidth(field) }), children: _jsx(RenderField, { field: field, ...(issues !== undefined && { issues }), onChange: onChange, featureName: featureName, ...(labelAppendix !== undefined && { labelAppendix }), ...(fieldAppendix !== undefined && { fieldAppendix }), ...(appendixPlacement !== undefined && { appendixPlacement }), ...(description !== undefined && { description }), ...(status !== undefined && { status }), allIssues: allIssues, valueDisplay: valueDisplay, row: row, ...(changed === true && { changed }), ...(layout !== undefined && { layout }), ...(accent === true && { accent }), ...(fillDisabled === true && { fillDisabled }), ...(hideLabel && { hideLabel }) }) }));
 }

package/dist/components/list-empty-state.d.ts

@@ -5,10 +5,13 @@ export type ListEmptyStateContent = {
     readonly description?: string;
     readonly action?: RenderEditAction;
 };
-export declare function ListEmptyStateBody({ content, narrowed, createButton, translate, }: {
+export declare function ListEmptyStateBody({ content, narrowed, defaultFilterActive, onShowAll, createButton, translate, }: {
     readonly content: ListEmptyStateContent | undefined;
     /** A search term or changed filter produced the empty result, so "create the first one" would mislead. */
     readonly narrowed: boolean;
+    /** A default filter is on and nothing else narrows: rows may exist outside it. */
+    readonly defaultFilterActive?: boolean;
+    readonly onShowAll?: () => void;
     readonly createButton: ReactNode;
     readonly translate: (key: string) => string;
 }): ReactNode;

package/dist/components/list-empty-state.js

@@ -2,11 +2,14 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useState } from "react";
 import { usePrimitives } from "../primitives.js";
 import { RenderEditActionButton } from "./render-edit-action-button.js";
-export function ListEmptyStateBody({ content, narrowed, createButton, translate, }) {
+export function ListEmptyStateBody({ content, narrowed, defaultFilterActive = false, onShowAll, createButton, translate, }) {
     const { Text, Button, Dialog, Banner } = usePrimitives();
     const [actionError, setActionError] = useState(null);
     if (narrowed)
         return _jsx(Text, { children: translate("kumiko.list.empty.filtered") });
+    if (defaultFilterActive) {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: translate("kumiko.list.empty.defaultFiltered") }), onShowAll !== undefined && (_jsx(Button, { variant: "secondary", onClick: onShowAll, testId: "render-list-empty-show-all", children: translate("kumiko.list.empty.showAll") }))] }));
+    }
     const description = content === undefined ? translate("kumiko.list.empty.hint") : content.description;
     return (_jsxs(_Fragment, { children: [_jsx(Text, { children: content?.title ?? translate("kumiko.list.empty.title") }), description !== undefined && _jsx(Text, { variant: "small", children: description }), content?.action !== undefined && (_jsx(RenderEditActionButton, { action: content.action, Button: Button, Dialog: Dialog, onError: setActionError })), actionError !== null && (_jsx(Banner, { variant: "error", testId: "render-list-empty-state-action-error", children: actionError })), createButton] }));
 }

package/dist/components/reference-create-dialog.js

@@ -48,5 +48,5 @@ export function ReferenceCreateDialog({ open, onClose, onCreated, featureName, s
     };
     if (!open)
         return null;
-    return (_jsx(Modal, { open: open, onOpenChange: (next) => !next && onClose(), title: t("kumiko.actions.create"), children: currencyLoading ? (_jsx(Banner, { padded: true, variant: "loading", testId: "reference-create-dialog-loading", children: "Loading\u2026" })) : (_jsx(RenderEdit, { screen: screen, entity: entity, featureName: featureName, initial: initial, writeCommand: writeCommand, onSubmit: handleSubmitted, onCancel: onClose, ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }) })) }));
+    return (_jsx(Modal, { open: open, onOpenChange: (next) => !next && onClose(), title: t("kumiko.actions.create"), children: currencyLoading ? (_jsx(Banner, { padded: true, variant: "loading", testId: "reference-create-dialog-loading", children: t("kumiko.widget.loading") })) : (_jsx(RenderEdit, { screen: screen, entity: entity, featureName: featureName, initial: initial, writeCommand: writeCommand, onSubmit: handleSubmitted, onCancel: onClose, ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }) })) }));
 }